uart raspberry pi, warum neuer pointer zum senden?

[Alex (Gast)]

Hallo,
auf 
https://www.einplatinencomputer.com/raspberry-pi-uart-senden-und-empfangen-in-c/ 
habe ich folgenden Code gefunden, um den uart bei einem RaspberryPi zu 
benutzen.

zum senden wird ein pointer auf einen buffer gelegt.
Was hat das für einen hintergrund? warum verwendet man den buffer nicht 
direkt?
Der kann ja auch eine länge von 100 oder so haben. Bei der funktion 
write wird dann ja die länge mitgegeben.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <fcntl.h>
#include <termios.h>

int main() {
  
int uart0_filestream = -1;
uart0_filestream = open("/dev/ttyAMA0", O_RDWR | O_NOCTTY | O_NDELAY);
if (uart0_filestream == -1) {
  printf("[ERROR] UART open()\n");
}

struct termios options;
tcgetattr(uart0_filestream, &options);
  options.c_cflag = B9600 | CS8 | CLOCAL | CREAD; 
  options.c_iflag = IGNPAR;
  options.c_oflag = 0;
  options.c_lflag = 0;
tcflush(uart0_filestream, TCIFLUSH);
tcsetattr(uart0_filestream, TCSANOW, &options);


// Bytes senden
unsigned char BUF_TX[20];
unsigned char *TX;

TX = &BUF_TX[0];
*TX++ = 'R';
*TX++ = 'a';
*TX++ = 's';
*TX++ = 'p';
*TX++ = 'b';
*TX++ = 'e';
*TX++ = 'r';
*TX++ = 'r';
*TX++ = 'y';
*TX++ = ' ';
*TX++ = 'P';
*TX++ = 'i';
  
if (uart0_filestream != -1)  {
  int out = write(uart0_filestream, &BUF_TX[0], (TX - &BUF_TX[0])); // 
  if (out < 0) {
    printf("[ERROR] UART TX\n");
  } else {
    printf("[STATUS: TX %i Bytes] %s\n", out, BUF_TX);
  }
} // if uart0

sleep(1);

// Bytes empfangen
if (uart0_filestream != -1) {
  unsigned char BUF_RX[50];
  int rx_length = read(uart0_filestream, (void*)BUF_RX, 50);

  if (rx_length < 0) {
    printf("[ERROR] UART RX\n");
  } else if (rx_length == 0) {
    printf("[ERROR] UART RX - no data\n");
  } else {
    BUF_RX[rx_length] = '\0';
    printf("[STATUS: RX %i Bytes] %s\n", rx_length, BUF_RX);
  } //rx_length check
} //if uart0

close(uart0_filestream);
  
return 0;
}

[Boris (Gast)]

Klemmt deine Shift-Taste oder bist du der Meinung, dass schlampige 
Rechtschreibung nicht weiter schlimm ist?

[Stefan F. (Gast)]

Alex schrieb:
> zum senden wird ein pointer auf einen buffer gelegt.

Wenn du den ganzen Buffer an die Funktion übergeben würdest, müsste er 
auf den Stack der aufgerufenen Funktion kopiert werden, denn 
Funktions-Argumente sind in C immer "by value" (eine Kopie).

[Stefan F. (Gast)]

Alex schrieb:
> // Bytes senden
> unsigned char BUF_TX[20];
> unsigned char *TX;
>
> TX = &BUF_TX[0];
> *TX++ = 'R';
> *TX++ = 'a';
> *TX++ = 's';
> *TX++ = 'p';
> *TX++ = 'b';
> *TX++ = 'e';
> *TX++ = 'r';
> *TX++ = 'r';
> *TX++ = 'y';
> *TX++ = ' ';
> *TX++ = 'P';
> *TX++ = 'i';

Warum nicht einfach:

char* TX_BUFFER="Raspberry Pi";

Oder wenigstens strncpy() benutzen, um den String zu kopieren.

[foobar (Gast)]

> Wenn du den ganzen Buffer an die Funktion übergeben würdest, müsste er
> auf den Stack der aufgerufenen Funktion kopiert werden, denn
> Funktions-Argumente sind in C immer "by value" (eine Kopie).

Die übergebene "value" ist der Pointer auf den Buffer.  Bei z.B.

write(fd, "Hello World\n", 12);
oder
write(fd, buffer, strlen(buffer));

 wird nichts kopiert.  Komplette Arrays kannst du nur über Umwege "by 
value" übergeben und wird aus den von dir genannten Gründen als 
schlechter Stil angesehen.

Der Kode ist von einem Programmieranfänger geschrieben und sollte nicht 
als Beispiel für saubere oder sinnvolle Programmierung angesehen werden.

[Alex (Gast)]

Stefanus F. schrieb:
> Wenn du den ganzen Buffer an die Funktion übergeben würdest, müsste er
> auf den Stack der aufgerufenen Funktion kopiert werden, denn
> Funktions-Argumente sind in C immer "by value" (eine Kopie).

Das heisst TX ist nur so groß, wie es elemente hat?

foobar schrieb:
> Der Kode ist von einem Programmieranfänger geschrieben und sollte nicht
> als Beispiel für saubere oder sinnvolle Programmierung angesehen werden.

ob jetzt jedes Element einzeln geschrieben, oder ob man TX mit strncpy 
beschreiben würde.
Ist das mit dem Pointer auf dem BUF_TX denn so gängig? Bzw. eine 'gute' 
Methode?
Oder wie sollte es man besser machen?

[foobar (Gast)]

> ob jetzt jedes Element einzeln geschrieben, oder ob man TX mit strncpy
> beschreiben würde.
> Ist das mit dem Pointer auf dem BUF_TX denn so gängig? Bzw. eine 'gute'
> Methode?
> Oder wie sollte es man besser machen?

Das (leicht gekürzte) Original:

   unsigned char BUF_TX[20];
   unsigned char *TX;

   TX = &BUF_TX[0];
   *TX++ = 'R';
   *TX++ = 'a';
   *TX++ = 's';
   *TX++ = 'p';
   *TX++ = 'b';
   *TX++ = 'e';
   *TX++ = 'r';
   *TX++ = 'r';
   *TX++ = 'y';
   *TX++ = ' ';
   *TX++ = 'P';
   *TX++ = 'i';

   out = write(uart0_filestream, &BUF_TX[0], (TX - &BUF_TX[0]));

Macht das gleiche wie:

   out = write(uart0_filestream, "Raspberry pi", 12);

oder

   static const char str[] = "Raspberry pi";

   out = write(uart0_filestream, str, sizeof(str));

oder, wenn man, z.B. wegen dynamischer Daten, einen Buffer nutzen 
möchte:

   char buffer[64];

   sprintf(buffer, "Raspberry pi, 3*4=%d\n", 3*4);
   out = write(uart0_filestream, buffer, strlen(buffer));

Such dir selbst aus, welche Variante "besser" ist.  Programmierer sind 
flexibel - man nutzt das, was gerade am besten passt.  Die erste 
Variante aber wohl eher selten ...


PS: Variablen nur aus Großbuchstaben sind ein "no go" - die Namen sind 
für den Präprozessor ("defines") reserviert.

[foobar (Gast)]

Muss natürlich "sizeof(str)-1" heißen :-/

[Johannes (Gast)]

Stefanus F. schrieb:
> Wenn du den ganzen Buffer an die Funktion übergeben würdest, müsste er
> auf den Stack der aufgerufenen Funktion kopiert werden, denn
> Funktions-Argumente sind in C immer "by value" (eine Kopie).

foobar schrieb:
> oder, wenn man, z.B. wegen dynamischer Daten, einen Buffer nutzen
> möchte:   char buffer[64];
>
>    sprintf(buffer, "Raspberry pi, 3*4=%d\n", 3*4);
>    out = write(uart0_filestream, buffer, strlen(buffer));


Dazu habe ich nochmal eine Nachfrage. Den weg von foobar habe ich sonst 
auch immer gemacht, wenn ich arrays an einer Funktion übergeben habe.
Stefanus F. aussage habe ich jetzt so verstanden, dass auch wenn ich 
eine länge kleiner der länge des Arrays angegeben wird, der komplette 
Array (also 64 Elemente) in die Funktion kopiert.
Wenn ich einen Pointer auf den buffer mache und diesen dann mit der 
entsprechenden länge übergebe, ist der pointer auch nur so lang wie 
beschrieben (im obigen Beispiel also 12).

Habe ich das so richtig verstanden?

[Stefan F. (Gast)]

Alex schrieb:
> Das heisst TX ist nur so groß, wie es elemente hat?

TX ist ein Zeicher auf ein Array von Zeichen. Also 32bit oder 4 Bytes, 
unter der Annahme, dass bei diesem System all Zeiger 32bit groß sind.

> Ist das mit dem Pointer auf dem BUF_TX denn so gängig? Bzw. eine 'gute'
Methode?

Ja und Ja, sonst wäre das in der Standard-C Bibliothek nicht so 
festgelegt. Die Bibliothek ist zwar alt, aber ihr Erfinder war kein 
Dummkopf und hatte bereits viele Jahre Erfahrung mit anderen 
Programmiersprachen.

[Sebastian (Gast)]

Johannes schrieb:
> Stefanus F. aussage habe ich jetzt so verstanden, dass auch wenn ich
> eine länge kleiner der länge des Arrays angegeben wird, der komplette
> Array (also 64 Elemente) in die Funktion kopiert


Ist falsch, wird nicht kopiert. Arrays degenerieren zu Zeigern.

[Stefan F. (Gast)]

Sebastian schrieb:
> Arrays degenerieren zu Zeigern.

Ja, das hatte mich anfangs auch irritiert. Schau Dir das an:

char* du = "Johannes";

Hier wird irgendwo ein char[] angelegt, mit dem Wort "Johannes" befüllt 
und mit einem \0 abgeschlossen. Das Array ist also 9 Bytes groß. "du" 
ist ein Zeiger auf dieses Array.

char ich[] = "Stefan";

Das hier ist technisch fast das Gleiche. Ehrlich gesagt weiß ich ich 
nicht, wo genau der Unterschied ist, denn man kann char[] und char* 
gleicher benutzen und mixen:

char* du = "Johannes";
char ich[] = "Stefan";

char ersterBuchstabe = du[0];
char ersterBuchstabe = ich[0];

char ersterBuchstabe = *du;
char ersterBuchstabe = *ich;

printf("Der Name ist: %s", du);
printf("Der Name ist: %s", ich);

void sende_string(char* name) {
    while (*name != '\0') {
        sende_zeichen(*name)
    }
}

void sende_string(char name[]) {
    while (*name != '\0') {
        sende_zeichen(*name)
    }
}

void sende_string(char* name) {
   for (int i=0; name[i]!='\0'; i++) {
        sende_zeichen(name[i])
    }
}

void sende_string(char name[]) {
   for (int i=0; name[i]!='\0'; i++) {
        sende_zeichen(name[i])
    }
}

Alle vier Funktionen kannst du wahlweise mit "ich" oder "du" aufrufen. C 
übergibt Arrays an Funktionen immer als Zeiger.

[GEKU (Gast)]

Stefanus F. schrieb:
> Funktions-Argumente sind in C immer "by value" (eine Kopie).

Trifft bei Pascal zu, aber nicht bei C!
Funktions-Argumente von Arrays, Strukturen und Strings sind in C immer 
"called by reference" .

[Stefan F. (Gast)]

> Stefanus F. schrieb:
>> Funktions-Argumente sind in C immer "by value" (eine Kopie).

GEKU schrieb:
> Trifft bei Pascal zu, aber nicht bei C!
> Funktions-Argumente von Arrays, Strukturen und Strings sind in C immer
> "called by reference" .

Ja, ich habe das missverständlich ausgedrückt. Die Übergabewerte werden 
immer auf den Stack der aufgerufenen Funktion kopiert, oder in CPU 
Registern übergeben.

Arrays und Strukturen zerfallen dabei zu Zeigern, weil es in der Regel 
keinen Sinn macht, größere Datenmengen zu kopieren. Es werden Zeiger auf 
die Daten übergeben.

Gibt es den Begriff "Referenz" überhaupt in C? Ich kenne nur Zeiger.

[GEKU (Gast)]

Stefanus F. schrieb:
> char* TX_BUFFER="Raspberry Pi";

Bei C++ mit dem Typ string anstelle von char* funktioniert es auch.

string tx_buffer = "Raspberry Pi";

https://www.w3schools.com/cpp/cpp_strings.asp

[GEKU (Gast)]

Stefanus F. schrieb:
> Gibt es den Begriff "Referenz" überhaupt in C? Ich kenne nur Zeiger

Ich denke schon.

http://www.lerneprogrammieren.com/blog/praxis/call-value-und-call-reference-bei-der-parameteruebergabe

Der Vorteil in Pascal von "called by value" ist, dass die ursprüngliche 
Zeichenkette erhalten bleibt auch wenn in die in die Funktion übergebene 
Zeichenkette (Kopie) verändert wird.

In C kann das nur mit dem Attribut const zur Compilerzeit verhindert 
werden.
(es wird eine Kopie im Unterprogramm erzwungen)

Allerdings kostet "called by value" viel Platz am Stack bzw. viel 
Rechnerleistung,  die im embedded Bereich sowieso zu kostbar sind.

[foobar (Gast)]

> Das hier ist technisch fast das Gleiche. Ehrlich gesagt weiß ich ich
> nicht, wo genau der Unterschied ist
>

>  char* du = "Johannes";
>  char ich[] = "Stefan";
>

Du merkst den Unterschied, wenn du den Variablen Werte zuweisen willst 
oder per sizeof die Größe abfragst ;-)

"du" ist der Name eines Pointers, der auf einen (anonymen, 
initialisierten) Datenblock zeigt.  "ich" ist der Name eines 
(initialisierten) Datenblocks.

In Pseudoassembler ungefähr so:

_an314: .byte "Johannes",0
du:     .word _an314
ich:    .byte "Stefan",0

[foobar (Gast)]

> Funktions-Argumente von Arrays, Strukturen und Strings sind in C immer
> "called by reference"

Nicht ganz.  Arrays, Strings (Arrays von Zeichen) und Funktionen 
degenerieren zu Pointer und werden als Pointer übergeben.  Strukturen 
werden aber neuerdings (ab C89 oder so ;-) ) kopiert!  Wird 
glücklicherweise selten benutzt - meist unbewusst von Anfängern.

[Stefan F. (Gast)]

foobar schrieb:
> Du merkst den Unterschied, wenn du den Variablen Werte zuweisen willst
> oder per sizeof die Größe abfragst ;-)

Ach ja, logisch. Also kenne ich den Unterschied ja doch, war mir nur 
nicht bewusst.

[Stefan F. (Gast)]

foobar schrieb:
> Strukturen werden aber neuerdings (ab C89 oder so ;-) ) kopiert!

Oh, das ist gemein. Bei STM32 habe ich mal gemerkt, dass bis zu 5 
Parameter in Registern übergeben werden. Bei mehr wird Stack verwendet.

Bei Strukturen muss man dazu wohl die einzelnen Elemente zählen, oder?

[foobar (Gast)]

> Bei Strukturen muss man dazu wohl die einzelnen Elemente zählen, oder?

Keine Ahnung, wie das bei ARM/STM32 ist - wird in der ABI (Application 
Binary Interface) festgelegt und kann teilweise noch per Compilerswitch 
modifiziert werden (bei ARM z.B. gibt es mehrere verschiedene ABIs).