*Sehr* viel Splatz sparen kannst du zB in der SerielleBitsZuordnenEmpfaenger(). etc
Code:
void SerielleBitsZuordnenEmpfaenger(void)
{
//Auszug
if( EmpfaengerRegister[1] == 0) { AuszugWert &= ~ 1 ; } // 0 setzen
else { AuszugWert |= 1 ; } // 1 setzen
if( EmpfaengerRegister[2] == 0) { AuszugWert &= ~ 2 ; } // 0 setzen
else { AuszugWert |= 2 ; } // 1 setzen
if( EmpfaengerRegister[3] == 0) { AuszugWert &= ~ 4 ; } // 0 setzen
else { AuszugWert |= 4 ; } // 1 setzen
if( EmpfaengerRegister[4] == 0) { AuszugWert &= ~ 8 ; } // 0 setzen
else { AuszugWert |= 8 ; } // 1 setzen
if( EmpfaengerRegister[5] == 0) { AuszugWert &= ~ 16 ; } // 0 setzen
else { AuszugWert |= 16 ; } // 1 setzen
if( EmpfaengerRegister[6] == 0) { AuszugWert &= ~ 32 ; } // 0 setzen
else { AuszugWert |= 32 ; } // 1 setzen
if( EmpfaengerRegister[7] == 0) { AuszugWert &= ~ 64 ; } // 0 setzen
else { AuszugWert |= 64 ; } // 1 setzen
if( EmpfaengerRegister[8] == 0) { AuszugWert &= ~ 128 ; } // 0 setzen
else { AuszugWert |= 128 ; } // 1 setzen
if( EmpfaengerRegister[9] == 0) { AuszugWert &= ~ 256 ; } // 0 setzen
else { AuszugWert |= 256 ; } // 1 setzen
if( EmpfaengerRegister[10] == 0) { AuszugWert &= ~ 512 ; } // 0 setzen
else { AuszugWert |= 512 ; } // 1 setzen
if( EmpfaengerRegister[11] == 0) { AuszugWert &= ~ 1024 ; } // 0 setzen
else { AuszugWert |= 1024 ; } // 1 setzen
if( EmpfaengerRegister[12] == 0) { AuszugWert &= ~ 2048 ; } // 0 setzen
else { AuszugWert |= 2048 ; } // 1 setzen
if( EmpfaengerRegister[13] == 0) { AuszugWert &= ~ 4096 ; } // 0 setzen
else { AuszugWert |= 4096 ; } // 1 setzen
if( EmpfaengerRegister[14] == 0) { AuszugWert &= ~ 8192 ; } // 0 setzen
else { AuszugWert |= 8192 ; } // 1 setzen
if( EmpfaengerRegister[15] == 0) { AuszugWert &= ~16384 ; } // 0 setzen
else { AuszugWert |= 16384 ; } // 1 setzen
if( EmpfaengerRegister[16] == 0) { AuszugWert &= ~32768 ; } // 0 setzen
else { AuszugWert |= 32768 ; } // 1 setzen
if( EmpfaengerRegister[17] == 0) { AuszugWert &= ~65536 ; } // 0 setzen
else { AuszugWert |= 65536 ; } // 1 setzen
}
Code:
void __SerielleBitsZuordnenEmpfaenger(void)
{
//Auszug
uint8_t i;
uint16_t mask = 1;
uint16_t awert = 0;
for (i=1; i <= 16; i++)
{
if (EmpfaengerRegister[i] != 0)
awert |= mask;
mask <<= 1;
}
AuszugWert = awert;
// versteh ich nicht das... die Aktion ist trivial, hat keine Wirkung!
if( EmpfaengerRegister[17] == 0) { AuszugWert &= ~65536 ; } // 0 setzen
else { AuszugWert |= 65536 ; } // 1 setzen
}
Originalgröße: 482 Bytes
Größe mit Schleife: 44 Bytes
Ausserden ist die Schleife besser zu lesen (find ich zumindest) und nicht so fehleranfällig gegen Tippfehler.
Code:
__SerielleBitsZuordnenEmpfaenger:
/* prologue: frame size=0 */
/* prologue end (size=0) */
ldi r18,lo8(1) ; mask, ; 9 *movhi/4 [length = 2]
ldi r19,hi8(1) ; mask,
ldi r20,lo8(0) ; awert, ; 11 *movhi/4 [length = 2]
ldi r21,hi8(0) ; awert,
ldi r30,lo8(EmpfaengerRegister+1) ; tmp57, ; 98 *movhi/4 [length = 2]
ldi r31,hi8(EmpfaengerRegister+1) ; tmp57,
ldi r25,lo8(15) ; i, ; 104 *movqi/2 [length = 1]
.L193:
ld r24,Z+ ; tmp47, EmpfaengerRegister ; 25 *movqi/4 [length = 1]
tst r24 ; tmp47 ; 26 tstqi [length = 1]
breq .L192 ; , ; 27 branch [length = 1]
or r20,r18 ; awert, mask ; 29 iorhi3/1 [length = 2]
or r21,r19 ; awert, mask
.L192:
lsl r18 ; mask ; 113 *ashlhi3_const/2 [length = 2]
rol r19 ; mask
subi r25,lo8(-(-1)) ; i, ; 105 addqi3/2 [length = 1]
sbrs r25,7 ; i, ; 112 *sbrx_branch [length = 2]
rjmp .L193 ;
sts (AuszugWert)+1,r21 ; AuszugWert, awert ; 66 *movhi/3 [length = 4]
sts AuszugWert,r20 ; AuszugWert, awert
/* epilogue: frame size=0 */
ret
Und das macht auch ein Assembler-Progger nur mühselig noch kleiner...ich seh da lediglich 2 Instruktionen die man sparen kann, also peanuts.
Du schreibst den Code so hin, wie GCC ihn mit -funroll-all-loops generieren würde (etwa bei -O3: alle Schleifen aufrollen). Ist das so Laufzeit-kritisch?
Also:
-1- Die Arithmetik in Schleifen akkumulieren
-2- Wenn du oft auf die gleiche Globale zugreifst, ist es besser, sie erst in eine Lokale zu kopieren, dann die vielen Aktionen zu machen und dann wieder zu speichern. Das spart dir loads (jeweils 4 Byte) und store (schon wieder je 4 Bytes)
Die Funktionen brauchen wohl keine Frames, von daher bringt -mcall-prologues keine Ersparnis.
Zitieren
;
// Endlosschleife, wird zwischen den geschweiften Klammern immer wieder durchlaufen
Lesezeichen