Programm doppelt so groß bei uart ausgabe anderer variable, gleichen types

[Johannes (Gast)]

Hallo,
ich habe mir ein Programm geschrieben, wo ich ein paar sachen berechnen 
möchte. Die Ergebnisse möchte ich mir am anfang noch über uart ausgeben, 
um zu kontrollieren, ob es richtig ist.

int main(void)
{
    setup();
    uint8_t n = 0; /* counter for loops */
    uint8_t m = 0; /* counter for loops */
    uint8_t input[4] = {1, 0, 0, 0};
    uint8_t output[4] = {0, 0, 0, 0};
    uint16_t netHidden[4] = {0, 0, 0, 0};
    uint16_t outHidden[4] = {0, 0, 0, 0};
    uint16_t netOut[4] = {0, 0, 0, 0};
    uint16_t outOut[4] = {0, 0, 0, 0};   
    uint16_t weightInputHidden[4][4] = {{755, 314, 245, 984},
                                        {233, 10, 1, 347},
                                        {645, 346, 642, 222},
                                        {987, 342, 234, 356},};
    uint16_t weightHiddenOut[4][4] = {{435, 536, 757, 72},
                                      {768, 357, 13, 3},
                                      {981, 234, 757, 452},
                                      {235, 10, 241, 342},};
    float tempValue = 0.0;

     
    sei(); /* enable Interrupt */
    
    uint8_t uartOutput = 1; /* usart output */
    while (1) 
    {
        if(state == STATE_TRAINING){
            /* calculate netHidden */
            for(n=0; n<4; n++){
                for(m=0; m<4; m++){
                    netHidden[n] = netHidden[n] + (input[m] * weightInputHidden[n][m]);
                }
            }
            /* calculate outHidden */
            for (n = 0; n < 4; n++) {
                tempValue = netHidden[n] / 1000.0;
                tempValue = 1 / (1 + exp(tempValue * (-1)));
                outHidden[n] = tempValue * 1000;
            }
...
...

            if(uartOutput ==1)
            {
                for (unsigned int n = 0; n < 4; n++) {
                    usartTransmit(netHidden[n]);
                    usartTransmit(0x0A);
                }
                uartOutput =2;
                usartTransmit(0x0A);
            }
...
}



void usartTransmit( uint16_t value  )
{
    if(0x0A == value){
        while ( !( UCSRA & (1<<UDRE)) );/* Wait for empty transmit buffer */
        UDR = value & 0xFF; /* Put data into buffer, sends the lower 8 bite */
    }
    else{
        while ( !( UCSRA & (1<<UDRE)) );/* Wait for empty transmit buffer */
        UDR = value>>8; /* Put data into buffer, sends the upper 8 bite */
        while ( !( UCSRA & (1<<UDRE)) );/* Wait for empty transmit buffer */
        UDR = value & 0xFF; /* Put data into buffer, sends the lower 8 bite */
    }
}

Es geht insbesondere um die Zeile
usartTransmit(netHidden[n]);

Wenn ich mir die Variable netHidden ausgebe, ist das Programm 938 bytes 
groß. Wenn ich allerdings die Variable outHidden an der stelle ausgeben 
lasse, ist das Programm 2518 bytes groß. Wieso ist das so? Ich berechne 
ja zwischendrinn
outHidden[n] = tempValue * 1000;
wobei tempValue ein float ist. Aber bleibt outHidden nicht trotzdem ein 
uint16_t und schneidet alles andere ab?

Wenn nicht, was muss ich machen, damit es ein uint16_t bleibt?


Johannes

[Hmmm (Gast)]

Johannes schrieb:
> Wenn ich allerdings die Variable outHidden an der stelle ausgeben lasse,
> ist das Programm 2518 bytes groß. Wieso ist das so?

Am besten mal den Output angucken.

Vermutlich optimiert der Compiler die Berechnungen weg, wenn die 
Ergebnisse nicht verwendet werden.

[John (Gast)]

Wenn ich dich richtig verstanden habe, verwendest du in der Version, die 
ein kurzes "Programm" erzeugt, outHidden nicht. Damit können die float 
operationen weg optimiert werden, weil tempValue auch nicht verwendet 
wird. Da wird der Compiler die Float Operationen nicht einbinden, was 
sehr viel Platz einspart.

[Peter (Gast)]

outHidden als volatile deklarieren, dann wird es nicht wegoptimiert.