Systèmes embarqués

1 Composants des systèmes embarqués

1.1 Système embarqué

Système électronique et informatique autonome.
Notion de ressources limitées.
Notion de tâche spécifique.
Notion d’autonomie énergétique.
Le rêve (sonde spatiale) :
La réalité (points d’information) :
Une définition souvent bafouée :
- alimentation sur secteur ;
- un PC comme coeur informatique ;
- un système d’exploitation générique.

1.2 Circuit électronique

Un exemple, la calculatrice NumWorks N0110 :
Eléments classiques d’un système embarqué :
- le SoC (System on Chip), ici un STM32F730 incluant le CPU/FPU (Cortex-M7 jusqu’à 216Mhz), RAM (256Ko), Flash (64Ko), contrôleur USB, ...
- l’horloge, un quartz à 8Mhz, multipliée en interne ;
- une mémoire externe persistante de 64Mbits (8Mo).

1.3 Capteurs et actionneurs

Un exemple, la calculatrice NumWorks :
Des capteurs :
- apparentes, les touches ;
- caché, le "bouton" reset.
Des actionneurs :
- la LED multicolore ;
- l’écran.

1.4 Energie

Un exemple, la calculatrice NumWorks N0100 :
Une batterie LiPo (lithium-ion polymer).
Source d’énergie particulièrement légère.
La gestion de l’énergie va au-delà de la batterie :
- mesure de tension pour contrôler la décharge ;
- régulation de tension pour obtenir 2,8V fixe ;
- circuit de recharge via le port USB.

2 Microcontrôleur ou microprocesseur

2.1 Microcontrôleur

Microcontrôleur simple, e.g. ATMega328p :
- concepteur et fondeur ATMEL (Microchip Technology depuis 2016) ;
- microcontrôleur des Arduino UNO ;
- horloge de 20Mhz au maximum ;
- mémoire : 32Ko flash, 2Ko RAM ;
- bus de communication : 1 série, 2 SPI (ATMega328pb), 1 I2C ;
- 3 minuteurs, acquisition analogique, 6 PWM ;
- programmation facile :
```
#include <avr/io.h>
#include <util/delay.h>

int main(void){
DDRB |= 0x01;
while(1){
  PORTB ^= 0x01;
  _delay_ms(500);
  }
}
```
Microcontrôleur complexe, e.g. Cortex-M4 :
- concepteur ARM Holding ;
- fondeur STMicroelectronics (série STM32F4) ;
- même famille (Cortex M) que le coeur de la NumWorks (STM32F7) ;
- STM32F401 => horloge de 84Mhz, STM32F427 => 180Mhz ;
- STM32F401 => mémoire : 512Ko flash, 96Ko RAM, STM32F427 => 2Mo flash, 256Ko ;
- STM32F427 => 4 bus SPI ;
- pour faire clignoter une LED, environ 300 lignes de configuration ;
- établir la carte des entrées/sorties mais surtout initialiser les horloges :

2.2 Microprocesseur

Microprocesseur, e.g. Cortex-A72 :
- concepteur ARM Holding ;
- processeur de la Raspberry PI 4B ;
- horloge tournant autour de quelques Ghz ;
- mémoires : SD pour mémoire de masse et RAM externe ;
- pipeline d’instructions et prédiction de sauts ;
- gestion de mémoire, deux niveaux de cache ;
- unité arithmétique pour réels ;
- 4 coeurs d’exécution d’instructions ;
- pour faire clignoter une LED, environ 500 lignes d’assembleur :
  - le processeur démarre avec le coeur 0 en mode hypervision ;
  - faire passer le coeur 0 en mode privilégié ;
  - préparer la pile d’exécution ;
  - démarrer l’unité arithmétique ;
  - dérouter le pointeur de programme sur le code.
Microprocesseur, e.g. processeur Intel :
- processeur des PC classiques ;
- horloge tournant autour de quelques Ghz ;
- mémoires : SSD pour mémoire de masse et RAM externe ;
- gestion de mémoire, trois niveaux de cache ;
- unité arithmétique pour réels ;
- plusieurs coeurs d’exécution d’instructions ;
- un "Intel Management Engine" pour démarrer le processeur :
  - CPU 32 bits tournant sous Minix ;
  - toujours sous tension ;
  - accès direct aux interfaces Ethernet (possède ses propres adresses) ;
  - communication avec le processeur via le bus PCI (/dev/mei0 sous Linux).

2.3 Organisation mémoire sur microprocesseur

2.4 Organisation mémoire sur microcontrôleur

Mémoire flash :
Mémoire vive :

2.5 Quel choix pour les systèmes embarqués ?

A priori des microcontrôleurs :
- par exemple une balle vibrante pour sourds :
- empreinte réduite ;
- une consommation maîtrisée.
Des systèmes embarqués avec des nano-ordinateurs :
- par exemple une voiture radioguidée autonome :
- programmation plus aisée ;
- une puissance bien supérieure ;
- prix et empreintes comparables.
Des systèmes embarqués avec des PC industriels :
- par exemple un robot de grande taille :
- systèmes reliés au secteur ou sur batteries ;
- pas de problème de place.

2.6 Un mot sur "Circuit Playground" d’AdaFruit

AdaFruit : le royaume de l’électronique récréative ;
Circuit Playground : plateforme d’apprentissage ;
Capteurs et actionneurs communs :
- détecteur de mouvements LIS3DH ;
- capteur de température ;
- capteur de luminosité ;
- capteur de sons ;
- boutons ;
- 10 NeoPixels (LED RGB avec microcontrôleur) ;
- haut-parleur, ...
Version classique : SoC ATMega32u4 :
- SoC AVR avec gestion USB ;
- utilisable avec l’IDE Arduino et avr-gcc.
Version express : SoC ATSAMD21 :
- SoC incluant un Cortex-M0 avec gestion USB ;
- programmation par blocs ou en Python.
Heu ... mais pourquoi un microcontrôleur démesuré ?

3 Microcontrôleurs AVR : fonctionnalités

3.1 ATMega328p : Caractéristiques

Peut être qualifié de "Système sur Puce" ;
Une architecture classique à la "Harvard" :
Microcontrôleur 8 bits jusqu’à 20Mhz.
Classifié comme RISC (nombre limité d’instructions).
Possède 32 registres généraux r0 à r31.
Mémoire flash de 32Ko pour stocker les programmes.
Mémoire vive (RAM) de 2Ko pour l’exécution des programmes.
Mémoire EEPROM de 1Ko pour des variables permanentes.
Une "Arithmetic and Logic Unit" en nombres entiers mais signés.
```
MULS r10,r11
```

3.2 ATMega328p : Entrées/sorties

Trois ports (ports B, C et D) pour les E/S numériques.
Un port (port C) pour les entrées analogiques.
Les entrées et sorties numériques travaillent à GND ou VCC.
Les entrées analogiques sont mesurées entre 0 (GND) et 1024 (AREF).
Limite absolue de 40mA par sortie pour un total de 200mA.
Il est possible de configurer une résistance de tirage aux entrées :
Exemple d’utilisation d’une entrée et d’une sortie numériques :

Gestion des entrées-sorties numériques avec l’IDE Arduino :

const int LED=8;
const int BOUTON=9;

void setup(){
pinMode(LED,OUTPUT);          // Sortie pour la LED
pinMode(BOUTON,INPUT_PULLUP); // Entrée pour le bouton (résistance de tirage)
}

void loop(){
int etat=digitalRead(BOUTON); // Lecture de l'état du bouton
if(etat==HIGH) digitalWrite(LED,LOW); // LED éteinte
else digitalWrite(LED,HIGH);            // LED allumée
}

Gestion des entrées-sorties numériques avec avr-gcc :

#include <avr/io.h>

#define LED     8
#define BOUTON  9

int main(void){
DDRB |= 0x01;                // Sortie pour la LED
DDRB &= ~0x02;               // Entrée pour le bouton
PORTB |= 0x02;               // Configuration de la résistance de tirage

while(1){
  if(PINB & 0x02) PORTB &= ~0x01;      // LED éteinte
  else PORTB |= 0x01;                  // LED allumée
  }
}

Exemple d’utilisation d’une entrée analogique :

Gestion des entrées analogiques avec l’IDE Arduino :

const int LED_G=8;
const int LED_D=9;
const int LIGNE_G=A0;
const int LIGNE_M=A1;
const int LIGNE_D=A2;

const int LIMITE=128;

void setup(){
pinMode(LED_G,OUTPUT);
pinMode(LED_D,OUTPUT);
}

void loop(){
int lg=analogRead(LIGNE_G);             // Valeurs des détecteurs de ligne
int lm=analogRead(LIGNE_M);
int ld=analogRead(LIGNE_D);
if(lg<LIMITE) digitalWrite(LED_D,HIGH); // Ligne perdue à gauche, tourner à droite
if(ld<LIMITE) digitalWrite(LED_G,HIGH); // Ligne perdue à droite, tourner à gauche
if(lm<LIMITE){                          // Sur la ligne continuer tout droit 
  digitalWrite(LED_D,LOW);
  digitalWrite(LED_G,LOW);
  }
}

Gestion des entrées analogiques avec avr-gcc :

#include <avr/io.h>

#define ADFR 5
#define LIMITE 64

void ad_init(unsigned char channel){    // Sélectionne un canal
ADCSRA |= (1<<ADPS2)|(1<<ADPS1)|(1<<ADPS0); // Division de fréquence 128 => 125KHz
ADCSRA &= ~(1<<ADFR);                       // Mode conversion unique
ADMUX |= (1<<REFS0)|(1<<ADLAR);             // Référence de mesure AVCC
ADMUX=(ADMUX&0xf0)|channel;             // Selection du canal   
ADCSRA|=(1<<ADEN);                      // Convertisseur activé
}

unsigned int ad_capture(void){          // Acquisition de tension
ADCSRA|=(1<<ADSC);                      // Début de conversion
while(bit_is_set(ADCSRA, ADSC));        // Attente de la fin de conversion
return ADCH;                            // Résultat sur 8 bits car ADLAR=1
}

int main(void){
DDRB |= 0x03;
int lg,lm,ld;
while(1){
  ad_init(0); lg=ad_capture();
  ad_init(1); lm=ad_capture();
  ad_init(2); ld=ad_capture();
  if(lg<LIMITE) PORTB |= 0x02; // Ligne perdue à gauche, tourner à droite
  if(ld<LIMITE) PORTB |= 0x01; // Ligne perdue à droite, tourner à gauche
  if(lm<LIMITE) PORTB &= ~0x03;  // Sur la ligne continuer tout droit
  }
}

3.3 ATMega328p : Bus de communication / série

Communication asynchrone sur deux fils.
Des bit de début et de fin pour reconnaître les octets.
Les symboles sont envoyés en séquence.
Vitesse en bauds, avec 0 et 1 comme symboles, 1 baud = 1 bit/s.
Un exemple de chronogramme de communication série :
L’ATMega328p posséde une liaison série matérielle.
Exemple de connexion série avec une Raspberry Pi :

Communication série avec l’IDE Arduino :

void setup(){
  Serial.begin(9600); // configuration de la vitesse
}

void loop(){
  while(1){           // il y a de l'écho
    if(Serial.available()){  // un octet disponible ?
      int c=Serial.read();   // lecture de l'octet reçu
      Serial.write(c);       // envoi d'un octet
    }
}

Communication série avec avr-gcc :

#include <avr/io.h>

void serie_init(long int vitesse){
UBRR0=F_CPU/(((unsigned long int)vitesse)<<4)-1; // configure la vitesse
UCSR0B=(1<<TXEN0 | 1<<RXEN0);                    // autorise l'envoi et la réception
UCSR0C=(1<<UCSZ01 | 1<<UCSZ00);                  // 8 bits et 1 bit de stop
UCSR0A &= ~(1 << U2X0);                          // double vitesse désactivée
}

void serie_envoyer(unsigned char c){
loop_until_bit_is_set(UCSR0A,UDRE0);
UDR0=c;
}

unsigned char serie_recevoir(void){
loop_until_bit_is_set(UCSR0A, RXC0);
return UDR0;
}

int main(void){
serie_init(9600);
while(1){
  unsigned char c=serie_recevoir();
  serie_envoyer(c);
  }
return 0;
}

3.4 ATMega328p : Bus de communication / SPI

Communication synchrone avec plusieurs lignes :
- ligne MOSI : Master Output Slave Input ;
- ligne MISO : Master Input Slave Output ;
- ligne SCK : horloge ;
- ligne SS : Slave Select.
Un exemple de chronogramme de communication SPI :
Débit plus rapide qu’une communication série asynchrone.
Possibilité d’avoir plusieurs périphériques ...
... mais il faut une ligne SS par périphérique.
Exemple de contrôle d’une matrice de LED :

Communication SPI avec l’IDE Arduino :

#include <SPI.h>

void setup(void){
SPI.begin();                            // Initialisation SPI
SPI.setClockDivider(SPI_CLOCK_DIV8);    // Horloge F_CPU/64
digitalWrite(SS,HIGH);                  // Désactive le périphérique
}

void loop(void){
digitalWrite(SS,LOW);
for(i=0;i<64;i++) SPI.transfer(0xe0);
digitalWrite(SS,HIGH);
}

Communication SPI avec avr-gcc :

#include <avr/io.h>

#define SPI_DDR         DDRB
#define SPI_PORT        PORTB
#define SPI_SS          2
#define SPI_MOSI        3
#define SPI_MISO        4
#define SPI_SCK         5

void spi_init(void){                                 // Initialisation du bus SPI
SPI_DDR |= (1<<SPI_MOSI)|(1<<SPI_SCK)|(1<<SPI_SS);   // Définition des sorties
SPI_DDR &= ~(1<<SPI_MISO);                           // Définition de l'entrée
SPI_PORT |= (1<<SPI_SS);                             // Désactivation du périphérique
SPCR = (1<<SPE)|(1<<MSTR)|(1<<SPR1);                 // Activation SPI (SPE) en état maître (MSTR)
                                                     // horloge F_CPU/64 (SPR1=1,SPR0=0)
}

void spi_activer(void){                              // Activer le périphérique
SPI_PORT &= ~(1<<SPI_SS);                            // Ligne SS à l'état bas
}

void spi_desactiver(void){                           // Désactiver le périphérique
SPI_PORT |= (1<<SPI_SS);                             // Ligne SS à l'état haut
}

uint8_t spi_echange(uint8_t envoi){                  // Communication sur le bus SPI
SPDR = envoi;                                        // Octet a envoyer
while(!(SPSR & (1<<SPIF)));                          // Attente fin envoi (drapeau SPIF du statut)
return SPDR;                                         // Octet reçu
}

int main(void){
spi_init();
int i;
spi_activer();
for(i=0;i<64;i++) spi_echange(0xe0);                 // Que de rouge
spi_desactiver();
}

3.5 ATMega328p : Bus de communication / I2C

Communication synchrone sur deux lignes :
- Ligne SDA : ligne de données ;
- Ligne SCL : horloge.
Débit plus rapide qu’une communication série asynchrone.
Possibilité d’avoir plusieurs périphériques ...
... chaque périphérique doit posséder une adresse unique.
Moins de lignes que pour le bus SPI.
Protocole avec accusés de réception.
Protocole complexe donc plus lent que SPI.
Chronogrammes de communication I2C :

i2c.svg
Exemple de contrôle d’un afficheur 7 segments :

Communication I2C avec l’IDE Arduino :

#define MATRICE_REG_LUMINE      0xE0
#define MATRICE_SYSTEME         0x20
#define MATRICE_AFFICHAGE       0x80
#define MATRICE_ADR_I2C         0x70

void luminosite(uint8_t adr_i2c,uint8_t lum){
if(lum>15) lum=15;
Wire.beginTransmission(adr_i2c);
Wire.write(MATRICE_REG_LUMINE|lum);
Wire.endTransmission();  
}

void matrice_init(uint8_t adr_i2c){
Wire.begin();
Wire.setClock(400000UL);
Wire.beginTransmission(adr_i2c);
Wire.write(MATRICE_SYSTEME|1);    // Démarre l'horloge
Wire.endTransmission();
Wire.beginTransmission(adr_i2c);
Wire.write(MATRICE_AFFICHAGE|1);  // Alimente les LED
}

void matrice_afficher(uint8_t adr_i2c,uint8_t image[8]){
Wire.beginTransmission(i2c_addr);
Wire.write((uint8_t)0x00);        // Adresse de départ
for(uint8_t i=0;i<8;i++){
  Wire.write(image[i]);    
  Wire.write(0);    
  }
Wire.endTransmission();  
}

Communication I2C avec avr-gcc :

#include <avr/io.h>

#define         ERROR   0
#define         SUCCESS 1

#define         IIC_START       0x08
#define         IIC_RESTART     0x10
#define         IIC_WADDR_ACK   0x18
#define         IIC_WDATA_ACK   0x28
#define         IIC_RADDR_ACK   0x40
#define         IIC_RDATA_ACK   0x50
#define         IIC_RDATA_NACK  0x58

#define         SCL_CLOCK       400000L // En Hertz

void i2c_init(void){
TWSR=0;                          // Pas de multiplicateur d'horloge
TWBR=((F_CPU/SCL_CLOCK)-16)/2;   // Fréquence de l'horloge i2c
TWCR=(1<<TWEN);                  // Activation de l'i2c matériel
}

static void i2c_start(void){     // Envoi d'un start
TWCR=(1<<TWINT)|(1<<TWSTA)|(1<<TWEN);
while((TWCR & (1<<TWINT))==0);   // Attente de fin d'envoi
}

static void i2c_stop(void){      // Envoi d'un stop
TWCR=(1<<TWINT)|(1<<TWSTO)|(1<<TWEN);
}

static uint8_t i2c_statut(void){ // Etat de la dernière transmission
return (TWSR & 0xF8);
}

void i2c_ecrire(uint8_t octet){  // Envoi d'un octet sur le bus i2c
TWDR=octet;                      // Ecriture de l'octet à envoyer
TWCR=(1<<TWINT)|(1<<TWEN);
while((TWCR & (1<<TWINT))==0);   // Attente de fin d'envoi
}

uint8_t i2c_lire_ack(void){      // Lecture d'un octet sur i2c avec accusé positif
TWCR=(1<<TWINT)|(1<<TWEN)|(1<<TWEA);
while((TWCR & (1<<TWINT))==0);
return TWDR;
}

uint8_t i2c_lire_nack(void){     // Lecture d'un octet sur i2c avec accusé négatif
TWCR=(1<<TWINT)|(1<<TWEN);
while((TWCR & (1<<TWINT))==0);
return TWDR;
}

uint8_t i2c_ecrire_registre(uint8_t adr_i2c,uint8_t reg_val,unsigned char stop){
                                 // Modification de la valeur d'un registre
int statut;
i2c_start();
statut=i2c_statut(); if(status!=IIC_START && status!=IIC_RESTART) return ERROR;
i2c_ecrire(adr_i2c<<1);
statut=i2c_statut(); if(status!=IIC_WADDR_ACK) return ERROR;
i2c_ecrire(reg_val);
statut=i2c_statut(); if(status!=IIC_WDATA_ACK) return ERROR;
if(stop) i2c_stop();
return SUCCESS;
}

uint8_t i2c_ecrire_donnee(uint8_t adr_i2c,uint8_t adresse,uint8_t donnee){
                                 // Ecriture dans la mémoire de l'esclave
int statut;
i2c_start();
statut=i2c_statut(); if(status!=IIC_START && status!=IIC_RESTART) return ERROR;
i2c_ecrire(adr_i2c<<1);
statut=i2c_statut(); if(status!=IIC_WADDR_ACK) return ERROR;
i2c_ecrire(reg_val);
statut=i2c_statut(); if(status!=IIC_WDATA_ACK) return ERROR;
i2c_ecrire(donnee);
statut=i2c_statut(); if(status!=IIC_WDATA_ACK) return ERROR;
TWI_stop();
return SUCCESS;
}

#define MATRICE_REG_LUMINE      0xE0
#define MATRICE_SYSTEME         0x20
#define MATRICE_AFFICHAGE       0x80
#define MATRICE_ADR_I2C         0x70

int matrice_afficher(uint8_t image[8]){
int dim=0x01;                   // Ecriture de quelques registres de la matrice
i2c_ecrire_registre(MATRICE_ADR_I2C,MATRICE_SYSTEME|1,1);
i2c_ecrire_registre(MATRICE_ADR_I2C,MATRICE_REG_LUMINE|dim,1);
i2c_ecrire_registre(MATRICE_ADR_I2C,MATRICE_AFFICHAGE|1,1);
int i;                          // Envoi de chaque ligne
for(i=0;i<8;i++) i2c_ecrire_donnee(MATRICE_ADR_I2C,2*i,image[i]);
return 0;
}

3.6 ATMega328p : Interruptions

Déclenchement d’une procédure sur événement matériel :
- donnée disponible ou envoyée sur bus série, SPI ou i2c ;
- changement sur une entrée quelconque (pas de mode, entrées groupées) ;
- changement sur des entrées spécifiques avec mode particulier ;
- déclenchement d’un minuteur ;
- conversion analogique numérique achevée ;
- valeur analogique dans une plage particulière ;
- opération sur l’EEPROM terminée.
Sur l’ATMega328p, changement avec mode disponible ...
... uniquement sur les broches 2 et 3 de PORTD.
Plusieurs modes possibles :
- sur signal à niveau bas ;
- sur changement quelconque du signal ;
- sur passage du niveau haut au niveau bas (front descendant) ;
- sur passage du niveau bas au niveau haut (front montant).
Circuit pour illustrer les interruptions :

Interruption avec l’IDE Arduino :

const byte LED=8;
const byte INT=3;
int etat=LOW;

void clignote(){            // Procédure d'interruption
etat=(etat==LOW)?HIGH:LOW;
digitalWrite(LED,etat);
}

void setup(){
pinMode(LED,OUTPUT);        // Sortie pour la LED
pinMode(INT,INPUT);         // Entrée pour le détecteur infrarouge 
attachInterrupt(digitalPinToInterrupt(INT),clignote,CHANGE);
}

void loop(){}               // Rien dans la boucle principale

Interruption avec avr-gcc :

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

#define INT_BAS         0
#define INT_CHANGE      1
#define INT_DESCENTE    2
#define INT_MONTEE      3

void interruption_init        // Initialisation d'interruption
   (uint8_t num,uint8_t mode){
uint8_t isc0=0,isc1=0;
switch(mode){
  case INT_BAS:               // Interruption sur niveau bas
    isc0=0; isc1=0; break;
  case INT_CHANGE:            // Interruption sur changement d'état
    isc0=1; isc1=0; break;
  case INT_DESCENTE:          // Interruption sur front descendant
    isc0=0; isc1=1; break;
  case INT_MONTEE:            // Interruption sur front montant
    isc0=1; isc1=1; break;
  }
if(num==0){                   // Configuration pour INT0
  EICRA |= (isc1<<ISC01)|(isc0<<ISC00);
  EIMSK |= (1<<INT0);
  }
if(num==1){                   // Configuration pour INT1
  EICRA |= (isc1<<ISC11)|(isc0<<ISC10);
  EIMSK |= (1<<INT1);
  }
}

ISR(INT1_vect){               // Procédure d'interruption
PORTB ^= 0x01; }

int main(void){
DDRB |= 0x01;
DDRD &= ~0x08;

interruption_init(1,INT_CHANGE);
sei();                        // Autorisation des interruptions
while(1);
return 0;
}

Différence de taille des exécutables :
- IDE => 1024 octets de programme, 15 octets de variables ;
- avr-gcc => 302 octets de programme, 6 octets de variables.

3.7 ATMega328p : Minuteurs

Minuteurs (timers) pour déclencher des interruptions.
Trois minuteurs sur l’ATMega328P :
- deux minuteurs TIMER0 et TIMER2 sur 8 bits ;
- un minuteur TIMER1 sur 16 bits.
Plusieurs modes pour les minuteurs :
- mode normal ;
- mode avec réinitialisation du compteur ;
- modes "Pulse Width Modulation" (génération de signal).
Des registres pour déclencher les interruptions OCRxB.
Un prédiviseur pour allonger les périodes possibles.
Circuit pour illustrer l’utilisation de minuteurs :
Pas d’objet standard pour gérer les minuteurs avec l’IDE Arduino.

Gestion de minuteur avec avr-gcc :

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

#define CTC1            WGM12           // Meilleur nom pour le bit

#define PERIODE         1000

void init_minuteur(int diviseur,long periode){
TCCR1A=0;               // Le mode choisi n'utilise pas ce registre
TCCR1B=(1<<CTC1);       // Réinitialisation du minuteur sur expiration
switch(diviseur){
  case    8: TCCR1B |= (1<<CS11); break;
  case   64: TCCR1B |= (1<<CS11 | 11<<CS10); break;
  case  256: TCCR1B |= (1<<CS12); break;
  case 1024: TCCR1B |= (1<<CS12 | 1<<CS10); break;
  }
// Un cycle prend 1/F_CPU secondes.
// Un pas de compteur prend diviseur/F_CPU secondes.
// Pour une periode en millisecondes, il faut (periode/1000)/(diviseur/F_CPU) pas
// soit (periode*F_CPU)/(1000*diviseur)
OCR1A=F_CPU/1000*periode/diviseur;  // Calcul du pas
TCNT1=0;                // Compteur initialisé
TIMSK1=(1<<OCIE1A);     // Comparaison du compteur avec OCR1A
}

ISR(TIMER1_COMPA_vect){    // Procédure d'interruption
int led=(PORTB&0x0f);
led >>= 1; if(led==0) led=0x08;
PORTB &= 0xf0; PORTB |= led;
}

int main(void){
DDRB |= 0x0f;              // Chenillard sur 4 LED
PORTB &= ~0x0f;            // LED éteintes
init_minuteur(256,PERIODE);
sei();
while(1);
}

3.8 ATMega{16|32}u{2|4} : différences

Les ATMega*u* possèdent un contrôleur USB ;
Les ATMega*u2 n’ont pas d’ADC (juste des comparateurs) :
Les ATMega*u2 ont 512 octets (16u2) et 1024 octets (32u2) de RAM ;
Les ATMega*u4 ont 12 canaux de numérisation ADC ;

Les ATMega*u4 possèdent plus d’entrées/sorties (ports B à F) ;

#include <avr/io.h>

void ad_init(unsigned char channel){
ADCSRA = (1<<ADPS2) | (1<<ADPS1) | (1<<ADPS0); // Résolution maximale
ADCSRB = (((channel&0x20)==0?0:1)<<MUX5); // Sélection du canal
ADMUX  = channel&0x1f;
ADMUX  |= (0<<REFS1) | (1<<REFS0);  // Référence de mesure AVCC
ADMUX  |= (1<<ADLAR);    // Alignement gauche de la valeur
ADCSRA |= (1<<ADEN);    // Convertisseur activé
}

unsigned int ad_capture(void){
ADCSRA |= (1<<ADSC);    // Début de conversion
while(ADCSRA & (1<<ADSC));   // Attente de la fin de conversion
return ADCH;     // Un seul octet retourné
}

Le port série USART0 de l’ATMega328p devient USART1.

Le bus SPI n’est pas sur les mêmes broches :

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

#define SPI_DDR         DDRB
#define SPI_PORT        PORTB
#define SPI_SS          0
#define SPI_SCK         1
#define SPI_MOSI        2
#define SPI_MISO        3

void spi_init(void){                                 // Initialisation du bus SPI
{
SPI_DDR |= (1<<SPI_MOSI)|(1<<SPI_SCK)|(1<<SPI_SS);
SPI_DDR &= ~(1<<SPI_MISO);
SPI_PORT |= (1<<SPI_SS);
SPI_PORT |= (1<<SPI_MISO);
SPSR = (1<<SPI2X);
SPCR = (1<<SPE)|(1<<MSTR)|(1<<CPOL)|(1<<CPHA);
}

void spi_activer(void){                              // Activer le périphérique
SPI_PORT &= ~(1<<SPI_SS);                            // Ligne SS à l'état bas
}

void spi_desactiver(void){                           // Désactiver le périphérique
SPI_PORT |= (1<<SPI_SS);                             // Ligne SS à l'état haut
}

uint8_t spi_echange(uint8_t envoi){                  // Communication sur le bus SPI
{
SPDR = envoi;
while(!(SPSR & (1<<SPIF)));
return SPDR;
}

3.9 ATMega16u2 : Bus de communication / USB

Accélération matérielle pour périphérique USB.
Gestion de la norme USB 2.0 (transferts jusqu’à 12Mb/s).
Implantation du point d’accès de contrôle 0 (8 à 64 octets).
Possibilité de 4 autres points d’accès :
- direction IN ou OUT, de 8 à 64 octets ;
- types interruption, de masse ou isochrone ;
Broches dédiées à USB sur la puce :
- alimentation sur la broche UVCC (5V) ;
- broches de données D- et D+ (logique 3.3V) ;
- un régulateur interne 5V -> 3.3V, sortie sur la broche UCAP.
Domaine de fonctionnement de l’accélération USB :
- alimentation de la puce 3V au minimum ;
- de 3V à 4V, nécessité d’une horloge externe de 8Mhz ;
- de 4V à 5V :
  - possibilité d’utiliser l’horloge interne de 8Mhz ;
  - 4,5V à 5V possibilité d’une horloge externe de 16Mhz.

4 Microcontrôleurs ARM : fonctionnalités

4.1 STM32F0 (Cortex-M0) : Caractéristiques

Peut être qualifié de "Système sur Puce" ;
Une architecture classique à la "Harvard".
Microcontrôleur 32 bits jusqu’à 48Mhz.
Classifié comme RISC (ancien acronyme Advanced RISC Machines).
Possède 16 registres généraux R0 à R15.
Mémoire flash jusqu’à 256Ko pour stocker les programmes.
Mémoire vive (RAM) jusqu’à 32Ko pour l’exécution des programmes.

4.2 STM32F0 : Entrées/sorties

Plusieurs banques (bank) d’E/S numériques.

Gestion des entrées-sorties numériques avec arm-gcc :

#include <stdint.h>

// Adresse de la broche de la LED
#define LED_PORT (*((volatile uint32_t *)0x40020000))
#define LED_PIN 5

// Fonction principale
int main(void) {
  // Initialise la LED
  LED_PORT |= (1 << (LED_PIN * 2));
  // Boucle infinie
  while (1) {
    // Allume la LED
    LED_PORT |= (1 << LED_PIN);
    // Attend une seconde
    for (uint32_t i = 0; i < 1000000; i++) {
    }
    // Éteint la LED
    LED_PORT &= ~(1 << LED_PIN);
  }
  return 0;
}

5 Bus série USB

5.1 Présentation du bus USB 1/3

USB = Universal Serial Bus.
Standard défini par un consortium autonome.
Composition de l’"USB Implementers Forum" :
- Agere Systems ;
- Apple Computer ;
- Hewlett-Packard ;
- Intel ;
- Microsoft ;
- NEC.
Spécifications disponibles sur http://usb.org.
Premier brouillon en novembre 1994.
Les différentes versions :
- USB 1.0, novembre 1995 :
  - débits de 1,5 Mb/s (low) et de 12 Mb/s (full),
  - correction pour les répéteurs => USB 1.1.
- USB 2.0, avril 2000 :
  - débits jusqu’à 480 Mb/s (high),
  - quelques modifications des connecteurs,
  - quelques modifications de l’alimentation.
- USB 3.0, novembre 2008 :
  - débits jusqu’à 5 Gb/s (super), débit possible de 3 Gb/s,
  - quelques modifications des connecteurs :
    - 5 broches supplémentaires ;
    - deux canaux unidirectionnels différentiels.
  - quelques modifications de l’alimentation.
- USB 3.1, septembre 2013 :
  - débits jusqu’à 10 Gb/s (super 10G), débit possible de 7 Gb/s,
  - puissance fournie jusqu’à 100W (20V).
- USB 3.2, septembre 2017 :
  - utilisation du nouveau connecteur USB-C :
    - utilise deux liaisons séries ;
    - chaque liaison série comporte deux canaux unidirectionnels différentiels.
  - débits jusqu’à 20 Gb/s.
- USB 4, août 2019 :
  - basé sur le protocole thunderbolt 3 :
    - thunderbolt est porté par Intel et Apple ;
    - porter des communications PCIExpress 3.0 et DisplayPort 1.2 ;
    - alimenter des périphériques.
  - utilisation du connecteur USB-C ;
  - débits jusqu’à 40 Gb/s ;
  - rétro-compatible jusqu’à USB 2.0.
- USB 4 v2.0, septembre 2022 :
  - débits jusqu’à 120 Gb/s.

5.2 Présentation du bus USB 2/3

Connecteurs USB 2.0 :
- connecteurs de type A, B, mini-B, micro-B ;
- une paire série différentielle D-, D+.
Connecteur USB 3.0 :
- deux paires différentielles blindées ;
- transmissions uni-directionnelles (RX-,RX+) et (TX-,TX+) ;
Connecteur USB C :
- la paire différentielle initiale D-, D+ persiste ;
- cette fois quatres paires différentielles blindées ...
- ... pour deux liaisons série haute vitesse (RX1,TX1) et (RX2,TX2) ;
- et encore des broches pour d’autres usages (SBU1, SBU2).

5.3 Présentation du bus USB 3/3

Caractéristiques remarquables :
- connexion et déconnexion à chaud ;
- mode de fonctionnement maître-esclave ;
  - un contrôleur maître,
  - des répéteurs formant une topologie en étoile,
  - répéteurs alimentés uniquement en feuille,
  - des périphériques esclaves,
  - une bande passante partagée (surcoût > 10%),
- gestion différenciée des esclaves :
  - USB 2.0 => interrogation cycliques,
  - USB 3.0 => interruptions possibles.
Types de contrôleurs USB :
- Universal Host Controller Interface (UHCI) :
  - prévu pour de l’USB 1.1,
  - peu de fonctions en matériel,
  - lourdement propriétaire.
- Open Host Controller Interface (OHCI) :
  - prévu pour de l’USB 1.1,
  - plus de fonctions en matériel.
- Enhanced Host Controller Interface (EHCI) :
  - prévu pour de l’USB 2.0,
  - cohabitait avec un UHCI ou un OHCI,
  - les ports USB sont communs,
  - les périphériques "high" sont gérés par un EHCI,
  - reroutage des "low" ou "full" vers un UHCI ou un OHCI,
  - introduction de Rate Matching Hub (RMH).
- Extensible Host Controller Interface (xHCI) :
  - prévu pour de l’USB 3.x,
  - mais gère les périphériques USB 2.x et USB 1.x en interne,
  - gestion plus pertinente de l’énergie,
  - décharge au maximum le CPU.

5.4 Conception des périphériques USB (1/2)

Des configurations :
- plusieurs par périphérique esclave ;
- différentes fonctionnalités selon l’alimentation ;
- jamais vu un périphérique avec plusieurs configurations.
Des sous-périphériques :
- plusieurs par périphérique ;
- appelés des fonctions de périphériques ;
- à une fonction est associée une interface ;
- exemple : webcam avec micro.

Des classes de périphériques :

Classe	Description	Exemple
00h	Inconnu	Spécifique
01h	Audio	Carte son
02h	Communications	Carte réseau
03h	Human interface device (HID)	Clavier
05h	Physical Interface Device (PID)	Equipement à retour de force
06h	Image	Webcam
07h	Printer	Imprimante
08h	Mass storage	Clef USB
09h	USB hub	Répéteur USB
0Bh	Smart Card	Lecteur de carte
0Dh	Content security	Lecteur d’empreinte digitale
0Eh	Video	Webcam
0Fh	Personal Healthcare	Tensiomètre
E0h	Wireless Controller	Adaptateur Bluetooth

5.5 Conception des périphériques USB (2/2)

Des points d’accès :
- plusieurs par interface (fonctionnalité) ;
- soit une source de données (direction IN vers le contrôleur) ...
- soit un puit de données (direction OUT en provenance du contrôleur) ;
- un maximum de 16 de chaque type.
En résumé, l’arbre des descripteurs :
Initialisation de périphérique :
- négociation du débit ;
- affectation d’une adresse (1 à 127) ;
- choix d’une configuration.
Quelques curiosités :
- contrôleurs situés sur le "pont sud" du circuit ;
- plusieurs types de contrôleurs USB par carte mère (avant xHCI) ;
- plusieurs contrôleurs USB de même type par carte mère ;
- un répéteur racine par contrôleur USB.

5.6 Les périphériques USB par la pratique (1/2)

Des périphériques USB sous Linux :

# lsusb
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
Bus 002 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
Bus 001 Device 002: ID 8087:0020 Intel Corp. Integrated Rate Matching Hub
Bus 002 Device 002: ID 8087:0020 Intel Corp. Integrated Rate Matching Hub
Bus 001 Device 003: ID 13d3:5130 IMC Networks 
Bus 001 Device 004: ID 058f:6366 Alcor Micro Corp. Multi Flash Reader
Bus 002 Device 003: ID 05fe:1958 Chic Technology Corp. 
Bus 002 Device 004: ID 13fe:1e00 Kingston Technology Company Inc.

Exercice : retirez un périphérique USB puis insérez le à nouveau, constat ?
Exercice : connectez deux périphériques de même modèle, constat ?
Exercice : connectez des périphériques USB 2.0 et USB 3.x, constat ?

Des contrôleurs USB sous Linux :

 ehci_hcd: USB 2.0 'Enhanced' Host Controller (EHCI) Driver
 ...
 ehci_hcd 0000:00:1a.0: new USB bus registered, assigned bus number 1
 ...
 usb usb1: New USB device found, idVendor=1d6b, idProduct=0002
 ...
 hub 1-0:1.0: USB hub found
 hub 1-0:1.0: 2 ports detected
 ...
 ehci_hcd 0000:00:1d.0: new USB bus registered, assigned bus number 2
 ...
 hub 2-0:1.0: USB hub found
 hub 2-0:1.0: 2 ports detected
 ...
 hub 1-1:1.0: USB hub found
 hub 1-1:1.0: 6 ports detected
 ...
 hub 2-1:1.0: USB hub found
 hub 2-1:1.0: 8 ports detected

5.7 Les périphériques USB par la pratique (2/2)

Détection d’un périphérique par le noyau Linux :

 usb 1-1.2: new high speed USB device number 3 using ehci_hcd
 usb 1-1.2: New USB device found, idVendor=13d3, idProduct=5130
 usb 1-1.2: New USB device strings: Mfr=2, Product=1, SerialNumber=0
 usb 1-1.2: Product: USB 2.0 Camera

Caractéristiques de la webcam :

# lsusb -v -s 1:3
Bus 001 Device 003: ID 13d3:5130 IMC Networks 
Device Descriptor:
  bLength                18
  bDescriptorType         1
  bcdUSB               2.00
  bDeviceClass          239 Miscellaneous Device
  bDeviceSubClass         2 ?
  bDeviceProtocol         1 Interface Association
  bMaxPacketSize0        64
  idVendor           0x13d3 IMC Networks
  idProduct          0x5130 
  bcdDevice           12.11
  iManufacturer           2 Sonix Technology Co., Ltd.
  iProduct                1 USB 2.0 Camera
  iSerial                 0 
  bNumConfigurations      1
...
# ls -d /sys/bus/usb/devices/1-1.2*
/sys/bus/usb/devices/1-1.2 /sys/bus/usb/devices/1-1.2:1.1
/sys/bus/usb/devices/1-1.2:1.0

Traduction du nom de répertoire 1-1.2:1.1 :
- fragment 1- pour contrôleur USB 1 ;
- fragment 1. pour le port 1 du répéteur racine ;
- fragment 2: pour le port 2 du répéteur secondaire ;
- fragment 1. pour la première configuration ;
- fragment 1 pour la seconde interface.

5.8 Communications sur un bus USB (1/3)

Communications de ou vers les points d’accès :
- en argot un point d’accès est un endpoint ;
- son identifiant est sur 8 bits :
  - 4 bits de poids faibles pour le numéro ;
  - 3 bits à zéro ;
  - 1 bit de poid fort pour la direction (1 = in).
Des canaux de communication vers les points d’accès ;
- ces canaux s’appellent des tubes (pipes) ;
- il existe plusieurs modes de communication ;
- les tubes peuvent être uni-directionnels ou bi-directionnels.
Différents modes de communication :
- isodromique (isochronous) : débit réservé (e.g. vidéo en temps réel) ;
- par interruption (interrupt) : latence garantie (e.g. souris) ;
- de volume (bulk) : débit maximal sans garantie (e.g. clef mémoire) ;
- de contrôle (control) : commande courte avec réponse (e.g. souris).
Direction des communication :
- le tube de contrôle est bi-directionnel ;
- les autres types de tubes sont uni-directionnels ;
- la direction est IN ou OUT vis à vis de l’hôte.
Exercice : examinez les descripteurs d’un clavier USB.

5.9 Communications sur un bus USB (2/3)

Les différents types de paquets sur le bus :
- Initiateur (token) : initie un transfert de données
  Type (8 bits) IN|OUT Adresse (7 bits) Point d’accès (4 bits) Somme de contrôle (5 bits)
- Données (data) : transport de données
  Type (8 bits) DATAx Données (8 à 1024 octets) Somme de contrôle (16 bits)
- Accusés (Handshakes) : confirme ou infirme
  Type (8 bits) ACK|NAK|STALL
Données DATA0 ou DATA1 pour éviter les doublons.
Tailles des données selon le débit et le type de tube.
Pour un tube de transfert de volume :
- low : 8 octets ;
- full : 1023 octets ;
- high : 1024 octets.
Exemple de paquets :
Implantation des tubes :
- Point d’accès OUT :
  - envoi par l’hôte d’un initiateur OUT ;
  - envoi par l’hôte de paquets DATAx ;
  - le périphérique accuse réception.
- Point d’accès IN :
  - envoi par l’hôte d’un initiateur IN ;
  - envoi par le périphérique de paquets DATAx ;
  - l’hôte accuse réception.
Le tube de contrôle du point d’accès 0 :
- tube bidirectionnel toujours présent ;
- tube défini hors interfaces au niveau périphérique ;
- taille des données; low 8o, full et high 64o, super 512o ;
- permet d’affecter au périphérique son adresse ;
- permet de récupérer les descripteurs ;
- permet de fixer la configuration ;
- permet d’activer un point d’accès ou de le libérer.

5.10 Communications sur un bus USB (3/3)

Tube de contrôle :
- permet de configurer le périphérique ;
- peut servir pour un protocole spécifique.
Tubes pour interruptions :
- permettent d’envoyer des interruptions ;
- interruptions IN :
  - l’hôte interroge périodiquement ;
  - le périphérique retourne l’éventuelle interruption.
- interruptions OUT :
  - l’hôte propage ses interruptions ;
  - le périphérique accuse réception.
Tubes isodromiques et de volume :
- pour des tailles de données plus importantes ;
- réservation préalable pour les isodromiques.

5.11 Programmation USB mode noyau

Installez les sources du noyau Linux.
Allez dans le répertoire des pilotes USB (drivers/usb/).
Consultez le squelette de pilote usb-skeleton.c.
Bon courage ...

5.12 Programmation USB mode utilisateur (1/2)

Utilisation de la bibliothèque libusb-1.0.
Documentation à https://libusb.info.
Implante les tubes isodromiques.

Initialisation de la bibliothèque :

libusb_context *context;
int status=libusb_init(&context);
if(status!=0) {perror("libusb_init"); exit(-1);}
/* ... some code ... */
libusb_exit(context);

Enumeration des périphériques USB :

libusb_device **list;
ssize_t count=libusb_get_device_list(context,&list);
if(count<0) {perror("libusb_get_device_list"); exit(-1);}
ssize_t i=0;
for(i=0;i<count;i++){
  libusb_device *device=list[i];
  struct libusb_device_descriptor desc;
  int status=libusb_get_device_descriptor(device,&desc);
  if(status!=0) continue;
  uint8_t bus=libusb_get_bus_number(device);
  uint8_t address=libusb_get_device_address(device);
  printf("Device Found @ (Bus:Address) %d:%d\n",bus,address);
  printf("Vendor ID 0x0%x\n",desc.idVendor);
  printf("Product ID 0x0%x\n",desc.idProduct);
  }
libusb_free_device_list(list,1);

Récupération du descripteur de la configuration actuelle du périphérique :

int status;
struct libusb_config_descriptor *configdesc;
status=libusb_get_active_config_descriptor(device,&configdesc);
if(status!=0){ perror("libusb_get_active_config_descriptor"); exit(-1); }

Ouverture/fermeture du périphérique à la sauce Unix :

libusb_device_handle *handle;
int status=libusb_open(device,&handle);
if(status!=0){ perror("libusb_open"); exit(-1); }
/* ... some ... code */
libusb_close(handle);

Sélection d’une configuration précise du périphérique :

int status;
int indice=0; /* e.g. première configuration */
struct libusb_config_descriptor *configdesc;
status=libusb_get_config_descriptor(device,indice,&configdesc);
if(status!=0){ perror("libusb_get_config_descriptor"); exit(-1); }
int configuration=configdesc->bConfigurationValue;
status=libusb_set_configuration(handle,configdesc->bConfigurationValue);
if(status!=0){ perror("libusb_set_configuration"); exit(-1); }

Appropriation et libération d’une interface (fonctionnalité USB) :

int indint=0 /* e.g. première interface */
int indalt=0 /* e.g. première alternative */
int interface=configdesc->interface[indint].altsetting[indalt].bInterfaceNumber;
int status=libusb_claim_interface(handle,interface);
if(status!=0){ perror("libusb_claim_interface"); exit(-1); }
/* ... some code ... */
status=libusb_release_interface(handle,interface);
if(status!=0){ perror("libusb_release_interface"); exit(-1); }

Si le méchant noyau est passé avant vous :

if(libusb_kernel_driver_active(handle,interface)){
  int status=libusb_detach_kernel_driver(handle,interface);
  if(status!=0){ perror("libusb_detach_kernel_driver"); exit(-1); }
  }

5.13 Programmation USB mode utilisateur (2/2)

Fonctions de communication bloquantes :

fonctions plutôt pour des prototypes ;

tube de contrôle :

int typ=LIBUSB_REQUEST_TYPE_xxx; /* see libusb.h */
int req=LIBUSB_REQUEST_yyy    ;  /* see libusb.h */
int val=...;          /* parameter for req */
int ind=...;          /* parameter for req */
char data[MAX_DATA];  /* data to send or to receive */
int size=...;         /* size to send or maximum size to receive */
int timeout=...;      /* timeout in ms */
int nb_bytes=libusb_control_transfer(handle,typ,req,val,ind,data,size,timeout);

tube pour interruptions :

int endpoint_out=...;   /* ID of endpoint (bit 8 is 0) */
int endpoint_in=...;    /* ID of endpoint (bit 8 is 1) */
char data[MAX_DATA];    /* data to send or to receive */
int size=...;           /* size to send or maximum size to receive */
int timeout=...;        /* timeout in ms */
/* OUT interrupt, from host to device */
int bytes_out;
int status=libusb_interrupt_transfer(handle,endpoint_out,data,size,&bytes_out,timeout);
if(status!=0){ perror("libusb_interrupt_transfer"); exit(-1); }
/* IN interrupt, host polling device */
int bytes_in;
int status=libusb_interrupt_transfer(handle,endpoint_in,data,size,&bytes_in,timeout);
if(status!=0){ perror("libusb_interrupt_transfer"); exit(-1); }

tube pour transfert de volume :

int endpoint_out=...;   /* ID of endpoint (bit 8 is 0) */
int endpoint_in=...;    /* ID of endpoint (bit 8 is 1) */
char data[MAX_DATA];    /* data to send or to receive */
int size=...;           /* size to send or maximum size to receive */
int timeout=...;        /* timeout in ms */
/* OUT bulk transfer */
int bytes_out;
int status=libusb_bulk_transfer(handle,endpoint_out,data,size,&bytes_out,timeout);
if(status!=0){ perror("libusb_bulk_transfer"); exit(-1); }
/* IN bulk transfer */
int bytes_in;
int status=libusb_bulk_transfer(handle,endpoint_in,data,size,&bytes_in,timeout);
if(status!=0){ perror("libusb_bulk_transfer"); exit(-1); }

Fonctions de communication asynchrones :
- un système de programmation par événements ;
- tube isodromique implanté.

5.14 Programmation USB sur AVR (1/3)

Plusieurs méthodes :
- "à la main" en utilisant les registres adaptés ;
- des bibliothèques bas niveau comme V-USB (tout AVR) ;
- des bibliothèques plus haut niveau comme LUFA (AVR avec USB matériel).
Bibliothèque LUFA, modes :
- programmation en mode périphérique sur tous les AVR USB ;
- programmation en mode contrôleur sur tous les AVR USB 32 bits ;
- programmation en mode contrôleur sur deux AVR USB 8 bits.
Bibliothèque LUFA, de nombreux exemples :
- des exemples de chargeurs (bootloaders) ;
- des exemples pour contrôler des périphériques ;
- des exemples pour programmer des périphériques ;
- des exemples à deux niveaux :
  - bas niveau, les fonctions manipulent directement les points d’accès ;
  - haut niveau, les fonctions remplissent des structures ...
  - ... la bibliothèque fait le reste.
Bibliothèque LUFA, principe :
- boucler sur la gestion des événements USB USB_USBTask ;
- éventuellement appeler aussi la gestion d’une classe (e.g. HID_Task) ;
- écrire les fonctions de rappel (callback) pour implanter les fonctionnalités souhaitées.

5.15 Programmation USB sur AVR avec LUFA (2/3)

Restriction au cas de la programmation de périphériques.
Copier une démonstration LUFA dans Demos/Device.
Configurer la cible dans le fichier makefile :
- changer le microcontrôleur (MCU) cible ;
- changer la carte cible (BOARD), généralement en NONE ;
- éventuellement changer la fréquence du processeur F_CPU.
Définition des descripteurs dans le fichier Descripteurs.h :
- ajouter des structures interfaces USB_Descriptor_Interface_t et/ou ...
- ajouter des structures points d’accès USB_Descriptor_Endpoint_t dans ...
- la structure générale USB_Descriptor_Configuration_t ;
- éventuellement ajouter des identifiants d’interface dans l’énumération InterfaceDescriptors_t ;
- éventuellement ajouter des numéros de points d’accès XXX_EPADDR ;
- éventuellement ajouter des tailles de données de points d’accès XXX_EPSIZE.
Configurer les descripteurs dans le fichier Descripteurs.c :
- modifier le descripteur de configuration ConfigurationDescriptor ;
- modifier le nombre d’interfaces dans le champ .Config ;
- ajouter les champs pour les nouvelles interfaces ;
- ajouter les champs pour les nouveaux points d’accès.

5.16 Programmation USB sur AVR avec LUFA (3/3)

Ajouter la gestion des points d’accès dans l’autre source C du projet.
Définir les points d’accès dans la fonction EVENT_USB_Device_ConfigurationChanged :
```
Endpoint_ConfigureEndpoint(<EPADDR>, <EP_TYPE>, <EPSIZE>, 1);
```
Appeler ces fonctions de gestion dans la boucle infinie USB_USBTask.

Fonction de gestion d’un point d’accès IN :

/* Select the IN Endpoint */
Endpoint_SelectEndpoint(IN_EPADDR);
/* Check if Endpoint Ready for Read/Write */
if(Endpoint_IsReadWriteAllowed()){
  /* Write Keyboard Report Data */
  Endpoint_Write_xxx(...);
  /* Finalize the stream transfer to send the last packet */
  Endpoint_ClearIN();
  }

Fonction de gestion d’un point d’accès OUT :

/* Select the OUT Endpoint */
Endpoint_SelectEndpoint(OUT_EPADDR);

/* Check if Endpoint contains a packet */
if(Endpoint_IsOUTReceived()){
  /* Check to see if the packet contains data */
  if(Endpoint_IsReadWriteAllowed()){
    /* Read from the host */
    ... Endpoint_Read_yyy(...);
    /* Process the data from the host */
    ...
    }
  /* Handshake the OUT Endpoint - clear endpoint and ready for next report */
  Endpoint_ClearOUT();
  }

6 Microcontrôleurs AVR : utilisation

6.1 ATMega328p : Chaîne de compilation (1/2)

Plusieurs niveaux de programmation de l’ATMega328p.
Environnement de Développement Intégré (IDE) Arduino :
- une interface graphique :
- langage objet C++ ;
- des exemples à explorer ;
- téléversement des programmes en un clic ;
- une gestion des bibliothèques simplifiée ;
- un terminal série intégré.

6.2 ATMega328p : Chaîne de compilation (2/2)

Compilation en ligne de commande avec gcc.
Oubliez le "concurrent" clang.

Compilation classique avec avr-gcc :

uniquement trois paquetages à installer :
```
# apt install gcc-avr avr-libc avrdude
```

compilation par ligne de commande :

$ avr-gcc -mmcu=atmega328p -DF_CPU=16000000UL -c -Wall -I. -Os timer.c -o timer.o
$ avr-gcc -mmcu=atmega328p -g -lm -Wl,--gc-sections -o timer.elf timer.o

téléversement sur le microcontrôleur en ligne de commande :

$ avr-objcopy -j .text -j .data -O ihex timer.elf timer.hex
$ stty -F /dev/ttyACM0 hupcl
$ avrdude -F -v -p atmega328p -c stk500v1 -b 115200 -P /dev/ttyACM0 -U flash:w:timer.hex

maitrise totale du code ;
des programmes compacts et efficaces.

6.3 ATMega328p : détails de la chaîne de compilation (1/6)

Exemple de programme timer.c :

#include <avr/io.h>  // for the input/output register
#include <avr/interrupt.h>  

#define PRESCALER 256
#define NB_TICK  12500
#define CTC1  WGM12  // Better name

int led_bit=0x01;

void init_ports(void){
DDRB  |= led_bit;
PORTB |= 0x00;
}

void init_timer(){
TCCR1A = 0;  // No output pin connected, no PWM mode enabled
TCCR1B = 1<<CTC1; // No input pin used, clear timer counter on compare match
#if (PRESCALER==8)
 TCCR1B |= (1<<CS11);
#endif
#if (PRESCALER==64)
 TCCR1B |= (1<<CS11 | 11<<CS10);
#endif
#if (PRESCALER==256)
 TCCR1B |= (1<<CS12);
#endif
#if (PRESCALER==1024)
 TCCR1B |= (1<<CS12 | 1<<CS10);
#endif
OCR1A = NB_TICK;
TCNT1 = 0;
TIMSK1 = (1<<OCIE1A); // No overflow mode enabled, no input interrupt, output compare interrupt
}

ISR(TIMER1_COMPA_vect){
PORTB ^= led_bit;
}

int main(void){
init_ports();
init_timer();
sei();
return 0;
}

A quelle fréquence la LED sur PB0 clignote-t-elle ?
Une erreur s’est glissée dans ce programme, trouvez-la avec le code assembleur généré.

6.4 ATMega328p : détails de la chaîne de compilation (2/6)

Production du code intermédiaire par :

expansion des macros ;

expansion des fichiers d’entêtes ;

$ avr-gcc -E -I. -DF_CPU=16000000 -mmcu=atmega328p -Wp,-P -Os timer.c -o timer-cpp.c
$ cat timer-cpp.c
...
int led_bit=0x01;
void init_ports(void){
(*(volatile uint8_t *)((0x04) + 0x20)) |= led_bit;
(*(volatile uint8_t *)((0x05) + 0x20)) |= 0x00;
}
void init_timer(){
(*(volatile uint8_t *)(0x80)) = 0;
(*(volatile uint8_t *)(0x81)) = 1<<3;
(*(volatile uint8_t *)(0x81)) |= (1<<2);
(*(volatile uint16_t *)(0x88)) = 12500;
(*(volatile uint16_t *)(0x84)) = 0;
(*(volatile uint8_t *)(0x6F)) = (1<<1);
}
void __vector_11 (void) __attribute__ ((signal,used, externally_visible)) ; void __vector_11 (void){
(*(volatile uint8_t *)((0x05) + 0x20)) ^= led_bit;
}
int main(void){
init_ports();
init_timer();
__asm__ __volatile__ ("sei" ::: "memory");
return 0;
}

création d’un arbre syntaxique abstrait (AST) ;

options pour obtenir l’arbre gcc --dump-tree-xxx ;

$ avr-gcc -Wall --dump-tree-all-graph -I. -DF_CPU=16000000 -Os  -mmcu=atmega328p -c -o timer.o timer.c

arbre initial (ou presque) :
arbre optimisé :

Exercice : trouvez l’effet de l’option -Wp,-P.

6.5 ATMega328p : détails de la chaîne de compilation (3/6)

Optimisations à plusieurs étapes :
- les principales sur l’arbre syntaxique (AST) ;
- certaines sur la représentation intermédiaire (RTL/IR).
Plusieurs techniques utilisées
- optimisations directes :
  - substitution de fonctions ;
  - déroulement de boucles ;
  - récursion terminale ;
  - ...
- conversion en affectation unique :
  - propagation de constantes ;
  - élimination de code mort ;
  - diminution de complexité ;
  - factorisation d’expressions ;
  - ...
- flots des données et modèle polyhédrique :
  - parallélisation de boucles ;
  - transformation de boucles ;
  - ...

6.6 ATMega328p : détails de la chaîne de compilation (4/6)

Génération de code pour un CPU virtuel.
GCC utilise Register Transfer Language http://gcc.gnu.org/onlinedocs/gccint/RTL.html.

Options pour obtenir le code RTL gcc --dump-rtl-xxx (e.g. --dump-rtl-expand) :

...
;; Function init_ports
(note 1 0 3 NOTE_INSN_DELETED)
(note 3 1 20 [bb 2] NOTE_INSN_BASIC_BLOCK)
(note 20 3 2 NOTE_INSN_PROLOGUE_END)
(note 2 20 6 NOTE_INSN_FUNCTION_BEG)
(insn 6 2 7 (set (reg:QI 25 r25 [orig:42 D.1651 ] [42])
        (mem/v:QI (const_int 36 [0x24]) [0 MEM[(volatile uint8_t *)36B]+0 S1 A8])) timer.c:13 71 {movqi_insn}
     (nil))
(note 7 6 8 NOTE_INSN_DELETED)
(insn 8 7 9 (set (reg:QI 24 r24 [orig:51 led_bit ] [51])
        (mem/c:QI (symbol_ref:HI ("led_bit") [flags 0x2]  <var_decl 0x7f6d24cf8cf0 led_bit>) [1 led_bit+0 S1 A8])) timer.c:13 71 {movqi_insn}
     (nil))
(insn 9 8 11 (set (reg:QI 24 r24 [orig:47 D.1651 ] [47])
        (ior:QI (reg:QI 24 r24 [orig:51 led_bit ] [51])
            (reg:QI 25 r25 [orig:42 D.1651 ] [42]))) timer.c:13 266 {iorqi3}
     (expr_list:REG_DEAD (reg:QI 25 r25 [orig:42 D.1651 ] [42])
        (nil)))
(insn 11 9 13 (set (mem/v:QI (const_int 36 [0x24]) [0 MEM[(volatile uint8_t *)36B]+0 S1 A8])
        (reg:QI 24 r24 [orig:47 D.1651 ] [47])) timer.c:13 71 {movqi_insn}
     (expr_list:REG_DEAD (reg:QI 24 r24 [orig:47 D.1651 ] [47])
        (nil)))
(insn 13 11 15 (set (reg:QI 24 r24 [orig:48 D.1651 ] [48])
        (mem/v:QI (const_int 37 [0x25]) [0 MEM[(volatile uint8_t *)37B]+0 S1 A8])) timer.c:14 71 {movqi_insn}
     (nil))
(insn 15 13 22 (set (mem/v:QI (const_int 37 [0x25]) [0 MEM[(volatile uint8_t *)37B]+0 S1 A8])
        (reg:QI 24 r24 [orig:48 D.1651 ] [48])) timer.c:14 71 {movqi_insn}
     (expr_list:REG_DEAD (reg:QI 24 r24 [orig:48 D.1651 ] [48])
        (nil)))
(jump_insn 22 15 21 (return) timer.c:14 453 {return}
     (nil)
 -> return)
(barrier 21 22 18)
(note 18 21 0 NOTE_INSN_DELETED)
...

6.7 ATMega328p : détails de la chaîne de compilation (5/6)

Production du code assembleur.
Sélection des instructions du CPU cible.
Gestion mémoire : globale, tas et pile.

Programme de l’exemple en assembleur :

$ avr-gcc -Wall -I. -DF_CPU=16000000 -Os  -mmcu=atmega328p -S -o timer.s timer.c
$ cat timer.s
__SP_H__ = 0x3e
__SP_L__ = 0x3d
__SREG__ = 0x3f
__tmp_reg__ = 0
__zero_reg__ = 1
 .text
.global init_ports
 .type init_ports, @function
init_ports:
.L__stack_usage = 0
 in r25,0x4
 lds r24,led_bit
 or r24,r25
 out 0x4,r24
 in r24,0x5
 out 0x5,r24
 ret
 .size init_ports, .-init_ports
.global init_timer
 .type init_timer, @function
init_timer:
.L__stack_usage = 0
 sts 128,__zero_reg__
 ldi r30,lo8(-127)
 ldi r31,0
 ldi r24,lo8(8)
 st Z,r24
 ld r24,Z
 ori r24,lo8(4)
 st Z,r24
 ldi r24,lo8(-44)
 ldi r25,lo8(48)
 sts 136+1,r25
 sts 136,r24
 sts 132+1,__zero_reg__
 sts 132,__zero_reg__
 ldi r24,lo8(2)
 sts 111,r24
 ret
 .size init_timer, .-init_timer
.global __vector_11
 .type __vector_11, @function
__vector_11:
 push r1
 push r0
 in r0,__SREG__
 push r0
 clr __zero_reg__
 push r24
 push r25
.L__stack_usage = 5
 in r25,0x5
 lds r24,led_bit
 eor r24,r25
 out 0x5,r24
 pop r25
 pop r24
 pop r0
 out __SREG__,r0
 pop r0
 pop r1
 reti
 .size __vector_11, .-__vector_11
 .section .text.startup,"ax",@progbits
.global main
 .type main, @function
main:
.L__stack_usage = 0
 call init_ports
 call init_timer
 sei
 ldi r24,0
 ldi r25,0
 ret
 .size main, .-main
.global led_bit
 .data
 .type led_bit, @object
 .size led_bit, 2
led_bit:
 .word 1
 .ident "GCC: (GNU) 5.4.0"
.global __do_copy_data

6.8 ATMega328p : détails de la chaîne de compilation (6/6)

Création d’un exécutable ou objet.
Format "Executable and Linkable" ELF :
- une entête ;
- des sections ;
- des segments (programs).

Exemple d’entête de fichier exécutable :

$ avr-readelf -h timer.elf
En-tête ELF:
  Magique:   7f 45 4c 46 01 01 01 00 00 00 00 00 00 00 00 00 
  Classe:                            ELF32
  Données:                           complément à 2, poids faible d'abord (little endian)
  Version:                           1 (current)
  OS/ABI:                            UNIX - System V
  Version ABI:                       0
  Type:                              EXEC (fichier exécutable)
  Machine:                           Atmel AVR 8-bit microcontroller
  Version:                           0x1
  Adresse du point d'entrée:         0x0
  Début des en-têtes de programme :  52 (octets dans le fichier)
  Début des en-têtes de section :    6256 (octets dans le fichier)
  Fanions:                           0x5, avr:5
  Size of this header:               52 (bytes)
  Size of program headers:           32 (bytes)
  Number of program headers:         2
  Size of section headers:           40 (bytes)
  Number of section headers:         12
  Section header string table index: 9

Liste des sections pour le même exemple :

$ avr-readelf -S timer.elf
There are 12 section headers, starting at offset 0x1870:

En-têtes de section :
  [Nr] Nom               Type            Adr      Décala.Taille ES Fan LN Inf Al
  [ 0]                   NULL            00000000 000000 000000 00      0   0  0
  [ 1] .data             PROGBITS        00800100 000182 000002 00  WA  0   0  1
  [ 2] .text             PROGBITS        00000000 000074 00010e 00  AX  0   0  2
  [ 3] .comment          PROGBITS        00000000 000184 000011 01  MS  0   0  1
  [ 4] .note.gnu.avr.dev NOTE            00000000 000198 000040 00      0   0  4
  [ 5] .debug_info       PROGBITS        00000000 0001d8 0005f4 00      0   0  1
  [ 6] .debug_abbrev     PROGBITS        00000000 0007cc 0005a2 00      0   0  1
  [ 7] .debug_line       PROGBITS        00000000 000d6e 00001a 00      0   0  1
  [ 8] .debug_str        PROGBITS        00000000 000d88 000208 00      0   0  1
  [ 9] .shstrtab         STRTAB          00000000 0017f3 00007a 00      0   0  1
  [10] .symtab           SYMTAB          00000000 000f90 0004e0 10     11  17  4
  [11] .strtab           STRTAB          00000000 001470 000383 00      0   0  1
Key to Flags:
  W (write), A (alloc), X (execute), M (merge), S (strings)
  I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)
  O (extra OS processing required) o (OS specific), p (processor specific)

Exemple de segments pour le même exemple :

$ avr-readelf -l timer.elf

Type de fichier ELF est EXEC (fichier exécutable)
Entry point 0x0
There are 2 program headers, starting at offset 52

En-têtes de programme :
  Type           Décalage Adr. vir.  Adr.phys.  T.Fich. T.Mém.  Fan Alignement
  LOAD           0x000074 0x00000000 0x00000000 0x0010e 0x0010e R E 0x2
  LOAD           0x000182 0x00800100 0x0000010e 0x00002 0x00002 RW  0x1

 Correspondance section/segment :
  Sections de segment...
   00     .text 
   01     .data

6.9 ATMega328p : édition des liens (1/3)

Bibliothèques statiques
Algorithme d’édition des liens :
- entrée : fichiers objets (variables et fonctions) ;
- entrée : bibliothéques (variables et fonctions) ;
- sortie : un exécutable (chargé par le système) ;
- entités considérées de gauche à droite ;
- 2 ensembles : symboles collectés, symboles indéfinis ;
- si l’entité est un fichier objet F :
  - les symboles exportés par F sont :
    - ajoutés aux symboles collectés ;
    - retranchés des symboles indéfinis.
  - erreur si un même symbole est collecté deux fois ;
  - les symboles importés par F sont :
    - ajoutés aux symboles indéfinis ;
    - sauf si présents comme symboles collectés.
- si l’entité est une bibliothèque B :
  - chaque objet de la bibliothèque est considéré ;
  - si l’objet exporte un symbole indéfini, on le traite ;
  - oubli des objets n’exportant aucun symbole indéfini ;
  - si la liste des symboles indéfinis est modifiée ...
  - ... la bibliothèque est examinée à nouveau.
- quand il ne reste plus d’entité à analyser :
  - erreur s’il reste des symboles indéfinis ;
  - sinon l’exécutable est créé :
    - les sections de même nom sont agrégées ;
    - les agrégats de même type sont agrégés ;
    - une adresse est affectée à chaque agrégat ;
    - les références aux symboles sont calculés.
Création d’une bibliothéque : commande ar.

6.10 ATMega328p : édition des liens (2/3)

Exemple d’exécutable final :

$ avr-objdump -d timer.elf
Déassemblage de la section .text :

00000000 <__vectors>:
   0: 0c 94 34 00  jmp 0x68 ; 0x68 <__ctors_end>
   4: 0c 94 49 00  jmp 0x92 ; 0x92 <__bad_interrupt>
   8: 0c 94 49 00  jmp 0x92 ; 0x92 <__bad_interrupt>
   c: 0c 94 49 00  jmp 0x92 ; 0x92 <__bad_interrupt>
  10: 0c 94 49 00  jmp 0x92 ; 0x92 <__bad_interrupt>
  14: 0c 94 49 00  jmp 0x92 ; 0x92 <__bad_interrupt>
  18: 0c 94 49 00  jmp 0x92 ; 0x92 <__bad_interrupt>
  1c: 0c 94 49 00  jmp 0x92 ; 0x92 <__bad_interrupt>
  20: 0c 94 49 00  jmp 0x92 ; 0x92 <__bad_interrupt>
  24: 0c 94 49 00  jmp 0x92 ; 0x92 <__bad_interrupt>
  28: 0c 94 49 00  jmp 0x92 ; 0x92 <__bad_interrupt>
  2c: 0c 94 6a 00  jmp 0xd4 ; 0xd4 <__vector_11>
  30: 0c 94 49 00  jmp 0x92 ; 0x92 <__bad_interrupt>
  34: 0c 94 49 00  jmp 0x92 ; 0x92 <__bad_interrupt>
  38: 0c 94 49 00  jmp 0x92 ; 0x92 <__bad_interrupt>
  3c: 0c 94 49 00  jmp 0x92 ; 0x92 <__bad_interrupt>
  40: 0c 94 49 00  jmp 0x92 ; 0x92 <__bad_interrupt>
  44: 0c 94 49 00  jmp 0x92 ; 0x92 <__bad_interrupt>
  48: 0c 94 49 00  jmp 0x92 ; 0x92 <__bad_interrupt>
  4c: 0c 94 49 00  jmp 0x92 ; 0x92 <__bad_interrupt>
  50: 0c 94 49 00  jmp 0x92 ; 0x92 <__bad_interrupt>
  54: 0c 94 49 00  jmp 0x92 ; 0x92 <__bad_interrupt>
  58: 0c 94 49 00  jmp 0x92 ; 0x92 <__bad_interrupt>
  5c: 0c 94 49 00  jmp 0x92 ; 0x92 <__bad_interrupt>
  60: 0c 94 49 00  jmp 0x92 ; 0x92 <__bad_interrupt>
  64: 0c 94 49 00  jmp 0x92 ; 0x92 <__bad_interrupt>

00000068 <__ctors_end>:
  68: 11 24        eor r1, r1
  6a: 1f be        out 0x3f, r1 ; 63
  6c: cf ef        ldi r28, 0xFF ; 255
  6e: d8 e0        ldi r29, 0x08 ; 8
  70: de bf        out 0x3e, r29 ; 62
  72: cd bf        out 0x3d, r28 ; 61

00000074 <__do_copy_data>:
  74: 11 e0        ldi r17, 0x01 ; 1
  76: a0 e0        ldi r26, 0x00 ; 0
  78: b1 e0        ldi r27, 0x01 ; 1
  7a: ee e0        ldi r30, 0x0E ; 14
  7c: f1 e0        ldi r31, 0x01 ; 1
  7e: 02 c0        rjmp .+4       ; 0x84 <__do_copy_data+0x10>
  80: 05 90        lpm r0, Z+
  82: 0d 92        st X+, r0
  84: a2 30        cpi r26, 0x02 ; 2
  86: b1 07        cpc r27, r17
  88: d9 f7        brne .-10      ; 0x80 <__do_copy_data+0xc>
  8a: 0e 94 7d 00  call 0xfa ; 0xfa <main>
  8e: 0c 94 85 00  jmp 0x10a ; 0x10a <_exit>

00000092 <__bad_interrupt>:
  92: 0c 94 00 00  jmp 0 ; 0x0 <__vectors>

00000096 <init_ports>:
  96: 94 b1        in r25, 0x04 ; 4
  98: 80 91 00 01  lds r24, 0x0100 ; 0x800100 <__DATA_REGION_ORIGIN__>
  9c: 89 2b        or r24, r25
  9e: 84 b9        out 0x04, r24 ; 4
  a0: 85 b1        in r24, 0x05 ; 5
  a2: 85 b9        out 0x05, r24 ; 5
  a4: 08 95        ret

000000a6 <init_timer>:
  a6: 10 92 80 00  sts 0x0080, r1 ; 0x800080 <__TEXT_REGION_LENGTH__+0x7f8080>
  aa: e1 e8        ldi r30, 0x81 ; 129
  ac: f0 e0        ldi r31, 0x00 ; 0
  ae: 88 e0        ldi r24, 0x08 ; 8
  b0: 80 83        st Z, r24
  b2: 80 81        ld r24, Z
  b4: 84 60        ori r24, 0x04 ; 4
  b6: 80 83        st Z, r24
  b8: 84 ed        ldi r24, 0xD4 ; 212
  ba: 90 e3        ldi r25, 0x30 ; 48
  bc: 90 93 89 00  sts 0x0089, r25 ; 0x800089 <__TEXT_REGION_LENGTH__+0x7f8089>
  c0: 80 93 88 00  sts 0x0088, r24 ; 0x800088 <__TEXT_REGION_LENGTH__+0x7f8088>
  c4: 10 92 85 00  sts 0x0085, r1 ; 0x800085 <__TEXT_REGION_LENGTH__+0x7f8085>
  c8: 10 92 84 00  sts 0x0084, r1 ; 0x800084 <__TEXT_REGION_LENGTH__+0x7f8084>
  cc: 82 e0        ldi r24, 0x02 ; 2
  ce: 80 93 6f 00  sts 0x006F, r24 ; 0x80006f <__TEXT_REGION_LENGTH__+0x7f806f>
  d2: 08 95        ret

000000d4 <__vector_11>:
  d4: 1f 92        push r1
  d6: 0f 92        push r0
  d8: 0f b6        in r0, 0x3f ; 63
  da: 0f 92        push r0
  dc: 11 24        eor r1, r1
  de: 8f 93        push r24
  e0: 9f 93        push r25
  e2: 95 b1        in r25, 0x05 ; 5
  e4: 80 91 00 01  lds r24, 0x0100 ; 0x800100 <__DATA_REGION_ORIGIN__>
  e8: 89 27        eor r24, r25
  ea: 85 b9        out 0x05, r24 ; 5
  ec: 9f 91        pop r25
  ee: 8f 91        pop r24
  f0: 0f 90        pop r0
  f2: 0f be        out 0x3f, r0 ; 63
  f4: 0f 90        pop r0
  f6: 1f 90        pop r1
  f8: 18 95        reti

000000fa <main>:
  fa: 0e 94 4b 00  call 0x96 ; 0x96 <init_ports>
  fe: 0e 94 53 00  call 0xa6 ; 0xa6 <init_timer>
 102: 78 94        sei
 104: 80 e0        ldi r24, 0x00 ; 0
 106: 90 e0        ldi r25, 0x00 ; 0
 108: 08 95        ret

0000010a <_exit>:
 10a: f8 94        cli

0000010c <__stop_program>:
 10c: ff cf        rjmp .-2       ; 0x10c <__stop_program>

La comparaison entre ce code et timer.s amène des questions :
- d’où sortent ces vecteurs d’interruption ?
- comment les données se retrouvent en RAM ?
- par quel mécanisme main se retrouve appelée ?

6.11 ATMega328p : édition des liens (3/3)

Un compilateur cache un éditeur de liens :

la commande pour obtenir le fichier exécutable ELF

$ avr-gcc -g -mmcu=atmega328p -lm -Wl,--gc-sections -o timer.elf timer.o

en ajoutant l’option -v (verbose) apparaît avr-ld :

$ avr-ld -mavr5 timer.o /usr/lib/avr/lib/avr5/crtatmega328p.o -o timer.elf \
         -L /usr/lib/avr/lib -L /usr/lib/avr/lib/avr5 -L /usr/lib/gcc/avr/5.4.0 \
         --start-group -lgcc -lm -lc -latmega328p --end-group

Exercice "programme sans main" :
- écrivez un programme sans fonction main ;
- tentez de le compiler, que se passe-t-il ?
- Trouvez où se cache le symbole _start.
Exercice "jouer avec le script de l’éditeur des liens" :
- lancez avr-ld avec l’option -verbose ;
- comprenez-vous d’où vient le nom du point d’entrée ?
- écrivez un script plus simple pour avr-ld ...
- ... quelques informations à l’adresse https://www.nongnu.org/avr-libc/user-manual/mem_sections.html ;
- liez votre programme en utilisant ce script.

6.12 ATMega328p : téléchargement en flash (1/2)

Par le connecteur ISP (In System Programming).
Utilise le bus série SPI, natif sur les AVR.
Le protocole ISP AVR est décrit sur le document https://ww1.microchip.com/downloads/en/AppNotes/Atmel-0943-In-System-Programming_ApplicationNote_AVR910.pdf.
Le protocole ISP AVR en résumé :
- passer en mode programmation AC 53 00 00 ;
- lecture du statut avec les séquences :
  - code fabricant par 03 00 00 xx (1E pour atmel, FF erreur, 00 protégé) ;
  - code taille par 03 00 01 xx ;
  - code type par 03 00 02 xx.
- effacer flash et EEPROM AC 80 00 00 ;
- lecture d’un mot en flash :
  - octet de poids faible par 20 AH AL xx ;
  - octet de poids fort par 28 AH AL xx.
- écriture d’un mot en flash :
  - octet de poids faible par 40 AH AL BL ;
  - octet de poids fort par 48 AH AL BH ;
  - valider l’écriture par 4C AH AL 00.

6.13 ATMega328p : téléchargement en flash (2/2)

Utilisation d’un chargeur en mémoire Flash (bootloader).
Par la liaison série asynchrone (UART).
Par la connexion USB (DFU / Device Firmware Upgrade).
Descripteurs en mode DFU USB :
- classe USB "spécifique vendeur", sous-class DFU ;
- identifiant USB 03EB:2FFB ;
- une configuration, une interface, pas de point d’accès ;
- programmation via le tube de contrôle.

7 Microcontrôleurs AVR : Capteurs et actionneurs

7.1 Capteurs (1/3)

Un capteur récupère une information de l’environnement.
Parfois mixte : e.g. LED d’éclairage pour un capteur de couleur.
Capteurs les plus simples => tout ou rien :
- retournent une information booléenne ;
- capteurs connectés sur une entrée numérique ;
- exemples : un bouton, un contacteur, ...
- il suffit de regarder l’état de la ligne d’entrée ;
- la pratique est retorse : rebond (les délais sont vos amis).
Capteurs simples => valeur analogique :
- délivrent une tension relative à la grandeur mesurée ;
- capteurs connectés sur une entrée analogique ;
- exemples : capteur de pression, accéléromètre, détecteur de ligne, ...
- il suffit d’acquérir la tension sur la ligne d’entrée ;
- opération assez lente ou imprécise.
Capteurs sur bus de données => série, SPI, i2C, ...
- microcontrôleur intégré pour communiquer les valeurs ;
- capteurs connectés sur les lignes du bus correspondant ;
- exemples : capteur de pression, accéléromètre, détecteur de lumière, ...
- un protocole est défini pour récupérer les valeurs ;
- procédé d’échantillonage éventuellement complexe.

7.2 Capteurs (2/3)

Capteurs avec leur propre protocole de communication :

Premier exemple, capteur de température/humidité DHT11 :

Montage avec DHT11 :
communication bi-directionnelle sur une ligne ;
le microcontrôleur déclenche l’envoi des informations ...
... le capteur répond avec un train de 40 bits :
des bibliothèque DHT11 pour l’IDE Arduino ;

un code C pour avr-gcc :

#include <avr/io.h>
#include <util/delay.h>

#define DTH_ERR_TIMEOUT         -1
#define DTH_ERR_CHECKSUM        -2

typedef struct{
  int temperature;
  int humidity ;
  } dht_values;

#define DTH_DDR         DDRD
#define DTH_PORT        PORTD
#define DTH_PIN         PIND
#define DTH_IO          7

#define DTH_ANSWER_SIZE 40
#define DTH_TIMEOUT     (F_CPU/40000)  // 2,5 ms

#define DTH_WAIT_LOW_MS         20
#define DTH_WAIT_HIGH_US        40
#define DTH_LOOP_CYCLES         2
#define DTH_HIGH_DELAY_US       40

static void dht_trigger(void){
uint8_t mask=(1<<DTH_IO);
DTH_DDR |= mask;
DTH_PORT &= ~mask;
_delay_ms(DTH_WAIT_LOW_MS);
DTH_PORT |= mask;
_delay_us(DTH_WAIT_HIGH_US);
DTH_DDR &= ~mask;
}

int dht_get(dht_values *values){
uint8_t bits[DTH_ANSWER_SIZE/8];
int i,l;
dht_trigger();                   // Trigger answer
uint8_t mask=(1<<DTH_IO);        // Check acknowledgment
for(l=DTH_TIMEOUT;l>=0 && (DTH_PIN&mask)==0;l--); if(l<0) return DTH_ERR_TIMEOUT;
for(l=DTH_TIMEOUT;l>=0 && (DTH_PIN&mask)!=0;l--); if(l<0) return DTH_ERR_TIMEOUT;
for(i=0;i<DTH_ANSWER_SIZE;i++){  // Read values
  if(i%8==0) bits[i/8]=0;
  for(l=DTH_TIMEOUT;l>=0 && (DTH_PIN&mask)==0;l--); if(l<0) return DTH_ERR_TIMEOUT;
  for(l=DTH_TIMEOUT;l>=0 && (DTH_PIN&mask)!=0;l--); if(l<0) return DTH_ERR_TIMEOUT;
  uint32_t time=l*DTH_LOOP_CYCLES/(F_CPU/1000000L);
  bits[i/8] <<= 1;
  if(time<DTH_HIGH_DELAY_US) bits[i/8] |= 0x01;
  }
uint8_t sum=bits[0]+bits[2];     // Verify checksum
if(sum!=bits[4]) return DTH_ERR_CHECKSUM;
values->humidity=bits[0];        // Convert values
values->temperature=bits[2];
return 0;
}

7.3 Capteurs (3/3)

Second exemple, sonar ultrason HC-SR04 :

Montage avec HC-SR04 :
communication sur deux lignes uni-directionnelles ;
un signal d’activation commande l’envoi d’ultrasons ;
un retour de durée proportionnelle à la distance :

le code pour IDE Arduino :

const int LED=13;
const int trigger=2;
const int echo=3;
 
void setup(){
pinMode(trigger,OUTPUT); // Broche pour activer la mesure (sortie)
pinMode(echo,INPUT);     // Broche pour lire la valeur (entrée)
pinMode(LED,OUTPUT);
}
 
void loop(){
digitalWrite(trigger,LOW);  delayMicroseconds(5);  // Activer
digitalWrite(trigger,HIGH); delayMicroseconds(10);
digitalWrite(trigger,LOW);
 
long duree=pulseIn(echo,HIGH);                     // Mesurer
long distance=(duree/2)/29.1;

if(distance<20) digitalWrite(LED,HIGH);            // Réagir
else digitalWrite(LED,LOW);
delay(500);
}

un code C pour avr-gcc :

#include <avr/io.h>
#include <util/delay.h>

#define US_DDR          DDRD
#define US_PORT         PORTD
#define US_PIN          PIND
#define US_TRIGGER      2
#define US_ECHO         3

void sonar_init(void){          // Initialiser le sonar
US_DDR |= (1<<US_TRIGGER);   // Broche pour activer la mesure (sortie)
US_DDR &= ~(1<<US_ECHO);     // Broche pour lire la valeur (entrée)
}

uint32_t sonar_mesure(void){    // Mesurer une distance
uint8_t statut=0;
uint32_t temps=0;
_delay_us(2);  US_PORT |= (1<<US_TRIGGER);    // Activer
_delay_us(10); US_PORT &= ~(1 << US_TRIGGER);
while(!statut){
  while(US_PIN&(1<<US_ECHO)){                 // Mesure la durée du signal haut
    temps++;
    statut=1;
    }
  }
return disTime * 0.00862;                     // Conversion en cm
}

7.4 Actionneurs (1/3)

Un actionneur réalise une action sur l’environnement.
Actionneurs les plus simples => tout ou rien :
- ces actionneurs sont éteints ou allumés ;
- ces actionneurs sont connectés sur une sortie numérique ;
- exemples : une LED, un vibreur, une pompe, ...
- commande par changement de l’état de la sortie ;
- pour des actionneurs consommateurs passer par un transistor :
  - schéma avec un transistor NPN classique (e.g BC547, 100mA, 45V, gain 100) :
  - considérons des LED classiques (20mA, 1,8V) ;
  - combien de LED peut-on commander par sortie ?
  - sans transistor :
    - deux en série sans souci ;
    - quatre en série et en parallèle à l’extrême limite.
  - avec transistor :
    - l’alimentation est une pile de 9V ;
    - il est déjà possible de mettre 4 LED en série ...
    - ... 1,8V pour chaque LED et 0,2V pour le transistor BC547 (7,4V) ;
    - possible d’aller jusqu’à 5 branches en parallèle (100mA) ;
    - soit 16 LED sans souci, 20 LED à la limite.
  - quelques calculs :
    - limiter le courant dans R1 à 20mA : R1=(9-7,4)/0,02=80 Ohm ;
    - en théorie il faut 100mA/gain soit 1mA sur la base ;
    - la documentation technique suggère plutôt 5mA ;
    - à 5mA sur la base VBE est de 0,9V, d’où R2=(5-0,9)/0,005=820 Ohm.
- pour les actionneurs très consommateurs passer par un relai.

7.5 Actionneurs (2/3)

Actionneurs simples => Pulse Width Modulation (PWM) :

une sortie PWM est une sortie analogique du pauvre ;
en hachant un signal à VCC, la tension moyenne est moindre ;
les actionneurs reçoivent une tension moyenne variable ;
ces actionneurs sont connectés sur une sortie numérique ;
exemples : une LED, un vibreur, ...

code avec l’IDE Arduino :

const int LED=8;

void setup(void){
for(int i=0;i<4;i++) pinMode(LED+i,OUTPUT);
for(int i=0;i<4;i++) analogWrite(LED+i,(100-25*i)*255/100);
}

void loop(void){ }

un code C pour avr-gcc :

#include <avr/io.h>

#define PWM_DDR         DDRD
#define PWM_PORT        PORTD
#define PWM1            5
#define PWM2            6

void PWM_init(void){               // Initialisation de la PWM
PWM_DDR |= (1<<PWM1)|(1<<PWM2);      // Les ports PWM sont des sorties
TCCR0A |= (1<<COM0A1)|(1<<COM0B1);   // Les ports PWM se comportent normalement
TCCR0A |= (1<<WGM01)|(1<<WGM00);     // Minuteur mis en mode PWM
TCCR0B |= (1<<CS00);                 // Pas de pré-diviseur, démarre le compteur
}

int main(void){
PWM_init();
int pwm=0;
while(1){
  pwm++; if(pwm>100) pwm=0;
  OCR0A=pwm*255/100;                 // PWM pour le port 5 (ramenée à 255)
  OCR0B=(100-pwm)*255/100;           // PWM pour le port 6 (ramenée à 255)
  _delay_ms(10);
  }
return 0;
}

Actionneurs sur bus de données.

7.6 Actionneurs (3/3)

Cas particulier des moteurs :

moteurs avec commande intégrée, les servos-moteurs :

un servo-moteur comprend : un moteur, un réducteur, un contrôleur ;
les servo-moteurs classique permettent de décrire un angle d’environ 180° ;
il existe des servo-moteurs continus, la vitesse est variable ;
montage avec servo-moteur :
commande de servo-moteurs :
les anciens servo-moteurs nécessitaient une période de 20ms ...
... les servo-moteurs actuels fonctionnent avec toute période.

code avec l’IDE Arduino :

#include <Servo.h>

const int SERVO=3;

Servo myservo;            // Objet servo

void setup(){
  myservo.attach(SERVO);  // Définit la broche du servo-moteur
}

void loop(){
for(pos=0;pos<=180;pos += 1){
  myservo.write(pos);     // Impose la position (en degrés) au servo
  delay(15);           
  }
for(pos=180;pos>=0;pos -= 1){
  myservo.write(pos);
  delay(15);
  }
}

un code C pour avr-gcc :

#include <avr/io.h>
#include <util/delay.h>

void servos_init(void){
DDRD |= 0x08; // La broche 3 du port D est controlée par le minuteur 2
DDRB |= 0x08; // La broche 3 du port B est controlée par le minuteur 2
TCCR2A=(1<<COM2A1)|(1<<COM2B1);      // COM2A et COM2B à 10 pour signaux normaux
TCCR2A |= (1<<WGM21) | (1<<WGM20);   // WGM2 à 011 pour mode "fast PWM"
TCCR2B = (1<<CS21) | (1<<CS22);      // CS2 à 110 pour un pré-diviseur de 256
// Une unité de OCR2A et OCR2B représente donc 256/16000000*1000*1000=16 us 
// Pour un plateau de 1ms il faut alors 62 unités
// Pour un plateau de 2ms il faut alors 125 unités
}

int main(void){
int a;
for(a=0;a<180;a++){ OCR2A=62+a*63/180; _delay_ms(10); }
for(a=180;a>0;a--){ OCR2A=62+a*63/180; _delay_ms(10); }
}

moteurs continus :

montage avec contrôleur de moteurs continus :
commande avec 5 sorties numériques et 2 sorties PWM ;
une sortie (STANDBY) pour activer ou non le contrôleur ;
deux sorties numériques pour le sens de rotation d’un moteur ;
une sortie PWM pour choisir la vitesse de rotation d’un moteur ;
un code C pour avr-gcc :

code avec l’IDE Arduino :

const int STANDBY=6;
const int PWMA=3;
const int AIN1=5;
const int AIN2=4;
const int PWMB=11;
const int BIN1=7;
const int BIN2=8;
const int broches[]={STANDBY,PWMA,AIN1,AIN2,PWMB,BIN1,BIN2,-1};

void setup(void){
int i=0; while(broches[i]>0) pinMode(broches[i++],OUTPUT);
digitalWrite(STANDBY,HIGH);     // Activation du contrôleur
digitalWrite(AIN1,HIGH);        // Les moteurs dans le même sens
digitalWrite(AIN2,LOW); 
digitalWrite(BIN1,HIGH); 
digitalWrite(BIN2,LOW); 
analogWrite(PWMA,128);          // Vitesse modérée
analogWrite(PWMB,128);
}

void loop(void){ }

le code en C avec avr-gcc ne présente pas de difficulté.

moteurs pas à pas :

moteurs beaucoup plus précis (pas de quelques degrés) ;
montage avec contrôleur de moteurs pas à pas :
commande avec 2 sorties numériques ;

code avec l’IDE Arduino :

const int DIR=2;
const int STEP=3;
const int CYCLE=200;

void setup(void){
pinMode(DIR,OUTPUT);
pinMode(STEP,OUTPUT);
}

void loop(void){
digitalWrite(DIR,HIGH);
for(int pas=0;pas<CYCLE;pas++){
  digitalWrite(STEP,HIGH);
  delayMicroseconds(2000);
  digitalWrite(STEP,LOW);
  delayMicroseconds(2000);
  }
delay(1000);
}

le code en C avec avr-gcc ne présente pas de difficulté.

8 Réalisations

8.1 Conception et réalisation d’un programmeur

But :
- pouvoir programmer tout AVR via ISP (bus SPI) ;
- interface USB "specifique vendeur" du coté PC ;
- utilitaire construit avec la libusb pour le téléversement.
Carte électronique :
- au coeur un ATMega8u2 (TQFP32) alimenté en 5V avec une horloge 16Mhz (HC-49/US) ...
- ... et tout son écosystème (découplage, résistance de rappel, ...) ;
- deux LED (CMS 0603 impérial) avec leurs résistances (idem) ;
- un connecteur USB femelle (Sparkfun mini-USB) et ses deux résistances de 22 Ohm (0603 impérial) ;
- un connecteur ISP AVR pour la programmation de l’ATMega8u2 ;
- un connecteur ISP AVR pour la programmation de la cible ;
- la broche reset du second ISP est connectée sur une sortie de l’ATMega8u2 ;
- prévoir deux boutons (type TL3342F260QG) pour le reset et la broche HWB.
Les étapes :
1. conception du schéma électronique sous KiCAD ;
2. routage de la carte sous KiCAD (impérativement en simple face) ;
3. soudure des composants (microcontrôleur, condensateurs, résistances, LED, connecteurs) ;
4. écriture d’un programme pour faire clignoter les LED (téléversement via ISP avec un Arduino Uno) ;
5. vérifier avec les deux boutons qu’il est possible de faire passer l’ATMega8u2 en DFU USB (lsusb) ;
6. utiliser la LUFA pour créer un périphérique USB avec deux points d’accès interruptions (un IN, un OUT) ;
7. dans un premier temps juste programmer votre périphérique USB pour gérer les LED avec le point d’accès OUT ;
8. écrire un programme C sur le PC pour envoyer les ordres à votre périphérique concernant les LED ;
9. programmer le périphérique USB pour renvoyer via le point d’accès IN les identifiants ISP AVR de la cible ;
10. modifier le programme PC pour récupérer les identifiants ISP AVR de la cible ;
11. programmer le périphérique USB pour envoyer, bloc par bloc, la flash de la cible via le point d’accès IN ;
12. modifier le programme PC pour récupérer le contenu de la flash cible, vérifier la cohérence des données reçues ;
13. programmer le périphérique USB pour mettre à jour la flash de la cible (utilisation des deux points d’accès) ;
14. écrire un programme PC complet pour réaliser toutes les opérations sur la cible :
  - récupération des identifiants ISP AVR de la cible,
  - récupération du contenu de la mémoire flash de la cible,
  - modification du contenu de la mémoire flash de la cible.
Configuration de l’horloge du programmateur :
- d’usine l’ATMega8u2 utilise son horloge interne de 8Mhz avec un diviseur de fréquence par 8 ;
- nous voulons basculer sur l’horloge externe de 16Mhz sans diviseur ;
- une solution logicielle consiste à ajouter en entête du programme :
```
CLKSEL0 = 0b00010101;   // sélection de l'horloge externe
CLKSEL1 = 0b00001111;   // minimum de 8Mhz
CLKPR = 0b10000000;     // modification du diviseur d'horloge (CLKPCE=1)
CLKPR = 0;              // 0 pour pas de diviseur (diviseur de 1)
```
- une autre solution consiste à modifier des "fuses" ...
- ... soit des registres de configuration matérielle ;
- problème : d’usine l’ATMega8u2 ne permet pas la modification des "fuses" ;
- il est possible de le débloquer via l’AVR ISP ...
- ... en utilisant un Arduino Uno comme programmateur :
```
$ avrdude -c avrisp -p atmega8u2 -P /dev/ttyACM0 -b 19200 -t
avrdude> erase
avrdude> quit
$
```
- du coup les "fuses" peuvent être programmées pour une horloge 16Mhz externe :
```
$ avrdude -c avrisp -p atmega8u2 -P /dev/ttyACM0 -b 19200 -U lfuse:w:0xde:m -U hfuse:w:0xd9:m -U efuse:w:0xf4:m
```
- malheureusement le débloquage a effacé le chargeur DFU USB ;
- il faut en recharger une version (disponible ici : at90usb82-bl-usb-1_0_5.hex) :
```
$ avrdude -c avrisp -p atmega8u2 -P /dev/ttyACM0 -b 19200 -U flash:w:at90usb82-bl-usb-1_0_5.hex
```
Éléments utiles pour le logiciel du programmateur :
- un programme LUFA minimal : Minimal.tar ;
- les fonctions pour utiliser le bus SPI : voir 3.8 ;
- le protocole AVR ISP : voir 6.12.

Ce document a été traduit de L^AT_EX par H^EV^EA