Komisches Verhalten von Pointer auf Struct

[Daniel K. (daniel_k62)]

Hallo!

Ich möchte verschiedene Befehle an ein GSM Modul schicken. Dafür habe 
ich ein Struct definiert, in dem alle Strings (Befehle) stehen.

Dies sieht so aus:

#define F_CPU 11059200UL
#define BAUD 115200UL
#define BAUD_VAL ((F_CPU + BAUD * 8) / (BAUD * 16) - 1)

#include <avr/io.h>
#include <util/delay.h>
#include <USART.c>
#include <LCD.c>

// define struct with all AT commands
typedef struct
{
  unsigned char AT[3];
  unsigned char ATE0[5];
  unsigned char AT_CPIN[13];
  unsigned char AT_COPS[10];
  unsigned char AT_CMGF[10];
  unsigned char AT_CNMI[18];
  unsigned char AT_CMGR[10];
  unsigned char AT_CMGS[24];
  unsigned char SMS_TEXT_ON[9];
  unsigned char SMS_TEXT_OFF[9];
} CHAR_ARRAY;

// initialise struct and define pointer
CHAR_ARRAY AT_CMD =
{
  "AT\0",
  "ATE0\0",
  "AT+CPIN=4053\0",
  "AT+COPS=?\0",
  "AT+CMGF=1\0",
  "AT+CNMI=1,1,0,2,1\0",
  "AT+CMGR=0\0",
  "AT+CMGS=\"[phone]\"\0",
  "HZG EIN!\0",
  "HZG AUS!\0"
};

// create pointer to command struct
CHAR_ARRAY *AT_CMD_PTR = &AT_CMD;

Die Subroutine, die die Stings dann über USART an das GSM Modul schickt 
siehst so aus:

void GSM_WRITE (unsigned char *CMD)
{
  // clear display
  LCD_COMMAND(0x01);

  while (*CMD)
  {
    LCD_DATA(*CMD);
    USART_TX(*CMD++);
  }
}

Zum schluss, hier noch der Aufruf über eine Art state-machine. Der 
Subroutine wird der Pointer auf den jeweiligen string im struct 
übergeben.

while (1)
  {
    switch (STATE)
    {
      // init GSM module, just wait and send some CR
      case 0:
      _delay_ms(1000);
      _delay_ms(1000);
      _delay_ms(1000);

      USART_TX(0x0D);
      USART_TX(0x0D);
      USART_TX(0x0D);

      NEXT_STATE = 1;
      break;

      // send AT command to check state
      case 1:
      GSM_WRITE(AT_CMD_PTR -> AT);

      ERROR = GSM_CHECK();
      if (ERROR == 0) NEXT_STATE = 2;
      if (ERROR == 1) NEXT_STATE = 1;
      break;

      // turn off echo
      case 2:
      GSM_WRITE(AT_CMD_PTR -> ATE0);

      ERROR = GSM_CHECK();
      if (ERROR == 0) NEXT_STATE = 3;
      if (ERROR == 1) NEXT_STATE = 2;
      break;

      // send PIN code
      case 3:
      GSM_WRITE(AT_CMD_PTR -> AT_CPIN);

      ERROR = GSM_CHECK();
      if (ERROR == 0) NEXT_STATE = 4;
      if (ERROR == 1) NEXT_STATE = 3;
      break;

      // set SMS to text mode (1)
      case 4:
      GSM_WRITE(AT_CMD_PTR -> AT_CMGF);

      ERROR = GSM_CHECK();
      if (ERROR == 0) NEXT_STATE = 5;
      if (ERROR == 1) NEXT_STATE = 4;
      break;

      // set SMS notification and storage (1,1,0,2,1)
      case 5:
      GSM_WRITE(AT_CMD_PTR -> AT_CNMI);

      ERROR = GSM_CHECK();
      if (ERROR == 0) NEXT_STATE = 6;
      if (ERROR == 1) NEXT_STATE = 5;
      break;

      // idle state, wait for input from GSM (SMS)
      case 6:
      while(1) BLINK();
    }

    // set current state to next state
    STATE = NEXT_STATE;
  }

Es gibt noch viel mehr code mit den ganzen LCD subroutinen, aber ich 
glaube das hat mit meinem probmel nichts zum tun. Wenn ich den code so 
compiliere und an den Attiny2313 schicke, dann kommt ein ganz komisches 
verhalten raus. Die Pointeradressen, die der subroutine übergeben 
werden, stimmen nicht, die Ausgabe an der rs232 schnittstelle sieht dann 
so aus:

Statt dem CPIN string: #Q
Statt dem CNMI string: <>i
Statt dem CMGF string: 11AT+CNMI=1

und so weiter. Es werden also irgendwelche chars übertragen. teilweise 
dann auch wieder halbe strings. So, jetzt der komische / verwirrende 
Teil. wenn ich vor dem struct, ein dummy array mit mindestens 2 x 10 
elementen definiere (trial and error gg), funktioniert alles 
einwandfrei:

unsigned char DUMMY[2][10] = {"X","X"};

// initialise struct and define pointer
CHAR_ARRAY AT_CMD =
{
  "AT\0",
  "ATE0\0",
  "AT+CPIN=4053\0",
  "AT+COPS=?\0",
  "AT+CMGF=1\0",
  "AT+CNMI=1,1,0,2,1\0",
  "AT+CMGR=0\0",
  "AT+CMGS=\"[phone]\"\0",
  "HZG EIN!\0",
  "HZG AUS!\0"
};

Womit kann das zusammenhängen? wird das struct vielleicht in 
irgendwelchen nicht zulässigen speicherbereichen definiert? Ich hoffe 
die Frage ist so halbwegs verständlich :)

Vielen Dank im Voraus!

Daniel

[Peter D. (pdiener)]

Der Nullabschluss ist in "AT" bereits enthalten.
Im Fall von "AT\0" werden 4 Byte verbraucht.

Grüße,

Peter

[Klaus W. (mfgkw)]

Ja, und noch dazu:
Evtl. (insbesondere, wenn die Strings alle konstant sind), ist es auch 
viel einfacher, gar nicht sie in der struct zu halten, sondern dort nur 
Zeiger abzulegen (const char*).
Dann brauchst du gar nicht zu zählen, wie lang sie sind; der Compiler 
macht den Rest.

[Daniel K. (daniel_k62)]

Guten Morgen!

Danke für die schnellen Antworten! Also wenn ich das Array "AT" im 
Struct definiere, hat das die größe 3 obwohl nur 2 chars enthalten sind? 
Das '\0' Zeichen wird also automatisch hinzugefügt?

Erklährt diese falsche größendefinition auch das komische verhalten bei 
der ausgabe der strings?

@Klaus: Hast du für für die abgelegten Zeiger vielleicht ein kurzes 
code-schnipsel als beispiel? Ich bin leider noch nicht so fit was 
pointer betrifft  :)

Vielen Dank!

[Peter (Gast)]

Ja, wenn Du ein String definierst, dann fügt der Compiler automatisch 
noch das Stringende \0 hinzu. das erklärt dann auch das komische 
Verhalten, die Struktur-Pointer passen nicht mehr...

[Stefan E. (sternst)]

Daniel K. schrieb:
> Erklährt diese falsche größendefinition auch das komische verhalten bei
> der ausgabe der strings?

Nein, das ist nicht die Ursache. Und die Größendefinition ist auch nicht 
falsch. Bei

char a[3] = "AT\0";

wird die automatische Null weggeschnitten und das Endergebnis ist exakt 
das gleiche wie beim "korrekteren"

char a[3] = "AT";

oder

char a[] = "AT";

Daniel K. schrieb:
> wenn ich vor dem struct, ein dummy array mit mindestens 2 x 10
> elementen definiere (trial and error gg), funktioniert alles
> einwandfrei:

Dann hast du vermutlich irgendeine Art von Memory-Corruption, z.B. ein 
Out-Of-Bounds Schreibzugriff auf ein Array.

[Karl H. (kbuchegg)]

Daniel K. schrieb:

> @Klaus: Hast du für für die abgelegten Zeiger vielleicht ein kurzes
> code-schnipsel als beispiel? Ich bin leider noch nicht so fit was
> pointer betrifft  :)

Dann solltest du um die Dinger einen Bogen machen.
Bis jetzt konnte ich deinem Beispiel nicht wirklich entnehmen, wozu du 
da überhaupt eine struct brauchst und warum du auf die struct über einen 
Pointer zugreifst.

Alternativ kannst und solltest du natürlich die Dinge allerdings auch 
richtig lernen. Mit STrings, und damit auch mit Pointern, korrekt 
hantieren zu können ist eine der Grundfertigkeiten in C

So würde das aussehen

// define struct with all AT commands
typedef struct
{
  char* AT;
  char* ATE0;
  char* AT_CPIN;
  char* AT_COPS;
  char* AT_CMGF;
  char* AT_CNMI;
  char* AT_CMGR;
  char* AT_CMGS;
  char* SMS_TEXT_ON;
  char* SMS_TEXT_OFF;
} CHAR_ARRAY;

// initialise struct and define pointer
CHAR_ARRAY AT_CMD =
{
  "AT",
  "ATE0",
  "AT+CPIN=4053",
  "AT+COPS=?",
  "AT+CMGF=1",
  "AT+CNMI=1,1,0,2,1",
  "AT+CMGR=0",
  "AT+CMGS=\"[phone]\"",
  "HZG EIN!",
  "HZG AUS!"
};

Das würde dem ganze dann wenigstens die Wendung geben, die eine 
derartige Struktur rechtfertigen würde: Für unterschiedliche Geräte 
sehen die Strings anders aus und haben natürlich auch andere Längen, was 
mit dieser Lösung kein Problem mehr darstellt.

Aber wie Stefan schon sagte: Das ist nicht dein eigentliches Problem. Da 
muss in deinem Programm noch was anderes faul sein.


PS: Deine konsequente Grossschreibung aller Variablennamen ist keine 
gute Idee. Wenn es eine Übereinkunft gibt, an die sich tatsächlich mehr 
oder weniger alle C-Programmierer weltweit halten, dann ist es die, 
dass Namen komplett in Grossbuchstaben ausschliesslich für Makros 
reserviert sind. Im Code kann es einen Unterschied machen, ob man es mit 
einem echten Makro oder mit einer echten Funktion zu tun hat, so dass es 
an manchen Stellen lebenswichtig sein kann, diese Information schnell zu 
sehen. Die Konvention von "ausschliesslich Grossbuchstaben sind ein 
Kennzeichen für ein Makro" erfüllt diese Information, so dass es Sinn 
macht sich an diese Konvention zu halten.
Auch du solltest das tun. Denn auf lange Sicht gesehen erzeugst du mit 
einer anderen Konvention (deiner eigenen) nur Konfusion.

[Klaus W. (mfgkw)]

Karl Heinz Buchegger schrieb:
> So würde das aussehen

danke, ja.
So meinte ich das.

Karl Heinz Buchegger schrieb:
> Dann solltest du um die Dinger einen Bogen machen.

Wenn er Felder nimmt, hat er doch auch Zeiger - er sieht nur erst etwas 
später.

[Karl H. (kbuchegg)]

Klaus Wachtler schrieb:

>> Dann solltest du um die Dinger einen Bogen machen.
>
> Wenn er Felder nimmt, hat er doch auch Zeiger - er sieht nur erst etwas
> später.

Jein.
Ein Array wird per Zeiger an eine Funktion übergeben. Schon richtig. 
Aber ein Array ist kein Zeiger.

[Stefan (Gast)]

Im Programm ist die Verwendung der Struktur faul. Eine Struktur ist kein 
Array und somit zieht sowas wie *CMD++ nicht. Damit würde dein Programm 
auf speicher zurück greifen der hinter deine Struktur liegt. Also leg 
dir lieber ein Array mit Pointern auf const char an dann kannst du 
solche späße wie CMD++ machen.

Gruß Stefan

[Stefan E. (sternst)]

Stefan schrieb:
> Im Programm ist die Verwendung der Struktur faul. Eine Struktur ist kein
> Array und somit zieht sowas wie *CMD++ nicht.

Sorry, aber das ist Unsinn. CMD ist ja kein Pointer auf die Struktur, 
sondern auf ein Array in dieser. Mit der Funktion GSM_WRITE und der 
Verwendung von *CMD++ darin ist alles in Ordnung.

[Daniel K. (daniel_k62)]

Hallo Leute!

wow, sehr viel input, danke euch. Das ist mein erstes Atmel C Programm, 
habe früher immer PICs mit ASM programmiert, deshalb noch die ganzen 
"Unschönheiten" im code.

Ist es theoretisch nicht egal ob man einzelne Arrays anlegt, die die 
ganzen Strings enthalten oder die alle zusammen in einem struct 
unterbringt? Der Hintergrund für das struct war eigentlich der ein 
Artikel über Codeoptimierung. Die Idee des Zusammefassens von Variablen 
in einem Struct hat mir gut gefallen:

http://www.mikrocontroller.net/articles/AVR-GCC-Codeoptimierung#Statische_.28globale.29_Variablen_in_einer_Struktur_sammeln

Zu den Variablennamen: Danke für den tip. wollte hier natürlich nicht 
für verwirrung sorgen. Wird auf jeden Fall beim nächsten Projekt 
berücksichtigt.

Ich werde heute Abend das Programm mal auf einem anderen Attiny laufen 
lassen um zu sehen, ob das unerklärbare Verhalten immer noch auftritt.

Daniel

[Karl H. (kbuchegg)]

Daniel K. schrieb:

> Ist es theoretisch nicht egal ob man einzelne Arrays anlegt, die die
> ganzen Strings enthalten oder die alle zusammen in einem struct
> unterbringt?

Mit der jetzigen struct Lösung (die mit den Pointern) verbrauchst du 
mehr Speicher. Die vorhergehende struct Lösung hatte das Problem, dass 
ein Ändern der Strings viel Arbeit nach sich zieht.

> Der Hintergrund für das struct war eigentlich der ein
> Artikel über Codeoptimierung. Die Idee des Zusammefassens von Variablen
> in einem Struct hat mir gut gefallen:
>
> 
http://www.mikrocontroller.net/articles/AVR-GCC-Codeoptimierung#Statische_.28globale.29_Variablen_in_einer_Struktur_sammeln
>

Vergiss den Artikel. Besser gesagt diesen einen Abschnitt über 
Strukturvariablen. Das dort gezeigte Beispiel ist nicht repräsentativ, 
weil dieses gewählte Beispiel etwas ausser acht lässt: Die 3 Variablen 
sind nicht voneinander unabhängig, sondern haben als Uhrzeit einen 
logischen Zusammenhalt. Den hast du mit deinen Strings aber nicht.

[Peter D. (pdiener)]

Alleine die ganzen Strings brauchen bei einem ATTiny2313 (oder welcher 
Tiny ist da drin?) über 80% vom Ram. Nachdem die gezeigten Sourcen nicht 
komplett sind, ist es durchaus möglich, dass es noch wesentlich mehr 
ist. Somit tippe ich auf einen Stackoverflow.

Dass der gcc bis zu eine \0 am Stringende automatisch wegschneidet hab 
ich noch nicht gewusst. Stimmt aber, habs gerade ausprobiert. Erst wenn 
mehrere \0 am Ende sind, sind die auch im Code enthalten.

Die ganzen Texte sollten im Flash abgelegt werden und die Fehler mit den 
Pointern behoben werden (es gibt beim Compilieren von obigem Code 
mindestens 2 Warnings wegen falschen Datentypen).

Grüße,

Peter

[Klaus W. (mfgkw)]

Karl Heinz Buchegger schrieb:
> Jein.
> Ein Array wird per Zeiger an eine Funktion übergeben. Schon richtig.
> Aber ein Array ist kein Zeiger.

Auch in anderen Ausdrücken ist der Feldname ein (const-) Zeiger auf das 
erste Element.