Inter Fa Cage
15
1 Mini-projet INTERFACAGE Thème : Programmation de périphériques sur les bus SPI en langage C
Transcript of Inter Fa Cage
1
Mini-projet INTERFACAGE
Thème : Programmation de périphériques sur les bus SPI en langage C
2
Table des matières I. Introduction ..................................................................................................................................... 3
II. Gestion de la liaison série ................................................................................................................ 3
Objectifs........................................................................................................................................... 3
Description ...................................................................................................................................... 3
Programme ...................................................................................................................................... 4
Explications ...................................................................................................................................... 6
III. Gestion de la liaison SPI pour le capteur de température .......................................................... 8
Le capteur de température TMP 125 .............................................................................................. 8
Le bus SPI ......................................................................................................................................... 9
IV. Conclusion ................................................................................................................................. 14
V. Bibliographies ................................................................................................................................ 15
3
I. Introduction
Le but du projet est d’illustrer le cours d’Interfaçage au travers d’un exemple qui met en évidence le
transfert de données entre différents composants. Le principe est de récupérer l’information d’un
capteur de température et de l’afficher en utilisant un afficheur graphique. Par manque de temps, on
se contentera d’utiliser l’HyperTerminal pour afficher la température.
Logiciels et matériels utilisés :
Comme pour le projet de première année on utilise les cartes ATMEGA16 (munies d’un afficheur
graphique SP5 GFX1 et d’un capteur de température TMP125) et le logiciel AVR STUDIO.
II. Gestion de la liaison série
Objectifs
Dans un premier temps, on délaisse le capteur de température pour ne s’intéresser qu’à l’affichage
d’une chaîne de caractères quelconques.
Description
La liaison série (USART) du microcontrôleur ATMEGA16 permet d’envoyer et de recevoir des
données. Cette interface est utilisée pour établir un dialogue entre le microcontrôleur et
l’ordinateur.
Pour pouvoir communiquer, pc et microcontrôleur doivent partager les mêmes paramètres de
transmission. La vitesse de transmission et donc fixée à 9 600 bps (correspondant à un temps bit).
Ci-dessous, figure le schéma des connexions relatives au microcontrôleur ATMEGA16 et aux
différents composants mis en jeu dans le système :
4
Schéma des différentes connexions
Programme
#include <stdio.h>
#include <avr\io.h>
#define FOSC 11059200// Clock Speed
#define BAUD 9600
#define MYUBRR FOSC/16/BAUD-1
// Partie Initialisation
void USART_Init(void)
{ /* Vitesse de transmission */
UBRRH = 0x00;
UBRRL = 71; /* pour fixer BAUD=9600bps */
UCSRB = 0x18; /* Active mode récepteur et transmetteur */
UCSRC = 0x86;
UCSRA = 0x20;
}
5
//Partie Transmission
void USART_Transmit(unsigned char data )
{ /* Attendre que la mémoire tampon soit vide pour transmettre */
while ( !( UCSRA & (1<<UDRE)) );
/* Ecriture dans la mémoire tampon, envoi des données */
UDR = data;
}
//Programme principal
void main(void)
{ USART_Init ();
int i;
for(i=0; i<10;i++)
{ unsigned char caractere = 'J';
USART_Transmit(caractere);
}
while(1);
}
6
Explications
// Partie Initialisation
Registre UBBR :
On désire une vitesse de transmission de 9600 bauds avec un quartz de 11,059MHz : dans ce cas la
datasheet de l’ATMEGA nous indique que UBRR = 71. De plus, étant donné qu’on utilise une petite
fréquence d’horloge, il est possible de coder seulement sur 8 bits donc UBBRH = 0 et UBBRL = 71.
Registre UCSRA : 00100000
Bit 5 - UDRE à 1, indique que la mémoire tampon est vide et prête pour l’écriture. Tous les autres bits
à 0.
7
Registre UCSRB : 00011000
Bit 4 - RXEN à 1, active le mode récepteur.
Bit 5 - TXEN à 1, active le mode transmetteur.
Tous les autres bits à 0.
Registre UCSRC : 10000011
Bit 1, 2 - UCSZ0, UCSZ1 à 1, détermine la taille des caractères à transmettre, ici 8 bits suffisent pour
afficher un caractère à la fois(le bit 3 - UCSZ2 du registre UCSRB est mis à 0. En effet il participe lui
aussi à la définition de la taille des caractères).
Bit 7 - URSEL à 1, sélection du registre UCSRC ???
Tous les autres bits à 0.
//Partie Transmission
La fonction « USART_Transmit » autorise l’écriture dans le registre UDR (TXB), à condition que la
mémoire tampon soit vide. Elle permet aussi de lire puis d’afficher les données contenues dans la
partie réception du registre UDR (RXB).
//Programme principal
La boucle for permet d’écrire la chaîne de caractères : « JJJJJJJJJJ ».
8
III. Gestion de la liaison SPI pour le capteur de température
On utilise cette fois le capteur de température TMP125 .Toutefois on ne va pas chercher à afficher la
température sur l’afficheur SP5 GFX1 par manque de temps. On se contentera d’afficher la
température sur l’interfaçage Terminal de Windows.
On utilisera pour cela la liaison SPI (Serial Peripheral Interface) de l’Atmega 16. Une liaison SPI est un
bus de donnée série qui exploite plusieurs broches du port B du processeur. Les circuits
communiquent selon un schéma maître-esclaves, où le maître s'occupe totalement de la
communication.
Le bus SPI contient 4 signaux logiques :
SCK - Horloge MOSI - Sortie du maitre MISO - Entrée du maitre SS - Sélection de l’esclave
Nous utiliserons le port C afin de sélectionner les circuits CS. Ici étant donné que nous utiliserons seulement le thermomètre nous n’utiliserons que le bit 7 du port C.
Le capteur de température TMP 125
Nous remarquons tout d’abord qu’il est primordial d’activer le capteur sur le port C afin de pouvoir l’utiliser
9
Toutefois, nous utiliseront une boucle qui retarde l’activation du capteur, car le chronogramme est décalé par rapport au chronogramme SCK.
On obtient ainsi le code suivant :
/*CS_TMP permet de sélectionner et d'activer le capteur température */
int i;
for(i=0; i<10;i++)
{ PORTC =0x7F;
}
Le bus SPI
On initialise tout d’abord le bus SPI
Registre du port B
Registre DDRB : 10111111 Port B : 10111111 On met toutes les broches en sorties à l’exception de PB6, car MISO est une entrée.
10
Registre du port C
Registre DDRB : 11111111 Port B : 11111111 On met toutes les broches en sorties bien que l’on utilisera car le port PC7 pour le capteur température.
Registre SPCR
Registre SPCR : 01011101
Bit 6 – SPE: SPI Enable à 1 Il permet d’activer le mode SPI du microcontrôleur Bit 4 – MSTR: Master/Slave Select à 1 On sélectionne le mode maitre du SPI en mettant le bit à 1 Bit 3 – CPOL: Clock Polarity à 1 Bit 2 – CPHA: Clock Phase à 1 On souhaite le mode 3 pour le SPI
11
Bits 1, 0 – SPR1, SPR0: SPI Clock Rate Select 1 and 0 On choisit ici le temps d’horloge du SPI par rapport à la fréquence d’oscillation du microcontrôleur On désire un temps d’horloge lent.
On obtient ainsi le code suivant pour l’initialisation du SPI maitre:
void SPI_MasterInit(void)
{ DDRB=0xBF;/* tout sauf MISO qui est une entrée */
DDRC=0xFF;/* On sélectionne tout bien que l'on utilisera que le bit 7 */
SPCR =0x5d;/* Enable SPI
PORTB=0xBF;
PORTC=0xFF;
SPSR=0x00;
}
On écrit ensuite les fonctions d’écriture et de lecture avec des temps d’attente pour ces étapes.
12
Registre SPDR
Ce registre est le registre d’écriture et de lecture pour les données du SPI. Il fait la liaison pour envoyer et recevoir les données au SPI.
Le capteur nous renvoi 16 bits, nous devons donc mettre en place un algorithme.
Dans un premiers temps, on écrit les 8 premiers bits de données du capteur de température. On enregistre ces données dans le SPDR, puis on les décale de huit bits vers la gauche. Ainsi on possède la partie haute.
Ensuite dans la partie lecture, on ajoute les 8 bits restants. D’où temperature = SPDR + temperature. On a la totalité du registre de notre capteur température (De D15 à D0). Toutefois, seuls les bits D14, D13, D12, D11, D10, D9, D8, D7 nous intéresse. Ainsi on enlève d’abord l’octet D15 puis on décale l’ensemble sur le droite (voir algorithme ci-dessous)
13
void SPI_Master(char data) { int temperature; /* Fonction d’écriture */ SPDR = data; /* Temps d’attente pour la fonction d’écriture */ while(!(SPSR & (1<<SPIF))); temperature=SPDR; temperature=temperature<<8; /* Fonction de lecture */ SPDR = data; /* Temps d’attente pour la fonction de lecture */ while(!(SPSR & (1<<SPIF))); temperature=SPDR+temperature; /* On décale de 1 octets sur la droite pour enlever le 0 de D15 car seul D14 à D7 nous intéresse*/ temperature=temperature<<1; /* On décale les 16 octets sur la gauche pour obtenir juste 8 octets (on récupère la partie haute et on met le signe en poids fort)*/ temperature=temperature>>8; }
On écrit le programme principal en faisant appel aux fonctions déjà établis : En ce qui concerne l’affichage de la chaine de caractère, on décide d’utiliser un tableau qui nous renverra tous les caractères de données du capteur de température par une boucle while. En faisant varier une variable i, chaque caractère aura sa place dans le tableau. On utilise la fonction USART_Transmit programmée précédemment. Puis, on affiche la température avec la fonction sprintf.
14
Programme principal
void main(void) { USART_Init(); SPI_MasterInit(); SPI_Master(temperature); int i; /*CS_TMP permet de sélectionner et d'activer le capteur température ou alors avec al boucle*/ for(i=0; i<10;i++) { PORTC =0x7F; } /* Il ne reste plus qu'à afficher lachaine de caractère */ char tab[i]; sprintf(tab,'%d',temperature); i=0; while(tab[i] !=0) { USART_Transmit(tab[i]); i++; } while(1); }
Toutefois, le test de ce programme ne nous renvoie pas la température sur l’HyperTerminal. Par
manque de temps, le problème n’a pas été résolu !
IV. Conclusion
Nous n’avons pas totalement répondu au cahier des charges qui nous était imposé car le programmé
testé ne nous renvoie pas la température. Toutefois, ce projet nous a parmi d’approfondir le cours
d’Interfaçage de manière pratique. La gestion de l’USART pour le processeur ATMEGA 16 a été
validée, puisque le programme nous renvoie des données sur le terminal de l’ordinateur
15
V. Bibliographies
Les tableaux et figures sont des captures d’écran des différentes datasheet.
Datasheet du ATMEGA 16. http://www.datasheetcatalog.org/datasheet/atmel/2466S.pdf
Datasheet du TMP125. http://pdf1.alldatasheet.com/datasheet-pdf/view/114779/TI/TMP125.html
