Cours:TPS 2103 tp uart
IMPORTANT, à la fin du tp, remettre le µcontrôleur dans la configuration initiale à l'aide de la commande suivante :
avrdude -pm328p -cavrisp2 -Pusb -B 100 -u -Ulfuse:w:0xc2:m -Uhfuse:w:0xd9:m -Uefuse:w:0x7:m
Attention, suivant la source d'horloge, il peut être nécessaire d'ajouter l'option -B 100 pour avrdude, afin de réduire la vitesse de programmation.
Nous allons mettre en place une communication sans fil entre 2 µcontrôleurs, l'objectif étant d'avoir une commande (action de l'utilisateur) d'un côté, et un objet commandé de l'autre.
Les modules Xbee seront utilisés comme support de transmission.
D'un côté vous utiliserez une carte arduino, tandis que l'autre côté sera un atmega328p câblé sur une plaque à essais.
Dans un premier temps, la connexion sera filaire, et nous ajouterons seulement à la fin le module Xbee.
Sommaire
Côté commande
Nous utilisons ici une carte arduino UNO avec son bootloader, mais sans utiliser les librairies arduino !
Pas besoin de programmateur, seulement la liaison USB avec le PC.
On fera donc un projet AVR sur éclipse et on choisira comme programmateur "arduino UNO ttyACM0". La fréquence du cpu est alors de 16MHz (configuration standard sur les cartes arduino UNO).
Liaison UART
Nous allons configurer le module USART de l'atmega328p pour réaliser une liaison série ayant les caractéristiques suivantes :
- 8 bits de données
- parité paire
- 1 bit de stop
- 57600 bauds
Nous allons nous servir :
- de la figure ci-contre
- de la documentation atmel
- page 190
- pages 191 à 195
configuration
Nous ne ferons qu'émettre des données à partir de la carte arduino UNO.
Complétez le code suivant qui permettra d'émettre en boucle le caractère @
#include <avr/io.h>
#include <util/delay.h>
int main()
{
// autoriser la transmission
// données sur 8 bits
// parité paire
// 1 bit de stop
// 57600 bauds
while(1)
{
UDR0 = '@';
_delay_ms(200);
}
}
Remarque : Vous utiliserez gtkterm pour observer les données envoyées par votre carte. Il faudra quitter gtkterm pour pouvoir reprogrammer le µcontrôleur.
cosmétique
Simplifions l'écriture de notre programme en utilisant des fonctions.
void uart_putchar(char c)
{
loop_until_bit_is_set(UCSR0A, UDRE0); /* Wait until data register empty. */
UDR0 = c;
}
void uart_init()
{
// a completer
}
int main()
{
uart_init();
while(1)
{
uart_putchar('@');
}
}
Implémentez la fonction uart_init(), et vérifier le fonctionnement.
connectons un bouton
Ajoutons un bouton sur notre carte que l'on reliera judicieusement sur la broche associée soit à INT0, soit à INT1. Vous pouvez consulter cet extrait de datasheet qui vous permettra de configurer correctement les différents registres.
Écrire un programme qui envoie un caractère différent aux événements de bouton suivant :
- à l'appui, envoi du caractère A (pour allumer)
- au relâchement, envoi du caractère E (pour éteindre)
Côté actionneur
Comme précisé en introduction, on utilise ici un µcontrôleur atmega328p câblé sur plaque à essais.
préparation
Servez-vous du début du TP précédent pour configurer votre µcontrôleur sur source d'horloge interne à 8MHz.
Ajouter les connections entre µcontrôleurs pour la liaison série
Liaison série
Il s'agit maintenant de configurer la liaison série.
Il faut bien évidemment utiliser la même configuration que précédemment, et on utilisera la fonction suivante pour la réception des données :
char uart_getchar() {
loop_until_bit_is_set(UCSR0A, RXC0); /* Wait until data exists. */
return UDR0;
}
Écrire un programme qui allume ou éteint une led suivant le caractère reçu (A ou E )
potentiomètre - servomoteur
A la place d'une led et d'un bouton, nous utilisons maintenant un potentiomètre et un servomoteur.
L'objectif est bien évidemment de connecter le potentiomètre sur la carte arduino UNO, le servomoteur de l'autre côté, et faire en sorte de commander la position du servomoteur à l'aide du potentiomètre en passant par la liaison série.
Potentiomètre
On reliera bien évidemment ce potentiomètre sur une entrée analogique du µcontrôleur.
Le convertisseur nous donne une valeur sur 10bits, sur laquelle nous ne garderons que les 8 bits de poids fort.
Plusieurs méthodes sont possibles :
- opérateur de décalage n=ADC>>2
- positionnement du bit ADLAR et lecture de ADCH :
- ADMUX |= 1<<ADLAR;
- n=ADCH;
On envoie alors cette valeur 8bits sur la liaison série.
Écrire un programme répondant au cahier des charges
ServoMoteur
Si ça n'avait pas été fait, reprenez le TP précédent pour appréhender le fonctionnement du servomoteur.
Faire un premier programme qui fait varier la position du servomoteur entre ses positions extrêmes
Couplez ensuite avec la lecture de la liaison série
Xbee
logiciel XCTU
