====== Introduction ======
Nous allons faire communiquer deux atmega de chez ATMEL via la communication série
===== Protocole =====
==== Transmission synchrone ====
Dans une transmission synchrone, on transmet l'information et l'horloge qui synchronise la transmission. Ce mode de transmission est plus rapide car il n'est pas nécessaire d'ajouter des bits de contrôle à l'information. Cependant, il est plus couteux car il faut réserver 2 lignes (information + horloge)
==== Transmission asynchrone ====
Dans une transmission asynchrone, on ne transmet pas d'horloge au récepteur. Cela implique que l'émetteur et le récepteur doivent avoir la même configuration (vitesse de transmission et longueur de l'information). L'information doit être envoyée en petit paquet (9 bits maximum) et doit être accompagnée de bits de contrôle. Ce mode est donc plus lent mais plus efficace pour les longues distances.
BIT START - 5 à 9 BIT INFORMATION - BIT PARITE - 1 ou 2 BIT STOP

====== Implementation ======
===== Registre USART =====
UDR : registre de donnée. il contient l'octet reçu ou envoyé.
UCSRA : registre de controle
  * RXC : ce bit indique que la reception est terminée
  * TXC : ce bit indique que la transmission est terminée
  * UDRE : ce bit indique que le registre de donnée est vide
  * FE : ce bit signale que la frame reçue est erronée
  * DOR :  ce bit indique que la taille du message recu dépasse celle attendue
  * UPE : ce bit indique une erreur de parité
  * U2X : vitesse double
  * MPCM : mode de communication multi processeur
UCSRB : 
  * RXCIE : ce bit valide l'interruption sur la reception d'une donnée
  * TXCIE : ce bit valide l'interruption sur l'emission d'une donnée
  * UDRIE
  * RXEN : ce bit permet d'activer la reception
  * TXEN : ce bit permet d'activer l'emission
  * UCSZ2 : ce bit contient la taille de l'information(avec UCSZ1 et UCSZ0)
  * RXB8 : ce bit contient le 9eme bit de l'information reçue
  * TXB8 : ce bit contient le 9eme bit de l'information à envoyer
UCSRC :
  * UMSEL1-UMSEL0 : ces bits déterminent le mode de communication (synchrone, asynchrone)
  * UPM1-UPM0 : ces bits déterminent le type de parité (aucune, paire ou impaire)
  * USBS :  ce bit détermine le nombre de bit de STOP (1 ou 2)
  * UCSZ1-UCSZ0 : ces bits déterminent la taille de l'information (5 à 9 bits)
  * UCPOL : ce bit détermine la olarite de l'horloge (non utilsé en mode asynchrone)
UBRRH-UBRRL : ces registres contiennent la vitesse de communication (BAUD = Fosc/(16*(UBRR+1)) )
===== Utilisation =====
Nous allons utiliser une communication asynchrone 9600 bauds avec 8 bits de données, 1 bit de STOP et une parité paire.
Le premier exemple est très simple, envoi et reception d'une donnée.

<code>
/*
 * usart.c
 *
 *  Created on: 13 avr. 2010
 *      Author: ldo
 */

/* ATMEGA48 @20MHz
 * LOW FUSE : F7
 * CKDIV8=1		no divided clock by 8
 * CKOUT=1		no clock output on PORTB
 * SUT1..0=11	slowly rising power
 * CKSEL3..0=0111	full swing crystal oscillator
 */

#include<avr/io.h>

void usartInitialise(void)
{
	// set baud rate : 9600 bps
	UBRR0H = 0;
	UBRR0L = 129;
	// enable receiver and transmiter
	UCSR0B = (1 << RXEN0) | (1 << TXEN0);
	// set frame format : asynchronous mode 8 data, 1 stop bit, even parity
	UCSR0C = (0 << UMSEL01) | (0 << UMSEL00) | (1 << UPM01) | (0 << UPM00) | (0
			<< USBS0) | (1 << UCSZ01) | (1 << UCSZ00);
}

// transmit a char
void usartTransmit(unsigned char data)
{
	// wait for empty transmit buffer
	while (!(UCSR0A & (1 << UDRE0)))
		;
	// put data info buffer, sends the data
	UDR0 = data;
}

// receive a char
unsigned char usartReceive(void)
{
	// wait for data to be received
	while (!(UCSR0A & (1 << RXC0)))
		;
	// get and return received data from buffer
	return UDR0;
}

int main(void)
{
        unsigned char receiveChar;
        
	usartInitialise();

	while (1)
	{
		usartTransmit(22);
		receiveChar = usartReceive();
	}
}
</code>

Le deuxième exemple utilise l'interruption sur la réception d'une donnée. En effet, dans l'exemple précédent, la réception de la donnée est bloquante.

<code>
/*
 * usart.c
 *
 *  Created on: 13 avr. 2010
 *      Author: ldo
 */

/* ATMEGA48 @20MHz
 * LOW FUSE : F7
 * CKDIV8=1		no divided clock by 8
 * CKOUT=1		no clock output on PORTB
 * SUT1..0=11	slowly rising power
 * CKSEL3..0=0111	full swing crystal oscillator
 */

#include<avr/io.h>
#include<avr/interrupt.h>

volatile unsigned char receiveChar;

// receiver interrupt
ISR(USART_RX_vect)
{
	unsigned char dustbin;
	// If frame error or parity error or data overRun
	if ((UCSR0A & (1 << FE0)) || (UCSR0A & (1 << UPE0)) || (UCSR0A
			& (1 << DOR0)))
	{
		dustbin = UDR0;
	}
	// no error
	else
	{
		receiveChar = UDR0;
	}
}

void usartInitialise(void)
{
	// set baud rate : 9600 bps
	UBRR0H = 0;
	UBRR0L = 129;
	// enable receiver and transmiter and RX complete interrupt
	UCSR0B = (1 << RXCIE0) | (1 << RXEN0) | (1 << TXEN0);
	// set frame format : asynchronous mode 8 data, 1 stop bit, even parity
	UCSR0C = (0 << UMSEL01) | (0 << UMSEL00) | (1 << UPM01) | (0 << UPM00) | (0
			<< USBS0) | (1 << UCSZ01) | (1 << UCSZ00);
}

// transmit a char
void usartTransmit(unsigned char data)
{
	// wait for empty transmit buffer
	while (!(UCSR0A & (1 << UDRE0)))
		;
	// put data info buffer, sends the data
	UDR0 = data;
}

int main(void)
{
	usartInitialise();
	SREG = (1 << SREG_I); /* The Global Interrupt Enable bit must be set for the interrupts to be enabled */

	while (1)
	{
		usartTransmit(22);
	}
}


</code>