0x00 über UART übertragen

Ich hänge mich mal an den alten Thread weil ich gerade vor dem gleichen 
Problem stehe.

Ich möchte eine Zeichenkette aus hexadezimalen Daten zu Peter Fleury's 
UART Lib übertragen:

char *zeichenkette = "\x10\x02\x68\x00\xff\x10\x03\x8c" ;
uart_puts(zeichenkette);

Hier scheitert es daran, dass die Lib das 0x00 als Stringende erkennt 
und nach dem 0x68 zum senden aufhört.

So sieht seine Lib aus:

void uart1_puts(const char *s )
{
    while (*s)
      uart1_putc(*s++);

}

Wie löse ich das am besten, dass die ganze Zeichenkette übertragen wird? 
Soll ich die Zeichen irgendwie anders deklarieren?

Schreib am anfang des strings die länge des Strings. Dann sendest du 
soviele Zeichen wie am anfang des Strings angegeben ist.

1

char *zeichenkette = "\x09\x10\x02\x68\x00\xff\x10\x03\x8c" ;

2

3

4

void uart1_puts(const char *s )

5

{

6

    int tmp = *s;

7

    int count = 0;

8

    while (count != tmp)

9

      uart1_putc(*s+count++);

10

11

}

sowas in der Art vielleicht?

Kann man die Länge der Zeichenkette nicht irgendwie in der Funktion 
ermitteln? Endet *s denn nie?

Das Problem ist, dass die Lib auf Strings aufgebaut ist.
Ein String endet aber definitionsgemäs bei einem 0x00 Zeichen.

Was du da hast sind keine Strings. Daher ist die Funktion uart1_puts und 
alle Stringfunktionen ganz einfach die falschen Werkzeuge für das was du 
vor hast.

Um weiter zu kommen, musst du von Strings Abschied nehmen und auf Bytes 
neu aufbauen.

Igor Ebner schrieb:
> Kann man die Länge der Zeichenkette

Du hast keine Zeichenkette, die den C Regeln für eine Zeichenkette 
genügt.

> nicht irgendwie in der Funktion
> ermitteln? Endet *s denn nie?

Es gibt kein Kriterium dafür.
Daher musst du allen Funktionen, die mit solchen Daten arbeiten immer 
die Länge deiner Bytefolge mitgeben.

Sieh dir den Unterschied in den Familien der str... und mem... 
Funktionen an. Die str... Funktionen sind für Strings. Die mem... 
Funktionen sind für beliebige Bytefolgen.

Kannst Du mal ein Beispiel zeigen wie es mit bytes aussehen würde?

Wie ich schon sagte: Du musst die Anzahl der Bytes mitgeben

1

#define ARRAY_SIZE(x)  ( sizeof(x) / sizeof(*x) )

2

3

unsigned char zeichen[] = { 0x10, 0x02, 0x68, 0x00, 0xff, 0x10, 0x03, 0x8c };

4

5

void uart1_put_data( const unsigned char * data, size_t len )

6

{

7

  size_t i;

8

9

  for( i = 0; i < len; ++i )

10

    uart1_putc( *data++ );

11

}

12

13

int main()

14

{

15

  ...

16

17

  uart1_put_data( zeichen, ARRAY_SIZE( zeichen ) );

18

19

  ...

20

}

Ja, so klappt es auch. Danke dafür. Aber trotzdem ist es schade, dass 
die Funktion nicht selbst erkennt, wie viel Hex Daten man ihr schickt - 
ist kein bequemes schreiben, wie man es z.B. von Peter Fleury's UART Lib 
her kennt:

uart_puts("Hello World");

wäre doch viel schöner als:

uart_puts("Hello World",11);

oder

uart_puts(zeichen, ARRAY_SIZE( zeichen ));

Schreib halt eine eigene "putx" Funktion, die bis zu einem anderen 
Terminierungszeichen als 0x00 geht. Wenn du kein Zeichen ausschließen 
kannst, dann gehts nur über die Nachrichtenlänge.