String einlesen und bearbeiten

#include <avr/io.h>

#include "global.h"     // include our global settings

#include "i2cmaster.h"   // Auskommentieren, falls nicht benötigt...

#include "lcd.h"

#include "adc.h"  // include printf function library

#include <avr/interrupt.h>

#include <avr/wdt.h>

#include "string.h"

#include "timer.h"

#include <stdlib.h>

//#include <avr/signal.h>

#include <stdio.h>

//#include "usart.h"

//#include "uart.h"

#define DS1307  0xd0  /* I2C Adresse unseres DS1307 Uhrenbausteins, write-Zugriff */

#define USE_LCD 1    // 1 Falls LCD verwendet wird

// type declarations - Hier werden neue Typen für Variablen definiert

typedef unsigned char uint8;         /*!< vorzeichenlose 8-Bit-Zahl          0..255      */

// Hier die Variablen definieren, die im Programm verwendet werden sollen

uint8 i;  // Eine Variable: Zahlenbereich 0..255

uint8 sec,minute,hour,wd,day,month,year; // Variablen für Zeit, Wochentag, Datum

const char zeichen[] = ",:/";

char string[30];

char *wert, empfang[20];

int schutz = 0, buffer = 0, (f), (t) = 0;

/*unsigned*/ char tempstr[20]; // temporärer String (Variable für eine Folge von Zeichen)

// Definitionen für Unterprogramme

void init(void);

void i2cGetdatetime(void);

void i2cSettime(void);

void i2cSetdate(void);

void rs232_recieve (void);  //Fernsteuerung über RS-232

  /* 

  UART-Init: 

  Berechnung des Wertes für das Baudratenregister 

  aus Taktrate und gewünschter Baudrate

  */

#ifndef F_CPU

  /* In neueren Version der WinAVR/Mfile Makefile-Vorlage kann

   F_CPU im Makefile definiert werden, eine nochmalige Definition

   hier wuerde zu einer Compilerwarnung fuehren. Daher "Schutz" durch

   #ifndef/#endif 

   Dieser "Schutz" kann zu Debugsessions führen, wenn AVRStudio 

   verwendet wird und dort eine andere, nicht zur Hardware passende 

   Taktrate eingestellt ist: Dann wird die folgende Definition 

   nicht verwendet, sondern stattdessen der Defaultwert (8 MHz?) 

   von AVRStudio - daher Ausgabe einer Warnung falls F_CPU

   noch nicht definiert: */

  #warning "F_CPU war noch nicht definiert, wird nun nachgeholt mit 14756000"

  #define F_CPU 14756000UL  // Systemtakt in Hz - Definition als unsigned long beachten 

                         // Ohne ergeben sich unten Fehler in der Berechnung

  #endif

  #define BAUD 9600UL      // Baudrate

  // Berechnungen

  #define UBRR_VAL ((F_CPU+BAUD*8)/(BAUD*16)-1)   // clever runden

  #define BAUD_REAL (F_CPU/(16*(UBRR_VAL+1)))     // Reale Baudrate

  #define BAUD_ERROR ((BAUD_REAL*1000)/BAUD) // Fehler in Promille, 1000 = kein Fehler.

  #if ((BAUD_ERROR<990) || (BAUD_ERROR>1010))

  #error Systematischer Fehler der Baudrate grösser 1% und damit zu hoch! 

  #endif 

// Unterprogramm init: Hier werden die Initialisierungen vorgenommen

void init(void)

{

  wdt_disable();    // Watchdog ausschalten 

  // Port B initialisieren

  DDRB= 0xFF;       // alle 8 pins sind als Ausgang geschaltet

  // Port A initialisieren

  DDRA= 0x00;       // alle 8 pins sind als Eingänge geschaltet

  PORTB= 0x00;    // Alle unteren Pins sind low (Ruhestellung)

  timer0Init();      /*   Mit diesem Befehl wird die include-Datei timer initialisiert,

            die uns u.a. den Befehl timerPause() zur Verfügung stellt.

            */ 

  i2c_init();       // Initialisierung des I2C-Busses

  sei();        // Interrupts zulassen (für timer.c wichtig)

#if USE_LCD  

  lcd_init(LCD_DISP_ON);

#endif  

  lcd_clrscr(); // LCD löschen

  UCSRB |= (1<<TXEN);                           // UART TX einschalten

  UCSRC |= (1<<URSEL)|(1 << UCSZ1)|(1 << UCSZ0); // Asynchron 8N1 

  UBRRH = UBRR_VAL >> 8;

  UBRRL = UBRR_VAL & 0xFF;

  uartInit();     // initialize the UART (serial port)

  uartSetBaudRate(9600); // serielle Schnittstelle auf 19200 Baud setzen

  rprintfInit(uartSendByte);

} // Ende init

uint8 bcd2hex(uint8 hexb) // Umwandlung von BCD nach Hex

              // der DS1307 tickt in BCD

{

 u08 tempb1, tempb2; //lokale Variablen

 tempb1 = hexb >> 4;

 tempb1 = tempb1 * 10;

 tempb2 = hexb & 0x0F;

 return (tempb1 + tempb2);

}

uint8 hex2bcd(uint8 hexb) // Umwandlung von Hex nach BCD

{

 uint8 tempb1, tempb2; //lokale Variablen

 tempb1 = hexb / 10;

 tempb2 = hexb % 10;

 tempb1 = tempb1 << 4;

 return (tempb1 | tempb2);

}

void i2cGetdatetime(void) // Holt Zeit,Datum von DS1307

{

    unsigned char ret,isec,imin,ihour,iwd,iday,imonth,iyear; // Lokale Variablen

      /* write 0x75 to eeprom address 0x05 (Byte Write) */

    ret = i2c_start(DS1307+I2C_WRITE);       // set device address and write mode

  if ( ret ) {

      rprintf("I2cnotready",ret,"<<>>");

        /* failed to issue start condition, possibly no device found */

        i2c_stop();

    }else {

        /* issuing start condition ok, device accessible */

        i2c_start_wait(DS1307+I2C_WRITE);     // set device address and write mode

        i2c_write(0x00);                      // write address = 0

        i2c_rep_start(DS1307+I2C_READ);       // set device address and read mode

        isec  = i2c_readAck();                // read one byte and go on

    imin  = i2c_readAck();                // read one byte and go on

    ihour = i2c_readAck();                // read one byte and go on

    iwd   = i2c_readAck();                // read one byte and go on

    iday  = i2c_readAck();                // read one byte and go on

    imonth = i2c_readAck();               // read one byte and go on

    iyear  = i2c_readNak();               // read one byte and finish

        i2c_stop(); // Stop i2c

    sec   = bcd2hex(isec);

    minute   = bcd2hex(imin);

    hour  = bcd2hex(ihour);

    wd = iwd;

    day   = bcd2hex(iday);

    month = bcd2hex(imonth);

    year  = bcd2hex(iyear);

    }

}

void i2cSettime(void) // setzt die Zeit im DS1307

{

    unsigned char ret;

      /* write 0x75 to eeprom address 0x05 (Byte Write) */

    ret = i2c_start(DS1307+I2C_WRITE);       // set device address and write mode

  if ( ret ) {

        /* failed to issue start condition, possibly no device found */

    rprintf("\r\nKeine I2C-Uhr gefunden in SetTime!\r\n");

        i2c_stop();

    }else {

        /* issuing start condition ok, device accessible */

        i2c_start_wait(DS1307+I2C_WRITE);     // set device address and write mode

        i2c_write(0x00);                      // write address 0

        i2c_write(hex2bcd(sec));    // Sekunden

    i2c_write(hex2bcd(minute)); // Minuten

    i2c_write(hex2bcd(hour));   // Stunden

    i2c_stop();

    }

}

void i2cSetdate(void) // setzt die Zeit im DS1307

{

    unsigned char ret;

      /* write 0x75 to eeprom address 0x05 (Byte Write) */

    ret = i2c_start(DS1307+I2C_WRITE);       // set device address and write mode

  if ( ret ) {

        /* failed to issue start condition, possibly no device found */

    rprintf("\r\nKeine I2C-Uhr gefunden in SetDate!\r\n");

        i2c_stop();

    }else {

        /* issuing start condition ok, device accessible */

        i2c_start_wait(DS1307+I2C_WRITE);     // set device address and write mode

        i2c_write(0x03);                      // write address 0

    i2c_write(wd);            // Wochentag 

    i2c_write(hex2bcd(day));   // Tag

    i2c_write(hex2bcd(month)); // Monat

    i2c_write(hex2bcd(year));  // Jahr

        i2c_stop();  

    }

}

void rs232_recieve (void)  //Fernsteuereung über RS-232

{

//bei prgrammstart "rprintf("AT+CCLK?\r\n");"  dann kommt +CCLK: "02/08/15,00:09:29" 

string[f] = '\0';  //erst mal einen sauberen C-String daraus machen

wert = strtok(string, zeichen);// initialisieren und ersten Abschnitt erstellen

while(wert != NULL) 

{

empfang[t] = atoi(wert);

wert = strtok(NULL, zeichen);

t++;

}

  sec = empfang[5];

  minute = empfang[4];

  hour = empfang[3];

  day = empfang[2];

  month = empfang[1];

  year = empfang[0];

  i2cSettime(); // i2c Befehl zum Setzen der Zeit

  i2cSetdate(); // i2c Befehl zum Setzen des Datums

}  //ende rs232_recieve

int main (void) 

{ 

  init(); // Aufruf des Unterprogramms init

    while (!(UCSRA & (1<<UDRE)))  // warten bis Senden moeglich                   

    {

    }

  rprintf("AT+CCLK?\r\n");

  timerPause(1000);

    while (1) // Endlosschleife

  { 

  lcd_clrscr();

  lcd_puts("Kontrolle l\xE1uft");

        i2cGetdatetime(); // Hier werden die Variablen für Zeit und Datum aktualisiert

    lcd_gotoxy(15,1);

    sprintf(tempstr,"%02d",hour);

    lcd_puts(tempstr);

    lcd_puts(":");           // : zwischen stunde und minute

    sprintf(tempstr,"%02d",minute);

    lcd_puts(tempstr);

  PORTB |= (1<<PB0);

  timerPause(300);

  PORTB &= ~(1<<PB0);

  PORTB |= (1<<PB1);

  timerPause(300);

  PORTB &= ~(1<<PB1);

  PORTB |= (1<<PB2);

  timerPause(300);

  PORTB &= ~(1<<PB2);

  PORTB |= (1<<PB3);

  timerPause(300);

  PORTB &= ~(1<<PB3);

  } // ende Endlosschleife

} // Ende main (Hauptprogramm)

ISR (USART_RXC_vect)  //SIGNAL (SIG_UART_RECV)  //ISR  (SIG_USART_RECV) //ISR (USART_RX_vect) //ISR (SIG_UART0_RECV)            //RS232 (UART) Interrupt

{

  if (schutz == 1)          //Schutz vor nicht benötigter Interruptauslösung  

  {  

  buffer = UDR;            //Daten aus dem buffer lesen .....

  while (!(UCSRA & (1<<UDRE)))    //.... warten bis der Sende´buffer leer ist ....

  UDR = buffer;            //.....und gleich wieder zurück schicken

    if (buffer != 26)        //bei einem Return beginnnt die Auswertung, solange kein Return kommt, werden die Zeichen einfach nur gesammelt

    {

    string[f] = buffer;

    buffer = 0;

    f++;

    //rprintf("buffer");

    }

    else

    {

    schutz = 1;

    rs232_recieve();

    schutz = 0;

    }

  }

}