Time-Interrupt beim RFM12

[P. F. (pfuhsy)]

Hallo zusammen,

ich habe 2 Schaltungen. 2x ATmega8 mit RFM12 und ein paar LEDs.
Ich verwende das RFM12 und sende auf einer Siete jede sekunde 16 Bytes 
mit Checksumme. Auf der anderen Seite empfange ich die Bytes und 
signalisiere mit einer LED das die Checksumme ok ist. Somit weiß ich 
schonmal das dort etwas ankommt. Die Sendeseite hat einen Time-Interrupt 
der jede ms auslöst und mit einem Zähler meine LEDs schön blinken zu 
lassen. Dummerweise hab ich festgestellt, dass damit der RFM12 überhaupt 
nicht klar kommt. Ich sehe durch signalisierung der LED, dass der 
Empänger die gesendeten Bytes 5-10 mal empfängt und dann kommt nichts 
mehr an. Schalte ich den Timer des Senders aus, funtioniert alles 
tadellos.

//Hauptschleife
while(true)
{
    DATEN_SENDEN(COMMANDO);
    LED_GN();      //Ausgang der grünen LED setzten
    LED_RT();      //Ausgang der roten LED setzten
}

void DATEN_SENDEN(unsigned char data[15])
{
  unsigned char ChkSum;
  int i;
  
  RFM_CMD_SENDER(0x0000);//Statusregister auslesen
  RFM_SENDER_EIN();  //Sender einschalten
  ChkSum=0;
  
  //Prefix zur Datenübertragung
  RFM_SEND(0xAA);//PREAMBLE
  RFM_SEND(0xAA);//PREAMBLE
  RFM_SEND(0xAA);//PREAMBLE
  RFM_SEND(0x2D);//SYNC HI BYTE
  RFM_SEND(0xD4);//SYNC LOW BYTE

  //0-15 bytes senden
  for (i=0;i<16;i++)
  {
    //RFM_SEND(0x35);
    RFM_SEND(data[i]);
    ChkSum+=data[i];
    //ChkSum+=(0x35);
  }

  //Suffix zum Datenabschluss senden
  RFM_SEND(ChkSum); //Checksumme senden
  RFM_SEND(0xAA);//DUMMY BYTE
  RFM_SEND(0xAA);//DUMMY BYTE
  RFM_SEND(0xAA);//DUMMY BYTE
  RFM_SENDER_AUS();  //Sender wieder ausschalten
}

Durch Simulationen im AVRStudio weiß ich, dass die Funktion 
"DATEN_SENDEN" ca. 5ms und die anderen Funktionen etwa 9µs bei 8MHz 
brauchen. Somit wird mit dem Timer das Senden garantiert unterbrochen, 
ich verstehe aber nicht warum ihn das so stört. Er macht doch an der 
Stelle weiter wo er aufgehört hat.

Kann jemand helfen ?

[P. F. (pfuhsy)]

Nachtrag.
Testweise schalte ich den Interrupt mit "cli();" aus, sende die Daten 
und schalte ihn dannach wieder mit "sei();" ein. Dort das geht es auch 
nicht.
bis auf ...

TCNT0  = 131;      //Register Nachladen

...habe ich auch versucht alles in der Interrupt-Routine 
auszukommentieren. Hätte ja sein können, dass ich mit irgendwelchen 
Variablen unabsichtlich einen Überlauf produziere. man sagt ja, damit 
könnte der µC eigenartige zustände annehmen. Das klappt aber auch nicht. 
Es geht nur wenn den Timer komplett von Anfang an ausschaltet ist.

[P. F. (pfuhsy)]

So wie ich das sehe stoppt der Timer-Interrupt nach einer bestimmten 
Zeit. Aber warum ???

//#define F_CPU 8000000          //CPU festlegen

//#include <stdio.h>        //für die sprintf-Funktion notwendig
#include <stdbool.h>        //für Bool-Variablen
#include <util/delay.h>        //für Warteschleifen
#include <stdlib.h>          //für Zufallszahlen
#include <avr/eeprom.h>        //für den Speicher
#include <avr/interrupt.h>      //für Interrupts
#include <avr/sleep.h>        //für den Schlafmodus
#include "uart.h"
#include "ports.h"
#include "rfm12.h"

//Konstanten für Sendekommandos
//#define KOMMANDO_PRE  "HAAv2"    //Prefix zum Sendekommando 
//#define REED01_ON    "R01C01"  //Reedkontakt 1 einschalten
//#define REED01_OFF  "R01C00"  //Reedkontakt 1 ausschalten
//#define REED01_STATUS  "R01S00"  //Reedkontakt 1 allg. Status 
//#define KOMMANDO_SUF  "FV1"    //Sufix zum Sendekommando (Fuhsy Verschlüsselung v1)

//#define CODE      "MNiPFuiba140582g"  //Verschlüsselungscode
#define COMMANDO    "012345678901234#"

//TODO: Konstanten in Funktion verwenden
//Konstanten
//#define T_VORALARM     = 10000;  //Totzeit bis Voralarm zum Alarm wird in ms
//#define T_SCHARF    = 10000    //Totzeit bis Analge scharf geschaltet wird in ms

//Globale Variablen: Zustände der Anlage
bool  _kontakt_alarm  = false;
bool  _rfm_alarm    = false;
bool  _voralarm      = false;
bool  _alarm      = false;
bool  _anlage_start    = false;
bool  _anlage_scharf  = false;

//Globale Variablen: Zeitmessungen
int16_t _zeit_LED_rot = 0;
int16_t _zeit_ms = 0;
bool _zeit_LED_rot_reset = false;
int16_t _zeit_LED_gruen = 0;
bool _zeit_LED_gruen_reset = false;
int16_t _zeit_anlage_scharf = 0;
bool _zeit_anlage_scharf_reset = false;
int16_t _zeit_voralarm = 0;
bool _zeit_voralarm_reset = false;

void initPorts() //Ports deklarieren
{
  //PB
  //Output
  DDRB |= (1<<REL_K1);  //Relais K1 OUTPUT        
  DDRB |= (1<<RFM_SEL);  //SEL_OUTPUT
  DDRB |= (1<<RFM_SDI);  //SDI_OUTPUT
  DDRB |= (1<<RFM_SCK);  //SCK_OUTPUT  
  //Input
  DDRB &=~(1<<RFM_SDO);  //SDO_INPUT

  //PC
  //Output
  DDRC |= (1<<CS_EXIT);  //Externer Zugriff auf Codeschloss
  //Input
  DDRC &=~(1<<REED_0);  //Reed 0
  DDRC &=~(1<<REED_1);  //Reed 1
  DDRC &=~(1<<REED_2);  //Reed 2
  DDRC &=~(1<<REED_3);  //Reed 3
  DDRC &=~(1<<CS_REL2);  //Relais 2 des Codeschlosses
  
  //PD
  //Output
  DDRD |= (1<<RFM_POWER);  //Ausgang für Spannungsversorgung des RFMs
  DDRD |= (1<<LED_ROT);  //LED für allg. Statuszustand  
  DDRD |= (1<<LED_GRUEN);  //LED für "Anlage nicht scharf"
  DDRD |= (1<<LED_RES);  //Reserve
  //Input
  DDRD &=~(1<<RFM_IRQ);  //IRQ_IN  
  DDRD &=~(1<<CS_REL1);  //Relais 1 vom Codeschloss

  //interne Pull-Up-Widerstände einschalten
  PORTC |= (1<<CS_REL2); //Realis 2 vom Codeschloss  
  PORTD |= (1<<CS_REL1); //Realis 1 vom Codeschloss  

  //Ports initiaisieren, aus LOW setzten
  REL_K1_OFF();
  CS_EXIT_OFF();
  RFM_OFF();
  LED_ROT_OFF();
  LED_GRUEN_OFF();
  LED_RES_OFF();
}

void Zustand_Anlage() //allg. Zustand der Alarmanlage abfragen
{
  int16_t zeit = 5000;          //Totzeit bis Anlage scharf geschaltet wird in ms TODO: Zeit für Testzwecke runtergesetzt

  //Relais 1 vom Codeschloss aktiv
  if (CS_REL1_OPEN())            
  {
    _anlage_start = true;
    
    //Totzeit ist noch nicht abgelaufen.
    if (_zeit_anlage_scharf <= zeit)
    {
      _anlage_scharf = false;
    }
    
    //Totzeit ist abgelaufen
    else
    {
      _anlage_scharf = true;
      _zeit_anlage_scharf = zeit;
    }
  }
  
  //Relais 1 vom Codeschloss nicht aktiv
  else
  {
    _anlage_start = false;
    _anlage_scharf = false;
    _zeit_anlage_scharf = 0;
  }
  
  //Ein Reedkontakt ist geöffnet
/*  if (REED_0_OPEN() | REED_1_OPEN() | REED_2_OPEN() | REED_3_OPEN())
  {
    _kontakt_alarm = true;
  }

  //Alle Reedkontakte sind geschlossen
  else
  {
    _kontakt_alarm = false;
  }
*/
}

void initTimer()
{
  TCCR0 =(1<<CS01) | (1<<CS00);     //Vorteiler 64 setzten
  TCNT0  = 131;            //register Vorladen
  TIMSK |= (1<<TOIE0);        //Timer 0 enable
  sei();                //alle Interrups einschalten
}


void RFM_Ueberwachung()  //RFM-Reed_kontakte abfragen
{
/*  static bool pruefung_start = true;  //damit soll nur einmal pro Zeitheit geprüft werden
  static int wiederholung = 0;  //Anzahl der Prüfungswiederholungen
  //static int zeit_rfm = 0;    //Zeitvergleich für Variable "zeit"
  int zeit = 100;          //Zeit für Prüfungsintervalle  
  
  //Prüft ob die Anlage scharf ist oder gerade startet
  if (_anlage_start || _anlage_scharf)
  {
    RFM_ON();  //Modul einschalten
  }
  
  else
  {
    RFM_OFF();  //Modul auschaltet
  }
  
  //Anlage ist scharf geschaltet
  if (_anlage_scharf)
  {
  }

  //Anlage ist noch nicht scharf
  else
  {
    //Anlage startet gerade
    if (_anlage_start)
    {
      //Wiederholungen für Prüfungsinterval prüfen
      //Wiederholungen noch nicht erreicht
      if (wiederholung <= 5)
      {
        //Prüfen ob schonmal geprüft wurde
        if (pruefung_start)
        {
          pruefung_start == false;  //damit die Prüfung nicht nochmal gestartet wird
          wiederholung ++;      //nur 5mal prüfen
          //RFM_Kommando(Sender)     //RFM als Sender konfiguieren
          //RFM_Senden(Reed_abfragen);//Reed-Status abfragen
          //RFM_Kommando(Empfang)   //RFM als Empfänger konfiguieren
        }

        //noch nicht geprüft
        else
        {
          //Zeit noch nicht erreicht
          if (zeit_rfm <= zeit -1)
          {
            zeit_rfm ++;
          }

          //Zeit wurde erreicht
          else
          {
            zeit_rfm == 0;
            pruefung_start == true;
          }
        }
      }

      //Wiederholungen erreicht
      else
      {
        _rfm_alarm == true;  //RFM-Alarm setzten
      }
    }

    //Anlage startet nicht mehr
    else
    {
      pruefung_start == true;  //Prüfungintervall wieder zulassen
      wiederholung == 0;  //Widerholungsinterval zurücksetzten
      zeit_rfm == 0;    //Zeit zurücksetzten
    }
  }*/
}

void Voralarm()  //Abfragen ob ein Voralarm vorhanden ist
{
  //Alarmanlage ist scharf gestellt
  if (_anlage_scharf)
  {  
    //Reed 0 ist ausgelöst
    if (REED_0_OPEN())
    {
      _voralarm = true;
    }
  }

  //Alarmanlage noch nicht scharf gestellt
  else
  {
    _voralarm = false;
  }
}

void Alarm() //Abfragen ob ein Alarm vorhanden ist
{
  int16_t zeit = 10000;        //Totzeit bis Voralarm zum Alarm wird

  //Alarmanlage ist scharf geschaltet
  if (_anlage_scharf)
  {  
    //Reed 1, 2 oder 3 ist ausgelöst (Reed 0 ist die Tür)
    if (REED_1_OPEN() | REED_2_OPEN() | REED_3_OPEN())
    {
      REL_K1_ON();
      _alarm = true;
    }

    //Voralarm wurde ausgelöst
    if (_voralarm)
    {
      //Totzeit für Voralarm noch nicht abgelaufen
      if (_zeit_voralarm < zeit)
      {
      }

      //Totzeit für Voralarm abgelaufen
      else
      {
        REL_K1_ON();
        _zeit_voralarm = zeit;
        _alarm = true;
      }  
    }

    //Voralarm noch nicht ausgelöst
    else 
    {
      _zeit_voralarm = 0;
    }
  }
  
  //Alarmanlage noch nicht scharf gestellt
  else
  {
    REL_K1_OFF();
    _alarm = false;
    _zeit_voralarm = 0;
  }
}

void LED_GN()  //LED grün für "Alles OK" setzten
{
  static int16_t t_an = 0;  //Zeitvariable für LED-Blinkfunktion
  static int16_t t_aus = 0;  
  
  //Ein Kontakt ist geöffnet
  if (_kontakt_alarm)
  {
    t_an  = 500; //Zeitvariable für LED-Blinkfunktion
    t_aus = 500; //Zeitvariable für LED-Blinkfunktion
  }
  
  //alle Kontakte geschlossen
  else
  {
    t_an  = 0; //Zeitvariable für Dauerlicht
    t_aus = 0; //Zeitvariable für Dauerlicht
  }

  //Anlage ist scharf
  if (_anlage_scharf)
  {
    LED_GRUEN_OFF();
    _zeit_LED_gruen = 0;
  }
  
  //Anlage ist nicht scharf
  else
  {
    
    //Blinkfrequenz LED an
    if (_zeit_LED_gruen <= t_an) 
    {
      LED_GRUEN_ON();
    }

    else
    {
      //Blinkfrequenz LED aus
      if (_zeit_LED_gruen <= t_an + t_aus)
      {
        LED_GRUEN_OFF();
      }

      //...Zähler wieder zurücksetzten
      else
      {
        _zeit_LED_gruen = 0;
      }
    }
  }
}

void LED_RT()  //LED rot für allg. Betriebszustände setzten
{
  static int16_t t_an = 0;    //Zeitvariable für LED-Blinkfunktion
  static int16_t t_aus = 0;    

  //Wenn einer davon auf true ist, fängt die LED an zu blinken
  if (_rfm_alarm ||
    _voralarm || _alarm || 
    _anlage_start || _anlage_scharf)
  {
    //Blinkfrequenz LED an
    if (_zeit_LED_rot <= t_an)
                  
    {
      LED_ROT_ON(); //LED einschalten
    }
      
    //Blinkfrequenz LED aus
    else
    {
      if (_zeit_LED_rot <= t_an + t_aus)
      {
        LED_ROT_OFF();
      }

      //...Zähler wieder zurücksetzten
      else
      {
        _zeit_LED_rot = 0;
      }
    }      
  }

  //keine Aktivität der Anlage vorhanden
  else
  {
    LED_ROT_OFF();
  }

  //Blinkzeiten setzten, Reihenfolge beachten    
  //Anlage startet gerade
  if (_anlage_start)
  {
    t_an = 500;  //in Milisekunden
    t_aus = 500;
  }

  //Anlage ist scharf
  if (_anlage_scharf)
  {
    t_an = 100;  //in Milisekunden
    t_aus = 2900;
  }

  //Voralarm ist vorhanden
  if (_voralarm)
  {
    t_an = 250;  //in Milisekunden
    t_aus = 250;
  }

  //Alarm ist vorhanden
  if (_alarm)
  {
    t_an = 0;  //in Milisekunden
    t_aus = 0;  
  }
}

void Verschluesseln(char kommando[])
{
/*
  int zufall = rand();  //Zufallszahl erzeugen
  int i = 0;        //Laufvariable
  int ascii[16] = {0};  //Array für Sendetext
  int ascii_int;       //zeigen als integerzahl

  //Prefix "HAAv2"
  for(i=0; i<=4; i++)
  {
    ascii[i] = zufall + CODE[i] + KOMMANDO_PRE[i];  
  }

  //Kommando "R01C01"
  for(i=5; i<=10; i++)
  {
    ascii_int = *&kommando[i];
    ascii[i] = ascii_int;
    //ascii[i] = zufall + CODE[i] + ascii_int;
  }

  //Laufvariable "1"
  ascii[11] = zufall + CODE[11];

  //Zufallszahl "#"
  ascii[12] = zufall + CODE[12];

  //Sufix "FV1"
  for(i=13; i<=15; i++)
  {
    ascii[i] = zufall + CODE[i] + KOMMANDO_SUF[i];  
  }

  while(true)
  {
    int zufall = rand();

    int b0 = zufall + 'M' + 72; //H
    int b1 = zufall + 'N' + 65;  //A
    int b2 = zufall + 'i' + 65;  //A
    int b3 = zufall + 'P' + 118;//v
    int b4 = zufall + 'F' + 50;  //2
    int b5 = zufall + 'u' + 82; //R
    int b6 = zufall + 'i' + 48; //0
    int b7 = zufall + 'b' + 49;  //1
    int b8 = zufall + 'a' + 67; //C
    int b9 = zufall + '1' + 48;  //0
    int b10 = zufall + '4' + 49;//1
    int b11 = zufall + '0' + 49;//1
    int b12 = zufall + '5'; //reine Zufallszahl
    int b13 = zufall + '8' + 116;//F
    int b14 = zufall + '5' + 86;//V
    int b15 = zufall + 'g' + 49;//1

    int zufall_x = b15 - 'g';
    int c0 = b0 - zufall_x - 'M';
    int c1 = b1 - zufall_x - 'N';
    int c2 = b2 - zufall_x - 'i';
    int c3 = b3 - zufall_x - 'P';
    int c4 = b4 - zufall_x - 'F';
    int c5 = b5 - zufall_x - 'u';
    int c6 = b6 - zufall_x - 'i';
    int c7 = b7 - zufall_x - 'b';
    int c8 = b8 - zufall_x - 'a';
    int c9 = b9 - zufall_x - '1';
    int c10 = b10 - zufall_x - '4';
    int c11 = b11 - zufall_x - '0';
    int c12 = b12 - zufall_x - '5';
    int c13 = b13 - zufall_x - '8';
    int c14 = b14 - zufall_x - '5';
    int c15 = b15 - zufall_x - 'g';    
  }
*/
}

void Test()
{
  static int16_t zeit_anff = 0;
  static int16_t zeit_ende = 0;
  static bool erstes_mal = true;
    
  int16_t zeit_diff = 0;
  int16_t t_an = 500;
  int16_t t_aus = 500;
  int16_t addition = 0;

  //damit beim ersten mal die Zeit notiert wird
  if (erstes_mal)
  {
    erstes_mal = false;
    zeit_anff = _zeit_ms;
    zeit_ende = _zeit_ms;
  }
  
  //bei nicht ersten mal wird dann nur die Endzeit notiert
  else
  {
    zeit_ende = _zeit_ms;
  }
  
  //damit beim errechnen keine negativen zahlen kommen
  //da die Zeit bis 999 geht und dann wieder mit 0 anfängt
  if (zeit_anff > zeit_ende)
  {
    addition = 1000;
  }
  zeit_diff = (zeit_ende + addition) - zeit_anff;

  //Zeit zum Ausschalten noch nicht erreicht
  if (zeit_diff <= t_an)
  {
    LED_ROT_ON();
  }
  
  //Zeit zum ausschalten erreicht
  else
  {
    if (zeit_diff <= t_an + t_aus)
    {
      LED_ROT_OFF();
    }
    else
    {
      //alle Zähler wieder reseten
      erstes_mal = true;
      zeit_anff = 0;
      zeit_ende = 0;
    }
  }

  
}


int main(void)
{
  initPorts();    //Ports deklarieren
  initUART();      //UART initialisieren
  initTimer();    //Timer initialisieren

  RFM_ON();      //Modul einschalten
  _delay_ms(100);    //etwas warten bis das Modul bereit ist
  init_RFM_Ports();  //RFM-Ports initialisieren
  init_RFM();      //RFM initialisieren
  
  //Hauptschleife
  while(true)
  {
    Test();
    Zustand_Anlage();  //Anlagenzustand abfragen    
    //RFM_Ueberwachung();  //RFM-Kontakte abfragen
    DATEN_SENDEN(COMMANDO);
    //Verschluesseln (&REED01_ON[0]);
    Voralarm();      //Abfragen ob ein Voralarm vorhanden ist
    Alarm();      //Abfragen ob ein Alarm vorhanden ist
    LED_GN();      //Ausgang der grünen LED setzten
    //LED_RT();      //Ausgang der roten LED setzten
    //_delay_ms(1000);
  } 
}

//Time-Interrupt, wird jede ms ausgelöst
ISR(TIMER0_OVF_vect)
{
  //TODO: Zeiten müssen zurückgesetzt werden, wenn sie nicht gebraucht werden.
  //z.b. während der Funktion "Daten senden" die ca. 6ms dauert.
  //sonst sind die Zeitvariablen > 0 und die LED zeigen was falsches an

  //Zeitkonstsnten für verschiedene Aufaben
  //_zeit_LED_rot ++;      
  //_zeit_LED_gruen ++;
  //_zeit_anlage_scharf ++;
  //_zeit_voralarm ++;

  TCNT0  = 131;      //Register Nachladen
  //Zu testzwecken
  if (_zeit_ms < 999)
  {
    _zeit_ms ++;
    
  }
  
  else
  {
    _zeit_ms = 0;
  }
}

[P. F. (pfuhsy)]

Das ganze Programm bleibt stehen. Wenn ich den Timer ausschalte geht es. 
Warum ??? Irgendwie führe ich selbstgespräche !

[Carsten M. (ccp1con)]

Tja ... schwer zu sagen. Das ist ein Haufen Zeug.
Hast du keine Möglichkeit breake points zu setzten und zu debuggen?

[P. F. (pfuhsy)]

Nein debuggen kann ich leider nicht. ich konnte das ganz schon etwas auf 
den timer eingrenzen. Wenn ich einen Timer mit Compare benutze scheint 
es zu funktionieren.

[Felix P. (fixxl)]

Nachdem es ja einige Male zu funktionieren scheint, könnte es 
unerheblich sein, mir fällt aber auf:

COMMANDO besteht aus 16 Zeichen + String-Terminierung, das Array von 
DATEN_SENDEN ist dafür aber zu klein. Ich würde die Funktion so 
deklarieren*:

void DATEN_SENDEN(unsigned char *data)

Dann gibt es mit der Array-Größe schon mal kein Vertun.

* ich würde, da es eine Funktion ist, auch den Namen in Kleinbuchstaben 
schreiben, aber das ist sicher nicht das Problem.

[Mobilist (Gast)]

Peter F. schrieb:
> Aber warum ???

Ist bei dir die Funktion für Dateianhänge kaputt?
Da kriegt man doch wunde Finger vom Scrollen.