Zeitabhängige Spannungssteuerung

#define   F_CPU   3686400

#include <avr\io.h>

//---------------------------------------------------------------------------------

// TWI-Funktionssammlung

#ifndef TWI_CLOCK

#define TWI_CLOCK 100000 // Geschwindigkeit des TWI-Busses

#endif

// TWCR - Control-Register-Bits

#define _TWINT 0b10000000

#define _TWEA 0b01000000

#define _TWSTA 0b00100000

#define _TWSTO 0b00010000

#define _TWWC 0b00001000

#define _TWEN 0b00000100

#define _TWIE 0b00000001

uint8_t   twiAdr = 0xD0;

void twiInitMaster(uint8_t twiAdr);

#include <util\delay.h>

#include <util\delay.h>

//------------------------------------------------------------------------

// twiInitMaster

//------------------------------------------------------------------------

void twiInitMaster(uint8_t twiAdr)

{

  // Clock

  TWBR=((F_CPU/TWI_CLOCK)-16)*2;

  // TWI-Status-Register (Vorteiler)

  TWSR=0;

  // Bus-Addr

  TWAR=twiAdr;

  // Enable

  TWCR=_TWINT|_TWEN;

}

//------------------------------------------------------------------------

// Start TWI (ohne Interrupt)

//------------------------------------------------------------------------

void twiStart()

{

  uint8_t x=TWCR;

  x&=_TWEN|_TWIE;    // nur Beibehalten von Enable und InterruptJ/N 

  TWCR=x|_TWINT|_TWSTA;

  // warten bis fertig

  while( !(TWCR & _TWINT))

  {}

}

//------------------------------------------------------------------------

// Stopp TWI (ohne Interrupt)

//------------------------------------------------------------------------

void twiStop()

{

  uint8_t x=TWCR;

  x&=_TWEN|_TWIE;    // nur Beibehalten von Enable und InterruptJ/N 

  TWCR=x|_TWINT|_TWSTO;

}

//------------------------------------------------------------------------

// Write Byte per TWI (ohne Interrupt)

// PE: data = zu sendende Daten

//     ackn = wenn !=0 wird Acknowledge (=TWEA) gesetzt

//------------------------------------------------------------------------

void twiWriteByte(uint8_t data, uint8_t ackn)

{

  TWDR=data;      // Daten bereitlegen

  // Befehl zusammenstellen

  uint8_t x=TWCR;

  x&=_TWEN|_TWIE;      //nur Beibehalten von Enable und InterruptJ/N 

  x|=_TWINT;

  if(ackn)   

    x|=_TWEA;   // evt. TWEA setzen, für Datenanforderung

  TWCR=x;         // senden

  // warten bis fertig

  while( !(TWCR & _TWINT))

  {}

}

//------------------------------------------------------------------------

// Read Byte per TWI (ohne Interrupt)

// PE: ackn = wenn !=0 wird Acknowledge (=TWEA) gesetzt

// PA: Data

//------------------------------------------------------------------------

int twiReadByte(uint8_t ackn)

{

  // Befehl zusammenstellen

  uint8_t x=TWCR;

  x&=_TWEN|_TWIE;      //nur Beibehalten von Enable und InterruptJ/N 

  x|=_TWINT;

  if(ackn)   

    x|=_TWEA;   // evt. TWEA setzen, für Datenanforderung

  TWCR=x;         // senden

  // warten bis fertig

  while( !(TWCR & _TWINT))

  {}

  return TWDR;

}

//-------------------------------------------------------------------------

// rtcGetRtcData

//-------------------------------------------------------------------------

uint8_t rtcGetRtcData(uint8_t Register)

{

  // Adresse senden   

  twiStart();

  twiWriteByte(twiAdr,0);

  twiWriteByte(Register,1);

  // Daten lesen

  twiStart();

  twiWriteByte(twiAdr+1,1);

  uint8_t b = (uint8_t)twiReadByte(0);

  twiStop();

  return b;

}

//-------------------------------------------------------------------------

// rtcGetSeconds

//-------------------------------------------------------------------------

uint8_t rtcGetSeconds()

{

  return rtcGetRtcData(0) & 0x7F;

}

//-------------------------------------------------------------------------

// rtcGetMinute

//-------------------------------------------------------------------------

uint8_t rtcGetMinute()

{

  return rtcGetRtcData(1);

}

//-------------------------------------------------------------------------

// rtcGetHour

//-------------------------------------------------------------------------

uint8_t rtcGetHour()

{

  return rtcGetRtcData(2) & 0x3F;

}

//-------------------------------------------------------------------------

// rtcWaitMs

//-------------------------------------------------------------------------

void rtcWaitMs(int miliSec)

{

  _delay_loop_2( 1*(F_CPU/(1000/4)) * miliSec);   // 4 Zyklen warteschleife

}

//--------------------------------------------------------------------

// myWait_ms - Warte-Routine für x-Millisekunden (0-255)

// ein Millisekundenzyklus dauert 1,052 ms

// PE: Anzahl der zu wartenden Milisekunden

//--------------------------------------------------------------------

void myWait_ms(uint8_t dauer_ms)

{

  __asm__ volatile (

    "myWait_ms_0%=:\n"

    "push   %0\n"

    "ldi   %0,1\n"

    "myWait_ms_3%=:\n"

    "push   %0\n"

    "ldi   %0,5\n"

    "myWait_ms_2%=:\n"

    "push   %0\n"

    "ldi   %0,255\n"

    "myWait_ms_1%=:\n"

    "dec   %0   \n"

    "brne   myWait_ms_1%=\n"

    "pop   %0   ; Register wiederherstellen\n"

    "dec   %0   \n"

    "brne   myWait_ms_2%=\n"

    "pop   %0   ; Register wiederherstellen\n"

    "dec   %0   \n"

    "brne   myWait_ms_3%=\n"

    "pop   %0   ; Register wiederherstellen\n"

    "dec   %0   \n"

    "brne   myWait_ms_0%=\n"

    :

    :"d" (dauer_ms)

    );

}

//---------------------------------------------------------------------------

void waitMs(int miliSec)

{

  _delay_loop_2( 1*(F_CPU/(1000/4)) * miliSec);   // 4 Zyklen warteschleife

}

//------------------------------------------------------------------------

// Initialisierungen

//------------------------------------------------------------------------

void init()

{

  twiInitMaster(twiAdr);

}

//------------------------------------------------------------------------

// Zahlensystem-Wandler

//------------------------------------------------------------------------

int dectobcd(int dec)

{

  int BCD;

  BCD = (((dec / 10) * 16) + (dec % 10));

  return BCD;

}

int bcdtodec(int BCD)

{

  int dec;

  dec = ((((BCD >> 4)&0b111)*10)+(BCD&0b1111));

  return dec;

}

//------------------------------------------------------------------------

// Einstellung der Zeit

//------------------------------------------------------------------------

void define_time(int stunde, int minute, int sekunde)

{

  twiStart();

  twiWriteByte(twiAdr,0);

  twiWriteByte(0,1);

  sekunde = dectobcd(sekunde);

  twiWriteByte(sekunde,1);

  minute = dectobcd(minute);

  twiWriteByte(minute,1);

  stunde = dectobcd(stunde);

  twiWriteByte(stunde,1);

  twiStop();

}

//------------------------------------------------------------------------

// Ein/Ausschalten des Relais

//------------------------------------------------------------------------

int switcher(int stunde_on, int stunde_off)

{

  int stunde = 0;

  stunde = rtcGetHour();

  stunde = bcdtodec(stunde);

  if ((stunde>=stunde_on) && (stunde<stunde_off))

  {

    PORTC = 0x08;

  }

  else

  {

    PORTC = 0x00;

  }

}

/////////////////////////////////////////////////////////////////////////////

// Main-Funktion

/////////////////////////////////////////////////////////////////////////////

main()

{

  //Variablen-Initialisierung

  int zeit1,zeit2;

  init();               // Initialisierungen

  //Zur Zeiteinstellung Kommentare entfernen!

  /*zeit1 = rtcGetHour();

  zeit2 = rtcGetMinute();

  if ((zeit1==0)&&(zeit2==0))

  {

    define_time(8,19,31);          

  }*/

  // Alternativ: direkte Überschreibung

  // define_time(10,10,15);

  DDRC = 0x08;

  while (true)              // Mainloop-Begin

  {

    switcher(11,13);

    _delay_ms(1000);

  }