uart dinge

/*
 * UART
 *
 * Created: 08.09.2011 07:03:07
 *  Author: MessKali
 */ 

#include <avr/io.h>
#include <stdlib.h>   //damit man die zeichen in "nicht-informatiker" form senden und empfangen kann


//Dinge definieren

#define LED_DDR		DDRC        //definieren der LED DDR
#define LED_PORT	PORTC       //defintion des genauen ports für die DDR
#define LED_PORTPIN  PC1        //definition des bits
/*
 * UART
 *
 * Created: 08.09.2011 07:03:07
 *  Author: MessKali
 */ 

#include <avr/io.h>
#include <stdlib.h>   //damit man die zeichen in "nicht-informatiker" form senden und empfangen kann
#include <avr/interrupt.h> //damit die interrupts eingebunden werden


//Dinge definieren

#define LED_DDR		DDRC        //definieren der LED DDR
#define LED_PORT	PORTC       //defintion des genauen ports für die DDR
#define LED_PORTPIN  PC1        //definition des bits
#define max_str_length  23      //festlegen der maximalen string laenge fuer die uart (platz im puffer)

//(hier speziell die Badurate + Fehler) 
#define F_CPU 7372800UL     //CPU Frequenz (die des externen Quarzes)  
#define BAUD 9600L         //Baudrate    
#define UBRR_VALUE 47L     //nach der tabelle ausm datasheet ist der wert 47
    
//globale Variablen definieren

 volatile uint8_t uart_str_complete = 0;      //definieren der variable, die besagt dass die zeichenkette vollstaendig gesendet wurde
 volatile uint8_t uart_str_count = 0;         //variable, die zaehlt wieviele zeichen bereits im string enthalten sind,
                                            //muss kleiner (letzes zeichen bestimmt das string ende (\0)) sein wie die maximale anzahl an zeichen im string (max_str_length)
 volatile char uart_str [max_str_length+1] = "" ; //variable uart_str, die spaeter vom prog weiterverarbeitet wird, wenn das string komplett ist
uint8_t uart_LED_blink = 0;         //variable, die zaehlt wie oft die LED manuell eingeschaltet wurde   


//Funktionen definieren


//USART INIT
void usart_init ()  //definiton der usart init
{
	UBRRH = UBRR_VALUE >> 8;  //UBRRH wert setzen /aus datasheet und tutorial
	UBRRL = UBRR_VALUE ;      //UBRRL wert setzen /aus tutorial
	
	//die reihenfolge der definitionen der UBRRH und UBRRL muss eingehalten werden!  da ubrr=47, ist ubrh=0 und ubrl=47 (47<255, wegen 8bit und so)
	
	UCSRB |= (1<<TXEN) | (1<<RXEN); //aktivieren der Empfänger- und Senderbits
 
	UCSRB |= (1<<RXCIE);            //aktivieren des Bits der für den Interrupt in der USART zuständig ist, wenn der Sendevorgang an den Rechner vollständig ausgeführt wurde 
	                                //siehe Datenblatt   
	
	UCSRC = (1<<URSEL) |(1<<UCSZ1)|(1<<UCSZ0); //URSEL muss zu 1 geschrieben werden damit erstmal der UCSRC angesprochen wird
	                                           //URSEL ist hier auf 0 (initial), das heisst es ist asynchroner Modus ausgewählt 								  								  
											  //das setzen der USZ1 und USCZ0 zu 1 ermöglicht die Datenübertragungsgröße von 8 bit (aus Tabelle vom Datasheet)  
   
                                             //in das hauptprog (hauptloop) muessen jetzt die send- und empfaenger vorgaenge geschrieben werden
    	                        
}

//USART Senden (vom mikrokontroller zum rechner) (sendet einzelne zeichen, auch verwendung bei puts)
void USART_Transmit (char zeichen)  //definieren der sende funktion
	{
		while (! (UCSRA & (1<<UDRE)))  //die funktion wartet erst ob der sendepuffer leer ist, indem es den UDRE Flag ueberprueft (aus datenblatt)
		{
		}
		UDR = zeichen;                      //es wird das zeichen gesendet (an den rechner halt)
  	}
	
// Puts definieren (fuer das senden von zeichenketten, funktioniert mit putc, bzw. hier mit usart_transmit
void uart_puts (char *s)
{
    while (*s)
    {                        
        USART_Transmit(*s);
        s++;                        //sende solange zeichen von der transmit fkt. bis das \0 errreicht ist, welches das ende der zeichenkette beschreibt
    }
}
	
// UART Empfangen (vom rechner zu mikrocontroller)
//     uint8_t USART_Recieve (void)  //definieren der empfaenger funktion
//     {
//     	while (! (UCSRA & (1<<RXC)));  //wartet bis die daten empfangen werden, indem das RXC flag ueberprueft wird
//         return UDR;                    //holt die empfangenen daten aus dem register 
//     }

              
  
 


int main(void)    //hauptprog
{  
	
  usart_init ();  //usart initialisieren
   
	 LED_DDR = 2;     //PC 1 als ausgang festlegen und einschalten  
     LED_PORT = (0<<LED_PORTPIN); //LED einschalten 
  
  sei(); //aktivieren der globalen interrupts (hier damit die UART Interrupt Routinen arbeiten koennen)   
  
    while(1)
    {
		
         if ( (UCSRA && (1<<RXC)) )  //zeichen wurde empfangen, jetzt abholen 
  	 	 {
	        			
  	 		
  	 		 if ( uart_str == "LEDein")
  	 		 {
  	            LED_PORT &= (0<<LED_PORTPIN); //wenn auf dem LED_PORT das "LEDein" liegt, soll die LED eingehen
  	 		    USART_Transmit("LEDein");         //usart_transmit starten
 				uart_LED_blink ++;
 			  
 			 } 
  	 		if (uart_LED_blink == 4)
			 {
  				uart_puts("LED hat 4 mal geblinkt");
				uart_LED_blink=0;  
			 }

  	 
		 }         
  	}		
	 	
}

//ISR fuer den Interruptbetrieb definieren
ISR (USART_RXC_vect) //der "vektor" drin "zeigt" dass die Sendung vom zeichen abgeschlossen wurde, bezeichnung des vektors aus dem datenblatt
{
	   
  unsigned char zeichen; 	 //zeichen festlegen 
  zeichen = UDR;           // Daten aus dem Sendepuffer lesen
 
  if( uart_str_complete == 0 )  //wenn uart_string gerade in Verwendung, neues Zeichen verwerfen
  {	                        
 
    
    if( zeichen != '\n' &&      //hier wird geschaut ob schon das string ende erreicht ist
        zeichen != '\r' &&      //dabei wird eben nach den jeweligen zeichen (\r und \n) geschaut (im endeffekt geguckt ob der fifo-puffer voll ist oder nicht)
        uart_str_count < max_str_length - 1 ) //und halt eben geschaut dass die anzahl der zeichen kleiner ist als die maximal erlaubte
	{
      uart_str[uart_str_count] = zeichen;  //wenn das der fall ist (s.o.) dann kann zu dem string das naechste zeichen zugefuegt werden
      uart_str_count++;                         //in dem fall wird die anzahl der zeichen im string um 1 erhoeht
    }
    else 
	{                                      //oder
      uart_str[uart_str_count] = '\0';          //wenn das letzte zeichen im string '\0' ist (also string ende erreicht ist)
      uart_str_count = 0;                       //dann setze den zeichenzaehler auf 0
      uart_str_complete = 1;                    //und sage dass der string voll ist, also die variable "uart_str" zu weiterverarbeitung im programm bereit ist
    }
	   
	   
	   if (uart_str_complete == 1)    //wenn µC "LEDaus" bekommt, dann
	   {
		   LED_PORT |= (1<<LED_PORTPIN);    //LED soll ausgehen
	        if (uart_str == "aus")
			 {
  				uart_puts("aus");
				 
			 }
	   }
  
  } 
}