4. Variable Hexzahlen übergeben

Variable Hexzahlen übergeben

  • J

    Hallo,

    ich bin C Anfänger und möchte mit der u. g. Routine eine max. 9 Byte lange Hexzahl übergeben. Der u.g. Weg ist aber immer sehr aufwendig, gibt es keine kürzere schreibweise?

    "Beispiel:" SendMessage(2, ID, 0x08207A0982000000);

    ID = 0x6C2;					
Send_Data[0]=0x08;
Send_Data[1]=0x20;
Send_Data[2]=0x7A;
Send_Data[3]=0x09;
Send_Data[4]=0x82;
Send_Data[5]=0x00;
Send_Data[6]=0x00;
Send_Data[7]=0x00;
Send_Data[8]=0x00;
SendMessage(2, ID, &Send_Data[0]);

    Hat jemand da nen Tipp für mich?

    Gruß
    Jackson

    0
  • ?
     

    char* s = "08207A0982000000";
    0
  • ?

    char nine_byte_buffer[9*2+2] = {0}; // +2: ein Zeichen für \0 und eins für \n

    0
  • ?
     

    SendMessage(2, ID, "\x08\x20\x7A\x09\x82\x00\x00\x00\x00");
    0
  • J

    Erstmal Danke für die Antworten.

    Das einzigste was bis jetzt funktioniert hat war

    SendMessage(2, ID, "\x08\x20\x7A\x09\x82\x00\x00\x00\x00");

    Ich programmiere einen Mikrocontroller in C kein c++

    Ich muss aber noch einen Wert modifizieren:

    ID = 0x6C2;                 
Send_Data[0]=0x08;
Send_Data[1]=0x20+Counter;
Send_Data[2]=0x7A;
Send_Data[3]=0x09;
Send_Data[4]=0x82;
Send_Data[5]=0x00;
Send_Data[6]=0x00;
Send_Data[7]=0x00;
Send_Data[8]=0x00;
SendMessage(2, ID, &Send_Data[0]);

    SendMessage(2, ID, "\x08\x20"+Counter"\x7A\x09\x82\x00\x00\x00\x00");

    funktioniert natürlich nicht, wie ist der richtige Syntax?

    0

  • Mal abgesehen davon, dass du hier keine "Hexzahl" übergibst sondern einen Zeiger auf ein Stringliteral-Objekt bzw. einen Zeiger auf das 1. Element eines char-Arrays:

    {
  char Send_Data[10]={0x08,0x20+Counter,0x7A,0x09,0x82};
  SendMessage(2, ID, Send_Data);
}

    Die "Rest"-Elemente werden immer genullt bei Initialisierungen, d.h. die brauchst du nicht vorzugeben, das macht der Compiler für dich.

    0
  • J

    Hallo Wutz,

    Ich möchte mehrere verschiedene Botschaften hintereinander senden habe in der Funktion als erstes

    void Funktion()
{
volatile unsigned int ID;
volatile unsigned char Send_Data[9];

ID = 0x6C2;                 
Send_Data[0]=0x08;
Send_Data[1]=0x20+Counter;
Send_Data[2]=0x7A;
Send_Data[3]=0x09;
Send_Data[4]=0x82;
Send_Data[5]=0x00;
Send_Data[6]=0x00;
Send_Data[7]=0x00;
Send_Data[8]=0x00;
SendMessage(2, ID, &Send_Data[0]);

ID = 0x6C2;                 
Send_Data[0]=0x08;
Send_Data[1]=0x20+Counter;
Send_Data[2]=0x11;
Send_Data[3]=0x22;
Send_Data[4]=0x33;
Send_Data[5]=0x44;
Send_Data[6]=0x55;
Send_Data[7]=0x66;
Send_Data[8]=0x77;
SendMessage(2, ID, &Send_Data[0]);
}

    Funktioniert

    void Funktion()
{
volatile unsigned int ID;
volatile unsigned char Send_Data[9];

ID = 0x6C2;                 
Send_Data[9]={0x08,0x20+Counter,0x11,0x7A,0x09,0x82};
SendMessage(2, ID, Send_Data);

ID = 0x6C2;                 
Send_Data[9]={0x08,0x20+Counter,0x11,0x22,0x33,0x44,0x55,0x66,0x77};
SendMessage(2, ID, Send_Data);

}

    geht irgenwie nicht, compiler sagt Fehler:
    *** ../src/MAIN.c(1675) E4029B: expected an expression
    *** ../src/MAIN.c(1675) E4137B: expression must be a modifiable lvalue

    Wenn ich char ... später in der Funktion schreibe kommt immer Fehler:

    declaration may not appear after executable statement in block

    0
  • S

    Klammern prüfen!

    0
  • J

    Klammer war nur ein Tippfehler, geht trozdem nicht.

    0
  • S

    du sollst initialisieren ... Schau nochmal genau hin, das ist nicht das selbe wie das was Wutz vorgeschlagen hat.

    0

  • Deshalb habe ich im o.g. Beispiel explizit die Klammerung vorgegeben, also nicht

    void Funktion()
{
volatile unsigned int ID;
volatile unsigned char Send_Data[9];

ID = 0x6C2;                
Send_Data[9]={0x08,0x20+Counter,0x11,0x7A,0x09,0x82};
SendMessage(2, ID, Send_Data);

ID = 0x6C2;                
Send_Data[9]={0x08,0x20+Counter,0x11,0x22,0x33,0x44,0x55,0x66,0x77};
SendMessage(2, ID, Send_Data);

}

    sondern

    void Funktion()
{
volatile unsigned int ID;

ID = 0x6C2;
{                
unsigned char Send_Data[9]={0x08,0x20+Counter,0x11,0x7A,0x09,0x82};
SendMessage(2, ID, Send_Data);
}
ID = 0x6C2;
{                
unsigned char Send_Data[9]=0x08,0x20+Counter,0x11,0x22,0x33,0x44,0x55,0x66,0x77};
SendMessage(2, ID, Send_Data);
}
}

    also bei jedem Aufruf eine Neudefinition des Arrays mit entsprechender Initialisierung.

    0
  • D
     

    Send_Data[9]={0x08,0x20+Counter,0x11,0x22,0x33,0x44,0x55,0x66,0x77};

    1. Diese Schreibeweise geht nur bei der Initialisierung !
    2. Selbst wenn du der Variable danach so etwas zuweisen könntest wäre das "[9]" zuviel.

    0
  • J

    Wenn ich das genau so wie Wutz schreibe kommt Fehler:

    E4028B: expression must have a constant value

    {
  unsigned char Send_Data[10]={0x08,0x20+Counter,0x7A,0x09,0x82};
  SendMessage(2, ID, Send_Data);
}

    Ich möchte dieser Variable dann später in der Funktion verschiedene Werte zuweisen also eine feste 1x INIT würde mir nichts nützen...

    0
  • ?

    Die Wertezuweisung bei einem Array geht nur bei der Definition.

    Der Fehler kommt wegen +counter.

    unsigned char Send_Data_org[9] = {0x08,0x20,0x11,0x7A,0x09,0x82}; 
volatile unsigned char Send_Data[9];
...
memcpy(Send_Data,Send_Data_org, sizeof(Send_Data_org));  // Werte kopieren
Send_Data[1] = 0x20+Counter;                             // Wert  ändern
SendMessage(2, ID, Send_Data);

    Wenn dir das mit dem memcpy zu aufwändig erscheint, soltest du bedenken, das der Compiler letztendlich auch nichts anders machen würde, wenn Send_Data = Send_Data_org klappen würde.

    0

  • Dann verhält sich dein Compiler hier nicht standardkonform, der C Standard schreibt nur für static spezifizierte Variablen const-Initialisierer vor.
    Nimm einen anderen Compiler und es wird laufen, vielleicht kann man deinen Compiler hier auch irgendwie austricksen,

    char Send_Data[10]={0x08,(1,0x20+Counter),0x7A,0x09,0x82};
    0
  • R

    Jackson0 schrieb:

    Ich möchte dieser Variable dann später in der Funktion verschiedene Werte zuweisen also eine feste 1x INIT würde mir nichts nützen...

    Bei Mikrocontroller ist es meist nicht ratsam, die Standardbibliothek zu benutzen oder mit Konstanten um sich zu werfen. Mir fällt da nur ein, die Blockzuweisung auszulagern:

    inline void Assign_Send_Data ( unsigned char* A,
                               unsigned char b0,
                               unsigned char b1,
                               unsigned char b2,
                               unsigned char b3,
                               unsigned char b4,
                               unsigned char b5,
                               unsigned char b6,
                               unsigned char b7,
                               unsigned char b8,
                               unsigned char b9 )
{
    A[0] = b0;
    A[1] = b1;
    A[2] = b2;
    A[3] = b3;
    A[4] = b4;
    A[5] = b5;
    A[6] = b6;
    A[7] = b7;
    A[8] = b8;
    A[9] = b9;
}

void Funktion ()
{   ...
    Assign_Send_Data (Send_Data,0x08,0x20+Counter,0x7A,0x09,0x82,0,0,0,0,0);
    SendMessage(2, ID, Send_Data);
    Assign_Send_Data (Send_Data,0x08,0x20+Counter,0x11,0x22,0x33,0x44,0x55,0x66,0x77,0);
    Send_Data[1] += 1;
    SendMessage(2, ID, Send_Data);
    ...
}

    viele grüße
    ralph

    0
  • ?

    memcpy ist wirklich eine kleine Funktion.
    Und Konstanten kannst du im Flash ablegen.
    Irgendwo müssen die Werte im Code untergebracht werden.

    0

  • Es geht natürlich auch einfach:

    void Funktion()
{
volatile unsigned int ID;

ID = 0x6C2;
{                
unsigned char Send_Data[9]={0x08,0x20,0x11,0x7A,0x09,0x82};
Send_Data[1]+=Counter;
SendMessage(2, ID, Send_Data);
}
ID = 0x6C2;
{                
unsigned char Send_Data[9]=0x08,0x20,0x11,0x22,0x33,0x44,0x55,0x66,0x77};
Send_Data[1]+=Counter;
SendMessage(2, ID, Send_Data);
}
}
    0
Anmelden zum Antworten