Atmel 8 hängt sich auf - trotz Watchdog und WDTON

/********************************************************************

Sende-Knoten

(c) 2009 by Sebastian Wille

**********************************************************************/

//* includes ************************************************

#include <stdint.h>

#include <avr/io.h>

#include <avr/interrupt.h>

#include <avr/sleep.h>

#include <avr/wdt.h>

//* defines *************************************************

#define SDO_PORT PORTB

#define SDO_PIN PINB

#define SDO_DDR DDRB

#define SDO_Nr 6

/*#define SDO_PORT PORTC

#define SDO_PIN PINC

#define SDO_DDR DDRC

#define SDO_Nr 5*/

#define SDO_OUTPUT() SDO_DDR |= (1<<SDO_Nr)

#define SDO_INPUT() SDO_DDR&= ~(1<<SDO_Nr)

#define SDO_LOW() SDO_PORT&=~(1<<SDO_Nr)

#define SDO_is_HI() SDO_PIN&(1<<SDO_Nr)

#define nIRQ_PORT PORTB

#define nIRQ_PIN PINB

#define nIRQ_DDR DDRB

#define nIRQ_Nr 7

/*#define nIRQ_PORT PORTC

#define nIRQ_PIN PINC

#define nIRQ_DDR DDRC

#define nIRQ_Nr 4 */

#define nIRQ_OUTPUT() nIRQ_DDR |= (1<<nIRQ_Nr)

#define nIRQ_INPUT() nIRQ_DDR&= ~(1<<nIRQ_Nr)

#define nIRQ_LOW() nIRQ_PORT&=~(1<<nIRQ_Nr)

#define DATA_PORT PORTD

#define DATA_PIN PIND

#define DATA_DDR DDRD

#define DATA_Nr 5

#define DATA_OUTPUT() DATA_DDR |= (1<<DATA_Nr)

#define DATA_INPUT() DATA_DDR&= ~(1<<DATA_Nr)

#define DATA_LOW() DATA_PORT&=~(1<<DATA_Nr)

#define DATA_OUT DDR_DATA|=(1<<DATA_Nr)

#define DATA_HI PORT_DATA|=(1<<DATA_Nr)

#define nSEL_PORT PORTD

#define nSEL_PIN PIND

#define nSEL_DDR DDRD

#define nSEL_Nr 6

#define nSEL_OUTPUT() nSEL_DDR |= (1<<nSEL_Nr)

#define nSEL_HI() nSEL_PORT|= (1<<nSEL_Nr)

#define nSEL_LOW() nSEL_PORT&=~(1<<nSEL_Nr)

#define SCK_PORT PORTD

#define SCK_PIN PIND

#define SCK_DDR DDRD

#define SCK_Nr 7

#define SCK_OUTPUT() SCK_DDR |= (1<<SCK_Nr)

#define SCK_HI() SCK_PORT|= (1<<SCK_Nr)

#define SCK_LOW() SCK_PORT&=~(1<<SCK_Nr)

#define SDI_PORT PORTB

#define SDI_PIN PINB

#define SDI_DDR DDRB

#define SDI_Nr 0

#define SDI_OUTPUT() SDI_DDR |= (1<<SDI_Nr)

#define SDI_HI() SDI_PORT|= (1<<SDI_Nr)

#define SDI_LOW() SDI_PORT&=~(1<<SDI_Nr)

#define LED1_PORT PORTD

#define LED1_DDR DDRD

#define LED1_Nr 0

#define LED1_OUTPUT() LED1_DDR|=(1<<LED1_Nr)

#define LED1_OFF() LED1_PORT&=~(1<<LED1_Nr)

#define LED1_ON() LED1_PORT|=(1<<LED1_Nr)

#define MODULE_PORT PORTB

#define MODULE_DDR DDRB

#define MODULE_Nr 1

#define MODULE_OUTPUT() MODULE_DDR|=(1<<MODULE_Nr)

//#define MODULE_OFF() MODULE_PORT&=~(1<<MODULE_Nr)

#define MODULE_ON() MODULE_PORT|=(1<<MODULE_Nr)

#define MASSE0_PORT PORTD

#define MASSE0_DDR DDRD

#define MASSE0_Nr 1

#define MASSE0_OUTPUT() MASSE0_DDR |= (1<<MASSE0_Nr)

#define MASSE0_LOW() MASSE0_PORT&=~(1<<MASSE0_Nr)

#define MASSE1_PORT PORTD

#define MASSE1_DDR DDRD

#define MASSE1_Nr 4

#define MASSE1_OUTPUT() MASSE1_DDR |= (1<<MASSE1_Nr)

#define MASSE1_LOW() MASSE1_PORT&=~(1<<MASSE1_Nr)

#define INT0_PIN PIND

#define INT0_PORT PORTD

#define INT0_DDR DDRD

#define INT0_Nr 2

#define INT0_INPUT() INT0_DDR&= ~(1<<INT0_Nr)

#define INT0_HI() INT0_PORT|= (1<<INT0_Nr)

#define INT1_PIN PIND

#define INT1_PORT PORTD

#define INT1_DDR DDRD

#define INT1_Nr 3

#define INT1_INPUT() INT1_DDR&= ~(1<<INT1_Nr)

#define INT1_HI() INT1_PORT|= (1<<INT1_Nr)

// Knoten-Parameter

#define NodeID 0b01100000

#define KeepAliveMin 120

#define INT0_delays 12 // x Mal 250ms entprellen

#define INT1_delays 12 // x Mal 250ms entprellen

#define ADC_threshold 85

//* variables ***********************************************

unsigned int timer2counterIntern = 0;

unsigned int timer2counterSec = 0;

unsigned int timer2counterMin = 0;

unsigned int INT0_changed = 0;

unsigned int INT1_changed = 0;

unsigned int INT1_is_Movement = 0;    // 1=ja, Bewegungsmelder statt Reed

unsigned int Movement_Timer = 60;

unsigned int Movement_Timer_max = 60; // Sekunden

unsigned int INT0_old = 0;

unsigned int INT1_old = 0;

uint16_t ADC0_old = 1000; // Offset von 1000 wg. +/- ADC_threshold!!!

uint16_t ADC1_old = 1000;

unsigned int KeepAlive_changed = 0;

unsigned int sendCounter = 0;

uint8_t goBsp=0;

//* functions ***********************************************

void Delay_ms(unsigned char amS){

  unsigned char i;

  unsigned int j;

  //for(i=0;i<amS;i++)for(j=0;j<914;j++);

  for(i=0;i<amS;i++)for(j=0;j<440;j++);

}

void MODULE_OFF(void){

  MODULE_PORT&=~(1<<MODULE_Nr);

  nSEL_LOW();

  SDI_LOW();

  SCK_LOW();

  SDO_OUTPUT();

  SDO_LOW();

  nIRQ_OUTPUT();

  nIRQ_LOW();

  DATA_OUTPUT();

  DATA_LOW();

}

void Port_init(void){

  DDRB=0x00;//PB INPUT

  DDRC=0x00;//PC INPUT

  DDRD=0x00;//PD INPUT

  PORTC=0x00;

  LED1_OUTPUT();

  LED1_OFF();

  MODULE_OUTPUT();

  MODULE_OFF();

  MASSE0_OUTPUT();

  MASSE0_LOW();

  MASSE1_OUTPUT();

  MASSE1_LOW();

  INT0_INPUT();

  INT0_HI();

  INT1_INPUT();

  INT1_HI();

}

void ADC_init_freerunning(uint8_t ch) {

  ADCSRA = 0;

  ADMUX = 0;

  ADMUX = ch;                      // Kanal waehlen

  ADMUX |= (1<<ADLAR) | (1<<REFS1) | (1<<REFS0); // externe Referenzspannung nutzen

  ADCSRA = 0;

  ADCSRA = (1<<ADEN) | (1<<ADSC) | (1<<ADFR) | (0<<ADIF) | (0<<ADIE) | (1<<ADPS2) | (1<<ADPS1) | (1<<ADPS0);

}

uint16_t ADC_read_single(uint8_t ch){

  uint8_t i;

  uint16_t result;

  ADMUX = 0;

  ADMUX = ch;                      // Kanal waehlen

  ADMUX |= (0<<ADLAR) | (1<<REFS1) | (1<<REFS0); // externe Referenzspannung nutzen

  ADCSRA = 0;

  ADCSRA = (1<<ADEN) | (0<<ADSC)| (0<<ADFR) | (0<<ADIF) | (0<<ADIE) | (1<<ADPS2) | (1<<ADPS1) | (1<<ADPS0);

  // Dummy-Readout

  ADCSRA |= (1<<ADSC);              // eine ADC-Wandlung 

  while ( ADCSRA & (1<<ADSC) ) {

     ;     // auf Abschluss der Konvertierung warten 

  }

  result = ADCW;  // ADCW muss einmal gelesen werden,

                  // sonst wird Ergebnis der nächsten Wandlung

                  // nicht übernommen.

  /* Eigentliche Messung - Mittelwert aus 4 aufeinanderfolgenden Wandlungen */

  result = 0; 

  for( i=0; i<4; i++ )

  {

    ADCSRA |= (1<<ADSC);            // eine Wandlung "single conversion"

    while ( ADCSRA & (1<<ADSC) ) {

      ;   // auf Abschluss der Konvertierung warten

    }

    result += ADCW;        // Wandlungsergebnisse aufaddieren

  }

  ADCSRA &= ~(1<<ADEN);             // ADC deaktivieren (2)

  result /= 4;                     // Summe durch vier teilen = arithm. Mittelwert

  return result;

}

void LED1_blink_3x(void){

  unsigned int i;

  for(i=0;i<3;i++){

    Delay_ms(75);

    LED1_ON();

    Delay_ms(75);

    LED1_OFF();

  }

}

unsigned int RFXX_WRT_CMD(unsigned int aCmd){

  unsigned char i;

  unsigned int temp;

  SCK_LOW();

  nSEL_LOW();

  for(i=0;i<16;i++){

    temp<<=1;

    if(SDO_is_HI()){

      temp|=0x0001;

    }

    SCK_LOW();

    if(aCmd&0x8000){

      SDI_HI();

      }else{

      SDI_LOW();

    }

    SCK_HI();

    aCmd<<=1;

  };

  SCK_LOW();

  nSEL_HI();

  return(temp);

}

void RF12_SEND(unsigned char aByte){

  while(nIRQ_PIN&(1<<nIRQ_Nr));//wait for previously TX over

    RFXX_WRT_CMD(0xB800+aByte);

}

void MODULE_init(void){

  SDO_INPUT();

  nIRQ_INPUT();

  DATA_INPUT();

  MODULE_ON();

  Delay_ms(200);

  // module ports init

  nSEL_HI();

  SDI_HI();

  SCK_LOW();

  nSEL_OUTPUT();

  SDI_OUTPUT();

  SDO_INPUT();

  SCK_OUTPUT();

  // set parameters

  RFXX_WRT_CMD(0x80D7);//EL,EF,12.0pF 433 MHz

  //RFXX_WRT_CMD(0x80E7);//EL,EF,12.0pF 868 MHz

  RFXX_WRT_CMD(0x8239);//!er,!ebb,ET,ES,EX,!eb,!ew,DC

  RFXX_WRT_CMD(0xA640);//A140=430.8MHz

  //RFXX_WRT_CMD(0xA6F8);//868,92MHz

  RFXX_WRT_CMD(0xC647);//4.8kbps

  RFXX_WRT_CMD(0x94A0);//VDI,FAST,134kHz,0dBm,-103dBm

  //RFXX_WRT_CMD(0x94B8);//VDI,FAST,134kHz,-20dBm,-103dBm

  RFXX_WRT_CMD(0xC2AC);//AL,!ml,DIG,DQD4

  RFXX_WRT_CMD(0xCA81);//FIFO8,SYNC,!ff,DR

  RFXX_WRT_CMD(0xC483);//@PWR,NO RSTRIC,!st,!fi,OE,EN

  RFXX_WRT_CMD(0x9850);//!mp,9810=30kHz,MAX OUT

  RFXX_WRT_CMD(0xE000);//NOT USE

  RFXX_WRT_CMD(0xC800);//NOT USE

  RFXX_WRT_CMD(0xC400);//1.66MHz,2.2V

  // DATA port init

  DATA_DDR|=(1<<DATA_Nr);

  DATA_PORT|=(1<<DATA_Nr);// SET nFFS pin HI when using TX register

  // nIRQ init

  nIRQ_DDR&=~(1<<nIRQ_Nr);

}

void send_Byte(unsigned char dataByte){

  //unsigned char i;

  MODULE_init();

  LED1_ON();

  RFXX_WRT_CMD(0x0000);//read status register

  RFXX_WRT_CMD(0x8239);//!er,!ebb,ET,ES,EX,!eb,!ew,DC

  RF12_SEND(0xAA);//PREAMBLE

  RF12_SEND(0xAA);//PREAMBLE

  RF12_SEND(0xAA);//PREAMBLE

  RF12_SEND(0x2D);//SYNC HI BYTE

  RF12_SEND(0xD4);//SYNC LOW BYTE

  //for(i=0;i<10;i++){

    RF12_SEND(dataByte);//DATA BYTE

  RF12_SEND(0xFF-dataByte);//Checksum

    //Delay_ms(2);

  //}

  RF12_SEND(0xAA);//DUMMY BYTE

  RF12_SEND(0xAA);//DUMMY BYTE

  RF12_SEND(0xAA);//DUMMY BYTE

  RFXX_WRT_CMD(0x8201);

  LED1_OFF();

  MODULE_OFF();

}

void send_Byte_multiple(unsigned char dataByte, unsigned char multiple){

  unsigned char i;

  MODULE_init();

  for(i=0;i<multiple;i++){

    LED1_ON();

    RFXX_WRT_CMD(0x0000);//read status register

    RFXX_WRT_CMD(0x8239);//!er,!ebb,ET,ES,EX,!eb,!ew,DC

    RF12_SEND(0xAA);//PREAMBLE

    RF12_SEND(0xAA);//PREAMBLE

    RF12_SEND(0xAA);//PREAMBLE

    RF12_SEND(0x2D);//SYNC HI BYTE

    RF12_SEND(0xD4);//SYNC LOW BYTE

    RF12_SEND(dataByte);//DATA BYTE

  RF12_SEND(0xFF-dataByte);//Checksum

    RF12_SEND(0xAA);//DUMMY BYTE

    RF12_SEND(0xAA);//DUMMY BYTE

    RF12_SEND(0xAA);//DUMMY BYTE

    RFXX_WRT_CMD(0x8201);

    LED1_OFF();

  }

  MODULE_OFF();

}

void sendCounterInc(void){

  sendCounter = sendCounter +1;

  if(sendCounter > 1){

    sendCounter = 0;

  }

}

ISR (SIG_INTERRUPT0)

{

  uint8_t tmp_sreg;

  tmp_sreg = SREG;

  asm("cli");

  INT0_changed=1;

  // muss drin bleiben!

//  LED1_ON();

//  Delay_ms(1);

//  LED1_OFF();

  asm("sei");

  SREG = tmp_sreg;

}

ISR (SIG_INTERRUPT1)

{

  uint8_t tmp_sreg;

  tmp_sreg = SREG;

  asm("cli");

  INT1_changed=1;

  // muss drin bleiben!

//  LED1_ON();

//  Delay_ms(1);

//  LED1_OFF();

  asm("sei");

  SREG = tmp_sreg;

}

ISR (SIG_OVERFLOW2)

{

  uint8_t tmp_sreg;

  tmp_sreg = SREG;

  timer2counterIntern += 1;

  //if(timer2counterIntern == 30){ // 1 Sekunde

  if(timer2counterIntern == 36){ // 1 Sekunde

    timer2counterIntern=0;

  //goBsp=1;

    if(Movement_Timer == Movement_Timer_max){

      //Movement_Timer = Movement_Timer;

  }else{

      Movement_Timer = Movement_Timer +1;

  }

    timer2counterSec += 1;

    if(timer2counterSec == 60){

    timer2counterSec = 0;

      timer2counterMin += 1;

      if(timer2counterMin == KeepAliveMin){

        timer2counterMin = 0;

      KeepAlive_changed = 1;

      }

  }

  }

  SREG = tmp_sreg;

}

void main(void)

{

  //unsigned int i,j;

  uint8_t ADC_readout;

  uint8_t dataByte;

  int16_t i1;

  // Watchdog an

  wdt_enable(WDTO_500MS);

  asm("cli"); // interrupts off

  Port_init();

  //ADC_init_freerunning(0);

  // Externe Interrupts konfigurieren

  MCUCR &= 0b11110000;

  if (INT1_is_Movement == 0){

    MCUCR |= (1<<ISC10)|(1<<ISC00);

  }else{

    MCUCR |= (1<<ISC11)|(1<<ISC00);

  }

  GICR |= (1<<INT1)|(1<<INT0);

  GIFR |= (1<<INTF1)|(1<<INTF0);

  asm("sei"); // interrupts on

  //LED1_blink_3x();

  // Normaler oder Watchdog-Reset?

  if ((MCUCSR&(1<<WDRF)) > 0){

    send_Byte_multiple(NodeID, 5);

    MCUCSR = 0;

  }else{

  send_Byte_multiple(NodeID, 3);

  }

  while(1){

    wdt_reset();

    //asm("cli"); // interrupts off

    /*if(goBsp==1){

    send_Byte('S');

    goBsp=0;

    }*/

  // ADC0 changed?

    ADC_readout = (ADC_read_single(0) >> 2) & 0x00FF;

  //send_Byte(ADC_readout);

    i1 = ADC0_old - ADC_threshold;

  if (ADC_readout +1000 < i1){

      ADC0_old = ADC_readout +1000;

    dataByte = NodeID;

      dataByte |= (1<<3);

    sendCounterInc();

    dataByte |= sendCounter;

      send_Byte(dataByte);

    //send_Byte(ADC_readout);

  } else

  {

  i1 = ADC0_old + ADC_threshold;

  if (ADC_readout +1000 > i1){

      ADC0_old = ADC_readout +1000;

    dataByte = NodeID;

      dataByte |= (1<<3);

    dataByte |= (1<<1);

    sendCounterInc();

    dataByte |= sendCounter;

      send_Byte(dataByte);

    //send_Byte(ADC_readout);

  }

  }

    if(KeepAlive_changed==1){

    KeepAlive_changed = 0;

    dataByte = NodeID;

      dataByte |= (1<<3);

    dataByte |= (1<<2);

    sendCounterInc();

    dataByte |= sendCounter;

      send_Byte(dataByte);

  }

    if(INT0_changed==1){

      // entprellen

    for(i1=0;i1<INT0_delays;i1++){

      Delay_ms(250);

    wdt_reset();

      }

    INT0_changed=0;

      if(INT0_old != (INT0_PIN&(1<<INT0_Nr))){

        INT0_old = (INT0_PIN&(1<<INT0_Nr));

      dataByte = NodeID;

      if((INT0_PIN&(1<<INT0_Nr))>0){

          dataByte |= (1<<1);

      }

      sendCounterInc();

      dataByte |= sendCounter;

        send_Byte(dataByte);

      }

  }

    if(INT1_changed==1){

      if (INT1_is_Movement == 0){

        // entprellen

    for(i1=0;i1<INT1_delays;i1++){

        Delay_ms(250);

      wdt_reset();

        }

      INT1_changed=0;

      if(INT1_old != (INT1_PIN&(1<<INT1_Nr))){

          INT1_old = (INT1_PIN&(1<<INT1_Nr));

        dataByte = NodeID;

        dataByte |= (1<<2);

        if((INT1_PIN&(1<<INT1_Nr))>0){

            dataByte |= (1<<1);

        }

        sendCounterInc();

        dataByte |= sendCounter;

          send_Byte(dataByte);

        }

      }else{

        INT1_changed=0;

      if(Movement_Timer == Movement_Timer_max){

          Movement_Timer = 0;

        dataByte = NodeID;

        dataByte |= (1<<2);

        sendCounterInc();

        dataByte |= sendCounter;

          send_Byte(dataByte);

        }

    }

  }

    set_sleep_mode(SLEEP_MODE_IDLE);

  sleep_enable();

    // Timer2 stellen

  TCCR2=0b00000000; // Stop

    TCNT2=90; //0;  // so etwas genauer

    //ASSR=0b00001000; // AS2 = an (ext. 32,768kHz)

  ASSR=0;

  TIMSK|=(1<<6);

    //asm("sei"); // interrupts on

    TCCR2=0b00000111; // Start, prescaler 1024

  //TCCR2=0b00000010; // Start, prescaler 8

  sleep_cpu();

  sleep_disable();

  };

}