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 :
  
• Eléments classiques d’un système embarqué :
  • le micro-contrôleur, un STM32F730 (Cortex-M7) ;
  • l’horloge, un quartz à 8Mhz ;
  • une mémoire externe de 64Mbits.

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 :
  
• 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  Micro-contrôleur ou micro-processeur

2.1  Micro-contrôleur

• Micro-contrôleur simple, e.g. ATMega328p :
  • concepteur et fondeur ATMEL (Microchip Technology depuis 2016) ;
  • micro-contrô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);
      }
    }
    

• Micro-contrô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  Micro-processeur

• Micro-processeur, 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.
• Micro-processeur, 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  Quel choix pour les systèmes embarqués ?

• A priori des micro-contrô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.

3  Micro-contrôleurs AVR

3.1  Caractéristiques du micro-contrôleur

• Peut être qualifié de "Système sur Puce" ;
• Une architecture classique à la "Harvard" :
  
• 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  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>
  
  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  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)speed)<<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(char c){
  loop_until_bit_is_set(UCSR0A,UDRE0);
  UDR0=c;
  }
  
  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  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 = output;                                       // 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  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  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  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  Chaîne de compilation

• 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é.
• 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 programme.c -o programme.o
    $ avr-gcc -mmcu=atmega328p -g -lm -Wl,--gc-sections -o interrupts.elf interrupts.o
    

  • téléversement sur le micro-contrôleur en ligne de commande :

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

  • maitrise totale du code ;
  • des programmes compacts et efficaces.
• Il existe des alternatives plus accessibles :
  • Ardublock => à la dérive depuis 2014 ?
  • Minibloq => windows ...
  • S4A (dérivé de Scratch) => pas de génération de programme.

4  Capteurs et actionneurs

4.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, ...
  • micro-contrô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.

4.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 micro-contrô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;
    }
    

4.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
    }
    

4.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.

4.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.

4.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é.

5  Etudes de cas

5.1  Système embarqué de A à Z (1/3)

• Trois grandes étapes :
  • conception et réalisation du circuit électronique ;
  • conception et réalisation de la partie mécanique ;
  • programmation du système embarqué.
• Conception du circuit :
  • de nombreux logiciels (eagle, kicad, ...) ;
  • Fritzing recommandé pour une initiation :
    
  • une vue "planche à pain" facile à comprendre ;
    
  • la vue "schéma électronique" pour la structuration ;
    
  • la vue circuit pour la fabrication du circuit (placement et routage).
    
    MicroRobotv10.fzz
• Exemples de circuits purement électriques :
          
  Bouclier_Robot_Uno.fzz         Bouclier_Robot_Mega.fzz
• Réalisation du circuit :
  • gravure du circuit :
    • Chine avec https://www.elecrow.com, 5$ pour 10 PCB, port + douane ;
    • Allemagne avec https://aisler.net, 8€ par PCB port compris, pas de douane ;
    • production au lycée avec du perchloroéthylène ? soucis de sécurité et pollution ;
    • graveuse au lycée ? les modèles évolués sont hors de prix (10K€).
  • souder les composants :
    • étonnamment réalisable avec un minimum de surveillance ;
    • il est possible de faire souder des composants de surface aux élèves :
      
    • des fers à souder utilisables pour quelques dizaines d’euros ;
    • matériel courant : fers, soudure, tresse à dessouder, brucelles, multimètres, ...

5.2  Système embarqué de A à Z (2/3)

• Conception de la partie mécanique :
  • pas de système embarqué sans partie mécanique mais ...
  • ... hors du cadre de l’informatique ;
  • angle de l’outil de conception assisté par ordinateur ?
  • logiciels de CAO => OnShape, FreeCAD, ...
  • logiciels de dessin vectoriel => inkscape, ...
  • exemple de chassis sous FreeCAD :
    
  • exemple de chassis sous inkscape :
            

5.3  Système embarqué de A à Z (3/3)

• Exemple de programme de robot avec l’IDE Arduino :

  #include <Servo.h>
  #include "IRLibAll.h"
  
  #define PIN_TRIG     A4
  #define PIN_ECHO     A3
  
  #define PIN_IR       2
  IRrecvPCI myReceiver(PIN_IR);
  IRdecode myDecoder;
  
  #define PIN_MOT1  11
  #define PIN_MOT2  5
  #define CENTER_MOT1  88
  #define CENTER_MOT2  89
  #define FACTOR_MOT1  1
  #define FACTOR_MOT2  1
  Servo motor1;
  Servo motor2;
  int speed = 80;
  int dir = -1;
  
  long mesureDistance(void){
    digitalWrite(PIN_TRIG,LOW);
    delayMicroseconds(2);
    digitalWrite(PIN_TRIG,HIGH);
    delayMicroseconds(10);
    digitalWrite(PIN_TRIG,LOW);
    long duration_hc=pulseIn(PIN_ECHO,HIGH);
    long distance_hc=duration_hc/58;
    return distance_hc;
  }
  
  void setup(void){
    pinMode(PIN_TRIG,OUTPUT);
    pinMode(PIN_ECHO,INPUT);
    myReceiver.enableIRIn();
    motor1.attach(PIN_MOT1);
    motor2.attach(PIN_MOT2);
    motor1.write(CENTER_MOT1);
    motor2.write(CENTER_MOT2);
  }
  
  void loop(void){
    if(myReceiver.getResults()){
      myDecoder.decode();
      int value=myDecoder.value&0xff;
      if(value==2 || value==4 || value==5 || value==6 || value==8) dir=value;
      switch(value){
        case 0x11 :
          if(speed>0) speed -= 5;
          break; 
        case 0x10 :
          if(speed<90) speed += 5;
          break; 
        }
      delay(50);
      myReceiver.enableIRIn();
      }
    long distance=mesureDistance();
    if(distance<20 && dir==2) dir=5;
    switch(dir){
      case 2 :
        motor1.write(CENTER_MOT1+speed*FACTOR_MOT1);
        motor2.write(CENTER_MOT2-speed*FACTOR_MOT2);
        break;
      case 4 :
        motor1.write(CENTER_MOT1-speed/6*FACTOR_MOT1);
        motor2.write(CENTER_MOT2-speed/6*FACTOR_MOT2);
        break;  
      case 5 :
        motor1.write(CENTER_MOT1);
        motor2.write(CENTER_MOT2);
        break;  
      case 6 :
        motor1.write(CENTER_MOT1+speed/6*FACTOR_MOT1);
        motor2.write(CENTER_MOT2+speed/6*FACTOR_MOT2);
        break;   
      case 8 :
        motor1.write(CENTER_MOT1-speed);
        motor2.write(CENTER_MOT2+speed);
        break;
      }
      delay(10);
  }
  

• Utilisation de la bibliothèque : https://github.com/cyborg5/IRLib2.

5.4  Mais où est Python ? (1/2)

• TI-Innovator Hub pour calculatrices TI :
  • prix élevé : 80€, prix public pour le hub :
    
  • prix élevé : 150+€, prix public pour le rover ;
  • un système embarqué par lui-même (comme la calculatrice) ;
  • possibilité d’interconnexion via le port "plaque d’essai" :
    
  • 10 entrées/sorties dont 4 PWM (4,8,9,10) et 3 analogiques (5,6,7) ;
  • possibilité de commander un contrôleur de moteurs :

     
    CONNECT DIGITAL.OUT 1 TO BB1
    CONNECT DIGITAL.OUT 2 TO BB2
    CONNECT DIGITAL.OUT 3 TO BB3
    CONNECT DIGITAL.OUT 4 TO BB4
    CONNECT ANALOG.OUT 1 TO BB8
    CONNECT ANALOG.OUT 2 TO BB9
    SET DIGITAL.OUT 1 TO LOW
    SET DIGITAL.OUT 2 TO HIGH
    SET DIGITAL.OUT 3 TO LOW
    SET DIGITAL.OUT 4 TO HIGH
    SET ANALOG.OUT 1 TO 128
    SET ANALOG.OUT 2 TO 128
    

  • a priori pas de communication série possible, utiliser des E/S.
• Connexion série avec des calculatrices :
  • bricolage pour les anciennes TI 83 : https://github.com/jw0k/serial2ti83 ;
  • bricolage pour les NumWorks : https://zardam.github.io/post/numworks-uart-over-usb/ :
    
  • bricolage pour les NumWorks : https://github.com/zhaofengli/epsilon/tree/uart ;
  • je suis confiant, ça va venir ...

5.5  Mais où est Python ? (2/2)

• Ajouter un (nano-)ordinateur au système embarqué :
  • un prix raisonnable autour de 50€ pour une RPi3 B+ ;
  • les nano-ordinateurs sont moyennement doués en E/S et bus ...
  • ... par exemple peu de PWM matérielles sur la RPi ;
  • connexion série avec le micro-contrôleur :
    
  • rappel du montage d’illustration de la connexion série :
    
  • exemple de programme sur l’Arduino :

    void setup(){
      Serial.begin(9600); // configuration de la vitesse
      sonar_init();
      controleur_init();
      ligne_init();
    }
    
    void loop(){
      int mesure,ligne,i;
      while(1){
        if(Serial.available()){  // commande de la Raspberry
          int c=Serial.read();   // lecture de l'octet de commande
          switch(c){
            case 'M': controleur_demarrer(); break;
            case 'A': controleur_arreter(); break;
            case 'D':
              delay(10);
              if(Serial.available()){
                int v=Serial.read(); // lecture de la vitesse
                controleur_moteur_droit(v);
                }
              break;
            case 'G':
              delay(10);
              if(Serial.available()){
                int v=Serial.read(); // lecture de la vitesse
                controleur_moteur_gauche(v);
                }
              break;
            case 'U':
              mesure=sonar_mesure();
              Serial.write(mesure);
              break;
            case 'L':
              for(i=0;i<3;i++){ 
                ligne=ligne_detecte(i);
                Serial.write(ligne);
                }
              break;
            }
          }
        }
    }
    

  • exemple de configuration de la Raspberry Pi :
    • point d’accès WiFi avec le paquetage hostapd (mode WPA-PSK) :

      # cp /usr/share/doc/hostapd/examples/hostapd.conf.gz /etc/hostapd
      # gunzip /etc/hostapd/hostapd.conf.gz
      # # Effectuer les modification sur le .conf
      # grep 'Modif$' /etc/hostapd/hostapd.conf
      ssid=MonReseauWiFi # Modif
      country_code=FR # Modif
      channel=1 # variez les canaux ! Modif
      wpa=1 # Modif
      wpa_passphrase=ABCDEFGH # 8 caractères minimum ! Modif
      wpa_key_mgmt=WPA-PSK # Modif
      # grep 'Modif$' /etc/default/hostapd
      DAEMON_CONF=/etc/hostapd/hostapd.conf # Modif
      # hostapd -d /etc/hostapd/hostapd.conf # Pour tester
      # service hostapd restart # Pour lancer en tâche de fond
      

    • serveur DHCP avec le paquetage isc-dhcp-server ;

      # cat >> /etc/network/interfaces <<!
      auto wlan0
      iface wlan0 inet static
        address 192.168.100.1
        netmask 255.255.255.0
      !
      # grep 'Modif$' /etc/dhcp/dhcpd.conf
      option domain-name=monrobot.org          # Modif
      option domain-name-servers=192.168.100.1 # Modif
      authoritative                            # Modif
      subnet 192.168.100.0 netmask 255.255.255.0 { # Modif
        range 192.168.100.100 192.168.100.200;     # Modif
        option routers 192.168.100.1;              # Modif
      }                                            # Modif
      # ifup wlan0
      # service isc-dhcp-server restart
      

    • éventuellement serveur DNS avec le paquetage bind9 ;
    • serveur web dynamique avec les paquetages apache2 et php7 ;
    • enfin une application python pour :
      • dialoguer par bus série avec l’Arduino :

        import termios
        import time
        
        d=open("/dev/ttyACM0")
        iflag,oflag,cflag,lflag,ispeed,ospeed,cc=termios.tcgetattr(d)
        cc[termios.VMIN]=1
        cc[termios.VTIME]=0
        cflag=termios.CLOCAL|termios.CREAD|termios.B9600|termios.CS8
        termios.tcsetattr(d,termios.TCSANOW,[0,0,cflag,0,ispeed,ospeed,cc]) 
        
        time.sleep(2)
        
        d.write(b'D\x80')
        d.write(b'G\x80')
        d.write(b'M')
        time.sleep(5)
        d.write(b'A')
        
        d.close()
        

      • recevoir des paquets UDP d’une page web :

        import socket
        
        UDP_IP="127.0.0.1"
        UDP_PORT=5005
        
        sock=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
        sock.bind((UDP_IP,UDP_PORT))
        
        while True:
          data,addr=sock.recvfrom(1024)
          print "received message:",data
        

      • envoi UDP par une page web PHP :

        <?php
        $server_ip='127.0.0.1';
        $server_port=5005;
        $message='A';
        if($socket=socket_create(AF_INET,SOCK_DGRAM,SOL_UDP)){
          socket_sendto($socket,$message,strlen($message),0,$server_ip,$server_port);
          }
        }
        ?>
        

      • ou utiliser Flask pour une solution intégrée :

        import flask
        import flask_serial
        import termios
        
        SERIAL_PORT='/dev/ttyACM0'
        
        web=flask.Flask(__name__)
        web.config['SERIAL_PORT'] = SERIAL_PORT
        web.config['SERIAL_BAUDRATE'] = 9600
        web.config['SERIAL_BYTESIZE'] = 8
        web.config['SERIAL_PARITY'] = 'N'
        web.config['SERIAL_STOPBITS'] = 1
        
        it=False
        def init_term():
          d=open("/dev/ttyACM0")
          iflag,oflag,cflag,lflag,ispeed,ospeed,cc=termios.tcgetattr(d)
          cc[termios.VMIN]=1
          cc[termios.VTIME]=0
          cflag=termios.CLOCAL|termios.CREAD|termios.B9600|termios.CS8
          termios.tcsetattr(d,termios.TCSANOW,[0,0,cflag,0,ispeed,ospeed,cc]) 
          d.close()
        
        s=flask_serial.Serial(web)
        
        @web.route('/')
        def use_serial():
          return 'use flask serial!'
        
        @web.route('/send/',methods=['GET','POST'])
        def send_mess():
          global it
          if not it:
            init_term()
            it=True
          if flask.request.method=='POST':
            m=flask.request.form.get('message')
          else:
            m=flask.request.args.get('message')
          print(m)
          s.on_send(m)
          return 'message sent.'
        
        @s.on_message()
        def handle_message(msg):
            print("message received:", msg)
        
        if __name__ == '__main__':
          web.run(host="0.0.0.0",port=int("8000"),debug=True)
        

    • ajoutez la vidéo sur le site web !
• Ajouter une plateforme micro-python au système embarqué :
  • une plateforme officielle (environ 50€) :
    
  • d’autres plateformes supportées (stm32f4-discovery environ 20€) :
    
  • impossible d’installer micro-python sur un ATMega328p ;
  • la stm32f4-discovery est construite autour d’un Cortex-M4 ;
  • connexion série entre l’Arduino et la stm32f4-discovery ;
  • mode d’emploi de micro-python sur la stm32f4-discovery :
    • instructions d’installation : https://github.com/micropython/micropython/wiki/Board-STM32F407-Discovery ;
    • connexion seulement avec le port micro-USB, alimentation 5V sur PA9 (P2) ;
    • connexion sur la console micro-python par minicom -D /dev/ttyACM0 ;
    • utilisez lsblk pour repérer la mémoire flash de votre plateforme et ...
    • ... montez cette partition par la commande mount /dev/sdb1 /mnt ;
    • écrivez le programme python dans /mnt/main.py et ...
    • ... chargez-le dans l’interpréteur par CTRL-D ;
    • un sync après la sauvegarde de main.py va aider ;
    • créez le port série de connexion avec l’Arduino : voir http://docs.micropython.org/en/latest/library/pyb.UART.html ;
    • vous n’avez plus qu’à écrire le programme du robot en python ...

5.6  Autres projets possibles

• Projets artistiques :
                   
• Projets USB :
          
• Horloge connectée (Gilles DHAUSSY, lycée Fénelon de Lille) :
  

6  EIL : pyboard

6.1  Carte pyboard : composants

• Carte basée sur un Cortex-M4 :
  
• Horloge à 168Mhz.
• 1Go pour les programmes, 192Ko de RAM.
• Capteurs et actionneurs embarqués :
  • 4 LED (rouge, verte, jaune, bleue) sur B4, A13 à A15 ;
  • 1 boutons-poussoir sur B3 ;
  • accéléromètre alimenté par B5 sur le bus i2c B6 (scl) et B7 (sda).
• Lecteur de carte micro-SD.
• Compatible micro-python.
• Connexion série avec l’interpréteur micro-python :
  • périphérique /dev/ttyACM0 (sous Linux) ;
  • vitesse 115200 bauds ;
  • CLI Linux : minicom -o -D /dev/ttyACM0 -b 115200.
• Partition vfat contenant un fichier main.py.
• Programmation assez pratique :
  • modification du fichier main.py (ou autre) ;
  • éventuellement synchronisation avec l’utilitaire sync ;
  • chargement dans l’interpréteur par CTRL-D.

6.2  Carte pyboard : entrées/sorties

• Chenillard sur les 4 LED en micro-python :

  sorties=['B4','A15','A14','A13']
  leds=[]
  for (i,sortie) in enumerate(sorties):
    leds.append(machine.Pin(sortie,machine.Pin.OUT))
  while True:
    for led in leds:
      led.value(1)
      time.sleep_ms(500)
      led.value(0)
  

• Autre version de plus haut niveau :

  leds=[]
  for i in range(0,4):
    leds.append(pyb.LED(i+1))
  while True:
    for led in leds:
      led.on()
      pyb.delay(500)
      led.off()
  

• Utilisation du bouton utilisateur :

  b=machine.Pin('B3',machine.Pin.IN,machine.Pin.PULL_UP)
  l=machine.Pin('B4',machine.Pin.OUT)
  while True:
    if(b.value()==0) l.value(1)
    else l.value(0)
  

• Autre version de plus haut niveau :

  b=pyb.Switch()
  l=pyb.LED(1)
  while True:
    if(b()==1): l.on()
    else: l.off()
  

• Autre version d’encore plus haut niveau :

  b=pyb.Switch()
  l=pyb.LED(1)
  b.callback(lambda: l.toogle())
  

6.3  Carte pyboard : bus série

• Cinq ports série (1 à 4 et 6).
• A ne pas confondre avec le port USB/série.
• Exemple micro-python d’utilisation de l’UART 1 :

  s=machine.UART(1,9600)                         
  s.init(9600,bits=8,parity=None,stop=1)
  while True:
    if s.any()>=0:
      c=s.read(1)
      s.write(c)
  

6.4  Carte pyboard : bus i2c

• Un accéléromètre I2C sur le second bus I2C du Cortex-M4.
• Accéléromètre alimenté par la sortie B5.
• Programme micro-python de bas niveau :

  ACCEL_ADDR=0x4c
  ACCEL_AXIS_X_REG=0x00
  ACCEL_AXIS_Y_REG=0x01
  ACCEL_AXIS_Z_REG=0x02
  ACCEL_MODE_REG=0x07
  i2c=machine.I2C(scl=machine.Pin('B6'),sda=machine.Pin('B7'))
  alim=machine.Pin('B5',machine.Pin.OUT)
  alim.value(1)
  i2c.writeto_mem(ACCEL_ADDR,ACCEL_MODE_REG,bytes([1]))
  while True:
    x=i2c.readfrom_mem(ACCEL_ADDR,ACCEL_AXIS_X_REG,1)
    y=i2c.readfrom_mem(ACCEL_ADDR,ACCEL_AXIS_Y_REG,1)
    z=i2c.readfrom_mem(ACCEL_ADDR,ACCEL_AXIS_Z_REG,1)
    print(x,y,z)
    time.sleep_ms(1000)
  

• Programme micro-python de haut niveau :

  accel=pyb.Accel()
  while True:
    x=accel.x()
    y=accel.y()
    z=accel.z()
    print(x,y,z)
    pyb.delay(1000)
  

7  EIL : microbit/maqueen

7.1  Carte microbit : composants

• Carte basée sur un Cortex-M0 :
  
• Horloge à 48Mhz.
• 128Ko pour les programmes, 16Ko de RAM.
• Capteurs et actionneurs embarqués :
  • matrice de 5x5 LED rouges ;
  • 2 boutons-poussoirs sur P5 et P11 ;
  • accéléromètre 3 axes ;
  • magnétomètre.
• Communication par Bluetooth Low Energy (BLE).
• Version particulière de micro-python.
• Connexion série avec l’interpréteur micro-python :
  • périphérique /dev/ttyACM0 (sous Linux) ;
  • vitesse 115200 bauds ;
  • CLI Linux : minicom -o -D /dev/ttyACM0 -b 115200.
• Partition vfat pour reprogrammation de la carte.
• Programmation assez peu pratique :
  • modification du fichier main.py (ou autre) sur PC ;
  • transfert des fichiers avec ufs (paquetage PIP microfs) ;
  • chargement dans l’interpréteur par CTRL-D.

7.2  Carte maqueen : composants

• Chassis robotique :
  
• Capteurs et actionneurs embarqués :
  • deux LED rouges sur P8 et P12 ;
  • quatre neopixels sur P15 ;
  • deux détecteurs de ligne sur P13 et P14 ;
  • un buzzer sur P0 ;
  • un récepteur infrarouge sur P16 ;
  • un sonar ultrason sur P1 (trigger) et sur P2 (echo) ;
  • un contrôleur de moteurs I2C.

7.3  Carte microbit : entrées/sorties

• La méthode Pin de la bibliothèque machine est désactivé.
• Des entrées/sorties déjà instanciées.
• Exemple micro-python pour allumer les LED du chassis maqueen ...
• ... en utilisant les boutons de la microbit :

  import microbit
  
  while True:
    if microbit.pin11.read_digital()==0:
      microbit.pin8.write_digital(1)
    else:
      microbit.pin8.write_digital(0)
    if microbit.pin5.read_digital()==0:
      microbit.pin12.write_digital(1)
    else:
      microbit.pin12.write_digital(0)
    microbit.sleep(100)
  

7.4  Carte maqueen : contrôleur de moteurs

• Le contrôleur est à l’adresse i2c 0x10 ;
• Contrôle par envoi de 3 octets :
  • le numéro du moteur (0 ou 2) ;
  • le sens de rotation (0 ou 1) ;
  • la vitesse de rotation.
• Fonctions micro-python avec la bibliothèque i2c de microbit :

  import microbit
  
  I2C_MOTORS_ADDR=0x10
  MOTOR_A=0
  MOTOR_B=2
  
  def moteurs(sensA,puissA,sensB,puissB):
    microbit.i2c.write(I2C_MOTORS_ADDR,bytes([MOTOR_A,sensA,puissA]))
    microbit.i2c.write(I2C_MOTORS_ADDR,bytes([MOTOR_B,sensB,puissB]))
  
  def moteurs_init():
    microbit.i2c.init()
  
  moteurs_init()
  while True:
    moteurs(0,128,0,128)
    microbit.sleep(2000)
    moteurs(1,64,0,64)
    microbit.sleep(1000)
  

7.5  Carte maqueen : télémètre ultrason

• Le télémètre est un HC-SR04 classique.
• Le télémètre utilise deux broches génériques :
  • la broche trigger est pin1 ;
  • la broche echo est pin2.
• Fonctions micro-python avec la bibliothèque standard de microbit :

  import microbit
  import machine
  import time
  
  def ultrason():
    # Envoi d'un plateau de 10 us
    microbit.pin1.write_digital(1)
    time.sleep_us(10)
    microbit.pin1.write_digital(0)
    # Lecture de la taille du plateau en retour
    t=machine.time_pulse_us(microbit.pin2,1)
    # Calcul temps vers distance
    d=340*t/20000
    return d
  
  def ultrason_init():
    microbit.pin1.write_digital(0)
    microbit.pin2.read_digital()
  
  moteurs_init()
  ultrason_init()
  while True:
    if ultrason()<=20:
      moteurs(0,128,0,128)
    else:
      moteurs(1,64,0,64)
  

7.6  Carte maqueen : neopixels

• LED multicolores avec micro-contrôleur intégré.
• Quatre neopixels sous le chassis maqueen.
• Les neopixels sont connectées sur P15.
• Exemple de programme micro-python avec bibliothèque de haut niveau :

  import neopixel
  
  def pixels_init():
    global pixels
    pixels=neopixel.NeoPixel(microbit.pin15,4)
  
  def pixels_couleurs(c1=(0,0,0),c2=(0,0,0),c3=(0,0,0),c4=(0,0,0)):
    global pixels
    pixels[0]=c1
    pixels[1]=c2
    pixels[2]=c3
    pixels[3]=c4
    pixels.show()
  

7.7  Chassis KS0426 : composants

• Chassis robotique :
  
• Capteurs et actionneurs embarqués :
  • deux LED multicolores contrôlées par un pilote de LED PCA9685 ;
  • dix-huit neopixels sur P5 ;
  • une photo-résistance sur P1 ;
  • deux détecteurs de ligne sur P12 et P13 ;
  • deux détecteurs de proximité infrarouges sur P2 et P11 ;
  • un buzzer sur P0 ;
  • un récepteur infrarouge sur P16 ;
  • un sonar ultrason sur P14 (trigger) et sur P15 (echo) ;
  • un contrôleur de moteur TB6612FNG commandé par le PCA9685.
• Les LED, les neopixels, les détecteur, le buzzer et le sonar ...
• ... s’utilisent comme montré pour le chassis Maqueen.
• Le pilote de LED PCA9685 :
  • est un périphérique I2C comme le contrôleur de moteur du chassis Maqueen ;
  • a une adresse i2c codée 0x43 ;
  • les sorties 1 (direction) et 2 (vitesse) commandent le moteur gauche ;
  • les sorties 3 (direction) et 4 (vitesse) commandent le moteur droite ;
  • les sorties 5, 6 et 7 commandent la couleurs des deux LED RGB.
• Code micro-python "micro-bit" pour gérer le PCA9685 :

  import microbit
  
  PCA9685_ADDR=0x43
  PCA9685_FREQ=60
  
  def PCA9685_init():
    microbit.i2c.init()
    microbit.i2c.write(PCA9685_ADDR,bytes([0x00,0x10]))
    prescale=int(25000000.0/4096.0/PCA9685_FREQ+0.5)
    microbit.i2c.write(PCA9685_ADDR,bytes([0xfe,prescale]))
    microbit.i2c.write(PCA9685_ADDR,bytes([0x00,0xa0]))
  
  def PCA9685(canal,taux):
    adresse=0x06+4*canal
    on_l=0x00
    on_h=0x00
    off_l=0x00
    off_h=0x00
    if taux==0: off_h=0x10
    if taux==100: on_h=0x10
    if taux>0 and taux<100:
      arret=taux*40
      off_l=arret&0x00ff
      off_h=arret>>8
    microbit.i2c.write(PCA9685_ADDR,bytes([adresse,on_l,on_h,off_l,off_h]))
  
  def PCA9685_LED(r,g,b):
    PCA9685(4,100-b)
    PCA9685(5,100-g)
    PCA9685(6,100-r)
  
  def PCA9685_moteurs(sensA,puissA,sensB,puissB):
    PCA9685(0,0) if sensA==0 else PCA9685(0,100)
    PCA9685(2,0) if sensA==0 else PCA9685(2,100)
    PCA9685(1,puissA)
    PCA9685(3,puissB)
    
  PCA9685_init()
  PCA9685_LED(0,0,100)
  PCA9685_moteurs(0,50,0,50)
  

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