-         

Seite 1 von 2 12 LetzteLetzte
Ergebnis 1 bis 10 von 12

Thema: Hilfe Programmspeicher voll!

  1. #1
    jojo.glaser
    Gast

    Hilfe Programmspeicher voll!

    Anzeige

    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.

  2. #2
    jojo.glaser
    Gast
    #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()
    //----------------------------------------------------------------------------------

  3. #3
    jojo.glaser
    Gast
    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>> ;
    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>>;
    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 & 12 == 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 & == 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;
    }

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

  4. #4
    jojo.glaser
    Gast
    //----------------------------------------------------------------------------------
    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 & == 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 & 12 == 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 & == 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 & 12 == 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;
    }

  5. #5
    jojo.glaser
    Gast
    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.

  6. #6
    Erfahrener Benutzer Roboter Experte
    Registriert seit
    13.07.2004
    Ort
    bei Stuttgart
    Alter
    35
    Beiträge
    760
    hi,
    nimm doch einfach nen mega16, dann hast du no gut platz.
    mfg jeffrey

  7. #7
    jojo.glaser
    Gast

    AW

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

  8. #8
    Erfahrener Benutzer Robotik Einstein Avatar von squelver
    Registriert seit
    20.07.2006
    Ort
    Hoykenkamp
    Alter
    37
    Beiträge
    2.474
    Is der Mega168 nicht auch Pinkompatibel?
    * Da geht noch was *

  9. #9
    Erfahrener Benutzer Roboter Genie
    Registriert seit
    21.10.2005
    Ort
    Erde
    Alter
    50
    Beiträge
    1.195
    Genau Mega168.

    Kompilierst Du mit -Os -mcall_prologues ?

  10. #10
    Erfahrener Benutzer Robotik Einstein Avatar von SprinterSB
    Registriert seit
    09.06.2005
    Ort
    An der Saar
    Beiträge
    2.801
    *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.
    Disclaimer: none. Sue me.

Seite 1 von 2 12 LetzteLetzte

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •