ASCI Low Byte + High Byte zu char umrechnen

[Sunny (Gast)]

Hallo Gemeinde,

ich stehe gerade irgendwie auf dem Schlauch...

In einer Modbus-Anwendung wird der HEX Wert in Form von ASCI Zeichen 
übertragen....

Beispiel:

unsigned char zeichen = 0x48;

wird übertragen  als ['4','8'].

Wenn ich das Modbus Telegram nun wieder einlese, möchte diese beiden 
Bytes wieder zu einem 0x48 umwandeln... aber wie?

Kann mir vielleicht jemand auf die Sprünge helfen?

LG, sunny

[g457 (Gast)]

> Kann mir vielleicht jemand auf die Sprünge helfen?

man strtol. Kann man aber auch als Dreizeiler selber implementieren.

[Karl M. (Gast)]

Hallo,

ziehen jeweils von jedem Zeichen der Dezimalwert von '0' ab und addiere 
die Ziffer mit ihrer Wertigkeit und addiere sie.
Zahl a = 10^1*a1 + 10^0*a0

Jede dezimal Zahl x lässt sich auf diese Art und Weise auf Basis von 
*10^n* darstellen!

[Karl M. (Gast)]

Sorry,

die Basis in deiner Zahlendarstellung ist natürlich 16, also ersetze 
bitte 10^n durch 16^n.

[Joe F. (easylife)]

Karl M. schrieb:
> ziehen jeweils von jedem Zeichen der Dezimalwert von '0' ab

Gibt dann natürlich auch noch a-f und/oder A-F...

[Sunny (Gast)]

Hey,

vielen Dank für eure Antworten.
Ich habe das mal ausprobiert und erhalte leider nicht das Ergebnis, was 
ich erhofft habe.

Was mache ich denn wohl falsch?

#include <stdio.h>


int main(void) {

        unsigned char vergleich = 0x48;
        unsigned char modbus[] = {'4','8'};

        modbus[0] -= '0';
        modbus[1] -= '0';

        unsigned char wert = 16^1 * modbus[0] + 16^0 * modbus[1];

        printf("vergleich = %d\n", vergleich);
        printf("     wert = %d\n", wert);

        return(0);
}

Ausgabe:

vergleich = 72
     wert = 4

[Joe F. (easylife)]

^ ist XOR

#include <stdint.h>
#include <stdio.h>

uint32_t hex2bin(char *str, uint8_t digits)
{
  uint32_t val = 0;
  int      i;
  
  for (i=0; i<digits; i++)
  {
    val <<= 4;
    
    if (*str >= 'A')
      val |= *str - 'A' + 10;
    else if (*str >= 'a')
      val |= *str - 'a' + 10;
    else
      val |= *str - '0';
      
    str++;
  }
  return val;
}      
  
  

int main(void) 
{
        unsigned char vergleich = 0xba;
        char          modbus[] = {'b','A'};
        
        unsigned char wert = hex2bin(modbus, 2);

        printf("vergleich = %d\n", vergleich);
        printf("     wert = %d\n", wert);

        return(0);
}

Funktioniert bis 32-bittige Werte (8 digits), und sowohl für Groß- als 
auch Kleinschreibung.
Großartige Plausibilitätsprüfung wird zugunsten der Perfomance nicht 
gemacht.
"G7" ergäbe natürlich Unsinn.

[Wolfgang (Gast)]

Sunny schrieb:
> Ich habe das mal ausprobiert und erhalte leider nicht das Ergebnis, was
> ich erhofft habe.

Guck dir mal als Grundlage in einer ASCII-Tabelle die Werte der Ziffern 
'0'..'9' und die der Buchstaben 'A'..'F' bzw. 'a'..'f' an.

Die Umwandlung Klein- nach Großbuchstaben kann man einfach durch 
Maskierung des 0x20-Bits machen, ganz ohne große Fallunterscheidung.

Aus

Joe F. schrieb:
> if (*str >= 'A')
>       val |= *str - 'A' + 10;
>     else if (*str >= 'a')
>       val |= *str - 'a' + 10;

wird dann

if (*str >= 'A')
    val |= (*str & ~0x20) - 'A' + 10;

[Rufus Τ. F. (rufus)]

Wolfgang schrieb:
> Die Umwandlung Klein- nach Großbuchstaben kann man einfach durch
> Maskierung des 0x20-Bits machen, ganz ohne große Fallunterscheidung.

Dafür gibt es in der C-Umgebung auch die Macros tolower und toupper.

[Joe F. (easylife)]

Rufus Τ. F. schrieb:
> die Macros tolower und toupper

Bin gar nicht sicher, ob das wirklich Macros sind.
Schneller als ein if() werden die auch nicht sein, und im ungünstigsten 
Fall knallen die eine ziemlich große Lookuptable in die Firmware.

Hatte allerdings noch einen Fehler in hex2bin, denn 'a'-'z' hat höhere 
Ascii Werte als 'A'-'Z'.

Wolfgang schlug ein schnelles toupper() vor, genauso einfach wäre dann 
ein tolower(), indem man das 6. Bit auf 1 zwingt.

uint32_t hex2bin(char *str, uint8_t digits)
{
  uint32_t val = 0;
  int      i;
  
  for (i=0; i<digits; i++)
  {
    val <<= 4;
    
    if (*str <= '9')
      val |= *str - '0';
    else
      val |= (*str | 0x20) - 'a' + 10;
      
    str++;
  }
  return val;
}

[fop (Gast)]

Sunny schrieb:
> unsigned char wert = 16^1 * modbus[0] + 16^0 * modbus[1];

Hier klafft die Schreibweise von Basic und C auseinander. Der Dir den 
Vorschlag gemacht hat, meinte 16 hoch 1 also. In Basic schreibt man das 
auch 16^1. In C bedeutet ^ jedoch bitweises exklusiv oder.
  0
16  = 1

  1
16  = 16

16 exklusiv oder 0 = 16
16 exklusiv oder 1 = 17
das ergibt natürlich nur Grütze.

unsigned char wert = 16 * modbus[0] + modbus[1];

Denke ich, kann man schreiben, ohne es so stark vereinfacht zu haben, 
dass es niemand mehr nachvollziehen kann.

[Sunny (Gast)]

Hallo zusammen,

vielen Dank für eure Antworten.

Da ich Kleinbuchstaben im Telegramm nicht erhalte, habe ich mir nun mit 
Eurer Hilfe folgende Funktion geschrieben:

#include <stdio.h>

unsigned char chr2val(unsigned char);

int main(void) {

        unsigned char vergleich = 0xFF;
        unsigned char modbus[] = {'F','F'};

        unsigned char wert = chr2val(modbus[0]) * 16 + chr2val(modbus[1]);

        printf("vergleich = %d\n", vergleich);
        printf("     wert = %d\n", wert);
        return(0);
}

unsigned char chr2val(unsigned char c) {

    if (c >= '0' && c <= '9')
        return(c - '0');

    if (c >= 'A' && c <= 'F')
        return(10 + c - 'A');

    return(0);
}

Damit funktioniert das Vergleichen der Werte prima.

Besten Dank nochmal - Sunny

[Wolfgang (Gast)]

Sunny schrieb:
> Damit funktioniert das Vergleichen der Werte prima.

Was bringen dir die ganzen Vergleiche?

Wenn die Daten ok sind, kommen keine anderen Zeichen vor und wenn die 
Daten nicht ok sind, gibst du fehlerhafte Daten aus deiner Funktion 
zurück, ohne es zu merken. Wenn du schon die anderen Fälle aussortierst, 
sollte ein Fehlerzähler hochlaufen, damit man merkt, dass die 
zurückgegebenen 0-en falsch sind. Oder ist in deinen Modbustelegrammen 
ausgeschlossen, dass der Fehlerwert 0 auch als übertragene "0" vorkommt?

[Joe F. (easylife)]

Sunny schrieb:
> Da ich Kleinbuchstaben im Telegramm nicht erhalte

Na, dann hätte ich noch diesen Vorschlag für ein Macro mit einer 
Lookup-Table.
Da zwischen Zahlen und Großbuchstaben nur 7 Zeichen liegen, ist die 
Speicherplatzverschwendung vernachlässigbar.

#include <stdio.h>
#include <stdint.h>

const uint8_t h2b_lookup[] = 
{ 
  0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F 
};

#define hex2bin(str) (h2b_lookup[str[0]-'0'] << 4 | h2b_lookup[str[1]-'0'])

int main(void)
{
  int i;
  char str[3];
  
  for (i=0; i<256; i++) {
    sprintf(str, "%02X", i);
    printf("string: %s  hex2bin: %02X\n", str, hex2bin(str));
  }
  return 0;
}

[Sunny (Gast)]

Hallo,

@Joe: Das sieht auch interessant und übersichtlich aus... werde das mal 
ausprobieren und dann evtl. die Funktion durch das Makro ersetzen.

@Wolfgang:
Im Grunde ist mir der Inhalt des Modbus Telegrams garnicht so wichtig, 
weil ich eigentlich nur wissen will, ob überhaupt ein vollständiges 
Telegram angekommen ist.
Allerdings ist im Telegramm eine LRC Summe enthalten, die ich noch 
prüfen will, bevor ich die Daten weiterreiche.

Das LRC wird ebenfalls Form von 2 ASCII Zeichen übertragen, z.B. ['3', 
'F'], die aber ein 0x3F repräsentieren...

Wenn also das Modbus Telegram z.B. so aussieht:

:0103000600043F[CR][LF] (alles ASCII Zeichen, wohlbemerkt)

Dann muss ich ja selbst auch ein LRC bilden um es mit dem übertragenen 
LRC vergleichen zu können.

Dafür die Umrechnung der ASCII Zeichen in entsprechende hex Werte.

Sollte ein Byte im Telegramm kaputt sein und die chr2val() Funktion eine 
0 zurückgeben, würde ja auch der LRC Check fehlschlagen und das 
Telegramm wird aussortiert.

So zumindest meine Theorie ;)

LG, Sunny

[Joe F. (easylife)]

Sunny schrieb:
> @Joe: Das sieht auch interessant und übersichtlich aus... werde das mal
> ausprobieren

Der Nachteil dieser Lösung ist, sie setzt voraus, dass keine unerlaubten 
Zeichen verwendet werden. Ansonsten entstehen Array-Indizes, die 
ausserhalb des Arrays liegen. Kann gutgehen, kann aber auch das Programm 
zum Absturz bringen.

Da bei einer Datenübertragung immer auch mit Fehlern gerechnet werden 
muss, hier nochmal eine Alternative der Makro-Lösung, die zumindest das 
Programm nicht crahed.
Bei 'illegalen' Zeichen kommt dann einfach ein falscher Wert raus.

const uint8_t h2b_lookup[32] = 
{ 
  0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 
};

#define hex2bin(str) (h2b_lookup[(str[0]-'0') & 0x1F] << 4 | h2b_lookup[(str[1]-'0') & 0x1F])

[Patrick J. (ho-bit-hun-ter)]

Hi

Wie schon geschrieben wurde, werden von den Zeichen nur der Wert von '0' 
abgezogen.
Wenn das Ergebnis dann noch >9 ist, werden weitere 7 abgezogen.
Wenn das Ergebnis immer noch >15 ist, ziehen wir 32 ab

"0" 0x30
"9" 0x39
"A" 0x41
"F" 0x46
"a" 0x61
"z" 0x66

0-9 wird zu Wert 0...9
A Wird zu Wert 17, ist somit >9, wir ziehen 7 weitere ab -> 10
a wird dadurch aber nur zu 42, ist somit >15, wir ziehen 32 ab -> 10

wenn jetzt immer noch Werte >15 vorliegen, war das Zeichen nicht für uns 
bestimmt ;)


MfG

Wenn ich die Syntax halbwegs gefressen habe, könnte Das passen:

 unsigned char chr2val(unsigned char c) {
   wert=c-'0'
   if (wert>9)
      wert=wert-7;
      if (wert>15)
         wert=wert-32;
      }
   }
   if (wert>15)
      wert=0xff;
   }
   return(wert);
 }

Im Fehlerfall liefert die Funktion 0xFF, statt einer 0