#include <avr/io.h>
#include <avr/interrupt.h> 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h> 


#define FOSC 8000000 // Clock Speed
#define BAUD 115200UL

// calcul du Baudrate:

#define UBRR_VAL ((FOSC+BAUD*8)/(BAUD*16)-1)   // clever runden
#define usart_buffer_size 100 

/****************************************************/
/* Initialisation des variables */

volatile char data2 ;
int i = 0, j = 0 ; // indixe des positions
int counter = 0 ; // counter
unsigned char x ;
unsigned char y ;

#define usart_buffer_size 50             
 
volatile uint8_t usart0_rx_flag=0;            // Flag, String completement recu
volatile uint8_t usart1_tx_flag=1;            // Flag, String completement envoye
unsigned char usart0_rx_buffer[usart_buffer_size];      // Buffer de reception
unsigned char usart1_tx_buffer[usart_buffer_size];      // Buffer de transmission



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

/*          Initialisation de LŽUSART

 USART: Unite du microcontrôleur permettant la communication entre 
 le microcontrôleur et le port serie RS232 dŽun appareil(Ici PC)  */

/****************************************************/
void USART_Init (unsigned int ubrr)
{

   /* Reglage du baudrate */

  UBRR0H = (unsigned char)(ubrr>>8);
  UBRR0L = (unsigned char) ubrr;

  UBRR1H = (unsigned char)(ubrr>>8);
  UBRR1L = (unsigned char) ubrr;

 /* Pins permettant reception et transmission de donnees */ 
 /*
     USART0 = RS232
	 USART1 = RS485

  si TXEN0 = 1 , Transmission de donnees actif a partir de l`USART0,
  si TXEN0 = 0 , Pas de transmission de donnees.

  si TXEN1 = 1 , Transmission de donnees actif a partir de l`USART1,
  si TXEN1 = 0 , Pas de transmission de donnees.
                 
  si RXEN0 = 1 , Le buffer UDR0 de LŽUSART0 peut recevoir les donnees. 
  si RXEN0 = 0 , pas dŽenvoi de donnees.

  si RXEN1 = 1 , Le buffer UDR1 de LŽUSART1 peut recevoir les donnees. 
  si RXEN1 = 0 , pas dŽenvoi de donnees.
  
 */

  UCSR0B = (1<<RXEN0) | (0<<TXEN0) |(1<<RXCIE1)|(0<<TXCIE0);
  UCSR1B = (0<<RXEN1) | (1<<TXEN1) |(0<<RXCIE1)|(1<<TXCIE1);

  /* 
     USBS0,USBS1: Stop bit.
	 USBS0 =1 --> 2 Stopbits  et USBS0 = 0 ---> 1 Stop bit

	 UCSZ02, UCSZ01 et UCSZ00: Taille des donnees.
	    0       0         0 ----> 5 bits
		0       0         1 ----> 6 bits
		0       1         0 ----> 7 bits
		0       1         1 ----> 8 bits
		 
  */

  UCSR0C = (1<<USBS0) | (0<<UCSZ02)|(1<<UCSZ01)|(1<<UCSZ00);
  UCSR1C = (1<<USBS1) | (0<<UCSZ12)|(1<<UCSZ11)|(1<<UCSZ10);
  
} 

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


/*-- fonction de reception de  USART0 --*/

  unsigned char USART0_Receive (void)
{
  while(!(UCSR0A & (1<<RXC0)) ) // Attente de la disponibilite des caracteres
    ;
  return UDR0; // Recevez et rendez des données reçues du tampon
}


/*-- fonction de transmission de  USART0 --*/

void USART0_Transmit (unsigned char data0)
{
  while ( !(UCSR0A & (1<<UDRE0)) )// Attendre jusquŽa ce que lŽenvoi soit possible 
    ;
  UDR0 = data0; /* Put data into buffer UDR0, sends the data0 */
} 


/*-- fonction de reception de USART1 --*/

unsigned char USART1_Receive (void)
{
  while(!(UCSR1A & (1<<RXC1)) ) // Attente de la disponibilite des caracteres
    ;
  return UDR1; // Recevez et rendez des données reçues du tampon
}


/*-- fonction de transmission de USART1 --*/  

void USART1_Transmit (unsigned char data1)
{
  while ( !(UCSR1A & (1<<UDRE1)) )// Attendre jusquŽa ce que lŽenvoi soit possible
    ;
  UDR1 = data1; // Put data into buffer UDR1, sends the data1 
}


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


 /*========fonction de transmission des donnees a partir de lŽUSART1 (port serie RS485)=======*/
/* puts est independant du type de microcontrôleur  */

 void USART1_puts (char *s)
{
while (*s)
    {   
	// Tant que *s != '\0' nŽest pas egal au caractere de la fin du string(Terminateur)" 
        
		USART1_Transmit(*s);
        s++;
    }
} 


/* La fonction dŽinterruption de reception du byte */
/* Cette fonction est active lorsque RXCIE0 = 1 */ 

ISR(USART0_RXC0_vect)
{
 // data2 = UDR0;		// Lecture du byte
 // UDR0 = data2;		// Renvoie du byte comme echo
 // UDR1 = data2;		// Transmission du byte au port serie RS485
 
 static uint8_t usart0_rx_cnt; // compteur pour la reception des positions
 unsigned char data ;

 data = UDR0 ; // Lecture progressive des positions
 

if (!usart0_rx_flag) // le buffer est-il libre pour recevoir de nouveaux donnees ?
 {
  if (data == '\r') // oui, La fin du string a t-elle ete atteint?
   {
    usart0_rx_buffer[usart0_rx_cnt] = 0 ; //, oui, alors terminer le string
    usart0_rx_flag=1; // definir le flag pour la reception complete dans le buffer 
    usart0_rx_cnt=0; // reinitialisation du compteur
   }

   else if(usart0_rx_cnt<(usart_buffer_size-1))
   {
 
      usart0_rx_buffer[usart0_rx_cnt] = data ;
	  UDR1 = usart0_rx_buffer[usart0_rx_cnt] ; 
	  usart0_rx_cnt++;

       }
     }
   } 
 
 /* La fonction dŽinterruption dŽenvoi de byte */
/* Cette fonction est active lorsque TXCIE1 = 1 */ 

ISR(USART1_UDRE1_vect)
 
{
     
 static uint8_t usart1_tx_cnt; // compteur pour lŽenvoi des positions
 uint8_t data3 ;

 
  data3 = UDR1 ; // Lecture de caracteres a envoyer,
   
    if ( data3 == 0 ) // La fin du String est-elle atteint ?
	{
     UCSR1B &= ~(1<<UDRIE1); // oui, alors deactiver UDRE1 Interrupt
     usart1_tx_flag = 1 ; // Definir Flag, Fin de la transmission de donnees	
	}
	 if((counter%2) == 0)
    {
	  // lecture des positions x

	  usart1_tx_buffer[usart1_tx_cnt] = data3 ;
	  x = usart1_tx_buffer[usart1_tx_cnt] ;
	  usart1_tx_cnt++ ;
	  
	 }
	  
	 else
	 {
	   // Lecture des positions y

       usart1_tx_buffer[usart1_tx_cnt] = data3 ;
	   y = usart1_tx_buffer[usart1_tx_cnt] ;
	   usart1_tx_cnt++ ;
	  
	 }
       counter++ ;
	}
  


/* Activation de la transmission des donnees via RS485 de USART1 */

 void RS485_Init (void)
{
  DDRD = (1<<PD4)|(1<<PD3)|(1<<PD5);//pilotage et sortie des donnees actives.
  PORTD = (1<<PD4);	// Activation de lŽenvoi des donnees.
}  


int main (void)

{ 

  // unsigned char c ;
  int control = 0;
  USART_Init(UBRR_VAL) ;  // initialisation USART
  RS485_Init (); // port serie USART1
  sei(); // Activation des  fonctions dŽinterruption

  while(1)

  {

   USART1_puts("#2D0\r");// Considerer la position actuelle comme lŽorigine sur lŽaxe x
   USART1_puts("#3D0\r");// Considerer la position actuelle comme lŽorigine sur lŽaxe y
  
  if ((control%2) == 0)
    {
 
  USART1_puts("#2C\r");      // Demande de la  position actuelle sur lŽaxe x
  USART1_puts("#2p2\r");     // Mode de travail: Position absolue --> P = 2
  USART1_puts("#2 sx \r");// Definir la distance (distance = x) a pacourir (USART1_puts("#3 s-4320 \r"))
  USART1_puts("#2A\r");      // Go 
      
	}
  else
  
  {
 
  USART1_puts("#3C\r");      // Demande de la  position actuelle sur lŽaxe y
  USART1_puts("#3p2\r");     // Mode de travail: Position absolue --> P = 2
  USART1_puts("#3 sy \r");// Definir la distance a pacourir (USART1_puts("#2 s-4320 \r");)
  USART1_puts("#3A\r");      // Go

  }

control++ ; 
 

/*-- Test USART0 (Receive and Transmit) --*/
    
//  USART0_Transmit( 'X' );
//  c = USART0_Receive();
//	USART0_Transmit(c); 

/*-- Test USART1 (Receive and Transmit) --*/

//	USART1_Transmit( 'X' );
//	c = USART0_Receive();
//	USART1_Transmit(c);
	
      
  }

}