LDRBlinker.c

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

*

*  Einfacher Reaktivlicht-Blinker mit LDR

*  Stromverbrauch:

*    ca. 4,1µA @ 3V im Tag- und im Nachtmodus

*

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

/*

ATtiny13

SELFPRGEN=0

DWEN=0

BODLEVEL=Brown-out detection disabled

RSTDISBL=0

SPIEN=1

EESAVE=0

WDTON=0

CHKDIV8=1

SUT_CKSEL=Int. RC Osc. 9.6 MHz; Start-up time: 14 CK + 64 ms

Low/High = 0x6A,0xFF

*/

/*

Vers. 1.01 vom 24.06.2009

- Urversion

Vers. 1.02 vom 15.07.2009

- Verbesserte Helligkeitswerte; Timing bei Tag- und Nachtbetrieb unterschiedlich

Vers. 1.03 vom 19.07.2009

- Testmodus, Logikanalysator-Ausgabe, Dauerblinken

Vers. 1.04 vom 25.02.2010

- Timing leicht geändert; Umschaltung zwischen Reaktivlicht-Typen nach LED-Farbe

Vers. 1.05 vom 26.05.2010

- Fehlerkorrektur in WDT_Prescaler_Change

- andere Helligkeitsbewertung (heller = höherer Wert)

- diverse Verbesserungen, Vereinfachungen und Bereinigungen

*/

#define F_CPU 600000UL // Taktfrequenz 600 kHz

#include <avr/io.h>

#include <avr/interrupt.h>

#include <avr/sleep.h>

#include <avr/eeprom.h>

#include <avr/wdt.h>

//#include <avr/pgmspace.h>

#include <util/delay.h>

//#include <stdint.h>

//#include <string.h>

// Systemkonstanten

// System Clock Prescaler [CLKPR]

#define CLKDIV1         0

#define CLKDIV2         1

#define CLKDIV4         2

#define CLKDIV8         3

#define CLKDIV16        4

#define CLKDIV32        5

#define CLKDIV64        6

#define CLKDIV128       7

#define CLKDIV256       8

// ADC-Referenz [REFS0]

#define RefVcc          0x0  // Vcc als Referenz

#define Ref11           0x1  // interne Referenz 1,1V

// ADC-Messmodus [MUX0]

#define ADC_PB5         0

#define ADC_PB2         1

#define ADC_PB4         2

#define ADC_PB3         3

// ADC-Clock-Vorteiler (für ADC-Clock zw. 50kHz und 200kHz) [ADPS0]

#define ADC_Clk2        1

#define ADC_Clk4        2

#define ADC_Clk8        3

#define ADC_Clk16       4

#define ADC_Clk32       5

#define ADC_Clk64       6

#define ADC_Clk128      7

// ADC Autotrigger Source [ADTS0]

#define ADC_FreeRunning 0   // freilaufend

#define ADC_AnalogComp  1   // Analog Comparator

#define ADC_ExtIRQ0     2   // External Interrupt Request 0

#define ADC_CompareA    3   // Timer/Counter Compare Match A

#define ADC_TimerOvr    4   // Timer/Counter Overflow

#define ADC_CompareB    5   // Timer/Counter Compare Match B

#define ADC_PinChange   6   // Pin Change Interrupt Request

// Timer Clock Divider [CS00]

#define Tim0CLKoff      0

#define Tim0CLK1        1

#define Tim0CLK8        2

#define Tim0CLK64       3

#define Tim0CLK256      4

#define Tim0CLK1024     5

#define Tim0CLKExtHL    6

#define Tim0CLKExtLH    7

// Timer Clock Divider [CS10]

#define Tim1CLKoff      0

#define Tim1CLK1        1

#define Tim1CLK2        2

#define Tim1CLK4        3

#define Tim1CLK8        4

#define Tim1CLK16       5

#define Tim1CLK32       6

#define Tim1CLK64       7

#define Tim1CLK128      8

#define Tim1CLK256      9

#define Tim1CLK512      10

#define Tim1CLK1024     11

#define Tim1CLK2048     12

#define Tim1CLK4096     13

#define Tim1CLK8192     14

#define Tim1CLK16384    15

#define WPD_16ms        0b00000000  // 16 ms

#define WPD_32ms        0b00000001  // 32 ms

#define WPD_64ms        0b00000010  // 64 ms

#define WPD_125ms       0b00000011  // 0.125 s

#define WPD_250ms       0b00000100  // 0.25 s

#define WPD_500ms       0b00000101  // 0.5 s

#define WPD_1s          0b00000110  // 1.0 s

#define WPD_2s          0b00000111  // 2.0 s

#define WPD_4s          0b00100000  // 4.0 s

#define WPD_8s          0b00100001  // 8.0 s

// Definitionen

#define LED_TEST  0

#define LED_ROT   1

#define LED_GRUEN 2

#define LED_WEISS 3

// Hier LED-Typ (nach Farbe) wählen !!!

//#define LEDTYP  LED_TEST

#define LEDTYP  LED_ROT

//#define LEDTYP  LED_GRUEN

//#define DataOut       // serielle Datenausgabe zum Logikanalysator

//#define Dauerblinken  // ständiges Blinken

#define Blinkwartezeit  300   // Wartezeit (ms) bevor das Blinken beginnt

#define Blinkdauer      60    // Dauer (ms) eines Blinkimpulses

#define Blinkpause      (500-Blinkdauer)   // Pause (ms) zwischen zwei Blinkimpulsen

#if LEDTYP == LED_TEST

#define Blinkzahl       1     // Anzahl der Blinkimpulse

#elif LEDTYP == LED_ROT

#define Blinkzahl       5     // Anzahl der Blinkimpulse

#elif LEDTYP == LED_GRUEN

#define Blinkzahl       6     // Anzahl der Blinkimpulse

#endif

// Grenze zwischen Tag- und Nachtumschaltung:

// 1 Lux (R = 1,4 MOhm), ergibt einen ADC-Wert von ca. 154

#define HellDiff      10  // Auslöseschwelle

#define TagSchwelle   154  // Grenze für Umschaltung zwischen Tag und Nacht

#define NachtRate     WPD_250ms  // Messrate im Nachtmodus

#define NachtRateZt   250  // in ms

#define TagLimit      (5UL * 60000UL / NachtRateZt)  // 5 Minuten hell = Tag

#define NachtLimit    8  // 1 Minute dunkel = Nacht (8 * 8s)

// Portleitungen

#define LED           PB3

#define LDR           PB4  // ADC2

#define LDRSpg        PB0

#define Licht         PB1

#define CLKHI         PORTB |= (1<<0)

#define CLKLO         PORTB &= ~(1<<0)

#define DATAHI        PORTB |= (1<<1)

#define DATALO        PORTB &= ~(1<<1)

#define SYNC_ON       PORTB |= (1<<2)

#define SYNC_OFF      PORTB &= ~(1<<2)

#define LED_ON        PORTB |= (1<<LED)

#define LED_OFF       PORTB &= ~(1<<LED)

#define LDR_ON        PORTB |= (1<<LDRSpg)

#define LDR_OFF       PORTB &= ~(1<<LDRSpg)

#define LichtON       PORTB |= (1<<Licht)

#define LichtOFF      PORTB &= ~(1<<Licht)

// globale Variablen

unsigned int Helligkeit;

unsigned int Hintergrund;

unsigned char Tagmodus;

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

*                                         *

*  Auslösung erkannt, Aktion durchführen  *

*                                         *

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

void ExecuteAction (const unsigned char Anzahl)

{

  unsigned char i;

  _delay_ms(Blinkwartezeit);

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

  {

    LED_ON;

    _delay_ms(Blinkdauer);

    LED_OFF;

    _delay_ms(Blinkpause);

  }

}

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

*                             *

*  Ein Word seriell ausgeben  *

*  (für Logikanalysator)      *

*                             *

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

void SerOut (unsigned int Wert)

{

  unsigned char i;

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

  {

    if (Wert & 0x8000)

      DATAHI;

    else

      DATALO;

    CLKHI;

    Wert = Wert << 1;

    CLKLO;

  }

}

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

*                            *

*  Testwerte seriell an      *

*  Logikanalysator ausgeben  *

*                            *

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

void WertOut (void)

{

  CLKLO;

  SerOut(Helligkeit);

  SerOut(Hintergrund);

  SerOut(Tagmodus);

  DATALO;

}

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

*                        *

*  Watchdog-Zeit ändern  *

*                        *

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

void WDT_Prescaler_Change (unsigned char Value)

{

  cli();

  wdt_reset();

  WDTCR |= (1<<WDCE) | (1<<WDE);  // Start timed sequence

  WDTCR = (0<<WDE) | (1<<WDTIE) | (Value<<WDP0);  // Set new prescaler(time-out) value

  sei();

}

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

*                 *

*  Hauptprogramm  *

*                 *

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

int main(void)

{

  unsigned int TagCtr;

  unsigned int AuslGrw;

  #if LEDTYP == LED_TEST

  unsigned char Ausloes;

  #endif

  // Clock einstellen

  CLKPR = 0x80;  // CLKPCE setzen, um Zugriff auf Clock Prescaler zu erreichen

  CLKPR = CLKDIV16;  // Clock Prescaler auf /16 stellen (9,6 MHz -> 600 kHz)

  // Watchdog einstellen

  WDTCR = (1<<WDCE) | (1<<WDE);  // auf Einstellung vorbereiten

  WDTCR = (0<<WDCE) | (0<<WDE) | (1<<WDTIE) | (WPD_8s << WDP0);  // Interrupt mode, Zeit = 8s

  WDTCR |= (1<<WDTIF);  // Interruptflag löschen

  // Ports einstellen

  PORTB = 0b100000;

  DDRB  = 0b001111;

  //        |||||+- 0[5]:MOSI/AIN0/OC0A/PCINT0/TXD       LDR-Versorgung (DataOut-Clock)

  //        ||||+-- 1[6]:MISO/AIN1/OC0B/INT0/PCINT1/RXD  Licht-Anzeige (DataOut-Data)

  //        |||+--- 2[7]:SCK/ADC1/T0/PCINT2              (DataOut-Sync)

  //        ||+---- 3[2]:ADC3/CLKI/PCINT3                LED (über 100 Ohm gegen GND)

  //        |+----- 4[3]:ADC2/PCINT4                     LDR (gegen GND, 2,2 MOhm an Vcc)

  //        +------ 5[1]:RESET/dW/ADC0/PCINT5

  DIDR0 = (1<<ADC2D);

  // Timer 0 einstellen

  // ADC einstellen

  ADMUX = (RefVcc<<REFS0) | (1<<ADLAR) | (ADC_PB4<<MUX0);  // Referenz = Vcc

  // Variablen einstellen

  TagCtr = 0;

  Helligkeit = 255;

  Hintergrund = 255;

  #if LEDTYP == LED_TEST

  Ausloes = 0;

  #endif

  Tagmodus = 1;  // im Tagmodus starten

  // Hauptprogramm starten  

  sei();  // Interrupts ermöglichen

  ExecuteAction(Blinkzahl);  // beim Start zum Test

  while(1)

  {

  #ifdef Dauerblinken

    ExecuteAction(Blinkzahl);  //  dauernd Aktion durchführen

  #else

    // ADC abfragen (Tags alle 8s, Nachts alle <NachtRateZt> ms)

    set_sleep_mode(SLEEP_MODE_PWR_DOWN);

    sleep_mode();  // durch Watchdog-Timer aufwecken lassen

    LDR_ON;

    #ifdef DataOut

    SYNC_ON;  // Synchronsignal

    #endif

    ADCSRA = (1<<ADEN) | (1<<ADIE) | (ADC_Clk2<<ADPS0);  // ADC einschalten, ADC-Interrupt

    ADCSRA |= (1<<ADSC);  // ADC starten

    set_sleep_mode(SLEEP_MODE_ADC);

    sleep_mode();  // durch ADC aufwecken lassen

    LDR_OFF;

    Helligkeit = 255 - ADCH;  // 0 = dunkel, 255 = hell

    ADCSRA = 0;  // ADC ausschalten

    // gemessenen Helligkeitswert auswerten

    if (Tagmodus)  // aktuell im Tagmodus

    { 

      if (Helligkeit < TagSchwelle)  // prüfen ob es Nacht ist

      {

        #ifndef DataOut

        LichtOFF;

        #endif

        TagCtr++;

        if (TagCtr >= NachtLimit)

        {

          Tagmodus = 0;  // auf Nacht umschalten

          TagCtr = 0;

          WDT_Prescaler_Change(NachtRate);

        }

      }

      else

      {

        #ifndef DataOut

        LichtON;

        #endif

        TagCtr = 0;

      }

    }

    else  // aktuell im Nachtmodus

    {  

      AuslGrw = Hintergrund + HellDiff;  // zu erreichende Schwelle

      if (Helligkeit > AuslGrw)  // Auslösung durch Helligkeitssprung?

      {

        #if LEDTYP == LED_TEST

        ExecuteAction(++Ausloes);  //  ja, Aktion durchführen

        #else

        ExecuteAction(Blinkzahl);  //  ja, Aktion durchführen

        #endif

        Helligkeit = 255;

      }

      else

      {

        if (Helligkeit > TagSchwelle)  // prüfen ob es Tag ist

        {

          #ifndef DataOut

          LichtON;

          #endif

          TagCtr++;

          if (TagCtr >= TagLimit)

          {

            Tagmodus = 1;  // auf Tag umschalten

            TagCtr = 0;

            WDT_Prescaler_Change(WPD_8s);

          }

        }

        else

        {

          #ifndef DataOut

          LichtOFF;

          #endif

          TagCtr = 0;

        }

      }

    }

    #ifdef DataOut

    SYNC_OFF;

    WertOut();

    #endif

    Hintergrund = Helligkeit;  // letzten Helligkeitswert als Hintergrundhelligkeit

  #endif

  }

}

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

*                            *

*  Watchdog Timer Interrupt  *

*  (nur zum Aufwecken)       *

*                            *

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

EMPTY_INTERRUPT(WDT_vect);

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

*                           *

*  ADC conversion complete  *

*  (nur zum Aufwecken)      *

*                           *

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

EMPTY_INTERRUPT(ADC_vect);