Seltsame Ergebnisse durch Multiplikation von uint16_t Variable mit einer Nummer

Question

Ich habe ein sehr einfaches Stück C-Code, der mir seltsame Ergebnisse gibt. Ich entwickle eine einfache drahtlose Sensornetzwerkanwendung für Micaz motes. Es scheint ATmega128L 8-Bit-AVR-Mikroprozessoren zu haben. Ich benutze AVR Studio, um den Code zu schreiben und zu kompilieren.

uint16_t myvariable; 
uint16_t myresult; 
myresult = myvariable*256; 

Wenn myvariable 3 ist, fand ich MyResult immer auf 512. zurückgesetzt habe mich nur gefragt, warum es so funktioniert. Meine Vermutung ist, dass die Mischung aus einer solchen wörtlichen Zahl 256 und uint16_t das Problem magisch verursacht. Aber ich weiß nicht warum. Kann jemand dazu eine detaillierte Erklärung geben? Schätze für jede Hilfe!

Ausführlicherer Quellcode ist wie folgt.

static uint16_t myvariable[2]; 
static uint8_t AckMsg[32]; 
uint16_t myresult[MAX_SENDERS]; 

void protocol() 
{   
    if(thisnodeid != 5){ // sender nodes 
     while (1) 
     {   
     if(AckReceived && !MsgSent) { 
      // If ACK received and a new message not sent yet, 
      // send a new message on sending node. 
     } 

     else if(!AckReceived && MsgSent) 
     { 
      lib_radio_receive_timed(16, 32, AckMsg, 120); 
      myvariable[0] = AckMsg[0]; 
      myvariable[1] = AckMsg[1]; 
      // Bug!!!, variable overflowed. 
      myresult[thisnodeid] = 256*myvariable[1] + myvariable[0]; 
     } 

     } 
    }   

} 

Was ich wirklich herauszufinden wollen, ist, wie der Compiler folgende Codezeile kompiliert, weil ich es ist diese Zeile Code kennen, den Fehler verursacht. Vielen Dank im Voraus für jede Information!

myresult[thisnodeid] = 256*myvariable[1] + myvariable[0]; 

Wenn myvariable [1] = 3, myvariable [0] = 0, I MyResult immer [get] = 512. Sieht aus 768 zurückgesetzt wird immer auf 512. einfach nicht wissen, warum.

Answer 1

ich diesen Code versucht, ohne Probleme auf einem Standardsystem:

#include <stdio.h> 
#include <string.h> 
#include <stdint.h> 
#define MAX_SENDERS 10 
static uint16_t myvariable[2]; 
static uint8_t AckMsg[32]; 
uint16_t myresult[MAX_SENDERS]; 
main() 
{ 
    AckMsg[0] = 0; 
    AckMsg[1] = 3; 
    myvariable[0] = AckMsg[0]; 
    myvariable[1] = AckMsg[1]; 
    myresult[0] = 256*myvariable[1] + myvariable[0]; 
    printf("%d", (int)myresult[0]); 
} 

So Sie Code zu debuggen, versuchen Sie sollten die Linien zu ersetzen:

myvariable[0] = AckMsg[0]; 
myvariable[1] = AckMsg[1]; 
// Bug!!!, variable overflowed. 
myresult[thisnodeid] = 256*myvariable[1] + myvariable[0]; 

von:

uint16_t tmp; 
myvariable[0] = AckMsg[0]; 
myvariable[1] = AckMsg[1]; 
tmp = 256*myvariable[1] + myvariable[0]; 
myresult[thisnodeid] = 256*myvariable[1] + myvariable[0]; 
printf("%d %d\n", (int)(AckMsg[0]), (int)(AckMsg[1])); 
printf("%d %d\n", (int)(thisnodeid), (int)(MAX_SENDERS)); 
printf("%d %d\n", (int)(myvariable[0]), (int)(myvariable[1])); 
printf("%d %d\n", (int)(tmp), (int)(myresult[thisnodeid])); 

Dies kann nützliche Informationen über den Ursprung des Problems bringen.

Wenn Sie etwas nicht in Sie Debugger drucken können, können Sie das Folgende versuchen:

uint16_t i = 0; 
uint16_t n = 255; 
myresult[thisnodeid] += myvariable[1]; 
while (i != n) { 
    myresult[thisnodeid] += myvariable[1]; 
    i += 1; 
} 
myresult[thisnodeid] += myvariable[0]; 

Es wird langsam sein, aber es kann Ihnen erlauben, zu erkennen, wo die overlow tatsächlich geschieht, weil die einzige Variable, wird größer als 255 ist myresult.