Strings wollen nicht verbunden werden

[Martin K. (Firma: Student) (mkattinger)]

Hallo,
ich möchte Strings zusammenfügen und anschließend über die UART 
rausschicken.

Aufruf:
rs485_send_packet(0x01, 0x33, "Data");

Methode:
void rs485_send_packet(  const unsigned char* type,
      const unsigned char* dest,       const unsigned char* data)
{
  unsigned char* packet;

  // Das RS485 Paket erzeugen
  *packet = *type;
  *packet = strcat(*packet, *dest);
  *packet = strcat(*packet, RS485_ADDRESS);
  *packet = strcat(*packet, 1 + 1 + 1 + strlen(*data) + 1) ;
  *packet = strcat(*packet, *data);
  *packet = strcat(*packet, crc16(*packet));

  uart_puts(*packet);
}

Irgendwo muss/müssen da Fehler sein.

danke für euer Hilfe,
Martin

[Achim W. (Gast)]

char* xxx:
xxx ist ein Pointer auf char, und nicht *xxx

deshalb meine ich, es müsste in der Art sein:
strcat(xxx, ..); anstatt strcat(*xxx,...)

[Helfer (Gast)]

Martin Kattner schrieb:
> Irgendwo muss/müssen da Fehler sein.

Da ist kaum eine richtige Zeile.
Lies ein C-Buch.

[Jean P. (fubu1000)]

Hi,

Martin Kattner schrieb:
> void rs485_send_packet(  const unsigned char* type,
>       const unsigned char* dest,       const unsigned char* data)
> {
>   unsigned char* packet;
>
>   // Das RS485 Paket erzeugen
>   *packet = *type;
>   *packet = strcat(*packet, *dest);
>   *packet = strcat(*packet, RS485_ADDRESS);
>   *packet = strcat(*packet, 1 + 1 + 1 + strlen(*data) + 1) ;
>   *packet = strcat(*packet, *data);
>   *packet = strcat(*packet, crc16(*packet));
>
>   uart_puts(*packet);
> }

void rs485_send_packet(  const unsigned char* type,
                         const unsigned char* dest,       
                         const unsigned char* data)
{
   uint8_t* packet = (uint8_t*) malloc(strlen(type)+
                                       strlen(dest)+
                                       strlen(RS485_ADDRESS)+
                                       //sizeof(RS_485ADDRESS)+
                                       strlen(data)+
                                       6);
   strcpy(packet, type);
   strcat(packet, dest);
   strcat(packet, RS_485_ADDRESS);
   //uint8_t address[sizeof(RS_485ADDRESS)+1);
   //itoa(RS_485ADDRESS, address, 10);
   //strcat(packet, address);
   strcat(packet, data);
   //uint16_t crc;
   //uint8_t crc_str[6];
   //crc = crc16(packet);
   //itoa(crc, crc_str, 10);
   //strcat(packet, crc_str);
   strcat(packet, crc16(packet));

   uart_puts(packet);
}

Die auskommentierten Sachen sind optional, falls RS_485ADDRESS ne Zahl 
und kein string und crc16 ne Zahl und keinen string zurück liefert.
P.S.: und alles ohne Gewähr, nur schnell alles mal zusammen gereimt aus 
dem Kopf.

Helfer schrieb:
> Da ist kaum eine richtige Zeile.
> Lies ein C-Buch.
Das klingt zwar hart, ist aber leider die Wahrheit und das sollte er 
tun.

Gruß

[(prx) A. K. (prx)]

Mit malloc ohne free macht man sich aber auch keine Freunde.

[Martin K. (Firma: Student) (mkattinger)]

Danke!!!

[Jean P. (fubu1000)]

Autsch, danke A.K.,
 das war dann wohl doch etwas zu fix ;-(

void rs485_send_packet(  const unsigned char* type,
                         const unsigned char* dest,       
                         const unsigned char* data)
{
   uint8_t* packet = (uint8_t*) malloc(strlen(type)+
                                       strlen(dest)+
                                       strlen(RS485_ADDRESS)+
                                       //sizeof(RS_485ADDRESS)+
                                       strlen(data)+
                                       6);
   strcpy(packet, type);
   strcat(packet, dest);
   strcat(packet, RS_485_ADDRESS);
   //uint8_t address[sizeof(RS_485ADDRESS)+1);
   //itoa(RS_485ADDRESS, address, 10);
   //strcat(packet, address);
   strcat(packet, data);
   //uint16_t crc;
   //uint8_t crc_str[6];
   //crc = crc16(packet);
   //itoa(crc, crc_str, 10);
   //strcat(packet, crc_str);
   strcat(packet, crc16(packet));

   uart_puts(packet);
   free(packet);
}

[Martin K. (Firma: Student) (mkattinger)]

Ja, ein C-Buch wäre wiedermal nicht schelcht. Habe das letzte mal vor 
6-7 Jahren C Programmiert (Schule).

War zur Zeit eher mit "höheren" Sprachen beschäftigt. Java, C# ... da 
sind Zeichenketten komfortabler zu benützen.
Da erledigt die Runtime das allocieren :)

Trotz meines Unwissens: Danke für die Hilfe!!

[olf79 (Gast)]

Sind das wirklich alles Strings? Also 0-terminierte Byte-Arrays?
Dann empfehle ich einfach etwas wie

char packet[200];
sprintf(packet,"%s%s%s",string1,string2,string3);

Wie ist denn crc16 deklariert?

Gruß
OLF79

[Klaus W. (mfgkw)]

Und wozu überhaupt alle Teilstrings in einen langen String verpacken, 
nur um sie dann zu verschicken?
Da könnte man doch gleich die Teilstrings verschicken...

(So eine uneffektive Vorgehensweise gewöhnt man sich in Sprachen wie 
Java oder C# an :-)

[Achim W. (Gast)]

wahrscheinlich wegen der CRC Berechnung

[Martin K. (Firma: Student) (mkattinger)]

Fertige Methode:

void rs485_send_packet(  const char type,
                         const char dest,
                         const char* data)
{
  unsigned int length;
  unsigned int crc = 0xFFFF; //Vorladewert
  length = 1 + 1 + 1 + 2 + strlen(data) + 2;

  uart_putc(type);
  crc = crc16_update(crc, type);

  uart_putc(dest);
  crc = crc16_update(crc, dest);

  uart_putc(RS485_ADDRESS);
  crc = crc16_update(crc, RS485_ADDRESS);

  uart_putc(length>>8);
  crc = crc16_update(crc, length>>8);

  uart_putc(length);
  crc = crc16_update(crc, length);

  uart_puts(data);
  crc = crc16_update_s(crc, data);

  uart_putc(crc>>8);

  uart_putc(crc);

}

Meine Meinung auch Ressourcenschonend.