unsignet char zusammensetztzen

[Lars (Gast)]

Moin,

ich stehe auf dem schauch....ich habe diese Programm zum senden von HEX 
daten:

int sendenserial(int fd)   
{
  
  //Sende /?!crlf
  unsigned char send_bytes[] = { 0x2F, 0x3F, 0x21, 0x0D, 0x0A};
  write(fd, send_bytes, 5);  //Send data
  printf("Daten senden\n");
  return 0;
}

So nun möchte ich aber noch die Adresse da einfügen. Dafür lesen ich 
diesen String aus einer MYSQL "0x34, 0x38, 0x40"

Wie bekomme ich das nun zusammen? Ich habe es versucht mit sprinf aber 
dann geht das write nicht mehr richtig :-(

Und wie kann ich dynamisch die Sende länge einstellen?


Ich bin irgendwie gerade überfrag. Könnte mir wer einen Tip geben?



Lars

[Yalu X. (yalu) (Moderator)]

Lars schrieb:
> Wie bekomme ich das nun zusammen? Ich habe es versucht mit sprinf aber
> dann geht das write nicht mehr richtig :-(

Eher mit sscanf.

[Klaus W. (mfgkw)]

Lars schrieb:
> Könnte mir wer einen Tip geben?

1. Mein Tip: verständliche Fragen stellen.
Ich zumindest weiß nicht recht, was du willst und was nicht geht.

2. man kann write auch mehrfach hintereinander aufrufen, um erst einen 
Teil zu senden und dann den anderen.

3. Rückgabewerte sind dazu da, geprüft zu werden.

[Lars (Gast)]

Also ich habe das Problem mit dem String der aus der MYSQL Datenbank 
kommt.

Wie bekomme ich den gesendet?

Der String sieht ja so aus:

MYSQL Adresse:
0x34, 0x38, 0x40

Und diesen String will ich in den Vorhandenen
unsigned char send_bytes[] = { 0x2F, 0x3F, 0x21, 0x0D, 0x0A};
einbinden.

Also so soll es nachher aussehn:
->0x2F, 0x3F, 0x34, 0x38, 0x40, 0x21, 0x0D, 0x0A

Habs per sprint versucht aber dann wird gemeckert das send_bytes keine 
größen angabe hat.

Wenn ich dann send_bytes[100] schreibe, sender write meine Daten nicht 
mehr

:-(

[Peter (Gast)]

Stichwort verkettete Liste wäre da was

[Lars (Gast)]

Ok werde ich mal googlen...


Was ich noch so verstehe ist, warum sind die 0x.. sind der {} klammer?

unsigned char send_bytes[] = { 0x2F, 0x3F, 0x21, 0x0D, 0x0A};

Ich habe das kopiert..... Finde da aber auch nix im Netz.

[DirkB (Gast)]

In send_bytes[] hast du Binärwerte.
Dein SQL-String besteht aus einzelnen Zeichen.

Das soviel miteinander zu tun wie 10 mit "zehn"

Du musst also erstmal aus dem String Binärwerte machen.

Am einfachsten geht das mit sscanf (wurde schon genannt).

Dann kannst du die ersten zwei Zeichen von send_bytes senden,
dann die Werte die du mit scanf ermittelt hast und danach die letzten 
Zeichen von send_bytes. (wurde auch schon genannt)

Du kannst auch in send_bytes Füllzeichen einbauen und die Stellen dann 
entsprechen füllen.

unsigned char send_bytes[] = { 0x2F, 0x3F, 0, 0, 0, 0x21, 0x0D, 0x0A};

[Yalu X. (yalu) (Moderator)]

Sollen die SQL-Daten immer nach dem zweiten Byte von send_bytes
eingefügt werden?

Wenn ja, mach's doch einfach so:

char sql_string[] = "0x34, 0x38, 0x40";

int sendenserial(int fd)   
{
  static unsigned char prefix[] = { 0x2F, 0x3F };
  static unsigned char suffix[] = { 0x21, 0x0D, 0x0A };
  char *sql_ptr = sql_string;
  unsigned char c;
  int val, n;

  write(fd, prefix, sizeof prefix);

  if (sscanf(sql_ptr, "%i%n", &val, &n) == 1) {
    do {
      sql_ptr += n;
      c = (unsigned char)val;
      write(fd, &c, 1);

    } while (sscanf(sql_ptr, ",%i%n", &val, &n) == 1);
  }

  write(fd, suffix, sizeof suffix);

  return 0;
}

Erst werden die Bytes 0x2f und 0x3f gesendet.

Dann wird der SQL-String mit sscanf auseinandergeflückt und jedes
einzelne darin enthaltene Byte gesendet. Dabei ist die Anzahl dieser
Bytes beliebig.

Am Schluss werden die Bytes 0x21, 0x0d und 0x0a gesendet.

Ist es das, was du dir vorgestellt hast?

[DirkB (Gast)]

Lars schrieb:
> Was ich noch so verstehe ist, warum sind die 0x.. sind der {} klammer?
>
> unsigned char send_bytes[] = { 0x2F, 0x3F, 0x21, 0x0D, 0x0A};

Damit initialisierst du das Array send_bytes.
Dies geht so in C nur bei der Definition von einem Array.
Du kannst auch einen Wert in die [] setzen. Dann wird der Rest 
automatisch mit 0 aufgefüllt.

unsigned char send_bytes[10] = { 0x2F, 0x3F, 0x21, 0x0D, 0x0A}; // nur 5 Werte angegeben, die restlichen fünf werden mit 0 gefüllt

Die {} sind da wie die "" bei Stringliteralen.

char send_bytes[] = "/!?\r\n";
//oder 
char send_bytes[] = "\x2F\x3F\x21\x0D\x0A";

aber dann ist send_bytes jeweils 6 Zeichen groß

[Lars (Gast)]

Viel Dank für die Erklärung es egth




Danke

[Ich (Gast)]

geht mein ich :-D