Hilfe Programmspeicher voll!

Hallo mein Programmspeicher vom ATMEGA8 ist voll.

Ich habe schon oft gelesen, das man speicher einsparen kann, wenn man sachen kürzt oder so.

Leider hab ich mit Speicher einsparen noch keine erfahrung. :-(

Hast du ne Idee, was ich an meinem Programm ändern kann?

Im moment ist der Programmspeicher zu 100%voll und der Variablenspeicher nur zu 60%voll.


mir ist noch was komisches aufgefallen:
Wenn ich die Funktion
sprintf(messageSystemStatus, "\r%6d_%5d_%4d_OK", AuszugWert, Temperatur, Teilingsfaktor);

Weglasse, dann ist der Programmspeicher nur 78%voll.
Brauch die Finktion so viel speicher????

Danke für eure Hilfe!

Das Programm kommt als antwort nach, weil ich kann nur 20.000 Zeichen auf einmal reinstellen.

#include <inttypes.h>
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>
#include "uart.h"
#include <stdio.h>
volatile u08 UART_Ready;
volatile u08 UART_ReceivedChar;
u08 UART_RxChar;
u08* pUART_Buffer;

prog_char UART_pszEndOfLine[3] = {0x0d,0x0a,0};



/************************************************** *********************************
Schrittmotoransteuerung Poti und Display
************************************************** **********************************

Johannes Glaser
Mainstraße 52
97334 Nordheim
jojo.glaser@web.de
ICQ: 348-870-813
09381 4141
************************************************** **********************************/

#include <avr/io.h>
#include <inttypes.h>


//################################################## #################################
//############### Vatiablen setzen und initialisieren ###############################
//################################################## #################################

//Serielles Netzwerk Seriell
//Sender
unsigned char SeriellerPort_Hi ;
unsigned char SeriellerPort_Lo ;
unsigned char SeriellerPort_Reset ;

unsigned char SenderBitRegister[21] ;
unsigned char SenderBitRegisterZaehler ;

unsigned short SenderImpulslaenge = 1;
unsigned short SenderImpulslaengeZaehler ;

//Empfänger
unsigned char SeriellerPin_Hi ;
unsigned char SeriellerPin_Hi_Merker ;
unsigned char SeriellerPin_Lo ;
unsigned char SeriellerPin_Lo_Merker ;
unsigned char SeriellerPin_Reset ;
unsigned char SeriellerPin_Reset_Merker ;

unsigned char EmpfaengerRegister[51] ;
unsigned char EmpfaengerRegisterZaehler ;

unsigned short SeriellerPin_Hi_Zaehler ;
unsigned short SeriellerPin_Lo_Zaehler ;
unsigned short SeriellerPin_Reset_Zaehler ;
unsigned short SeriellerPin_Prell_Zeit = 2;

unsigned char EmpfaengerRiegelReset ;

//Port Variablen
unsigned char Pin_SeriellerPort_Hi ; //Ausgang
unsigned char Pin_SeriellerPort_Lo ; //Ausgang
unsigned char Pin_SeriellerPort_Reset ; //Ausgang

unsigned char Pin_SeriellerPin_Hi ; //Eingang
unsigned char Pin_SeriellerPin_Lo ; //Eingang
unsigned char Pin_SeriellerPin_Reset ; //Eingang


//Serielle Datenübertragung über 2 Pins für Temperatur
unsigned char Pin_Serielle_Bit ;
unsigned char Pin_Serielle_Bit_Merker ;
unsigned char Pin_Serielle_Setzen ;
unsigned char Pin_Serielle_Setzen_Merker ;

unsigned char Pin_Serielle_Bit2 ;
unsigned char Pin_Serielle_Setzen2 ;

unsigned char BitEmpfangen ;
unsigned short BitAdresse[11] = {0,1,2,4,8,16,32,64,128,256,512};

unsigned short TemperaturTmp ;
unsigned short TemperaturTmp1 ;
unsigned short TemperaturTmp2 ;
unsigned short Temperatur ;

unsigned short Temperatur_Abfrage_Zeit = 10;
unsigned short Temperatur_Abfrage_Zaehler ;


//Fertigliste wenn alle Seriellen daten gesendet und empfangen sind alle 1
unsigned short FertigSender = 1;
unsigned short FertigEmpfaenger = 1;
unsigned short FertigTemperatur = 1;


//Empfaenger Daten
unsigned short TemperaturEmpfangen ;
unsigned short AuszugWert ;
unsigned char SystemStatus ;
unsigned char Teilingsfaktor ;
unsigned char Hellichkeit ;
unsigned char Auszug ;
unsigned char LAN_nicht_Verbunden ;
unsigned char Nullpunkt_festlegen ;
unsigned char Temp_Ausgleich_EIN ;
unsigned char Temp_Ausgleich_AUS ;
unsigned char Joistik_EIN ;
unsigned char Joistik_AUS ;

unsigned char FreieEmpfaengerFunktion_1 ;
unsigned char FreieEmpfaengerFunktion_2 ;
unsigned char FreieEmpfaengerFunktion_3 ;
unsigned char SicherheitsBitsEmpfaenger ;

//Sender Daten
unsigned short Temperatur ;
unsigned short PotiWert ;
unsigned char SicherheitsBits2 ;


//Podi Abfrage
unsigned short ad_wert_zero ;

unsigned short ad_wert_up_max = 980;
unsigned short ad_wert_up_min ;

unsigned short ad_wert_down_max ;
unsigned short ad_wert_down_min = 670;

unsigned short ad_wert_up_diff ;
unsigned short ad_wert_down_diff ;

unsigned short ad_wert_up_Poti ;
unsigned short ad_wert_down_Poti ;

short prozent ;
short PotiProzent ;

unsigned short PotiADWert ;


//Display
//Nur Hellichkeit ändern, wenn sie sich auch endern soll.
unsigned char Hellichkeit_Merker ;

//Arrays für das Display festlegen
unsigned char messagenumber ;
unsigned char messagenumberMerker ;

unsigned char messageSystemStatus[21] ;

const char *messages[] = { "\r ",
/* 1 */ "\rLAN_nicht Verbunden ",
/* 2 */ "\rNullpunkt festlegen ",
/* 3 */ "\r Temp_Ausgleich EIN ",
/* 4 */ "\r Temp_Ausgleich AUS ",
/* 5 */ "\r Joistik EIN ",
/* 6 */ "\r Joistik AUS ",
/* 7 */ "\r Hellichkeit = 0% ",
/* 8 */ "\r Hellichkeit = 30% ",
/* 9 */ "\r Hellichkeit = 50% ",
/* 10 */ "\r Hellichkeit = 75% ",
/* 11 */ "\r Hellichkeit = 100% ",
/* 12 */ "\r System Status "
};


//Anzeigen Länge
unsigned short InfoAnzeigeLaenge = 10 ;
unsigned short InfoAnzeige_Zaehler ;

unsigned short LAN_nicht_Verbunden_Anzeigen ;
unsigned short Nullpunkt_festlegen_Anzeigen ;
unsigned short Temp_Ausgleich_EIN_Anzeigen ;
unsigned short Temp_Ausgleich_AUS_Anzeigen ;
unsigned short Joistik_EIN_Anzeigen ;
unsigned short Joistik_AUS_Anzeigen ;
unsigned short Hellichkeit_0_Anzeigen ;
unsigned short Hellichkeit_30_Anzeigen ;
unsigned short Hellichkeit_50_Anzeigen ;
unsigned short Hellichkeit_75_Anzeigen ;
unsigned short Hellichkeit_100_Anzeigen ;

unsigned short LAN_nicht_Verbunden_Merker ;
unsigned short Nullpunkt_festlegen_Merker ;
unsigned short Temp_Ausgleich_EIN_Merker ;
unsigned short Temp_Ausgleich_AUS_Merker ;
unsigned short Joistik_EIN_Merker ;
unsigned short Joistik_AUS_Merker ;
unsigned short Hellichkeit_0_Merker ;
unsigned short Hellichkeit_30_Merker ;
unsigned short Hellichkeit_50_Merker ;
unsigned short Hellichkeit_75_Merker ;
unsigned short Hellichkeit_100_Merker ;

//Hellichkeitsaufteilung
unsigned char Hellichkeit_0 ;
unsigned char Hellichkeit_30 ;
unsigned char Hellichkeit_50 ;
unsigned char Hellichkeit_75 ;
unsigned char Hellichkeit_100 ;



//################################################## #################################
//############### I/O-Ports initialisieren ##########################################
//################################################## #################################

//----------------------------------------------------------------------------------
void Init(void)
{
/*
Initialisierungsfunktion für die Hardware des AVR MEGA 8151
Hier werden alle Hardware-Komponenten in initialisiert
"in Grundstellung gebracht" 0=Eing. 1=Ausg.
*/

/*
Ein/Ausgangstabelle:
Port B 0 = 0 free
Port B 1 = 0 free
Port B 2 = 0 free
Port B 3 = 0 free
Port B 4 = 0 free
Port B 5 = 0 free
Port B 6 = 0 Pin_Serielle_Setzen
Port B 7 = 0 Pin_Serielle_Bit

Port C 0 = 0 free
Port C 1 = 0 free
Port C 2 = 0 free
Port C 3 = 0 free
Port C 4 = 0 free
Port C 5 = 0 free
Port C 6 = 0 free
Port C 7 = 0 free

Port D 0 = 0 free
Port D 1 = 1 Display
Port D 2 = 0 SeriellerPin_Bit
Port D 3 = 0 SeriellerPin_Set
Port D 4 = 0 SeriellerPin_Reset
Port D 5 = 1 SeriellerPort_Bit
Port D 6 = 1 SeriellerPort_Set
Port D 7 = 1 SeriellerPort_Reset
*/


// Ausgänge / Eingänge initialisieren
DDRB = 1; //00000001
DDRC = 0; //00000000
DDRD = 224; //11100000

//Grundstellung
PORTB = 254; //11111110
PORTC = 255; //11111111
PORTD = 001; //00000001


} // Ende der Funktion Initialisierung()
//----------------------------------------------------------------------------------

SIGNAL(SIG_UART_TRANS)
{
/* Test if a string is being sent */
if (pUART_Buffer!=0)
{
pUART_Buffer++; // Go to next character in string

// Test if the end of string has been reached
if (/* PRG_RDB */*(pUART_Buffer)== '\0')
{
/* String has been sent */
pUART_Buffer = 0;
/* Indicate that the UART is now ready to send */
UART_Ready = 1;
return;
}
/* Send next character in string */
UDR = /* PRG_RDB */*(pUART_Buffer);
return;
}
/* Indicate that the UART is now ready to send */
UART_Ready = 1;
}
/* EasyCASE ) */
/* EasyCASE ( 72
SIGNAL */
/* EasyCASE F */
/* UART Receive Complete Interrupt Function */
SIGNAL(SIG_UART_RECV)
{
/* Indicate that the UART has received a character */
UART_ReceivedChar = 1;
/* Store received character */
UART_RxChar = UDR;
}
/* EasyCASE ) */
/* EasyCASE ( 73
UART_SendByte */
/* EasyCASE F */
void UART_SendByte(u08 Data)
{
/* wait for UART to become available */
while (!UART_Ready)
{
;
}
UART_Ready = 0;
/* Send character */
UDR = Data;
}
/* EasyCASE ) */
/* EasyCASE ( 74
UART_ReceiveByte */
/* EasyCASE F */
u08 UART_ReceiveByte(void)
{
/* wait for UART to indicate that a character has been received */
while (!UART_ReceivedChar)
{
;
}
UART_ReceivedChar = 0;
/* read byte from UART data buffer */
return UART_RxChar;
}
/* EasyCASE ) */
/* EasyCASE ( 75
UART_PrintfProgStr */
/* EasyCASE F */
void UART_PrintfProgStr(u08* pBuf)
{
/* wait for UART to become available */
while (!UART_Ready)
{
;
}
UART_Ready = 0; // Indicate to ISR the string to be sent

pUART_Buffer = pBuf; // Send first character

UDR = /* PRG_RDB */*(pUART_Buffer); // fuer RAM-based Strings die PRG_RDB-Macros ausgeblendet
}
/* EasyCASE ) */
/* EasyCASE ( 76
UART_PrintfEndOfLine */
/* EasyCASE F */
void UART_PrintfEndOfLine(void)
{
/* wait for UART to become available */
while (!UART_Ready)
{
;
}
UART_Ready = 0; /* Indicate to ISR the string to be sent */
pUART_Buffer = (u08 *)(&UART_pszEndOfLine[0]);
UDR = *(pUART_Buffer); /* Send first character */
}
/* EasyCASE ) */
/* EasyCASE ( 77
UART_PrintfU4 */
/* EasyCASE F */
void UART_PrintfU4(u08 Data)
{
/* Send 4-bit hex value */
u08 Character = Data&0x0f;
if (Character>9)
{
Character+='A'-10;
}
else
{
Character+='0';
}
UART_SendByte(Character);
}
/* EasyCASE ) */
/* EasyCASE ( 78
UART_Printfu08 */
/* EasyCASE F */
void UART_Printfu08(u08 Data)
{
/* Send 8-bit hex value */
UART_PrintfU4(Data>>4);
UART_PrintfU4(Data );
}
/* EasyCASE ) */
/* EasyCASE ( 79
UART_Printfu16 */
/* EasyCASE F */
void UART_Printfu16(u16 Data)
{
/* Send 16-bit hex value */
UART_PrintfU4(Data>>12);
UART_PrintfU4(Data>> 8);
UART_PrintfU4(Data>> 4);
UART_PrintfU4(Data );
}
/* EasyCASE ) */
/* EasyCASE ( 80
UART_Init */
/* EasyCASE F */
void UART_Init(void)
{
UART_Ready = 1;
UART_ReceivedChar = 0;
pUART_Buffer = 0;
/* enable RxD/TxD and interrupts */
//outp(BV(RXCIE)|BV(TXCIE)|BV(RXEN)|BV(TXEN),UCR);
UCSRB = _BV(RXCIE) | _BV(TXCIE) | _BV(RXEN) | _BV(TXEN);
/* set baud rate */
UBRRH = (unsigned char)(UART_BAUD_SELECT>>8);
UBRRL = (unsigned char)(UART_BAUD_SELECT);
/* enable interrupts */
sei();
}
/* EasyCASE ) */
/* EasyCASE ( 65
ioinit */
/* EasyCASE F */
void ioinit (void)
{
/* enable interrupts */
sei();
}
/* EasyCASE ) */
/* EasyCASE ( 88
delay */
/* EasyCASE F */
void delay (unsigned int delay)
{
static unsigned int InnerLoop;
while (delay > 0)
{
for (InnerLoop = 0; InnerLoop < 3686; ++InnerLoop)
{
// warten ...
}
--delay;
}
}





//----------------------------------------------------------------------------------
uint16_t readADC(uint8_t channel) {
uint8_t i;
uint16_t result = 0;

// Den ADC aktivieren und Teilungsfaktor auf 64 stellen
ADCSRA = (1<<ADEN) | (1<<ADPS2) | (1<<ADPS1);

// Kanal des Multiplexers waehlen
ADMUX = channel;
// Interne Referenzspannung verwenden (also 2,56 V)
ADMUX |= (1<<REFS1) | (1<<REFS0);

// Den ADC initialisieren und einen sog. Dummyreadout machen
ADCSRA |= (1<<ADSC);
while(ADCSRA & (1<<ADSC));

// Jetzt 3x die analoge Spannung and Kanal channel auslesen
// und dann Durchschnittswert ausrechnen.
for(i=0; i<10; i++) {
// Eine Wandlung
ADCSRA |= (1<<ADSC);
// Auf Ergebnis warten...
while(ADCSRA & (1<<ADSC));

result += ADCW;
}

// ADC wieder deaktivieren
ADCSRA &= ~(1<<ADEN);

result /= 10;

return result;
}
//----------------------------------------------------------------------------------




//################################################## #################################
//############### Input / Output Register anlegen ###################################
//################################################## #################################


//----------------------------------------------------------------------------------
void Verz(long time)
{
/*
Verzögerungsfunktion
Der übergebene Parameter time bestimmt, wie oft die Verzögerungsschleife
durchlaufen wird und damit, wie lange die Verzögerung dauert
(jede Befehlsausführung benötigt immer eine gewisse Zeit).
*/
do // Beginn einer do/while-Schleife
{
--time; // der übergebene Wert wird um eins vermindert
}
while (time > 0); // hier wird geprüft, od der Wert inzwischen 0 ist
// wenn nicht, wird wird wieder an den Anfang der do-Schleife
// gesprungen (while = solange oder während)
// ist irgendwann time == 0, wird die Schleife verlassen

} // Ende der Funktion Verz()
//----------------------------------------------------------------------------------


//----------------------------------------------------------------------------------
void PortsSetzenEinlesen(void)
{

//-----------------------------------------------------------------
//----- Eingänge --------------------------------------------------
//-----------------------------------------------------------------

//Serielle übertragung über 2 Pins
if((PINB & 64) == 0) { Pin_Serielle_Setzen2 = 0; }
else { Pin_Serielle_Setzen2 = 1; }

if((PINB & 128) == 0) { Pin_Serielle_Bit2 = 0; }
else { Pin_Serielle_Bit2 = 1; }


//Serielles Netzwerk Empfänger
if((PIND & 4) == 0) { Pin_SeriellerPin_Hi = 0; }
else { Pin_SeriellerPin_Hi = 1; }

if((PIND & 8) == 0) { Pin_SeriellerPin_Lo = 0; }
else { Pin_SeriellerPin_Lo = 1; }

if((PIND & 16) == 0) { Pin_SeriellerPin_Reset = 0; }
else { Pin_SeriellerPin_Reset = 1; }



//-----------------------------------------------------------------
//----- Ausgänge --------------------------------------------------
//-----------------------------------------------------------------

//Serielles Netzwerk Sender
if(Pin_SeriellerPort_Hi == 1)
{ PORTD |= 32; } // 1 setzen
else
{ PORTD &= ~32; } // 0 setzen

if(Pin_SeriellerPort_Lo == 1)
{ PORTD |= 64; } // 1 setzen
else
{ PORTD &= ~64; } // 0 setzen

if(Pin_SeriellerPort_Reset == 1)
{ PORTD |= 128; } // 1 setzen
else
{ PORTD &= ~128; } // 0 setzen


}
//----------------------------------------------------------------------------------


//----------------------------------------------------------------------------------
void TemperaturSeriellEinlesen(void)
{


//Abfrage hat sich das Pin Setzen geändert?
if((Pin_Serielle_Setzen == Pin_Serielle_Setzen_Merker))
{

if((Pin_Serielle_Bit == Pin_Serielle_Bit_Merker))
{
}
else
{
//Merkser setzen, um auf änderung des Pins Bit zu warten
Pin_Serielle_Bit_Merker = Pin_Serielle_Bit;

// if(BitEmpfangen == 9)
{
BitEmpfangen = 0;

Temperatur = TemperaturTmp - 50;

//Markiert Temperatur erfolgreich eingelesen
FertigTemperatur = 1;


TemperaturTmp = 0;
}



}


}
else
{
if((Pin_Serielle_Bit == Pin_Serielle_Bit_Merker))
{
}
else
{
//Merkser setzen, um auf änderung des Pins Bit zu warten
Pin_Serielle_Bit_Merker = Pin_Serielle_Bit;
}


//Merkser setzen, um auf änderung des Pins Setzen zu warten
Pin_Serielle_Setzen_Merker = Pin_Serielle_Setzen;

//Setzt das Pin, das als nechstes empfangen werden soll
++ BitEmpfangen;

if(Pin_Serielle_Bit == 1)
{
TemperaturTmp = TemperaturTmp + (BitAdresse[BitEmpfangen]);
}
}






}
//----------------------------------------------------------------------------------


//----------------------------------------------------------------------------------
void SeriellesNetzwerkSender(void)
{

//Sobalt die Zeit SenderImpulslaenge abgelaufen ist, wird das nechste Bit gesendet.
if(SenderImpulslaengeZaehler == 0)
{
SenderImpulslaengeZaehler = SenderImpulslaenge;


//Ist das letzte Bit erreicht, .
if(SenderBitRegisterZaehler > 20)
{
//wird ein Reset befehl gesendet
if(SeriellerPort_Reset == 1)
{
SeriellerPort_Reset = 0;
}
else
{
SeriellerPort_Reset = 1;
}

//der Registerzähler zurückgesetzt
SenderBitRegisterZaehler = 0;
}

//Ist das letzte Bit nicht erreicht, wird das nechste gesendet.
else
{
//dann nechstes Bit
++ SenderBitRegisterZaehler;

//Wenn das Momentan Bit ist Hi,
if(SenderBitRegister[SenderBitRegisterZaehler] == 1)
{
//dann Wechsler Pin Hi
if(SeriellerPort_Hi == 1)
{
SeriellerPort_Hi = 0;
}
else
{
SeriellerPort_Hi = 1;
}
}

//wenn nicht,
else
{
//dann Wechsler Pin Lo
if(SeriellerPort_Lo == 1)
{
SeriellerPort_Lo = 0;
}
else
{
SeriellerPort_Lo = 1;
}
}
}

}

//wenn nicht
else
{
//dann incrementiere SenderImpulslängeZaehler
-- SenderImpulslaengeZaehler;
}

}
//----------------------------------------------------------------------------------

//----------------------------------------------------------------------------------
void SeriellesNetzwerkEmpfaenger(void)
{


//Wenn sich der Reset Pin nicht geändert hat,
if(SeriellerPin_Reset == SeriellerPin_Reset_Merker)
{

//wenn sich das Hi Pin geändert hat,
if(SeriellerPin_Hi != SeriellerPin_Hi_Merker)
{
//dann ist das Momentan Bit ist Hi.
EmpfaengerRegister[EmpfaengerRegisterZaehler] = 1;

//Verriegeln
SeriellerPin_Hi_Merker = SeriellerPin_Hi;

//dann nechstes Bit
++ EmpfaengerRegisterZaehler;
}


//wenn sich das Lo Pin geändert hat,
if(SeriellerPin_Lo != SeriellerPin_Lo_Merker)
{
//dann ist das Momentan Bit ist Lo.
EmpfaengerRegister[EmpfaengerRegisterZaehler] = 0;

//Verriegeln
SeriellerPin_Lo_Merker = SeriellerPin_Lo;

//dann nechstes Bit
++ EmpfaengerRegisterZaehler;
}
}

//wenn nicht
else
{
//Wenn schon mal ganz empfangen wurde
if(EmpfaengerRiegelReset > 1)
{
//Empfänger als fertig Markiren
FertigEmpfaenger = 1;
}

++ FertigEmpfaenger;

//dann erstes Bit
EmpfaengerRegisterZaehler = 1;

//Verriegeln
SeriellerPin_Reset_Merker = SeriellerPin_Reset;
}


}
//----------------------------------------------------------------------------------


//----------------------------------------------------------------------------------
void NetzwerkPinsEntprellen(void)
{

//Sender
Pin_SeriellerPort_Hi = SeriellerPort_Hi;
Pin_SeriellerPort_Lo = SeriellerPort_Lo;
Pin_SeriellerPort_Reset = SeriellerPort_Reset;

//Empfänger
//Hi
if(Pin_SeriellerPin_Hi == 0)
{
SeriellerPin_Hi_Zaehler = 0;
}

if(SeriellerPin_Hi_Zaehler >= SeriellerPin_Prell_Zeit)
{
SeriellerPin_Hi = 1;
}
else
{
++ SeriellerPin_Hi_Zaehler;
SeriellerPin_Hi = 0;
}

//Lo
if(Pin_SeriellerPin_Lo == 0)
{
SeriellerPin_Lo_Zaehler = 0;
}

if(SeriellerPin_Lo_Zaehler >= SeriellerPin_Prell_Zeit)
{
SeriellerPin_Lo = 1;
}
else
{
++ SeriellerPin_Lo_Zaehler;
SeriellerPin_Lo = 0;
}

//Reset
if(Pin_SeriellerPin_Reset == 0)
{
SeriellerPin_Reset_Zaehler = 0;
}

if(SeriellerPin_Reset_Zaehler >= SeriellerPin_Prell_Zeit)
{
SeriellerPin_Reset = 1;
}
else
{
++ SeriellerPin_Reset_Zaehler;
SeriellerPin_Reset = 0;
}


} // Ende der Funktion Verz()
//----------------------------------------------------------------------------------


//----------------------------------------------------------------------------------
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


//Temperatur
if( EmpfaengerRegister[18] == 0) { TemperaturEmpfangen &= ~ 1 ; } // 0 setzen
else { TemperaturEmpfangen |= 1 ; } // 1 setzen

if( EmpfaengerRegister[19] == 0) { TemperaturEmpfangen &= ~ 2 ; } // 0 setzen
else { TemperaturEmpfangen |= 2 ; } // 1 setzen

if( EmpfaengerRegister[20] == 0) { TemperaturEmpfangen &= ~ 4 ; } // 0 setzen
else { TemperaturEmpfangen |= 4 ; } // 1 setzen

if( EmpfaengerRegister[21] == 0) { TemperaturEmpfangen &= ~ 8 ; } // 0 setzen
else { TemperaturEmpfangen |= 8 ; } // 1 setzen

if( EmpfaengerRegister[22] == 0) { TemperaturEmpfangen &= ~ 16 ; } // 0 setzen
else { TemperaturEmpfangen |= 16 ; } // 1 setzen

if( EmpfaengerRegister[23] == 0) { TemperaturEmpfangen &= ~ 32 ; } // 0 setzen
else { TemperaturEmpfangen |= 32 ; } // 1 setzen

if( EmpfaengerRegister[24] == 0) { TemperaturEmpfangen &= ~ 64 ; } // 0 setzen
else { TemperaturEmpfangen |= 64 ; } // 1 setzen

if( EmpfaengerRegister[25] == 0) { TemperaturEmpfangen &= ~ 128; } // 0 setzen
else { TemperaturEmpfangen |= 128; } // 1 setzen

if( EmpfaengerRegister[26] == 0) { TemperaturEmpfangen &= ~ 256; } // 0 setzen
else { TemperaturEmpfangen |= 256; } // 1 setzen

if( EmpfaengerRegister[27] == 0) { TemperaturEmpfangen &= ~ 512; } // 0 setzen
else { TemperaturEmpfangen |= 512; } // 1 setzen

//Bereit
if( EmpfaengerRegister[28] == 0) { SystemStatus &= ~ 1 ; } // 0 setzen
else { SystemStatus |= 1 ; } // 1 setzen

if( EmpfaengerRegister[29] == 0) { SystemStatus &= ~ 2 ; } // 0 setzen
else { SystemStatus |= 2 ; } // 1 setzen

//Teilungsfaktor
if( EmpfaengerRegister[30] == 0) { Teilingsfaktor &= ~ 1 ; } // 0 setzen
else { Teilingsfaktor |= 1 ; } // 1 setzen

if( EmpfaengerRegister[31] == 0) { Teilingsfaktor &= ~ 2 ; } // 0 setzen
else { Teilingsfaktor |= 2 ; } // 1 setzen

//Hellichkeit
if( EmpfaengerRegister[32] == 0) { Hellichkeit &= ~ 1 ; } // 0 setzen
else { Hellichkeit |= 1 ; } // 1 setzen

if( EmpfaengerRegister[33] == 0) { Hellichkeit &= ~ 2 ; } // 0 setzen
else { Hellichkeit |= 2 ; } // 1 setzen

if( EmpfaengerRegister[34] == 0) { Hellichkeit &= ~ 4 ; } // 0 setzen
else { Hellichkeit |= 4 ; } // 1 setzen

if( EmpfaengerRegister[35] == 0) { Hellichkeit &= ~ 8 ; } // 0 setzen
else { Hellichkeit |= 8 ; } // 1 setzen

//Auszug
if( EmpfaengerRegister[36] == 0) { Auszug &= ~ 1 ; } // 0 setzen
else { Auszug |= 1 ; } // 1 setzen

if( EmpfaengerRegister[37] == 0) { Auszug &= ~ 2 ; } // 0 setzen
else { Auszug |= 2 ; } // 1 setzen

//Sonderfunktionen
if( EmpfaengerRegister[38] == 0) { LAN_nicht_Verbunden &= ~ 1 ; } // 0 setzen
else { LAN_nicht_Verbunden |= 1 ; } // 1 setzen

if( EmpfaengerRegister[39] == 0) { Nullpunkt_festlegen &= ~ 1 ; } // 0 setzen
else { Nullpunkt_festlegen |= 1 ; } // 1 setzen

if( EmpfaengerRegister[40] == 0) { Temp_Ausgleich_EIN &= ~ 1 ; } // 0 setzen
else { Temp_Ausgleich_EIN |= 1 ; } // 1 setzen

if( EmpfaengerRegister[41] == 0) { Temp_Ausgleich_AUS &= ~ 1 ; } // 0 setzen
else { Temp_Ausgleich_AUS |= 1 ; } // 1 setzen

if( EmpfaengerRegister[42] == 0) { Joistik_EIN &= ~ 1 ; } // 0 setzen
else { Joistik_EIN |= 1 ; } // 1 setzen

if( EmpfaengerRegister[43] == 0) { Joistik_AUS &= ~ 1 ; } // 0 setzen
else { Joistik_AUS |= 1 ; } // 1 setzen

//FreieEmpfaengerFunktion
if( EmpfaengerRegister[44] == 0) { FreieEmpfaengerFunktion_1 &= ~ 1 ; } // 0 setzen
else { FreieEmpfaengerFunktion_1 |= 1 ; } // 1 setzen

if( EmpfaengerRegister[45] == 0) { FreieEmpfaengerFunktion_2 &= ~ 1 ; } // 0 setzen
else { FreieEmpfaengerFunktion_2 |= 1 ; } // 1 setzen

if( EmpfaengerRegister[46] == 0) { FreieEmpfaengerFunktion_3 &= ~ 1 ; } // 0 setzen
else { FreieEmpfaengerFunktion_3 |= 1 ; } // 1 setzen

//FreieEmpfaengerFunktion
if( EmpfaengerRegister[47] == 0) { SicherheitsBitsEmpfaenger &= ~ 1 ; } // 0 setzen
else { SicherheitsBitsEmpfaenger |= 1 ; } // 1 setzen

if( EmpfaengerRegister[48] == 0) { SicherheitsBitsEmpfaenger &= ~ 2 ; } // 0 setzen
else { SicherheitsBitsEmpfaenger |= 2 ; } // 1 setzen

if( EmpfaengerRegister[49] == 0) { SicherheitsBitsEmpfaenger &= ~ 4 ; } // 0 setzen
else { SicherheitsBitsEmpfaenger |= 4 ; } // 1 setzen

if( EmpfaengerRegister[50] == 0) { SicherheitsBitsEmpfaenger &= ~ 8 ; } // 0 setzen
else { SicherheitsBitsEmpfaenger |= 8 ; } // 1 setzen



}
//----------------------------------------------------------------------------------


//----------------------------------------------------------------------------------
void SerielleBitsZuordnenSender(void)
{

unsigned short PotiWert;

//Poti
if( (PotiWert & 1) == 0) { SenderBitRegister[1] = 0; }
else { SenderBitRegister[1] = 1; }

if( (PotiWert & 2) == 0) { SenderBitRegister[2] = 0; }
else { SenderBitRegister[2] = 1; }

if( (PotiWert & 4) == 0) { SenderBitRegister[3] = 0; }
else { SenderBitRegister[3] = 1; }

if( (PotiWert & 8) == 0) { SenderBitRegister[4] = 0; }
else { SenderBitRegister[4] = 1; }

if( (PotiWert & 16) == 0) { SenderBitRegister[5] = 0; }
else { SenderBitRegister[5] = 1; }

if( (PotiWert & 32) == 0) { SenderBitRegister[6] = 0; }
else { SenderBitRegister[6] = 1; }

if( (PotiWert & 64) == 0) { SenderBitRegister[7] = 0; }
else { SenderBitRegister[7] = 1; }

if( (PotiWert & 128) == 0) { SenderBitRegister[8] = 0; }
else { SenderBitRegister[8] = 1; }

//Temperatur
if( (Temperatur & 1) == 0) { SenderBitRegister[9] = 0; }
else { SenderBitRegister[9] = 1; }

if( (Temperatur & 2) == 0) { SenderBitRegister[10] = 0; }
else { SenderBitRegister[10] = 1; }

if( (Temperatur & 4) == 0) { SenderBitRegister[11] = 0; }
else { SenderBitRegister[11] = 1; }

if( (Temperatur & 8) == 0) { SenderBitRegister[12] = 0; }
else { SenderBitRegister[12] = 1; }

if( (Temperatur & 16) == 0) { SenderBitRegister[13] = 0; }
else { SenderBitRegister[13] = 1; }

if( (Temperatur & 32) == 0) { SenderBitRegister[14] = 0; }
else { SenderBitRegister[14] = 1; }

if( (Temperatur & 64) == 0) { SenderBitRegister[15] = 0; }
else { SenderBitRegister[15] = 1; }

if( (Temperatur & 128) == 0) { SenderBitRegister[16] = 0; }
else { SenderBitRegister[16] = 1; }

if( (Temperatur & 256) == 0) { SenderBitRegister[17] = 0; }
else { SenderBitRegister[17] = 1; }

if( (Temperatur & 512) == 0) { SenderBitRegister[18] = 0; }
else { SenderBitRegister[18] = 1; }

//Sicherheits Bits
{ SenderBitRegister[19] = 0; }
{ SenderBitRegister[20] = 1; }

}
//----------------------------------------------------------------------------------



//----------------------------------------------------------------------------------
void PodiEinlesenAuswerten(void)
{


uint16_t result = readADC(0); //Auslesen der analogen Spannungen an Pin 0,
// also ADC0. In result steht das Ergebnis.

PotiADWert = result;

if(result >= ad_wert_up_min)
{

ad_wert_up_Poti = result - ad_wert_up_min ;

prozent = (ad_wert_up_Poti * 100 / ad_wert_up_diff);

if(prozent > 100)
{ prozent = 100; }

}


if(result <= ad_wert_down_max)
{

ad_wert_down_Poti = ad_wert_down_max - result ;

prozent = (ad_wert_down_Poti * 100 / ad_wert_down_diff);

if(prozent > 100)
{ prozent = 100; }

prozent = 0 - prozent;

}


if((result > ad_wert_down_max)&&(result < ad_wert_up_min))
{
prozent = 0;
}



PotiProzent = prozent;


}
//----------------------------------------------------------------------------------


//----------------------------------------------------------------------------------
void DisplayHellichkeut(void)
{

//Hellichkeit festlegen
//Wenn sich Hellichkeit geändert hat,

if(Hellichkeit_Merker != Hellichkeit)
{

UART_SendByte(0x1b); // ESC
UART_SendByte('L'); // Helligkeitssteuerung

//Wenn Hellichkeit ist 0
if(Hellichkeit == 0)
{
UART_SendByte(0x00); // 30% Helligkeit
}

if(Hellichkeit == 1)
{
UART_SendByte(0x00); // 30% Helligkeit
}

if(Hellichkeit == 2)
{
UART_SendByte(0x40); // 50% Helligkeit
}

if(Hellichkeit == 3)
{
UART_SendByte(0x80); // 75% Helligkeit
}

if(Hellichkeit == 4)
{
UART_SendByte(0xC0); // 100% Helligkeit
}

Hellichkeit_Merker = Hellichkeit;
}



}
//----------------------------------------------------------------------------------


//----------------------------------------------------------------------------------
void messagenumberSetzen(void)
{
//LAN_nichtVerbunden
if((LAN_nicht_Verbunden_Merker == 0)&&(LAN_nicht_Verbunden == 1))
{ messagenumber = 1; }

//Nullpunktfestlegen
if((Nullpunkt_festlegen_Merker == 0)&&(Nullpunkt_festlegen == 1))
{ messagenumber = 2; }

//TempAusgleichEIN
if((Temp_Ausgleich_EIN_Merker == 0)&&(Temp_Ausgleich_EIN == 1))
{ messagenumber = 3; }

//TempAusgleichAUS
if((Temp_Ausgleich_AUS_Merker == 0)&&(Temp_Ausgleich_AUS == 1))
{ messagenumber = 4; }

//JoistikEIN
if((Joistik_EIN_Merker == 0)&&(Joistik_EIN == 1))
{ messagenumber = 5; }

//JoistikAUS
if((Joistik_AUS_Merker == 0)&&(Joistik_AUS == 1))
{ messagenumber = 6; }

//Hellichkeit0
if((Hellichkeit_0_Merker == 0)&&(Hellichkeit_0 == 1))
{ messagenumber = 7; }

//Hellichkeit30
if((Hellichkeit_30_Merker == 0)&&(Hellichkeit_30 == 1))
{ messagenumber = 8; }

//Hellichkeit50
if((Hellichkeit_50_Merker == 0)&&(Hellichkeit_50 == 1))
{ messagenumber = 9; }

//Hellichkeit75
if((Hellichkeit_75_Merker == 0)&&(Hellichkeit_75 == 1))
{ messagenumber = 10; }

//Hellichkeit100
if((Hellichkeit_100_Merker == 0)&&(Hellichkeit_100 == 1))
{ messagenumber = 11; }


LAN_nicht_Verbunden_Merker = LAN_nicht_Verbunden ;
Nullpunkt_festlegen_Merker = Nullpunkt_festlegen ;
Temp_Ausgleich_EIN_Merker = Temp_Ausgleich_EIN ;
Temp_Ausgleich_AUS_Merker = Temp_Ausgleich_AUS ;
Joistik_EIN_Merker = Joistik_EIN ;
Joistik_AUS_Merker = Joistik_AUS ;
Hellichkeit_0_Merker = Hellichkeit_0 ;
Hellichkeit_30_Merker = Hellichkeit_30 ;
Hellichkeit_50_Merker = Hellichkeit_50 ;
Hellichkeit_75_Merker = Hellichkeit_75 ;
Hellichkeit_100_Merker = Hellichkeit_100 ;

}
//----------------------------------------------------------------------------------


//----------------------------------------------------------------------------------
void SystemStatusSetzen(void)
{

sprintf(messageSystemStatus, "\r%6d_%5d_%4d_OK", AuszugWert, Temperatur, Teilingsfaktor);

}
//----------------------------------------------------------------------------------


//----------------------------------------------------------------------------------
void DisplayAusgabe(void)
{


SystemStatusSetzen ();


DisplayHellichkeut ();


messagenumberSetzen ();


if(messagenumber != messagenumberMerker)
{
messagenumberMerker = messagenumber;

//Display Programmieren
UART_PrintfProgStr (messages[messagenumber]);

InfoAnzeige_Zaehler = InfoAnzeigeLaenge;
}



if(InfoAnzeige_Zaehler == 0)
{

if(Hellichkeit != 0)
{

UART_PrintfProgStr (messageSystemStatus);
}
else
{
UART_PrintfProgStr (messages[0]);
}

}
else
{
-- InfoAnzeige_Zaehler;
}

}
//----------------------------------------------------------------------------------



//################################################## #################################
//############### Funktion Main ################################################## ###
//################################################## #################################

int main (void)
{

Init ();
ioinit ();
UART_Init ();



Verz (100000);

//Poti Nullen
uint16_t result = readADC(0); //Auslesen der analogen Spannungen an Pin 0,
// also ADC0. In result steht das Ergebnis.

ad_wert_zero = result;
ad_wert_up_min = ad_wert_zero + 3;
ad_wert_down_max = ad_wert_zero - 3;
ad_wert_up_diff = ad_wert_up_max - ad_wert_up_min ;
ad_wert_down_diff = ad_wert_down_max - ad_wert_down_min ;



for(;;)// Endlosschleife, wird zwischen den geschweiften Klammern immer wieder durchlaufen

{

if((FertigSender == 1)&&(FertigEmpfaenger == 1)&&(FertigTemperatur == 1))
{

//Ports Einlesen
PortsSetzenEinlesen ();

//Poti
//Poti Auswerten
PodiEinlesenAuswerten ();

//Netzwerk
//Netzwerk Entprellen (Abfallverzögert)
NetzwerkPinsEntprellen();

//Netzwerk Register setzen
SerielleBitsZuordnenEmpfaenger ();
SerielleBitsZuordnenSender ();


//VFDisplay
DisplayAusgabe ();



FertigSender = 1;
FertigEmpfaenger = 0;
FertigTemperatur = 1;

//Empfänger verriegeln für min.2x Empfangen um halbe auszuschließen
EmpfaengerRiegelReset = 0;

}
else
{

//Ports Einlesen
PortsSetzenEinlesen ();

//Netzwerk
//Netzwerk Entprellen (Abfallverzögert)
NetzwerkPinsEntprellen();

//Senden
SeriellesNetzwerkEmpfaenger ();

//Empfangen
SeriellesNetzwerkSender ();

//Empfangen Temperatur
TemperaturSeriellEinlesen ();
}

}
return 0;
}

Das ist das ganze Programm in 3 Teile Zerlegt.
Ist bestimmt nicht Speichersparent programmiert, aber ich kanns leider noch nicht besser.

Vieleichthat jemand ne idee, wie ich etwas Platz im Programmspeicher einsparen kann.

hi,
nimm doch einfach nen mega16, dann hast du no gut platz.
mfg jeffrey

Hallo, ja danke für den tip, aber ich brauche die gleiche pinbelegung im Dill 20 gehäuse!

Is der Mega168 nicht auch Pinkompatibel?

Genau Mega168.

Kompilierst Du mit -Os -mcall_prologues ?

*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.

-3- Du zerlegst ständig Bytes in Bits und setzt die wieder zusammen. Wozu? Das brauchst du nicht. Überleg dir mal, daß du die ganze Umformatiererei sparen kannst! Das spart
-- Programmierzeit
-- Fehleranfälligkeit
-- Laufzeit
-- Programmspeicher
-- Nerven
-- Hirnschmalz

Also, wie müsste es aussehen??? Ich will dir hier janicht alles vorkauen *g*.

Mit den Stil von oben hast du nem mega168 auch ruck-zuck den Flash geplatzt.

Oha, also das würde ich selbst auf einem PC schon fast als verschwenderisch bezeichnen ;-)

Das wichtigste wurde schon gesagt:
- pack alle sich ständig wiederholenden Befehle in Schleifen
- Umformatierungen sollten nur dann nötig sein, wenn man z.B. Daten mit externer Hardware austauschen, oder Funktionen verwenden will die man nicht selbst geschrieben hat.

Außerdem solltest du mal schauen ob du nicht auf printf verzichten kannst, denn wie dir ja bereits aufgefallen ist braucht das Ding wahnsinnig viel Platz. (das gleiche gilt für scanf) Falls du die Funktion aber wirklich brauchst, nimm wenigstens die Sparversion(bei WinAVR kann man zwischen unterschiedlichen Varianten wählen)