AVRcode1

CODE IS STILL UNDER CONTRUCTION !

This ist what I have so far.

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

Project : ATM32Universal.
Version : 1.00
Datum : 08.09.2005
Author : H. Brachschoss

AVR : ATmega32 / 16 Mhz

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

#include <mega32.h>

#define xtal 16000000L

#define xdebug

// I2C Bus functions
#asm
   .equ __i2c_port=0x15
   .equ __sda_bit=1
   .equ __scl_bit=0
#endasm
#include <i2c.h>

// PCF8583 Real Time Clock functions
#include <pcf8583.h>

// 1 Wire Bus functions
#asm
   .equ __w1_port=0x15
   .equ __w1_bit=2
#endasm
#include <1wire.h>

// DS1820 Temperature Sensor functions
#include <ds1820.h>
// maximum number of DS1820 devices connected to the 1 Wire bus
#define MAX_DS1820 1
// number of DS1820 devices connected to the 1 Wire bus
unsigned char ds1820_devices;
// DS1820 devices ROM code storage area, 9 bytes are used for each device
unsigned char ds1820_rom_codes[MAX_DS1820,9];

// Alphanumeric LCD Module functions
#asm
   .equ __lcd_port=0x18
#endasm
#include <lcd.h>


#include <delay.h>
#include <ctype.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <stdio.h>

#define menukey PIND.2
#define cursorleft PIND.3
#define cursorright PIND.4

// Definitionen der Töne

#define A 220 // in Hz
#define B 233
#define H 247
#define C 262
#define CIS 277
#define D 294
#define DIS 311
#define E 330
#define F 349
#define FIS 370
#define G 392
#define GIS 415

#define T12000 // Tonlänge (ms)
#define T21000
#define T4 500
#define T8 250
#define T16 125
#define T32 67

#define T10 0// keine Pause (ms)
#define T11 5
#define T12 10
#define T13 20
#define T14 30
#define T15 40
#define P1 50

// Definitionen Serielle Schnittstelle
#define RXB8 1
#define TXB8 0
#define UPE 2
#define OVR 3
#define FE 4
#define UDRE 5
#define RXC 7

#define FRAMING_ERROR (1<<FE)
#define PARITY_ERROR (1<<UPE)
#define DATA_OVERRUN (1<<OVR)
#define DATA_REGISTER_EMPTY (1<<UDRE)
#define RX_COMPLETE (1<<RXC)

eeprom double etmin ; // NOV Speicher für min Temperatur
eeprom double etmax ;// NOV Speicher für max Temperatur
eeprom double eschaltdauer ;// NOV Speicher für Einschaltdauer in Minuten

// USART Receiver buffer
#define RX_BUFFER_SIZE 16
char rx_buffer[RX_BUFFER_SIZE];
unsigned char rx_wr_index,rx_rd_index,rx_counter;
// This flag is set on USART Receiver buffer overflow
bit rx_buffer_overflow;

// globale Variablen Deklaration
unsigned char keymode=0 ;
unsigned char keycnt=0 ;
unsigned char lcdlight=0 ;
char strRecBuff[10] ;
char dis[12] ;
double tcnt, tres, tfloat ;
int signedtemperature ;// Temperaturvariable +- 32768
unsigned char h,m,s,hs ;// Uhrzeitvariablen
unsigned char dummy[10] ;
unsigned char time[8] ;
double tmax, tmin ;
double schaltdauer ;

/***********************************************************************
lcdlightoff() Displaybeleuchung ausschalten oder abdimmen
************************************************************************/
void lcdlightoff(unsigned char status)
{
if ( status == 1 )
{
lcdlight=0 ;
OCR0=lcdlight ;
}
else
while (lcdlight > 0 )// Display Beleuchtung aufdimmen
{
lcdlight = lcdlight-5 ;
delay_ms(50);
if (lcdlight != 0 )
OCR0=lcdlight ;
}

}

/***********************************************************************
lcdlighton() Displaybeleuchung einschalten oder aufdimmen
************************************************************************/
void lcdlighton(unsigned char status)
{

if ( status == 1 )
{
lcdlight=170 ;
OCR0=lcdlight;
}
else
for (lcdlight=0; lcdlight<170;)// Display Beleuchtung aufdimmen
{
OCR0=lcdlight ;
lcdlight = lcdlight+5 ;
delay_ms(50);
}
}

/***********************************************************************
lcdline1clear() 2. Zeile am LCD löschen
************************************************************************/
void lcdline1clr(void)
{
lcd_gotoxy(0,1) ;
lcd_putsf(" ");
lcd_gotoxy(0,1);
}


/***********************************************************************
lcdline0clear() 1. Zeile am LCD löschen
************************************************************************/
void lcdline0clr(void)
{
lcd_gotoxy(0,0) ;
lcd_putsf(" ");
lcd_gotoxy(0,0);
}

/***********************************************************************
pause() Pause für die Tonwiedergabe
************************************************************************/
void pause(unsigned int timeout)
{
long n ;
double schleifen ;
unsigned int ischleifen ;

schleifen = 1000 * timeout ;
ischleifen = schleifen ;

for (n=0; n<schleifen;n++)
delay_us(1) ;
}


/***********************************************************************
note()spielt eine Note nach Übergabe von Note,Oktave, Dauer und Pause
************************************************************************/
void note(double freq, int octave, double dauer, unsigned int timeout)
{
long n,i ;
double frequenz ;
double schleifen ;
unsigned int ifrequenz, ischleifen ;

freq = freq * 10 * octave ;
frequenz = 1 / freq ;
frequenz = frequenz / 2 ;
frequenz = frequenz * 1000000 ;
schleifen = 1/ (frequenz * 2 ) ;
schleifen = schleifen * 1000 ;
schleifen = (schleifen * dauer) / 10 ;
ifrequenz = frequenz ;
ischleifen = schleifen ;

for(n=0;n<ischleifen;n++)
{
PORTD=0x80;
for(i=0; i< ifrequenz;i++)
delay_us(1);

   PORTD=0x00;
   for(i=0; i<ifrequenz;i++)
   delay_us(1) ;
}


   if ( timeout > 0 )
pause(timeout) ;
}



/***********************************************************************
setclock()hier wird der Uhrenchip beschrieben
************************************************************************/
void setclock(unsigned char zeit[10]) // Uhrzeit über Tastatur setzen
{
unsigned int v1,v2,v3,v4,v5 ;

   v1 = toascii(zeit[0]) ; // 00:00:00
   v2 = toascii(zeit[1]) ;
   v1 = v1 - 48 ;
   v2 = v2 - 48 ;
v3 = v1*10 ;
v3 = v3 + v2 ;

   v1 = toascii(zeit[3]) ;
   v2 = toascii(zeit[4]) ;
   v1 = v1 - 48 ;
   v2 = v2 - 48 ;
v4 = v1*10 ;
v4 = v4 + v2 ;

   v1 = toascii(zeit[6]) ;
   v2 = toascii(zeit[7]) ;
   v1 = v1 - 48 ;
   v2 = v2 - 48 ;
v5 = v1*10 ;
v5 = v5 + v2 ;

rtc_set_time(0,v3,v4,v5,0); // Zeit kann dezimal z.B. 22 oder hex z.B. 0x16 angegeben werden.
lcd_clear() ;
lcd_putsf("Zeit gesetzt.");
delay_ms(1000) ;
}

/***********************************************************************
timeedit() Eingaberoutine für die Uhrzeit
************************************************************************/
void timeedit(void)
{
int curpos=0 ;
unsigned char zeichen ;
unsigned int keyhold=0 ;
unsigned int exitfunction=0 ;

lcd_clear() ;
lcd_putsf("Uhrzeit Eingabe:");
rtc_get_time(0,&h,&m,&s,&hs);// Uhrzeit einlesen
sprintf(time,"%02d:%02d:%02d",h,m,s); // Uhrzeit im string "time" formatieren HH:MM:SS
time[6]=48; time[7]=48 ;// sekunden auf 0 setzen
lcd_gotoxy(curpos,1);
lcd_puts(time) ;

_lcd_ready() ;
_lcd_write_data(0x0f) ; // Cursor on, Cursor blink

while (menukey==1) {} ;// warten bis Menutaste losgelassen wurde

lcd_gotoxy(curpos,1);
while(exitfunction==0)
{
if ( cursorright==1 ) // Cursor nach rechts
{
note(A,5,T32,T10) ;
delay_ms(50) ;
while ( cursorright==1)
{
delay_ms(100);
keyhold++ ;
if ( keyhold >10 )
{
#ifdef debug
printf("%s",time) ;
#endif
note(G,1,T32,T11) ;
note(G,2,T16,T10) ;
setclock(time) ;
exitfunction=1 ;
lcd_clear() ;
}
}

if ( curpos<7)
{
_lcd_ready() ;
_lcd_write_data(0x14) ;
curpos++ ;
if (curpos==2) // unzulässige Eingabeposition ":"
{
curpos++ ;
_lcd_ready() ;
_lcd_write_data(0x14) ;
}
if (curpos==5) // unzulässige Eingabeposition ":"
{
curpos++ ;
_lcd_ready() ;
_lcd_write_data(0x14) ;
}

}
while ( cursorright==1) {} ;
keyhold=0 ;
}
// -----------------------------------------------------------------------------
if ( cursorleft==1 ) // Cursor nach links
{
note(A,5,T32,T10) ;
delay_ms(50) ;
while ( cursorleft==1)
{
delay_ms(100);
keyhold++ ;
if ( keyhold >10 )
{
exitfunction=1 ;
note(G,2,T32,T11) ;
note(G,1,T16,T10) ;
lcd_putsf("Eingabe abbruch");
delay_ms(1000) ;
while(cursorleft==1) {} ;
lcd_clear() ;
}
}

if (curpos>0 )
{
_lcd_ready() ;
_lcd_write_data(0x10) ;
curpos-- ;
if (curpos==2) // unzulässige Eingabeposition ":"
{
curpos-- ;
_lcd_ready() ;
_lcd_write_data(0x10) ;
}

if (curpos==5) // unzulässige Eingabeposition ":"
{
curpos-- ;
_lcd_ready() ;
_lcd_write_data(0x10) ;
}

}
while ( cursorleft==1) {} ;
keyhold=0 ;
}

// -----------------------------------------------------------------------------
if ( menukey == 1 ) // Zeicheneingabe
{
note(A,5,T32,T10) ;
delay_ms(50);
while( menukey == 1 ) {} ;
   zeichen = time[curpos] ;


   switch(curpos)
   {
   case 0: if ((zeichen>=48 ) && ( zeichen<50)) // nur 0-2 sind erlaubt
   {
   zeichen++ ; // zeichen erhöhen
   time[curpos]=zeichen ;
   }
   else
   {
   zeichen = 48 ;
   time[curpos]=zeichen ;
   }
   break ;

   case 1: if ( time[0] == 50)
   {
   if ((zeichen>=48 ) && ( zeichen<51)) // nur 0-3 sind erlaubt
   {
   zeichen++ ; // zeichen erhöhen
   time[curpos]=zeichen ;

   }
   else
   {
   zeichen = 48 ;
   time[curpos]=zeichen ;
   }
   }
   else
   {
   if ((zeichen>=48 ) && ( zeichen<57)) // nur 0-9 sind erlaubt
   {
   zeichen++ ; // zeichen erhöhen
   time[curpos]=zeichen ;

   }
   else
   {
   zeichen = 48 ;
   time[curpos]=zeichen ;
   }

   }
   break ;

   case 3: if ((zeichen>=48 ) && ( zeichen<53)) // nur 0-5 sind erlaubt
   {
   zeichen++ ; // zeichen erhöhen
   time[curpos]=zeichen ;
   }
   else
   {
   zeichen = 48 ;
   time[curpos]=zeichen ;
   }
   break ;

   case 4: if ((zeichen>=48 ) && ( zeichen<57)) // nur 0-9 sind erlaubt, also (chr(48) - chr(57)
   {
   zeichen++ ; // zeichen erhöhen
   time[curpos]=zeichen ;
   }
   else
   {
   zeichen = 48 ; // zeichen >57 (9) dann wieder mit zeichen = 48 (0)
   time[curpos]=zeichen ;
   }
   break ;
   case 6: if ((zeichen>=48 ) && ( zeichen<53)) // nur 0-9 sind erlaubt, also (chr(48) - chr(57)
   {
   zeichen++ ; // zeichen erhöhen
   time[curpos]=zeichen ;
   }
   else
   {
   zeichen = 48 ; // zeichen >57 (9) dann wieder mit zeichen = 48 (0)
   time[curpos]=zeichen ;
   }
   break ;
   case 7: if ((zeichen>=48 ) && ( zeichen<57)) // nur 0-9 sind erlaubt, also (chr(48) - chr(57)
   {
   zeichen++ ; // zeichen erhöhen
   time[curpos]=zeichen ;
   }
   else
   {
   zeichen = 48 ; // zeichen >57 (9) dann wieder mit zeichen = 48 (0)
   time[curpos]=zeichen ;
   }
   break ;


   }

#ifdef debug
printf(" %c-%i curpos:%i ",zeichen,zeichen,curpos) ;
#endif
lcd_gotoxy(0,1);
lcd_puts(time) ;
lcd_gotoxy(curpos,1);
}
} // while exitfunction==0

_lcd_ready() ;
_lcd_write_data(0x0c) ;// Cursor off, blink off
}


/***********************************************************************
tempedit() Eingabe funktion um Tmin oder Tmax (Schaltpunkte) zu editieren
************************************************************************/
double tempedit(unsigned char dispstr[5],double temperature)
{
int curpos=0 ;
char dummytemp[12] ;// "00.00"
unsigned char zeichen ;
unsigned int keyhold=0 ;
unsigned int exitfunction=0 ;
unsigned char anzeige[15] ;
double tnew ;

lcd_clear() ;
sprintf(anzeige,"%p Eingabe",dispstr);
lcd_puts(anzeige);
sprintf(dummytemp,"%5.2f \xdfC", temperature); // Temperatur string
lcd_gotoxy(curpos,1);
lcd_puts(dummytemp) ;

_lcd_ready() ;
_lcd_write_data(0x0f) ; // Cursor on, Cursor blink

while (menukey==1) {} ;// warten bis Menutaste losgelassen wurde
lcd_gotoxy(curpos,1);
while(exitfunction==0)
{
if ( cursorright==1 ) // Cursor nach rechts
{
note(A,5,T32,T10) ;
delay_ms(50) ;
while ( cursorright==1)
{
delay_ms(100);
keyhold++ ;
if ( keyhold >10 )
{
#ifdef debug
printf("%s",dummytemp) ;
#endif
note(G,1,T32,T11) ;
note(G,2,T16,T10) ;
lcdline0clr();
lcd_putsf("Temp. gesetzt");
delay_ms(1000) ;
lcd_clear() ;
tnew = atof(dummytemp) ;
#ifdef debug
printf("%p, %5.2f°C",dispstr,tnew) ;
#endif
return(tnew);
exitfunction=1 ;
}
}

if ( curpos<4)
{
_lcd_ready() ;
_lcd_write_data(0x14) ;
curpos++ ;
if (curpos==2) // unzulässige Eingabeposition "."
{
curpos++ ;
_lcd_ready() ;
_lcd_write_data(0x14) ;
}

}
while ( cursorright==1) {} ;
keyhold=0 ;
}
// -----------------------------------------------------------------------------
if ( cursorleft==1 ) // Cursor nach links
{
note(A,5,T32,T10) ;
delay_ms(50) ;
while ( cursorleft==1)
{
delay_ms(100);
keyhold++ ;
if ( keyhold >10 )
{
note(G,2,T32,T11) ;
note(G,1,T16,T10) ;
lcdline0clr();
lcd_putsf("Eingabe abbruch");
delay_ms(1000) ;
exitfunction=1 ;
return(0) ;
lcd_clear() ;
}
}

if (curpos>0 )
{
_lcd_ready() ;
_lcd_write_data(0x10) ;
curpos-- ;
if (curpos==2) // unzulässige Eingabeposition "."
{
curpos-- ;
_lcd_ready() ;
_lcd_write_data(0x10) ;
}

}
while ( cursorleft==1) {} ;
keyhold=0 ;
}

// -----------------------------------------------------------------------------
if ( menukey == 1 ) // Zeicheneingabe
{
note(A,5,T32,T10) ;
delay_ms(50);
while( menukey == 1 ) {} ;
   zeichen = dummytemp[curpos] ;


   switch(curpos)
   {
   case 0: if (zeichen <48 )
   zeichen = 48 ;
   if ((zeichen>=48 ) && ( zeichen<57)) // nur 0-9 sind erlaubt
   {
   zeichen++ ; // zeichen erhöhen
   dummytemp[curpos]=zeichen ;
   }
   else
   {
   zeichen = 48 ;
   dummytemp[curpos]=zeichen ;
   }
   break ;

   case 1: if(zeichen<48)
   zeichen=48 ;
   if ((zeichen>=48 ) && ( zeichen<57)) // nur 0-9 sind erlaubt
   {
   zeichen++ ; // zeichen erhöhen
   dummytemp[curpos]=zeichen ;

   }
   else
   {
   zeichen = 48 ;
   dummytemp[curpos]=zeichen ;
   }
   break ;

   case 3: if (zeichen<48)
   zeichen=48 ;
   if ((zeichen>=48 ) && ( zeichen<57)) // nur 0-9 sind erlaubt
   {
   zeichen++ ; // zeichen erhöhen
   dummytemp[curpos]=zeichen ;
   }
   else
   {
   zeichen = 48 ;
   dummytemp[curpos]=zeichen ;
   }
   break ;

   case 4: if (zeichen<48)
   zeichen=48 ;
   if ((zeichen>=48 ) && ( zeichen<57)) // nur 0-9 sind erlaubt, also (chr(48) - chr(57)
   {
   zeichen++ ; // zeichen erhöhen
   dummytemp[curpos]=zeichen ;
   }
   else
   {
   zeichen = 48 ; // zeichen >57 (9) dann wieder mit zeichen = 48 (0)
   dummytemp[curpos]=zeichen ;
   }
   break ;
   }

#ifdef debug
printf(" %c-%i curpos:%i ",zeichen,zeichen,curpos) ;
#endif
lcd_gotoxy(0,1);
lcd_puts(dummytemp) ;
lcd_gotoxy(curpos,1);
}
} // while exitfunction==0

_lcd_ready() ;
_lcd_write_data(0x0c) ;// Cursor off, blink off
}

/***********************************************************************
showinfoline() Infozeile am LCD ausgeben
************************************************************************/
void showinfoline(int info)
{
lcdline1clr() ;
lcd_gotoxy(0,1);
// 12345678901234567890

switch (info)
{
case 1: lcd_gotoxy(0,1);
lcd_putsf("1. Uhr stellen. ");
break ;

case 2:lcd_gotoxy(0,1);
lcd_putsf("2. min. Temp. ");
break ;

case 3: lcd_gotoxy(0,1);
lcd_putsf("3. max. Temp. ");
break ;

case 4: lcd_gotoxy(0,1);
lcd_putsf("4.Intervall(min)");
break ;
case 5: lcd_gotoxy(0,1);
lcd_putsf("5.Eingabe Ende? ");
break ;

}

if ( keymode == 0 )
{
delay_ms(2000) ;

lcdline1clr();
}

}

/***********************************************************************
Int 0 Serviceroutine(Menu-Taste)
************************************************************************/
interrupt [EXT_INT0] void ext_int0_isr(void)
{
int i=0 ;
int nextline=0 ;
int keytimeout=0 ;
double tnew=0 ;// temperaturübergabe
keymode=0 ;
keycnt=0 ;

delay_ms(100) ;
if ( menukey == 1 )
{
note(A,5,T32,T10) ;
while ( menukey == 1 ) {}; // warten bis Taste wieder losgelassen wird
keymode=1 ;
}

if ( keymode == 1 )
{
lcdlighton(1) ;
lcdline0clr() ;
lcd_gotoxy(0,0);
lcd_putsf("Eingabemodus: ");
lcd_gotoxy(0,1);
lcd_putsf("kurz=blaettern");
while ( menukey == 0 )
{
if ( keytimeout > 1000 ) // 10 Sek. keine Taste gedrückt - > Eingabemodus verlassen.
{
keycnt=0 ;
keymode=0 ;
break ;
}
keytimeout++ ;
delay_ms(10) ;
} ;

while ( menukey == 1 )
{
if ( keytimeout > 1000 ) // 10 Sek. keine Taste gedrückt - > Eingabemodus verlassen.
{
keycnt=0 ;
keymode=0 ;
break ;
}
keytimeout++ ;
delay_ms(10) ;
} ;

note(A,5,T32,T10) ;
lcd_gotoxy(0,1);
lcd_putsf("lang=auswaehlen");
while ( menukey == 0 )
{
if ( keytimeout > 1000 ) // 10 Sek. keine Taste gedrückt - > Eingabemodus verlassen.
{
keycnt=0 ;
keymode=0 ;
break ;
}
keytimeout++ ;
delay_ms(10) ;
} ;

}
while (keymode == 1 )
{
if ( menukey == 1 )
{
note(A,5,T32,T10) ;
while ( (i < 25 ) & (menukey == 1 ) ) // ca. 2 Sek. Taste lang gedrückt (Funktion ausführen)
{
delay_ms(50) ;
i++ ;

}
if ( i <= 10 ) // Taste kurz gedrückt (weiterblättern)
{
keycnt++ ;
nextline = 1 ;
i = 0 ;
keytimeout=0 ;
if ( keycnt==6)
keycnt=1 ;
}

if ( i >= 20 ) // wenn Taste lang gedrückt dann Funktion ausführen
{
i = 0 ;
switch ( keycnt )
{
   case 1: timeedit(); nextline=1 ;break ;
case 2: tnew=tempedit("Tmin",etmin);
if (tnew!=0)
{
tmin=tnew ;
etmin=tmin ;// Wert ins EEProm schreiben
}
nextline=1 ;
break ;

case 3: tnew=tempedit("Tmax",etmax);
if (tnew!=0)
{
tmax=tnew ;
etmax=tmax ;// Wert ins EEProm schreiben
}
nextline=1 ;
break ;
case 4: break ;

case 5: lcdline1clr() ;lcd_gotoxy(0,1); lcd_putsf("Eingabe beendet.");
keymode=0 ;keycnt=9 ;
note(A,1,T16,T10);
note(A,3,T8,T10);
break ;
}

lcd_gotoxy(0,0);
lcd_putsf("Eingabemodus: ");
keytimeout=0 ;
while ( menukey == 1 ) {} ;// warten bis Taste ganz sicher wieder freigegeben wurde
}

}
if ( keycnt==9) break ;// Eingabemodus verlassen

if ( nextline == 1 ) // Taste wurde kurz gedrückt, weiterblättern
{
switch ( keycnt )
{
case 1:showinfoline(keycnt) ; break ;
case 2: showinfoline(keycnt) ; break ;
case 3: showinfoline(keycnt) ; break ;
case 4: showinfoline(keycnt) ; break ;
case 5: showinfoline(keycnt) ; break ;
}
nextline=0 ;
keytimeout=0 ;
}

   if ( keycnt > 5 )
   keycnt = 0 ;

if ( keytimeout > 500 ) // 12,5 Sek. keine Taste gedrückt - > Eingabemodus verlassen.
{
keycnt=0 ;
keymode=0 ;
}
keytimeout++ ;
delay_ms(25) ;
}

lcd_clear() ;
#asm("cli")
#asm("sei")// Interrupts wieder zulassen
}

/***********************************************************************
Serial Interrupt Routine
************************************************************************/
#pragma savereg-
interrupt [USART_RXC] void usart_rx_isr(void)
{
char status,data;
#asm
   push r26
   push r27
   push r30
   push r31
   in r26,sreg
   push r26
#endasm
status=UCSRA;
data=UDR;
if ((status & (FRAMING_ERROR | PARITY_ERROR | DATA_OVERRUN))==0)
   {
   rx_buffer[rx_wr_index]=data;
   if (++rx_wr_index == RX_BUFFER_SIZE) rx_wr_index=0;
   if (++rx_counter == RX_BUFFER_SIZE)
   {
   rx_counter=0;
   rx_buffer_overflow=1;
   };
   };
#asm
   pop r26
   out sreg,r26
   pop r31
   pop r30
   pop r27
   pop r26
#endasm
}
#pragma savereg+

#ifndef _DEBUG_TERMINAL_IO_
/***********************************************************************
getchar() getchar von USART receive Buffer
************************************************************************/
#define _ALTERNATE_GETCHAR_
#pragma used+
char getchar(void)
{
char data;
while (rx_counter==0);
data=rx_buffer[rx_rd_index];
if (++rx_rd_index == RX_BUFFER_SIZE) rx_rd_index=0;
#asm("cli")
--rx_counter;
#asm("sei")
return data;
}
#pragma used-
#endif

/***********************************************************************
setclockRs232() Uhrzeit über RS232 vom PC aus stellen
************************************************************************/
void setclockRs232(void)
{
unsigned char sdatacnt=0 ;
unsigned char sdtime[20] ;
unsigned int v1,v2,v3,v4,v5 ;

delay_ms(500) ;


   while ( rx_counter != 0 )
   {
   sdtime[sdatacnt] = getchar() ;
   sdatacnt++ ;
   }

   v1 = toascii(sdtime[0]) ;
   v2 = toascii(sdtime[1]) ;
   v1 = v1 - 48 ;
   v2 = v2 - 48 ;
v3 = v1*10 ;
v3 = v3 + v2 ;

   v1 = toascii(sdtime[2]) ;
   v2 = toascii(sdtime[3]) ;
   v1 = v1 - 48 ;
   v2 = v2 - 48 ;
v4 = v1*10 ;
v4 = v4 + v2 ;

   v1 = toascii(sdtime[4]) ;
   v2 = toascii(sdtime[5]) ;
   v1 = v1 - 48 ;
   v2 = v2 - 48 ;
v5 = v1*10 ;
v5 = v5 + v2 ;

rtc_set_time(0,v3,v4,v5,0); // Zeit kann dezimal z.B. 22 oder hex z.B. 0x16 angegeben werden.

lcdline1clr();
lcd_gotoxy(0,1);
//sprintf(dtime,"%02d:%02d:%02d - %s",hh,mm,ss,sdtime) ;
// lcd_puts(dtime) ;
lcd_putsf("Zeit gesetzt.");
delay_ms(1000) ;
lcd_clear() ;

}


/***********************************************************************
readtemperature()
************************************************************************/
void readtemperature(unsigned int devno)
{
   signedtemperature=ds1820_temperature_10(&ds1820_rom_codes[devno][0]);// Temperatur einlesen.
   tcnt = __ds1820_scratch_pad.cnt_c ;
   tres = __ds1820_scratch_pad.cnt_rem ;
   tfloat = signedtemperature - 0.25 + ((tcnt - tres) / tcnt) ; // hires Umrechnung
   sprintf(dis,"");
   sprintf(dis,"T%-u: %6.2f\xdfC",devno+1,tfloat/10) ;
#ifdef debug
   printf("<t=%6.2f>\n\r",tfloat/10 ) ;
#endif
}

/***********************************************************************
einschaltmeldung
************************************************************************/
void einschaltmeldung(void)
{
// Determine the number of DS1820 devices connected to the 1 Wire bus
ds1820_devices=w1_search(0xf0,ds1820_rom_codes);

lcd_putsf(" ATMEGA32 ");
lcd_gotoxy(0,1);
lcd_putsf(" Board Rev. 107 ");
delay_ms(3000) ;
lcd_clear() ;
lcd_putsf("Temp. Sensors:");
sprintf(dis,"%d",ds1820_devices);
lcd_puts(dis) ;
lcd_gotoxy(0,1) ;
readtemperature(0) ;
lcd_puts(dis);
delay_ms(2000) ;
}

/***********************************************************************
main()
************************************************************************/
void main(void)
{

sprintf(dummy,"");

// Input/Output Ports initialization
// Port A initialization
// Func0=In Func1=In Func2=In Func3=In Func4=In Func5=In Func6=In Func7=In
// State0=T State1=T State2=T State3=T State4=T State5=T State6=T State7=T
PORTA=0x00;
DDRA=0x00;

// Port B initialization
// Func0=In Func1=In Func2=In Func3=In Func4=In Func5=In Func6=In Func7=In
// State0=T State1=T State2=T State3=T State4=T State5=T State6=T State7=T
PORTB=0x00;
DDRB=0x08;

// Port C initialization
// Func0=In Func1=In Func2=In Func3=In Func4=In Func5=In Func6=In Func7=In
// State0=T State1=T State2=T State3=T State4=T State5=T State6=T State7=T
PORTC=0x00;
DDRC=0x00;

// Port D initialization
// Func0=In Func1=In Func2=In Func3=In Func4=In Func5=In Func6=In Func7=In
// State0=T State1=T State2=T State3=T State4=T State5=T State6=T State7=T
PORTD=0x00;
DDRD=0x80;

// Timer/Counter 0 initialization
// Clock source: System Clock
// Clock value: 65,535 kHz
// Mode: Fast PWM top=FFh
// OC0 output: Non-Inverted PWM
TCCR0=0x6C;
TCNT0=0x00;
OCR0=0x00;

// Timer/Counter 1 initialization
// Clock source: System Clock
// Clock value: Timer 1 Stopped
// Mode: Normal top=FFFFh
// OC1A output: Discon.
// OC1B output: Discon.
// Noise Canceler: Off
// Input Capture on Falling Edge
TCCR1A=0x00;
TCCR1B=0x00;
TCNT1H=0x00;
TCNT1L=0x00;
OCR1AH=0x00;
OCR1AL=0x00;
OCR1BH=0x00;
OCR1BL=0x00;

// Timer/Counter 2 initialization
// Clock source: System Clock
// Clock value: Timer 2 Stopped
// Mode: Normal top=FFh
// OC2 output: Disconnected
ASSR=0x00;
TCCR2=0x00;
TCNT2=0x00;
OCR2=0x00;

// External Interrupt(s) initialization
// INT0: On
// INT0 Mode: Rising Edge
// INT1: Off
// INT2: Off
GICR|=0x40;
MCUCR=0x03;
MCUCSR=0x00;
GIFR=0x40;

// Timer(s)/Counter(s) Interrupt(s) initialization
TIMSK=0x00;

// USART initialization
// Communication Parameters: 8 Data, 1 Stop, No Parity
// USART Receiver: On
// USART Transmitter: On
// USART Mode: Asynchronous
// USART Baud rate: 9600
UCSRA=0x00;
UCSRB=0x98;
UCSRC=0x86;
UBRRH=0x00;
UBRRL=0x67;

// Analog Comparator initialization
// Analog Comparator: Off
// Analog Comparator Input Capture by Timer/Counter 1: Off
// Analog Comparator Output: Off
ACSR=0x80;
SFIOR=0x00;

// Hintergrundbeleuchtung aus
lcdlightoff(1) ;

// I2C Bus initialization
i2c_init();

// PCF8583 Real Time Clock initialization
rtc_init(0,0);
delay_ms(100) ;

// LCD module initialization
delay_ms(100) ;
lcd_init(16);
lcd_clear() ;

// Tonfolge abspielen
note(A,3,T16,T10) ;
note(H,3,T16,T10) ;
note(D,3,T16,T10) ;
note(A,3,T8,T10) ;


// Hintergrundbeleuchtung einschalten
lcdlighton(0) ;
delay_ms(200) ;

einschaltmeldung() ;

readtemperature(0) ;
//tmin = tfloat/10 ;
//tmax = tfloat/10 ;

if (etmax!=0 )
tmax = etmax ;
if (etmin!=0 )
tmin = etmin ;
if (eschaltdauer!=0 )
schaltdauer=eschaltdauer ;

// Global enable interrupts
#asm("sei")

lcd_clear() ;
while (1)
{

   while ( rx_counter == 0 ) // Ausgabe der Temperatur auf dem LCD, solange bis Kommandos über RS232 kommen.
   {
delay_ms(350) ;
readtemperature(0) ;
lcd_gotoxy(0,0);
lcd_puts(dis);
rtc_get_time(0,&h,&m,&s,&hs); // Uhrzeit einlesen
sprintf(time,"Zeit: %02d:%02d:%02d",h,m,s); // Uhrzeit im string "time" formatieren HH:MM:SS
lcd_gotoxy(0,1);
lcd_puts(time) ;

}

strRecBuff[0] = getchar() ; // 1. Zeichen abholen

if ( strRecBuff[0] == 'S' )
{
   lcdlighton(1) ;
strRecBuff[1] = getchar() ; // 2. zeichen abholen
if ( strRecBuff[1] == 'T' )
setclockRs232() ;
}
strcpyf(strRecBuff," ");

   }; // while(1)
} // main()