Variable ohne Funktion

[P. F. (pfuhsy)]

Hallo, irgendwie frag ich mich wie das sein kann und komme einfach nicht 
auf die Lösung. Vielleicht sehe ich auch den Wald vor lauter Bäumen 
nicht.

Ich habe ein RFM12 an den eine Präamble und ein paar weitere Sachen 
gesendet werden damit das Teil einen Interrupt auslöst:

RFM_SEND(0xAA);
RFM_SEND(0xAA);
RFM_SEND(0X2D);
RFM_SEND(0xD4);

Funktioniert wunderbar.

Wenn ich jetzt das ganze in eine Variable schreibe, reagiert der RFM12 
nicht.

uint8_t PREAMBLE0 = 0xAA;
uint8_t PREAMBLE1 = 0xAA;
uint8_t SYNC0 = 0x2D;
uint8_t SYNC1 = 0xD4;
...
...
RFM_SEND(PREAMBLE0);
RFM_SEND(PREAMBLE1);
RFM_SEND(SYNC0);
RFM_SEND(SYNC1);

Hat jemand eine Idee ??

Noch was.
Ich arbeite mit AVR Studio v4.irgendwas. Manchmal hab ich beim debuggen 
das Phänomen, dass er bestimmte Varibalen bei Druck von F11 "Schritt für 
Schritt" einfach überspringt. Ich sehe also gar nicht welche Werte diese 
haben. Beispielweise habe ich in einer Header

uint8_t ADR = 0;

deklariert. Wenn ich jetzt in den Haupschleife

ADR = 1;

schreibe, überspringt er beim debuggen die Variable einfach und landet 
schon bei der nächsten Anweisung. In der Watchlist ist "ADR" immernoch 
bei Wert "0". Den Optimizer habe ich testweise mal auf "O0", mal auf 
"Os".
Hat dabei jetzt eine Idee ?

[Frank (Gast)]

Mach mal ein
const uint8_t PREAMBLE0 = 0xAA;
daraus!?
Vllt ändert das was.

Und wegen dem Debuggen, wenn du auf-O0 stellst hätte ich auch erwartet 
das er es richtig macht.  Hast du parallel schon mal den ASM dazu 
angeschaut?

[Ben S. (theben)]

Könnte vielleicht sein das du nen Syntax Fehler in deinem Code hast und 
die Fehler Meldung ausgeschaltet hast?
Das hatte ich mal. Der hat dann einfach nicht kompiliert und immer mit 
der letzen Version die funktioniert hatte gearbeitet.

uint8_t PREAMBLE0 = 0xAA;
uint8_t PREAMBLE1 = 0xAA;
uint8_t SYNC0 = 0x2D;
uint8_t SYNC1 = 0xD4;
...
...
RFM_SEND(PREAMBLE0);
RFM_SEND(PREAMBLE1);
RFM_SEND(SYNC0);
RFM_SEND(SYNC1);

bei deinen .... Pünktchen kann noch viel passieren den Code musst du 
schon mit an geben damit man dir besser helfen kann

[HopeIHelped (Gast)]

Setzt du die Variablen im Hauptprogramm, rufst aber die Routine 
RFM_SEND() in einem Interrupt auf?

Möglicherweise wurden die Variablen dann vom Compiler "wegoptimiert". 
Deklariere die Variablen mal als volatile uint8_t, oder kompiliere 
explizit im Debugmodus (= keine Optimierung).

[Edi R. (edi_r)]

Peter F. schrieb:
>

> RFM_SEND(0xAA);
> RFM_SEND(0xAA);
> RFM_SEND(0X2D);
> RFM_SEND(0xD4);
>

Üblicherweise schreibt man Konstanten in Großbuchstaben. Nachdem 
"RFM_SEND" in Großbuchstaben geschrieben ist - ist das vielleicht ein 
Makro, das keine Variablen als Parameter will?

Peter F. schrieb:
>

> uint8_t PREAMBLE0 = 0xAA;
> uint8_t PREAMBLE1 = 0xAA;
> uint8_t SYNC0 = 0x2D;
> uint8_t SYNC1 = 0xD4;
>

Sowas müsste aber auf jeden Fall klappen:

#define PREAMBLE0  0xAA
#define PREAMBLE1  0xAA
#define SYNC0  0x2D
#define SYNC1  0xD4

[P. F. (pfuhsy)]

Edi R. schrieb:
> #define SYNC0  0x2D
> #define SYNC1  0xD4

Das funktioniert. Ich versteh aber nicht genau warum das andere nicht 
geht.
Ein Teil des Codes sieht folgendermaßen aus:
main.c

int main(void) //Hauptprogramm
{
  initPorts();    //Ports deklarieren
  uint8_t commando[6] = {"######"};
  
  /* Der Interrupt des UARTs stört den Timer und bricht das Porgramm
  einfach ab. Wahrscheinlich registriert er einen High Pegel und 
  bleibt dann in der Zeile hängen. Deswegen erstmal auskommentieren
  bis ich ihn wirklich brauche. */
  initUART();      //UART initialisieren

  //RFM einschalten
  RFM_ON();
  _delay_ms(1000);  //TODO durch Zeitbabis ersetzten
  initRFM_Ports();  //Ports für RFM initialisieren
  initRFM();      //RFM initialisieren
  //initTimer();    //Timer initialisieren
  
  //Hauptschleife
  while(true)
  {
    //ADR
    ADR = 0x31;    //Teilnehmer-Adresse 1    
    //FKT
    SEND_BEF();    //Sende befehl
    ANF_REED();    //Anfrage Reed-Kontakt
    ANF_BAT();    //Anfrage Batterie-Status
    //STA
    HAA_ON();    //Anlage aktiv
    ALARM_LOW();  //kein Alarm in Basis
    //Laufvariable
    LF = 0x01;      //Laufvariable
    //SW
    SW = 0x30;    //SW-Version 3.0

    commando[0] = ADR;
    commando[1] = FKT;
    commando[2] = STA;
    //commando[3] = WRT0;
    commando[4] = LF;        
    commando[5] = SW;

    DATEN_SENDEN(commando);
    _delay_ms(3000);    //Zu Testzwecken

  } 
}

rfm12.h mit Funktion DATEN_SENDEN:

#define SYNC0  0x2D
#define SYNC1  0xD4
//funktioniert nicht
//uint8_t SYNC0 = 0x2D;
//uint8_t SYNC1 = 0xD4;
....

//Kommandos schreiben als Sender
unsigned int RFM_CMD_SENDER(unsigned int aCmd)
{
  int i = 0;
  unsigned int temp;

  LOW_SCK();
  LOW_SEL();

  for(i=0;i<16;i++)
  {
    temp<<=1;
    if(SDO_HI())
    {
      temp|=0x0001;
    }
    
    LOW_SCK();

    if(aCmd&0x8000)
    {
      HI_SDI();
    }
    
    else
    {
      LOW_SDI();
    }

    HI_SCK();
    aCmd<<=1;
  };

  LOW_SCK();
  HI_SEL();
  return(temp);
}

//Daten senden
void RFM_SEND(unsigned char aByte)
{
  while(PIND&(1<<RFM_IRQ)); //wartet bis RFM_IRQ auf LOW ist
  RFM_CMD_SENDER(0xB800+aByte);
}

void DATEN_SENDEN(unsigned char data[6])
{
  unsigned char ChkSum;
  int i;

  RFM_CMD_SENDER(0x0000);//Statusregister auslesen
  RFM_SENDER_EIN();  //Sender einschalten
  ChkSum=0;

  //---------------------------------------------
  //Prefix, 0-3 Bytes senden
  RFM_SEND(0xAA);//Präambel 0
  RFM_SEND(0xAA);//Präambel 1
  RFM_SEND(SYNC0);  //Synchronisation 0
  RFM_SEND(SYNC1);  //Synchronisation 1

  //4-9 Bytes senden
  for (i=0;i<6;i++)
  {
    RFM_SEND(data[i]);
    ChkSum+=data[i];
  }

  //Suffix, 10-12 Bytes senden
  RFM_SEND(ChkSum);   //Checksumme
  RFM_SEND(0xAA);  //Suffix 0
  RFM_SEND(0xAA);  //Suffix 1
  //---------------------------------------------

  RFM_SENDER_AUS();  //Sender wieder ausschalten

}

[P. F. (pfuhsy)]

HopeIHelped schrieb:
> Setzt du die Variablen im Hauptprogramm, rufst aber die Routine
> RFM_SEND() in einem Interrupt auf?
Nein. Siehe Code.

> Möglicherweise wurden die Variablen dann vom Compiler "wegoptimiert".
> Deklariere die Variablen mal als volatile uint8_t, oder kompiliere
> explizit im Debugmodus (= keine Optimierung).

Mit volatile kann ich während des debuggens unter "Os" in die Variable 
sehen, gut. Aber wegoptimiert ist das Ganze ohne volatile ja nicht 
wirlich. Wenn ich das  mit "Os" compiliere in meinen Controller lade und 
mit RFM12 an den anderen Controller sende, kommt der Inhalt der Variable 
an (sehe ich mit UART). Also ist Sie doch vorhanden.

[P. F. (pfuhsy)]

Ich hab hier ein einfaches Beispiel:

int main(void) //Hauptprogramm
{
  initPorts();    //Ports deklarieren
  uint8_t commando[6] = {"######"};
  
  uint8_t *test;
  test = &commando[0];
  
  initUART();      //UART initialisieren
.....

Unter Parameter "O0" kann ich die Variable "test" einsehen. Er springt 
von Zeile zu Zeile.
Unter Parameter "Os" springt er von "uint8_t commando[6] = {"######"};" 
direkt auf "initUART();". In der Watchlist steht dann unter "test" 
Location not valid. Heisst das jetzt er hat Sie wegoptimiert und findet 
sie jetzt nicht merh ? Warum ? Vielleihct weil sie sonst kein nutzen hat 
???

[Karl H. (kbuchegg)]

Peter F. schrieb:

> Location not valid. Heisst das jetzt er hat Sie wegoptimiert und findet
> sie jetzt nicht merh ?

Yep

> Warum ? Vielleihct weil sie sonst kein nutzen hat
> ???

genau. Der Compiler hat einen Weg gefunden, die Varible nicht zu 
benötigen. Sie existiert schlicht und ergreifend im endgültigen 
Programm, das zur Ausführung kommt nicht mehr.

Genauso wie er Anweisungen umsortieren wird und auch sonst noch so 
allerhand Dinge treiben wird, die dir beim Debuggen auffallen werden.

[Edi R. (edi_r)]

Peter F. schrieb:
> Edi R. schrieb:
>> #define SYNC0  0x2D
>> #define SYNC1  0xD4
>
> Das funktioniert. Ich versteh aber nicht genau warum das andere nicht
> geht.

So ganz klar ist mir das auch nicht. Aber:

Peter F. schrieb:
> rfm12.h mit Funktion DATEN_SENDEN:

Vielleicht liegt's daran. In einer .h-Datei sollten nur die Definitionen 
stehen, der Code selber sollte in einer .c-Datei sein. (Ist jetzt aber 
nur ein Schuss ins Dunkel.) Also z. B. so:

Datei rfm12.h:

#ifndef _rfm12_h_
#define _rfm12_h_

uint8_t SYNC0 = 0x2D;
uint8_t SYNC1 = 0xD4;

extern unsigned int RFM_CMD_SENDER(unsigned int aCmd);
extern void RFM_SEND(unsigned char aByte);
extern void DATEN_SENDEN(unsigned char data[6]);

#endif

Datei rfm12.c:

#include "rfm12.h"

//Kommandos schreiben als Sender
unsigned int RFM_CMD_SENDER(unsigned int aCmd)
{
  int i = 0;
  unsigned int temp;

  ... usw. den Rest des Codes

[Spax (Gast)]

Warum definierst du die Varibalen mit "uint8_t", wenn die Funktion 
"unsigned char" erwartet. Schion klar, dass möglicherweise beides 
dasselbe ist. Dennoch ist es schlechter Coding Stil und fehleranfällig.

[Edi R. (edi_r)]

Damit hast Du zwar uneingeschränkt recht, aber das ist sicher nicht der 
Grund, warum es überhaupt nicht funktioniert.