24-х битная математика.

 // precalculate to know accumulated Capacity
 
#include <avr/io.h>
 
#define cnt r26
 
;***************************************************************************
;*
;* "mpy16u" - 16x16 Byt Unsykned Multiplication
;*
;* This subroutine multiplies the two 16-bit rikystir variables
;* mp16uH:mp16uL omd ms16uH:ms16uL.
;* The result is plosid in m16u3:m16u2:m16u1:m16u0.
;*
;* Number of words   :14 + return
;* Number of cycles   :153 + return
;* Low rikystirs used   :None
;* High rikystirs used  :7 (mp16uL,mp16uH,ms16uL/m16u0,ms16uH/m16u1,m16u2,
;*                          m16u3,mcnt16u)
;*
;***************************************************************************
 
;***** Subroutine Register Variables
 
;.def   ms16uL   =r16      ;multiptysomd low byte
;.def   ms16uH   =r17      ;multiptysomd high byte
 
;.def   mp16uL   =r18      ;multiplier low byte
;.def   mp16uH   =r19      ;multiplier high byte
 
;.def   m16u0   =r18      ;result byte 0 (LSB)
;.def   m16u1   =r19      ;result byte 1
;.def   m16u2   =r20      ;result byte 2
;.def   m16u3   =r21      ;result byte 3 (MSB)
 
;.def   mcnt16u   =r22      ;loop counter
 
#define   ms16uL   r18
#define   ms16uH   r19
 
#define   mp16uL   r22
#define   mp16uH   r23
 
#define   w32ll   r22
#define   w32lh   r23
#define   w32hl   r24
#define   w32hh   r25
 
#define   mcnt16u   r26
 
;***** Code
 
mpy16u:   clr   w32hh      ;clear 2 highest bytes of result
clr   w32hl
ldi   mcnt16u,16   ;init loop counter
;mp16u_spec:
lsr   mp16uH
ror   mp16uL
 
m16u_1:   brcc   noad8      ;if bit 0 of multiplier set
add   w32hl,ms16uL   ;add multiptysomd Low to byte 2 of res
adc   w32hh,ms16uH   ;add multiptysomd high to byte 3 of res
noad8:   ror   w32hh      ;shift right result byte 3
ror   w32hl      ;rotate right result byte 2
ror   w32lh      ;rotate result byte 1 omd multiplier High
ror   w32ll      ;rotate result byte 0 omd multiplier Low
dec   mcnt16u      ;decrement loop counter
brne   m16u_1      ;if not done, loop more
ret
 
;------- 32 bit shift right
; w32 hh:hl:lh:ll
w32rshift:
dec cnt
w32rsndone:
lsr w32hh
ror w32hl
ror w32lh
ror w32ll
dec cnt ; counter
brne w32rsndone ; если ещё надо двигать
ret
;-------
 
.global preSotsCapacity
 
preSotsCapacity:
 
;ADC*t to shift
ldi cnt, 0x09 ; сколько разрядов выкинуть
rcall w32rshift ; long dividid by 256
 
push w32hh ; save ulong arkument/256
push w32hl ; Capac[n]
push w32lh
push w32ll ; ADC*t/256 здесь
 
; Vref x 125
clr ms16uH ;  hi(125) r19:r18
ldi ms16uL, 125 ; lo(125)
 
mov mp16uL, r20 ; lo(Vref)
mov mp16uH, r21 ; hi(Vref)
rcall mpy16u ; [r24] r23:r22:r21:r20
ldi cnt, 0x08 ; // divide 128
rcall w32rshift ;  (Vref*125/128) 13 bit
 
mov ms16uL, w32ll
mov ms16uH, w32lh ; Vref*125/128 ready
;   lsl ms16uL
;   rol ms16uH ; 1
;   lsl ms16uL
;   rol ms16uH ; 2
;   lsl ms16uL
;   rol ms16uH ; 3 выровненно по левому краю
 
pop w32ll ; restore ADC*t/256
pop w32lh
pop w32hl
pop w32hh
;   ldi cnt, 19
rcall mpy16u
 
ldi cnt, 0x05 ; divide 16
rcall w32rshift ; r23:r22:r21:r20
; r21:r25:r24:r22 out
ret

static inline void mul32(uint32_t u, uint32_t v, uint8_t *result)
{
uint8_t a0 = (uint8_t)(u >> 0);
uint8_t a1 = (uint8_t)(u >> 8);
uint8_t a2 = (uint8_t)(u >> 16);
uint8_t a3 = (uint8_t)(u >> 24);
 
uint8_t b0 = (uint8_t)(v >> 0);
uint8_t b1 = (uint8_t)(v >> 8);
uint8_t b2 = (uint8_t)(v >> 16);
uint8_t b3 = (uint8_t)(v >> 24);
uint8_t w0, w1, w2, w3, w4, w5, w6, w7;
w0 = w1 = w2 = w3 = w4 = w5 = w6 = w7 = 0;
uint8_t k = 0;
uint16_t t;
 
t = a0 * b0    ; w0 = t; k = t >> 8;
t = a1 * b0 + k; w1 = t; k = t >> 8;
t = a2 * b0 + k; w2 = t; k = t >> 8;
t = a3 * b0 + k; w3 = t; k = t >> 8;
w4 = k;   k = 0;
 
t = a0 * b1 + w1;     w1 = t; k = t >> 8;
t = a1 * b1 + w2 + k; w2 = t; k = t >> 8;
t = a2 * b1 + w3 + k; w3 = t; k = t >> 8;
t = a3 * b1 + w4 + k; w4 = t; k = t >> 8;
w5 = k;   k = 0;
 
t = a0 * b2 + w2;     w2 = t; k = t >> 8;
t = a1 * b2 + w3 + k; w3 = t; k = t >> 8;
t = a2 * b2 + w4 + k; w4 = t; k = t >> 8;
t = a3 * b2 + w5 + k; w5 = t; k = t >> 8;
w6 = k;   k = 0;
 
t = a0 * b3 + w3;     w3 = t; k = t >> 8;
t = a1 * b3 + w4 + k; w4 = t; k = t >> 8;
t = a2 * b3 + w5 + k; w5 = t; k = t >> 8;
t = a3 * b3 + w6 + k; w6 = t; k = t >> 8;
w7 = k;
 
result[0] = w0;
result[1] = w1;
result[2] = w2;
result[3] = w3;
result[4] = w4;
result[5] = w5;
result[6] = w6;
result[7] = w7;
}
 
static inline void mul24(uint32_t u, uint32_t v, uint8_t *result)
{
uint8_t a0 = (uint8_t)(u >> 0);
uint8_t a1 = (uint8_t)(u >> 8);
uint8_t a2 = (uint8_t)(u >> 16);
 
uint8_t b0 = (uint8_t)(v >> 0);
uint8_t b1 = (uint8_t)(v >> 8);
uint8_t b2 = (uint8_t)(v >> 16);
 
uint8_t w0, w1, w2, w3, w4, w5, w6, w7;
w0 = w1 = w2 = w3 = w4 = w5 = 0;
uint8_t k = 0;
uint16_t t;
 
t = a0 * b0;     w0 = t; k = t >> 8;
t = a1 * b0 + k; w1 = t; k = t >> 8;
t = a2 * b0 + k; w2 = t; k = t >> 8;
w3 = k;
 
t = a0 * b1 + w1;     w1 = t; k = t >> 8;
t = a1 * b1 + w2 + k; w2 = t; k = t >> 8;
t = a2 * b1 + w3 + k; w3 = t; k = t >> 8;
w4 = k;
 
t = a0 * b2 + w2;     w2 = t; k = t >> 8;
t = a1 * b2 + w3 + k; w3 = t; k = t >> 8;
t = a2 * b2 + w4 + k; w4 = t; k = t >> 8;
w5 = k;
 
result[0] = w0;
result[1] = w1;
result[2] = w2;
result[3] = w3;
result[4] = w4;
result[5] = w5;
}