Funktion bekommt keinen Wert übergeben

[Kai L. (kcl_93)]

Hallo Leute,

ich bin gerade dabei ein Programm für einen ATmega644 zu schreiben, das 
unter anderem über UART Daten an den PC senden soll. Dabei werden immer 
3 Bytes als größeres Frame gesehen und versendet. Diese 3 Bytes 
enthalten eine 16Bit-Variable, einen 5Bit langen Befehl und 3 Bits zur 
Synchronisation.
Zu diesem Zweck habe ich mir eine Funktion geschrieben, die mir diese 3 
Bytes aus dem Befehl und den Daten zusammenbauen soll:

void daten_senden(uint8_t befehl, uint16_t daten)
{
  char frame[3];
  /*
            Aufbau: Byte    Bits    Funktion
                    1       1       Identifikator für erstes Byte (muss 1 sein)
                            2-6     Befehlsbits (1-31)
                            7-8     Datenbits 1-2
                    2       1       Identifikator für Daten-Bytes (muss 0 sein)
                            2-8     Datenbits 3-9
                    3       1       Identifikator für Daten-Bytes (muss 0 sein)
                            2-8     Datenbits 10-16
            */
  frame[0] = 0b10000000;
  frame[0] += (befehl<<2);
  frame[0] += (uint8_t)(daten>>14);
  frame[1] = (uint8_t)(daten>>7);
  daten = daten<<9;
  frame[2] = (uint8_t)(daten>>9);
  uart_putc(frame[0]);
  uart_putc(frame[1]);
  uart_putc(frame[2]);
}

Diese Funktion wird im Hauptprogramm aufgerufen, wobei der Befehl als 
Konstante übergeben wird:

#define PING_RET   2

//...

int maint()
{
   //...
   daten_senden(PING_RET, 1);
   //...
}

Mein Problem ist, dass egal was ich beim Aufruf der Funktion als 
Parameter übergeben möchte immer nur (0, 0) ankommt. Ich habe auch schon 
versuch die Konstanten vorher in einer Variable zu speichern und die 
dann zu übergeben aber das hat auch nichts geändert.
Könnt ihr mir sagen, was ich da falsch gemacht habe???

gruß,

Kai L.

[Johann L. (gjlayde)]

Das Problem liegt wohl in den //... Stellen

[Kai L. (kcl_93)]

Hier einmal der ganze Code.

[Karl H. (kbuchegg)]

Humpf.
Das ist jetzt im Gegenzug wieder relativ viel Tobak auf einmal.

Kannst du keinen Mittelweg machen?
Ein EINFACHES Testprogramm, welches nur 1 Befehl enthält und den sendet 
und du an der Gegenstelle dir ansiehst, was ankommt?
Wer ist eigentlich die Gegenstelle? Kann es sein, dass dein Problem von 
dort kommt bzw. dort entsteht?

Hintergrund: Ich finde es immer wieder recht faszinierend, dass da 
manchmal Code-Monster auftauchen, die scheinbar alle von einer gewissen 
Basisfunktionalität abhängen und es so aussieht, als sei diese 
Basisfunktionalität nie einzeln getestet und debuggt worden. Sondern im 
Gegenzug ist man davon ausgegangen, dass das schon funktionieren wird 
und dann hat man halt erst mal das Code-Monster produziert. Mit dem 
Endeffekt, dass nichts funktioniert und man nicht weiß, wo man mit der 
Fehlersuche anfangen soll.
Eine derartige Entwicklungsstrategie ist keine gute Idee.

[Karl H. (kbuchegg)]

Kann das mal wer kontrollieren?

void daten_empfangen()
{
  uint16_t empfangen;
  
  empfangen = uart_getc();
  if(!(empfangen & 0xff00))  //Prüfen ob Byte erfolgreich gelesen wurde
  {
    if(byte_empfangen == 0 && !(empfangen & 0x0080)) //Prüfen ob Befehlsbit korrekt gesetzt gesetzt ist
    {
      daten_senden(ERROR, 0);  //Error-Nachricht senden
      return; //Byte wird verworfen bis das nächste gültige Byte kommt
    }
    else if(empfangen & 0x0080)
    {
      daten_senden(ERROR, FRAME_ERROR);  //Error-Nachricht senden
      return; //Byte wird verworfen bis das nächste gültige Byte kommt
    }

....

Im Kontext gesehen, müsste meiner Meinung nach dieses immer zu einem 
gemeldeten Fehler führen, solange byte_empfangen 0 ist. Da es von Anfang 
an 0 ist, kommt er da aber auch nie heraus. byte_empfangen kann nie 
größer werden, denn egal ob das 7. Bit gesetzt ist oder nicht, es mündet 
immer in einem der beiden Zweige, in denen ein Fehler gesendet wird und 
ein vorzeitiger Ausstieg gemacht wird.

Da FRAME_ERROR aber auf 0 #defined ist, ist er in der Situation, dass 
immer ein (0, 0) zurück geschickt wird, egal was die Gegenstelle als 
Kommando sendet. Womit die Ausgangsfrage erklärbar wäre. Nur halt mit 
einer ganz anderen Begründung, als der nach der gefragt wurde.

Mein Fazit: viel zu viel Code auf einmal geschrieben, ohne die 
grundlegenden Basisdinge, wie zb hier die UART Protokollkommunikation 
ausreichend und für sich alleine getestet zu haben. Auf dem AVR keine 
vernünftigen Möglichkeiten für Test-Ausgaben zu haben (und seien es nur 
ein paar LED), tut dann noch sein übriges.

[Kai L. (kcl_93)]

Du hast Recht, was deine Vermutung mit der Empfangen-Funktion betrifft. 
Wenn ich die Abfrage nach dem 7. Bit korrigiere funktioniert es.
Ich hatte die Basisfunktionalität in Auszügen bereits getestet, indem 
ich Daten gesendet und mit Teraterm ausgewertet hab. Nur die 
Empfangsfunktion hatte ich ausgelassen, bis ich mit dem C#-Programm am 
PC weiter gekommen bin. Dabei hab ich auch parallel an dem Programm für 
den uC weiter gearbeitet, wenn mir danach war ;)
Jetzt hab ich folglich zurecht die Rechnung für dieses unsystematische 
Vorgehen bekommen. Vielen Dank für deine Mühen! :)