emb 7000, chapitre 3 : périphériques standardboukadoum_m/emb7000/notes/ch3 uc perip… · e/s...

Traduit et adapté de l’anglaisTraduit et adapté de MSP430 Teaching ROM et autres sources © Copyright 2009 Texas Instruments

1

EMB 7000, Chapitre 3 : Périphériques standard


Objectifs d’apprentissage

• Dispositifs pour la gestion du temps– Chronomètres, temporisateurs, compteurs et chiens de garde

• Interfaces avec le monde extérieur– Introduction– Interface pour la communication parallèle– Interfaces pour la communication sérielle

• UART, I2C, SPI, USB, PWM

– Interfaces pour afficheurs• À segments, LCD


Dispositifs pour la gestion du temps

• Composants essentiels dans un système embarqué• Utilisés pour

– Synchroniser des évènements temporels– Déterminer le temps et/ou la durée d’évènements– Réveiller le système d’un état de dormance– Surveiller l’opération du système

• Comprennent – les chronomètres/temporisateurs – les compteurs d’impulsions– les chiens de garde


Chronomètre/temporisateur (« timer »)• Compte les impulsions venant d’une horloge synchrone• Le compte max dépend de la période T d’horloge (résolution) et de la taille N du compteur. Par ex. :– N = 16 bits permet un compte max de 216‐1 = 65335

– N = 16 bits et T = 10 ns permettent de mesurer une durée max de (216‐1)*10 ns 0.7 ms avec une résolution de 10 ns

• Le compte repart à zéro après le compte maximal et un sémaphore (bit) indique le débordement

– Peut être associé avec des lignes d’e/s pour• Chronométrer un changement d’état en entrée

• Synchroniser un changement d’état en sortie

– Peut déclencher une demande d’interruption du CPU– Peut servir à incrémenter un compteur en logiciel pour étendre la durée maximale comptée

16-bit up counterClk Cnt

Basic timer

OFL

Reset

16


• Similaire au temporisateur, mais l’horloge est typiquement asynchrone et venant de sources externes au boîtier

• Fonctionnalité souvent partagée avec un temporisateur pour fin de minuterieP. ex., dans un intervalle de temps donné :– le nombre de voitures qui passent au dessus

d’un capteur de pression– Le nombre d’objets transportés qui coupent

un faisceau optique sur un convoyeur

16-bit up counter

Clk16

Cnt_in

2x1 mux

Mode

Timer/counter

Top

Reset

Cnt

Compteur (« counter »)


• Chronomètre spécialisé qui es utilisé pour :– Détecter les défaillances du système– Détecter des dépassements de délais

• Doit être rechargé régulièrement par le logiciel exécuté pour empêcher le débordement, indiquant que le MCU est sous contrôle– Interrompt le processeur ou remet le système à zéro

automatiquement en cas de débordement

Chien de garde (« watchdog »)


Autres structures de gestion du temps

Top2

Time with prescaler

16-bit up counter

Clk Prescaler

Mode

• Minuterie d’intervalle– Compte un intervalle de

temps de durée égale à une valeur de comparaison :

• intervalle désiré / période de l’horloge

• Compteurs en cascade– Permettent d’augmenter la

durée de compte maximale

• Pré‐diviseur– Augmente la gamme dynamique

au détriment de la résolution en divisant la fréquence d’horloge

16-bit up counter

Clk16

Terminal count

=Top

Reset

Timer with a terminal count

Cnt 16-bit up counter

Clk

16-bit up counter

16

Cnt2

Top1

16/32-bit timer

Cnt1

16


Exemple : le Timer_A de la famille MSP430

http://www.ti.com/general/docs/lit/getliterature.tsp?baseLiteratureNumber=slau144&fileType=pdf


Exemples sorties préprogrammées dans le le Timer_A de la famille MSP430

http://www.ti.com/general/docs/lit/getliterature.tsp?baseLiteratureNumber=slau144&fileType=pdf


Registres de Timer_A du MSP430F2274


Example: Mesure de temps de réaction

Témoin lumineux

Bouton

time: 100 msLCD

/* main.c */

#define MS_INIT 63535

void main(void){int count_milliseconds = 0;

Configure timer modeset Counter to MS_INIT

Wait a random amount of timeTurn on indicator lightStart timer

while (not pushed button){if(Top) {

count_milliseconds++;reset Top

}}Turn light offprintf(“time: %i ms“, count_milliseconds);}

Ex. Compteur de 16 bits, clk de 12 MHz divisée par 6. – Résolution effective = 6*(1/12 Mhz)=0.5 us– Gamme dynamique = 65535*0.5 us = 32.77 ms– Si un débordement à tous les 1 ms est désiré, le

compteur sera initialisé périodiquement avec la valeur de compte :

65535 – (1/0.0005) = 63535

• En psychologie du comportement, on mène souvent des expériences qui demandent de mesurer le délai entre l’allumage d’un témoin lumineux et la pesée d’un bouton par un sujet


12

Exemple : Chien de garde

scaleReg

checkFlg

timeReg to system resetor

interrupt

osc clkprescaler

overflow

/* main.c */

main(){Attendre l’insertion d’une carte clientAppeler watchdog_reset

while(transaction en cours){if(bouton pesé){accomplir action correspondanteappeler watchdog_reset

}

/* si watchdog_reset non appelé dans 2+ minutes, appeler interrupt_service */}

watchdog_reset() {/* checkreg is set so we can load value into timeReg. */

checkReg = 1scaleReg = 2timeReg = 11070

}

void interrupt_service_routine(){eject cardreset screen

}

• Compteur à recharger avant le débordementP. ex., délai d’inactivité à ne pas dépasser dans une machine ATM

– Valeur de compte pour un temporisateur de 16 bits avec 1ms de résolution : v = p*(216‐1)–délai

– Pour un délai x =2 min :p =2v = 131070–12000

= 11070

clk/p


Exemple de code pour base de temps//*****************************************************************************************// MSP430F22x4 Demo - Timer_A, Toggle P1.0, TACCR0 Cont. Mode ISR, DCO SMCLK//// Description: Toggle P1.0 using software and TA_0 ISR. Toggles every 50000 SMCLK cycles. // CPU is normally off. MCLK = SMCLK = TACLK = default DCO ~1.2MHz//// A. Dannenberg, Texas Instruments Inc., April 2006// Built with CCE Version: 3.2.0 and IAR Embedded Workbench Version: 3.41A//*****************************************************************************************

#include "msp430x22x4.h"

// Main codevoid main(void){WDTCTL = WDTPW+WDTHOLD; // Stop WDTP1DIR |= 0x01; // P1.0 outputTACCTL0 = CCIE; // TACCR0 int. enabledTACCR0 = 50000; // TACCR0 countTACTL = TASSEL_2+MC_2;// SMCLK, contmode

// Enter LPM0 with interrupt wakeup__bis_SR_register(LPM0_bits + GIE);

}

// Timer A0 interrupt service routine

// identify interrupt vector#pragma vector=TIMERA0_VECTOR

// Interrupt response code__interrupt void Timer_A (void){

P1OUT ^= 0x01; // Toggle P1.0TACCR0 += 50000;// Update TACCR0

}



• Périphériques pour la gestion du temps– Chronomètres, temporisateurs, compteurs et chiens de garde

• Interfaces avec le monde extérieur– Interface pour la communication parallèle– Interfaces pour la communication sérielle


– Afficheurs• À segments, LCD


Interaction avec le monde extérieur

• Se fait de plusieurs manières


Les E/S de base

• Peuvent être analogiques ou numériques • La forme la plus simple est un ensemble de lignes binaires

programmables (GPIO) – Fonction par défaut des lignes d’e/s du C à la mise sous tension– La direction des données est programmable, individuellement ou en

groupe (configuration en entrée par défaut à la mise sous tension), – Normalement, transferts asynchrones entre source et destination– Dans certains cas :

• synchronisation avec un compteur• Réaction aux fronts montants ou descendants en entrée• Pouvoir d’interrompre le CPU • Résistances de tirage (“pull up/down”)


E/S parallèles et sérielles

PC7

PÉRIPHÉRIQUEPARALLÈLE

(ex. imprimante de PC)

PC6

PC5

PC4

PC3

PC2

PC1

PC0

1

1

0

0

0

0

0

0

B = $42 ASCII

ex.: 68HC11 Contrôleur

1 10 0 0 00 0

B

68HC11(ou autre)

T x D

R x DSCI{ PÉRIPHÉRIQUE

SÉRIE(ex.: terminal,

modem)

Interface //

Interface ‐‐

• Parallèle plus simple et plus rapide, mais gourmand en lignes

• Sériel frugal en lignes ( => moins d’interférence électromagnétique => câbles plus longs permis), mais plus lent et difficile à synchroniser

• La tendance est au sériel! (USB, SATA, PCI, PCIe, SPI, I2C, etc.)


E/S parallèles simples

• Réalisées avec des circuits tampons, des bascules transparentes ou synchrones (flip‐flops) ou des ports de uC dédiés

74HC574

74HC573


Une application courante

• Valeur de la résistance de limitation de courant :

R ~ (VDD‐Vled‐Vol)/IdTypiquement [47 – 2.2 k]

• La configuration avec cathode à la masse est moins utilisée

• Valeur de la résistance de tirage :

R ~ (VDD‐Voh)/Ioh ou R ~ Vol/IolTypiquement [10 k – 470 k]

• Plusieurs ports // de uC récents ont des résistances de tirage internes (niveau haut ou bas programmable)


• On peut :• Utiliser des tampons pour augmenter la capacité en courant des

lignes de sortie• Mélanger les directions des lignes d’un même port


E/S conditionnelles

• Permettent de synchroniser la source et la destination par l’usage de :– Lignes de signalisation ajoutées aux lignes de données– Registres d’état avec bits indicateurs (sémaphores ou flags en

anglais)• Plusieurs mécanismes de contrôle

– boucles logicielles– Requête d’interruption automatique sur semaphore

» Les semaphores reflètent les lignes de signalisation


E/S conditionnelles à signalisation simple

• La source ou la destination utilise une ligne distincte – Une seule ligne utilisée

• Des bits de configuration déterminent la polarité et la phase (par rapport à une horloge)

• Un bit d’état indique le statut de l’opération en cours


E/S conditionnelles à signalisation simple

• Le mécanisme de signalisation peut se faire avec avec ou sans interruption

• Le bit d’état est utilisé dans les deux cas


Entrées parallèles synchrones

Mode à synchronisation simple Mode à synchronisation bidirectionnelle

Receiver Sender


Registre PIOC (Parallel I/0 Control): registre utilisé pour la configuration des échanges synchronisés sur les ports parallèles B et C:

STAFSTAI CWOM HDNS OIN PLS EGA INVS $1002

STAF (Strobe A Flag) : mis à 1 lorsqu'il y a une transition sur la ligne STRA, ce qui déclenche la mémorisation des données dans le registrePORT CL.

STAI (Strobe A Interrupt Flag) : Bit d'activation de l'interruption liée au bit STAF.

STAI = 1 : une transition sur STRA donne l'interruption.

STAI = 0: une transition sur STRA ne provoque pas d'interruption.

CWOM (Port C Wired-OR Mode): pour configurer le port C en Ou câblé

HNDS (Handshake/Simple Strobe Mode Select):

HNOS = 0: mode strobe simple sélectionné:

1 impulsion (2 cycles) sort sur STRB après l'écriture dans le port B.

La donnée présente sur le port C est lâchée dans le registre PORT CL chaque fois qu'il y a une transition sur STRA.

HNDS = 1: mode strobe complet sélectionnée pour le port C : STRA en entrée, STRB en sortie (PORTS B non concerné).

OIN (Output / Input Hand strobe Select): Utilisable quand HNDS =

OIN = 1 : Hand strobe complet pour port C en sortie.

OIN = 0 : Hand strobe complet pour port C en entrée.

PLS (Strobe B Pulse Mode Select).

Si HNDS = 1 :

PLS = 0 : mode bloqué : STRB passe à l'état bas quand il y a une transition sur STRA.

PLS = 1 : mode impulsion: Il y a une impulstion sur STRB 2 cycles E) quand il y a une transition sur STRA.

Si HNDS = 0 : mode impulsion toujours.

EGA (Edge Select for Strobe A) : choix de la transition active sur la ligne STRA

EGA = 0 : Front descendant actif

EGA = 1 : Front montant actif

INVB (Invent Strobe B) : choix du niveau actif sur la ligne STRB

INVB = 0 Niveau actif = 0

INVB = 1 Niveau actif = 1


Ex. : Le standard IEEE‐488• Le standard dans beaucoup d’instruments scientifiques pour

la commande et l’enregistrement des mesures• Remplacé aujourd’hui par des interfaces sériels (ex. USB)


Exemple de port parallèle embarqués

• Lignes GPIO du ADuC7026 de Analog Devices (Cœur ARM7TDMI)– 5 ports de 8 bits (broches multiplexées

avec d’autres fonctions)

– La fonction GPIO est établie par default à la mise sous tension ou par 5 registres de configuration ou

– Chaque registre de configuration fait partie d’un MMR (Memory MappedRegion)

• Ensemble de registres occupant un espace mémoire et servant à spécifier la fonctionnalité d’une interface donnée


ADuC7026 : MMRs pour le GPIO • GPxCON

– CONfiguration : fixe la fonctionnalité des broches d’un port

• Deux bits spécifient la fonction de chaque broche


ADuC7026 : MMRS de GPIO (cont)• GPxPAR

– PARamètres : décide de l’activation des résistances de tirage internes (non applicable aux ports 2 et 4)


ADuC7026 : MMRS de GPIO (cont)• GPxDAT

– Data : – Fixe la direction des broches– Donne l’état logique des broches en sortie– Donne l’état logique des broches en entrée– Donne l’état logique des broches à la mise à zéro du système (Reset)


ADuC7026 : MMRS de GPIO (cont)

• GPxSET (permet de charger des bits choisis avec 1)– 1 dans une position met le bit correspondent du port à 1– 0 n’a pas d’effet


ADuC7026 : MMRS de GPIO (cont)

• GPxCLR (permet de charger des bits choisis avec 0)– 1 dans une position met le bit correspondent du port à 0– 0 n’a pas d’effet


Exemple d’application d’un port //: décodage d’un clavier matriciel

• Les touches sont organisées suivant une matrice de rangées et de colonnes

• Chaque touche pesée crée un lien entre une rangée à une colonne– Codage ambigu si deux touches

sont pesées simultanément


Décodage de clavier matriciel (cont)

N1N2N3N4

M1M2M3M4

key_code

keypad controller

k_pressed

key_code4

N=4, M=4

• Deux Techniques

• ‘1’ mobile

• Inversion de lignes

• Des résistances de tiragesont requises pour fixer les valeurs par défaut

• Il faut aussi gérér le rebondissement des ressorts dans les touches


Algorithmes de scrutation • 1 Mobile

Répéter pour chaque colonne (rangée) :1.Mettre un 1 (0) sur la colonne

(rangée)2. Lire chaque rangée (colonne); un 1 (0)indique une clé pressée au croisement rangée‐colonne.

• Exige– Des résistances de tirage vers le bas (haut) pour garantir que l’état au repos des rangées (colonnes) est 0 (1).

• Lectures ambiguës– Si deux clés ou plus sont pesées simultanément, il faut décider laquelle décoder en premier

• Inversion de lignes1.Mettre un 1 (0) sur toutes les colonnes

(rangées) et lires les rangées (colonnes) pour identifier celle active

2. Inverser la direction de toutes les lignes et renvoyer le code lu ; lire les colonnes (rangées) pour identifier celle active.

• Exige– Des résistances de tirage vers le bas (haut) pour garantir que l’état au repos des rangées (colonnes) est 0 (1).

– Un tampon à collecteur/drain ouvert sur chaque colonne (rangée) pour éviter les problèmes électriques dus à l’activation simultanée de plusieurs clés.

• Lectures ambiguës– Si deux clés ou plus sont pesées ensemble, on peut détecter un nombre de clés supérieur à la réalité (circuits fantômes)

– Peut être résolu en plaçant une diode en série avec chaque clé.


Exemple 2 : contrôleur de moteur pas‐à‐pas

Sequence L1 L3 L2 L4 1 + + - - 2 - + + - 3 - - + + 4 + - - + 5 + + - -

• Moteur pas‐à‐pas : tourne d’un angle fini (pas) après réception d’un signal de commande– Par opposition, un moteur DC tourne

sans arrêt après la mise sous tension

• Le sens et l’amplitude de la rotation sont assurés par une séquence de tensions appliquées aux bobines

• Un contrôleur dédié simplifie la procédure (on peut aussi utiliser les lignes d’e/s du uC)

MC3479

Traduit et adapté de l’anglaisTraduit et adapté de MSP430 Teaching ROM et autres sources © Copyright 2009 Texas Instruments 38

Contrôleur de moteur Pas‐à‐pas (cont)

2 L13 L2

107

L3 15L4 14

Commande via un pilote intermédiare

Microcontrôleur

P1.0P1.1

StepperMotor

CLKCW’/CCW

Les lignes de sortie du contrôleur ne fournissent pasassez de puissance pour piloter le moteur pas‐à‐pas ;un étage tampon de puissance est requis. Uneimplémentation possible pour chaque ligne decommande est illustrée ci‐contre : Q1 est un transistorNPN MJE3055T et Q2 est un transistor PNP MJE2955T.A est relié au contrôleur et B va au moteur .

Q2

1K

1KQ1

+V

A B

void main(void){

/* turn the motor forward */cw=1; /* set direction */clk=0; /* pulse clock */delay();clk=1;

/*turn the motor backwards */cw=1; /* set direction */clk=0; /* pulse clock */delay();clk=1;

}

/* code pour uc 8051 */

sbit clk= P1^1;sbit cw =P1^0;

void delay(void){int i, j;for (i=0; i<1000; i++)for ( j=0; j<50; j++)i = i + 0;

}

MC3479P

Traduit et adapté de l’anglaisTraduit et adapté de MSP430 Teaching ROM et autres sources © Copyright 2009 Texas Instruments39

Contrôleur de moteur Pas‐à‐pas

StepperMotor

8051dirP2.4

P2.3P2.2P2.1P2.0

Tampon de puissance possible pour un pilotage par les lignes d’e/s du microcontrôleur

Q2

+V

1KQ1

1K

+V

A

B

330

/*main.c*/sbit notA=P2^0;sbit isA=P2^1;sbit notB=P2^2;sbit isB=P2^3;sbit dir=P2^4;

void delay(){int a, b;for(a=0; a<5000; a++)

for(b=0; b<10000; b++)a=a+0;

}

void move(int dir, int steps) {int y, z;

/* clockwise movement */if(dir == 1){

for(y=0; y<=steps; y++){for(z=0; z<=19; z+4){

isA=lookup[z];isB=lookup[z+1];notA=lookup[z+2];notB=lookup[z+3];delay();

}}

}

/* counter clockwise movement */if(dir==0){

for(y=0; y<=step; y++){for(z=19; z>=0; z - 4){

isA=lookup[z];isB=lookup[z-1];notA=lookup[z -2];notB=lookup[z-3];

delay( );}

}}

}void main( ){

int z;int lookup[20] = {

1, 1, 0, 0,0, 1, 1, 0,0, 0, 1, 1,1, 0, 0, 1,1, 1, 0, 0 };

while(1){/*move forward, 15 degrees (2 steps) */

move(1, 2);/* move backwards, 7.5 degrees (1step)*/move(0, 1);

}}

Commande directe


Interfaces sériels de communication• Port sériel

– Convertit un mot binaire en une séquence de bits transmis sur une ligne d’e/s

– Reçoit une séquence de bits d’une ligne d’e/s et les remet en parallèle

• Économise des lignes d’e/s par rapport à un port //• Plusieurs possibilités

– UART– SPI– I2C– USB– 1‐Wire, Fire‐wire et autres


Protocole sériels communs

• SPI• Serial Peripheral Interface• Single Master/Single Slave

• I2C

C Master

DACSlave

ADCSlave

C Slave

• Inter‐Integrated Circuit Interface• Single Master/Multiple Slaves

SPIMaster

SPISlave

SCLKMOSIMISOSSN

RR

SCLSDA

Vdd

• UART• Universal Asynchronous Receiver/

Transmitter• Full duplex

R/T R/TTxRx

RxTx


Universal Serial Communication Interface

USCI_A0 supports: SPIUART IrDA

USCI_B0 supports: SPI I2C

51

USCI

A

B


44

Universal Asynchronous Receiver Transmitter(UART)

embedded device1 0

0 11 0 1 1

Sending UART

1 0 0 1 1 0 1 1

Receiving UART

1 0 0 1 1 0 1 1

1 0 0 1 1 0 1 1

start bitdata

end bit

• Start bit, stop bit(s) ajoutés à chaque octet

• Bit de parité ajouté pour la détection d’erreurs de 1 bit– Paire et impaire

• Taux de Baud– Nombre maximum de bits

par seconde tout inclus– Habituellement jusqu’à 115

kB/s

• Les bits additionnels réduisent le rendement du lien


MSP430 USCI in UART mode(also USART peripheral)

• Données de 7 or 8‐bit data; parité paire, impaire, sans

• Communication en full duplex• Transmission à partir du premier ou dernier

bit• Réveil à partir du bit Start en mode LPMx• Capacité d’interruption distincte en mode

TX et RX• Registre de status pour la détection

d’erreurs

• Possibilité d’adressage pour opération en réseau


RS232 • Protocole pour la connection par cable et la gestion de la

communication entre DCE (Data Communications Equipment) and DTE (Data Terminal Equipment).

• Ajoutes des lignes de « handshake » (Souvent omises ou contrournées!) – RTS (Ready To Send)

• Envoyé par le DTE au DCE

– CTS (Clear To Send)• Envoyé par le DCE au DTE

– DTR (Data Terminal Ready)• Envoyé par le DTE au DCE

– DSR (Data Set Read)• Envoyé par le DCE au DTE

• Il existe aussi un « handshake » logiciel (XON/XOFF)

• DTE and DCE ont leurs broches de communication et de signalisation inversées.


RS232 Voltage levels

• From processor side, 0V=logic 0,• In a “serial” cable +12+3V=logic 0,

3.3V=logic 1‐3‐12V=logic 1


Serial Peripheral Interface (SPI)• Basé sur des registres à décalage• Une ligne de sortie, une ligne

d’entrée et une ligne de sélection• Normalement, Il faut une ligne de

sélection distincte pour chaque esclave!

• Un maître et un ou plusieurs esclaves

• Opération similaire à celle d’une courroie crénelée : pendant que des bits sortent (dessus), d’autres entrent (dessous)

• La synchronisation des transferts est assurée par une horloge

http://www.mct.net/faq/spi.html

• Terminologie– MOSI ou SDI : master out & slave

in– MISO ou SDO : Master in & slave

out– CLK : Horloge de synchronisation ;

transferts sur front montant ou descendant (programmable)

– SS ou CS : Slave select venant du maitre, habituellement actif bas


SPI

• Deux configurations majeures

Selection d’esclave par ligne individuelle Selection d’esclave par ligne commune


SPI• Séquence d’événements lors d’un échange

• Les périphériques opèrent souvent en semi duplex !– Écriture bidon pour faire une lecture

• Protocole facile, mais rudimentaire– Pas d’aquiescement, validation, arbitration, gestion de flux

lecture Écriture


Plusieurs modes d’horloge (pour faire compliqué)

• CPOL=0: la valeur de référence de l’horloge est 0– CPHA=0: lecture des données sur front montant, mise sur le bus sur front descendant.– CPHA=1: lecture des données sur front descendant, mise sur le bus sur front montant.

• CPOL=1: la valeur de référence de l’horloge est 1– CPHA=0: lecture des données sur front descendant, mise sur le bus sur front montant.– CPHA=1: D lecture des données sur front montant, mise sur le bus sur front descendant.


SPI et SCI

• 7‐ or 8‐bit• LSB‐first or MSB‐first data• Master or slave modes• Selectable clock polarity and phase control

• Programmable clockfrequency in master mode

• Independent transmit and receive• Continuous transmit and receive• Independent interrupt capability for receive and transmit

• Slave operation in LPM4


Inter‐Integrated Circuit (I2C)• Une ligne bidirectionnelle pour

les données et une ligne d’horloge• Un maître et un ou plusieurs

esclaves ; possibilité de plusieurs maîtres

• Le maître contrôle l’horloge et les signaux de départ et d’arrêt des transferts

• Chaque esclave possède une adresse unique (7 ou 10 bits) et réagit uniquement lorsque concerné

– Pas de slave select comme pour le SPI

• Terminologie– SDA : Serial DAta ; va dans les deux

sens– SCL : Serial CLock ; habituellement

sous le contrôle d’unu maître

• Les valeurs des résistances R1 et R2 sont importantes! (2.2k‐10k)

http://www.best‐microcontroller‐projects.com/i2c‐tutorial.html


Vdd(3.3~5V)

RPull

(10~100 kΩ)

Connection au bus I2C

• En l’absence d’activité, La tension du bus est Vdd

• Si un dispositif devient actif, Rpull agit comme résistance de charge

• Rpull petit ‐> transferts rapides et consommation en courant grande, et vice‐versa


I2C

1. Génération de l’état START 2. Génération de l’adresse de l’esclave

(ADDRESS) avec le bit R=1 (Read) ou W=0 (Write)

3. Attente du bit d’acquiescement de l’esclave (ACK)

4. Génération/réception de l’octet de données (DATA).

5. Attente/envoi du bit d’acquiescement (ACK)

6. Génération de l’état STOP (P) ou d’un nouvel état START (S)Lors d’un échange de plusieurs octets, les étapes 5 et 6 sont répétées

Séquence d’évènements lors d’un échange (gérée par le maitre)

Read

Write


I2C et SCI• Slave receiver/transmitter mode• Standard mode up to 100 kbps and fastmode up to 400 kbps support

• Programmable UCxCLK frequency in master mode

• Designed for low power• Slave receiver START detection for auto‐‐wake up from LPMx modes

• Slave operation in LPM4


Universal Serial Interface (USB)• Un maître et un ou plusieurs esclaves suivant une hiérarchie à 7 niveaux

– Adresses de 7 bits : maître, 0 et 126 adresses de prises

• Interface à 4 lignes (câble de 5 m max par niveau – +5 V et masse (500 mA ou 100 mA par prise) – 2 lignes de données différentielles communiquant par codage NRZI avec bits de remplissage (bit stuffing)

• Standard d’ordinateurs, mais aussi utilisé dans les systèmes embarqués (apparait comme un port COM)

• Plusieurs versions– 1.1 : 5 à 12 Mb/s– 2.0 : 480 Mb/s max.– 3.0 : 4.8 Gb/s max.

• Les connecteurs raccordent le courant avant les données, permettant un branchement sans éteindre l’hôte

– Deux types

• Standard privé (royautés dues à moins d’utiliser un composant qui l’a déjà!)

• Protocole compliqué ; il est souvent avantageux d’utiliser un composant qui l’intègre déjà et exploiter l’interface COM !


NRZI avec bits de remplissage (Non Return to Zero Invert with bit stuffing)

• Le signal d’horloge est encodé dans les données de manière que “0” mène à un changement de niveau.

• Une chaîne de zéros donnera une alternance d’états, alors qu’une chaine de uns maintiendra l’état présent.

• Une zéro est inséré après six uns afin de maintenir la synchronisation avec le circuit d’extraction d’horloge.


Architecture hierarchique • Jusqu’à 7 niveaux

– À la mise sous tension, l’hôte scrute chaque esclave pour connaître ses capacités, configurations et modes de communications et lui attribue une adresse (processus d’énumération)

– L’énumération est mise à jour lorsqu’un dispositif est branché ou retiré du réseau

• L’hôte contrôle tout transfert!– Possède un concentrateur racine

(Root Hub) et crée des conduits virtuels pour les transferts de donnés

– Communication par paquets (Token, Data, Handshake)


http://www.ti.com/lit/an/slaa457a/slaa457a.pdf


65

Modulation de largeur d’impulsion (PWM)

clk

pwm_o

25% duty cycle – average pwm_o is 1.25V

clk

pwm_o

50% duty cycle – average pwm_o is 2.5V.

clk

pwm_o

75% duty cycle – average pwm_o is 3.75V.

• Génère des impulsions avec des cycles de travail spécifiques

• Cycle de travail (« duty cycle »): % de temps à l’état “1”– Onde carrée: D = 50%

• Usages : – Tension moyenne pour piloter

un moteur électrique• Plus simple que convertisseur

DC‐DC or numérique‐analogique

• E.g. Vitesse de moteur DC ; gradateur de lumière

– Commandes codées• le récepteur utilise un

temporisateur pour le décodage


66

Commande d’un moteur DC par PWM

void main(void){...

/* controls period */PWMP = 0xff; /* controls duty cycle */PWM1 = 0x7f;

...

while(1){};}

The circuit PWM seul ne peut piloter le moteur DC ; un étage tampon de puissance est requis, par exemple un transistor de puissance

5V

B

A

Structure interne d’un modulateur PWM

diviseur

cycle_high

compteur( 0 – 255)

Comparateur 8 bits

compteur < cycle_high,pwm_o = 1compteur >= cycle_high, pwm_o = 0

pwm_o

clk Input Voltage % of MaximumVoltage Applied RPM of DC Motor

0 0 0

2.5 50 1840

3.75 75 6900

5.0 100 9200

Relation entre la tension appliquée et la vitesse de rotation du moteur

Moteur DC

5V

Du CPU


Afficheur à 7 segments


Mise en // de plusieurs afficheurs

• Généralement, on utilise des décodeur BCD à 7‐segment• Les lignes de données son

communes• Les lignes de sélection sont

individuelles et activées en séquence

• Des étages tampons (amplificateurs de courant) peuvent être requis pour compenser la perte de luminosité due au multiplexage temporel.


Limitation de courant dans les leds

Affichage multiplexé


1. Filtre de polarisation verticale 2. Substrat en verre avec électrodes

pour filtrage vertical3. Cristaux liquides 4. Substrat en verre avec électrodes

pour filtrage horizontal 5. Filtre de polarisation horizontale6. Surface réfléchissante (ou source de

lumière)

Afficheurs à cristaux liquides

• Principe : un cristal liquide qui est soumis à un champ électrique devient opaque

Structure d’un afficheur réflectif


Contrôleur d’ACL

• L’afficheur doit être biaisé par des tensions CA pour éviter la désagrégation que causerait un champ électrique continu

• Un multiplexage complexe des tensions de polarisation doit être réalisé dans le cas de multiples segments pour réduire le nombre de fils– Utilisation de tensions de polarisations multiples, appliquées suivant une

séquence prédéterminée


Exemple de C avec contrôleur d’ACL : MSP430FG4618

• Génération des tensions de biais par le module LCD_A

http://www.ti.com/litv/pdf/slau056l


• Le contrôleur LCD_A supporte 4 types d’ACL:– Statique (capacité de piloter 32 segments)

• Chaque segment est piloté individuellement ; une ligne de retour commune (COM0)

– 2‐mux, 1/2 bias (ou 1/3 bias ; capacité de piloter 64 segments)• Les segments sont pilotés par pairs ; deux lignes de retour distinctes (COM0 et

COM1)– 3‐mux, 1/3 bias (ou 1/2 bias ; capacité de piloter 90 segments)

• Les segments sont pilotés par groupes de trois; trois lignes de retour distinctes (COM0, COM1 et COM2)

– 4‐mux, 1/3 bias (ou 1/2 bias ; capacité de piloter 120 segments) • Les segments sont pilotés par groupes de quatre; quatre lignes de retour

distinctes (COM0, COM1, COM2 et COM3)

Contrôleur d’ACL du MSP430FG4618 : Modes


• ACL statique:– Une broche par segment;– Une broche pour le substrat

– Caractéristiques :• Pilotage simple• Haut contraste;• Nombre élevé de broches.

Contrôleurs de segments ACL : Modes


• ACL 2‐mux :– Nombre de broches réduit;– Segments ACL multiplexés:

• Matrice de segments;• Deux broches communes (COM0 and COM1).

– Example: 2‐mux;



• ACL 3‐mux LCD– Pour 1 broche de segment à piloter :

• 3 segments ACL;• 3 lignes communes (COM0 to COM2).

– Example: 3‐mux, biais 1/3.



• ACL 4‐mux– Pour 1 broche de segment à piloter :

• 4 segments ACL;• 4 lignes communes (COM0 to COM3).

– Example: 4‐mux, biais 1/3.



Exemple de code#include <msp430fg4618.h>typedef unsigned char UInt8;#define LCD_MEM_OFFSET 2 // Offset from LCDMEM[0]

// LCD Segments#define LCD_A 0x01#define LCD_B 0x02#define LCD_C 0x04#define LCD_D 0x08#define LCD_E 0x40#define LCD_F 0x10#define LCD_G 0x20

// LCD Segment Mappingconst UInt8 LCD_Char_Map[ ] ={LCD_A+LCD_B+LCD_C+LCD_D+LCD_E+LCD_F, // '0'LCD_B+LCD_C, // '1'LCD_A+LCD_B+LCD_D+LCD_E+LCD_G, // '2'…LCD_A+LCD_B+LCD_C+LCD_F+LCD_G, // '9'};

// Display character on LCD void dispChar(UInt8 pos, UInt8 index) {

LCDMEM[pos + LCD_MEM_OFFSET] = LCD_Char_Map[index]; // Set segments)

}

void initLCD_A(void){ // Initialize LCD_A

// Configure COM0-COM3 and R03-R33 pinsP5SEL |= (BIT4 | BIT3 | BIT2);P5DIR |= (BIT4 | BIT3 | BIT2);// Configure LCD_ALCDACTL = LCDFREQ_128 | LCDMX1 | LCDMX0

| LCDSON | LCDON;LCDAPCTL0 = LCDS4 | LCDS8 | LCDS12 | LCDS16

| LCDS20 | LCDS24;LCDAPCTL1 = 0;LCDAVCTL0 = LCDCPEN;LCDAVCTL1 = VLCD_2_60;

}

void main(){

WDTCTL = WDTPW + WDTHOLD; // Stop WDTinitLCD_A(); // Initialize LCD

// Display 2017dispChar (1,2); // 2dispChar (2,0); // 0dispChar (3,1); // 1dispChar (4,7); // 7

}

http://www.ti.com/general/docs/lit/getliterature.tsp?baseLiteratureNumber=slac129&fileType=zip


Afficheur LCD avec contrôleur intégré

E

R/W

RS

DB7–DB0

Interface

uContrôleur

8

void WriteCh (char c){

RS = 0/1; /* spécifier texte ou commande */DATA_BUS = c; /* préparer la donnée */EnableLCD(delay); /* Pulser E and attendre l’écoulement d’un délai */

}

CODES

I/D = 1 cursor moves left DL = 1 8-bit

I/D = 0 cursor moves right DL = 0 4-bit

S = 1 with display shift N = 1 2 rows

S/C =1 display shift N = 0 1 row

S/C = 0 cursor movement F = 1 5x10 dots

R/L = 1 shift to right F = 0 5x7 dots

R/L = 0 shift to left

RS R/W DB7 DB6 DB5 DB4 DB3 DB2 DB1 DB0 Description

0 0 0 0 0 0 0 0 0 1 Clears all display, return cursor home

0 0 0 0 0 0 0 0 1 * Returns cursor home

0 0 0 0 0 0 0 1 I/D S Sets cursor move direction and/orspecifies not to shift display

0 0 0 0 0 0 1 D C B ON/OFF of all display(D), cursorON/OFF (C), and blink position (B)

0 0 0 0 0 1 S/C R/L * * Move cursor and shifts display

0 0 0 0 1 DL N F * * Sets interface data length, number ofdisplay lines, and character font

1 0 WRITE DATA Writes Data

• Commande automatique des segments

• Interface à port parallèle 4/8 bits ou sériel – Pilotage des segments à partir de

codes ASCII– Activation de pixel par commande

• Initialisation requise pour régler le fonctionnement


Exemple de code type (horloge de 1MHz)

/********************************************************* Device driver for 4 bit LCD interface *********************************************************---------------+

| 68xx |

|PA0 +--------------------------+PA1 +--------------------------++PA2 +--------------------------+++PA3 +--------------------------++++

E Clock PA4 +-------------------+ ||||Register PA5 +-------------------+-+ ||||Select PA6 +- | | ||||

PA7 +- | | ||||| | | ||||| | | ||||| | | ||||| Vcc | | ||||

---------------+ - | | ||||+-----+| | ||||| || | ||||

+-+ || | ||||20K | +---+|| | ||||pot +-+ ||| | ||||+-----+---+++++| ||||| 1 |||||||||||||| 14| +------------------------+

--- | oooooooooooooo |- | LCD |

+------------------------+*/

void initLCD(void);void wLCDdat(unsigned char data);void wLCDctrl(unsigned char ctl);void wLCDctrl8(unsigned char ctl);

void putcharLCD(char car);void cputsLCD(char *putstr);

typedef struct {unsigned char data:4;unsigned char E:1;unsigned char RS:1;unsigned char :2;

} LCDPort ;extern LCDPort lcdPort; /* specifier l’address avec pragma

ou dans l’éditeur de liens */

unsigned char index;

#define LCDdata lcdport.data /* Data output (PA.0‐P0.3) */#define LCD_RS lcdport.RS /* Register Select bit (PA5) */#define LCD_E lcdport.E /* Clock bit (PA.4) */


/* Initialisation de l’afficheur LCD */void initLCD(void) {wLCDctrl4(0x00) ; // resetwLCDctrl4(0x02) ; // 4 bit interface wLCDctrl (0x24); // Function Set‐ 4‐bit,1‐line,5X7wLCDctrl (0x0c); // Display on, Cursor offwLCDctrl (0x06); // entry mode‐ Inc addr, no shiftwLCDctrl (0x01); // Clear Display}

/ * wLCDdat – écrit 8 bits à la position du curseurdélai de 120µs après l’écriture */

void wLCDdat(unsigned char data) {LCD_RS = 1 ; // RS‐>1 pour le registre de donnéesLCDdata = data >> 4; // Écriture du demi‐octet supérieurLCD_E = 1 ; LCD_E = 0 ; // E‐>1, 0LCDdata = data ; // Écriture du demi‐octet inférieurLCD_E = 1 ; LCD_E = 0 ; // E‐>1, 0LCD_RS = 0 ; // RS‐>0 pour revenir au registre de

cmd

index = 20;while (‐‐index); // ((6 * 19) + 2) =120 µs

}

/ * wLCDctrl – écrit commande de 8 bitsdélai de 4.5ms après si 0x01 ou 0x02 écrit, 120 µs autrement */

void wLCDctrl(unsigned char ctl) {LCDdata = ctl >> 4; // Écriture du demi‐octet supérieurLCD_E = 1 ; LCD_E = 0 ; // E‐>1, 0wLCDctrl4(ctl); // Écriture du demi‐octet inférieur

}

/ * wLCDctrl4 – écrit commande de 4 bitsdélai de 4.5ms après si 0x01 ou 0x02 écrit, 120 µs autrement */

void wLCDctrl4(unsigned char ctl) {LCDdata = ctl // Écriture du demi‐octet LCD_E = 1 ; LCD_E = 0 ; // E‐>1, 0

index = 20 ;while (‐‐index) ; // 120 µsec if (ctl <= 2) { // ajoute ~4.6 ms while (‐‐index);while (‐‐index);while (‐‐index);}

}


/ * putcLCD – écrit caractère ASCII de 8 bits à la position du curseur */

void putcharLCD(char car {if ((car == 0x0a) || (car == 0x0d)) // traiter CR ou LF{wLCDctrl(0x02) ; /* Home */wLCDctrl4(0x01); /* Clear Display */}elsewLCDdat(car);

}

/ * putsLCD – écrit chaine de caractères ASCII à la position du curseur */

void putsLCD(char *putstr){while(*putstr !=0)putcLCD(*putstr++);

}

/* test */

void main(void){… // code d’initialisation du MCU au besoininitLCD();putsLCD (« Salut !");for (;;) ;}

emb 7000, chapitre 3 : périphériques standardboukadoum_m/emb7000/notes/ch3 uc perip… · e/s...

Documents