Dans le prolongement des activités déjà menée sur la chaine d'information, ce carnet jupyter propose un tour d'horizon non exhaustif des possibilités de programmer en Python une carte à microcontroleur pour traiter l'information d'un robot (ou de tout système assimilé) à des fins d'applications en projets.

Histoire de robots :¶

In [1]:

%%HTML
<center><iframe frameborder="0" width="720" height="405"  src="https://www.dailymotion.com/embed/video/x2u6uxc" allowfullscreen="" allow="autoplay"></iframe></center>

Evolution technologique de l'unité de traitement :¶

Un système technique (automatisme, robot, objet connecté (IoT), système embarqué...) peut-être représenté par sa chaîne d'information et sa chaîne d'énergie tel que :

Dans un projet de robotique, le composant à programmer est celui qui réalise la fonction traiter.

C'est dans ce domaine que les solutions ont particulièrement évolué ces dernières années :

Les progrès en automatisme industriel et en robotique sont intimmement liés aux évolutions de l'informatique générale et à celle des ordinateurs en particulier. Ce sont des branches cousines qui suivent des évolutions parallèles avec souvent un décalage temporel inhérent aux besoins de développer des solutions fiables et robustes à coût réduit.


Séquenceur à cames	Séquenceur pneumatique	Relais	Tubes à vide

Les solutions mécaniques (cames), pneumatiques (séquenceur), électriques (relais), ont laissé la place à celles électroniques des tubes à vide, remplacés par des transistors à partir du milieu des années 1950 eux mêmes miniturisés dans des circuits intégrés (1958) et dans les microprocesseurs (1969).

Les premiers microcontroleurs apparaisent dans les années 70, Texas Instrument, son inventeur, commercialise à partir de 1974 les [TMS1000](https://en.wikipedia.org/wiki/Texas_Instruments_TMS1000) mais c'est depuis la fin des années 90 qu'ils se sont développés de manière spectaculaire.

Un microcontrolleur est en quelque sorte un ordinateur miniaturisé et simplifié généralement dédié à une application de traitement de l'information dans un système embarqué (clavier, souris, automobile, calculatrice, électroménagé, jeux, ...) Il inclut, sur une même puce, à minima, un microprocesseur, de la mémoire ROM et RAM, une interface entrées/sorties (GPIO, General Purpose Input/Output) et selon le cas d'autres modules tels qu'un oscillateur, un convertisseur analogique numérique (CAN), un Timer, de la mémoire flash, EPROM ou EEPROM, des générateurs de signaux MLI (PWM), des controleurs de communication UART, SPI, I2C, radio, Bluetooth, Wifi...

https://franco-micro-bit.github.io/introduction101/microcontroleurs/

On observe sur le boitier de ce microcontroleur la fenêtre qui permetait par insolation de rayons UV d'effacer l'EPROM, Ereasable Programmable Read Only Memory. Cette mémoire possède les mêmes propriétés que la ROM sauf que l'on peut l'effacer pour la reprogrammer. L'EPROM est accessible en lecture uniquement, et contient généralement le programme à exécuter. C'est de là que viendrait le verbe "flasher" synonyme de téléverser un programme dans le microcontroleur. Aujourd'hui on continue donc à "flasher" mais de l'EEPROM : Electrically Ereasable Programmable Read Only Memory.

Il était encore complexe et coûteux de mettre en œuvre un microcontrôleur au début des années 2000. L'arrivée de cartes à microcontroleur telles que l'Arduino à partir de 2005 a grandement simplifié la chose. Cela ne nécessite alors que du matériel peu coûteux, environ 20€ pour la carte la plus populaire qu'est l'Arduino Uno R3 basée sur l'ATmega328. Un simple PC suffit pour le développement du programme en langage C.

En 2012 l'ordinateur à carte unique Raspberry PI, un Single Board Computer low cost, avec son GPIO vient concurrencer les cartes à microcontroleur pour des applications qui requièrent un interfaçage vers des appareils simples mais avec plus de capacité de calcul. Le langage de programmation privilégié sur cette plateforme est Python.

Le processeur du Raspberry PI est également monté sur une puce (SoC) mais contrairement à un microcontroleur cette puce ne contient pas de mémoire.

Depuis 2013, l'augmentation des capacités de certains microcontrôleur permet de les programmer également en MicroPython une version allégée de Python 3 créée par Damien George

C'est le cas de la carte BBC micro:bit, du Circuit Playground Express (CPX), des ESP8266 et ESP32.


BBC micro:bit	Wemos ESP8266	Adafruit CPX	Wemos ESP32

Les microcontrôleurs sont donc devenus des composants électronique incontournables, modifiant profondément la manière de concevoir les circuits électroniques des systèmes embarqués et des objets connectés.

" Les objets qui sont dotés d'un microcontroleur embarqué, éventuellement en réseau, deviennent enchantés de la même façon que les objets des mondes magiques : il suffit de leur donner des ordres. Comme dans les histoires de magie, il est impératif d'apprendre comment réalise les incantations pour que les objets enchantés se plient à votre volonté.

Et c'est ici qu'entre en jeu le langage MicroPython "

Extrait du livre de Nicholas H. Tollervey, Programming with MicroPython.

Autres cartes :


CALLIOPE	m5stack	HALOCODE	Tiny 2040	Raspberry Pi4

Sortie en novembre 2020, le Raspberry Pi 400 inclut un ordinateur complet dans un clavier. Cette idée n'est pas nouvelle, elle s'inspire des machines des années 80 telles que le BBC micro :

Le Nouveau Raspberry Pi 400 : un mini-ordinateur dans un clavier !

Applications au BBC micro:bit :¶

CF : Programmation d'un BBC micro:bit

In [ ]:

from microbit import *

Le point de vue du programmeur en robotique concerne donc l'unité de traitement, un ordinateur à carte unique, une carte à microcontroleur, qui reçoit des informations électriques en entrées et en émet en sortie :

Sorties du BBC micro:bit :¶

L'affichage LED¶

La carte BBC micro:bit présente sur sa face avant un matrice de 5x5 LEDs :

C'est la seule sortie physique que possède la carte BBC micro:bit mais c'est déjà 25 fois mieux qu'une carte Arduino qui ne possède qu'une LED en dur sur la sortie 13.

Cet affichage est géré par le module display :

In [ ]:

display.scroll('Test')

In [ ]:

display.show(Image.HAPPY)

In [ ]:

display.set_pixel(2, 2, 4)

In [ ]:

display.clear()

Les broches :¶

Il y a 25 connecteurs en cuivre sur la tranche du bas de la carte BBC micro:bit. Ce sont des Entrées/Sorties qui permettent au micro:bit d'interagir avec son environnement en s'y connectant physiquement.

Le BBC micro:bit dispose de 19 broches qui peuvent être utiliser en tant que sortie pour faire fonctionner des actionneurs tels qu'une LED, un moteur ou encore un buzzer...

Chacunes est associées à un objet pinN, instance de la class pin, ou Ncorrespond au numéro attribué à la broche de 0 à 16 ainsi que 19 et 20.

Si ces broches sont utilisées en tant que sortie alors leurs autres fonctionnalités potentielles ne sont plus disponibles. Par exemple les broches pin3, pin4, pin6, pin7, pin9 et pin10 sont utilisées pour la matrice de LEDs, il faut donc désactiver l'affichage pour les utiliser à autre chose...

Pour pouvoir utiliser ces broches il faut aussi les raccorder physiquement à d'autres composants électoniques par l'intermédiaire de fils à connecteur bannane ou à pince crocodile ou encore avec des straps sur une breadboard via un connecteur...

bread:bit

Sortie logique, Tout Ou Rien (TOR), digital output :¶

Les niveaux électriques des broches du BBC micro:bit ne peuvent être mis qu'à 0V ou à 3,3V. Ce qui correspond respectivement aux valeurs 0 ou 1.

In [ ]:

pinN.write_digital(valeur)

A faire vous-même - défi n°0 :

Prendre en main l'environnement de développement et programmer un "Hello World" :¶

Le premier programme que réalise tout apprenti informaticien est le fameux Hello World!... Celà permet avec un programme minimal de prendre en main un langage et surtout de s'assurer du bon fonctionnement de l'environnement de développement choisi IDE.

"Hello World" spécial robotique :¶

Raccorder une LED sur la sortie P0 tel que sur les circuit et schéma ci-dessous puis programmer un allumage alternatif à la fréquence de 1Hz.


Circuit	Schéma

Sachant que la sortie P0 délivre au maximum une tension de 3,3V, calculer la résistance R1 minimale afin de limiter le courant dans la LED à 20mA pour une tension de 2V à ses bornes.

La valeur réelle retenue pour la résistance R1 est ici de 220 Ohms, en déduire l'intensité du courant dans la LED.

Sortie pseudo-analogique, Modulation de Largeur d'Impulsion (MLI), Pulse Width Modulation (PWM), analog output :¶

Même si les broches du BBC micro:bit ne peuvent être mises qu'à 0V ou à 3,3V, il est possible de faire croire au composant raccordé qu'il est alimenté sous une tension comprise entre 0 et 3,3V.

La technique s'appelle Modulation de Largeur d'Impulsion (MLI), Pulse Width Modulation (PWM) en Anglais. Le principe consiste à générer un signal pseudo-périodique qui met à 1 la sortie sur une portion ($t_h$) de la période ($T$) du signal.

On appelle rapport cyclique le ratio $\alpha = {t_h \over T}$. Ainsi le composant connecté à une sortie PWM aura l'impression d'être alimenter en moyenne sous une tension telle que $V_{MOY} = \alpha \times 3,3$

Dans l'instruction suivante valeur est telle que $\alpha = {{valeur \times 100} \over 1023}$. Une valeur à 0 correspond à $\alpha = 0 %$ et à une tension de 0V en sortie, une valeur à 511 correspond à $\alpha = 50$% et à une tension de 1,65V en sortie et une valeur à 1023 correspond à $\alpha = 100$% et à une tension de 3,3V en sortie.

In [ ]:

pinN.write_analog(valeur)

La durée de la pseudo-période est choisie suffisamment petite par rapport au temps de réaction de l'oeil humain dans le cas d'une LED ou, de l'inertie du composant électrique piloté par cette broche dans le cas d'un moteur par exemple.

Il est possible de régler la pseudo-période du signal PWM soit en millisecondes (1ms minimum) soit en microseconde (254µs minimum) :

In [ ]:

set_analog_period(period)

In [ ]:

set_analog_period_microseconds(period)

/!\ Attention :¶

Le BBC micro:bit ne peux gérer qu'un maximum de trois sorties en PWM simultannément.

A faire vous-même - défi n°1 :

Raccorder une LED sur la sortie P0 et programmer un allumage progressif en intensité sur 5 secondes à partir de l'initialisation de la carte ( = une rampe de démarrage). Puis la LED s'éteint instantannément après 6 secondes...

Plus d'informations sur les broches du BBC micro:bit :¶

Faites du Bruit, Buzzer¶

Avec deux fils à embouts crocodiles, connecter les broches P0 et GND respectivement au fils + et - d'un buzzer ou à une prise jack tel que :

On peut alors gérer un buzzer sur une sortie TOR comme là :

https://microbit-micropython.readthedocs.io/fr/latest/tutorials/io.html#bip-bip

Mais il est plus intéressant d'utiliser les modules :

Entrées du BBC micro:bit :¶

Le BBC micro:bit embarque en dur un grand nombre d'équipements sui délivrent des informations à l'entrée de son microcontrôleur.

Deux Boutons poussoirs repérés A et B¶

La carte BBC micro:bit dispose, sur sa face avant, de deux boutons poussoir repérés par les lettres A et B.

Chacun est représenté par un objet button_a et button_b, instance de la classe button.

In [ ]:

button_a.is_pressed()

In [ ]:

button_a.was_pressed()

In [ ]:

button_a.get_presses()

A faire vous-même - défi n°2 :

Raccorder une LED sur la sortie P0 et programmer l'intensité de son allumage par paliers progressifs de sorte que quatres impulsions successives sur l'entrée A conduisent à l'éclairage maximal. Tandis qu'une impulsion sur le bouton B provoque l'extinction totale de la LED.

Plus d'informations sur les boutons poussoirs du BBC micro:bit :¶

Trois touches sensitives 0, 1, 2¶

Les trois grandes broches (pin) repérées 0, 1, 2 sont sensibles à un changement de capacité provoqué au contact d'un doigt.

Les instances de pin0, pin1 et pin2 possèdent une méthode qui renvoie un booléen :

In [ ]:

pinN.is_touched()

Normalement ces touches capacitives devraient réagir au conctact de votre doigt à la condition de tenir le BBC micro:bit par le GND avec l'autre main ; mais pour plus d'efficaccité le plus sûr est de raccorder un bout d'un câble à pince crocodile au GND et avec l'autre bout de venir toucher la broche 0, 1 ou 2.

Plus d'informations sur les touches sensitives du BBC micro:bit :¶

Magnétomètre¶

Le magnétomètre détecte tout champ magnétique à proximité et donc à fortiori le champ magnétique terrestre, ce qui permet de savoir quelle direction le BBC micro:bit indique. Cette boussole doit être étalonnée avant de pouvoir être utilisée.

Comment ? A l'aide des références de code ci-dessous :

Accéléromètre¶

La carte BBC micro:bit embarque un accéléromètre 3 axes. Ce composant détecte quand le micro:bit est en mouvement. Il peut aussi détecter d'autres actions, par exemple quand il est secoué, incliné ou qu'il tombe.

Comment ? A l'aide des références de code ci-dessous :

In [ ]:

from microbit import *
monBool = True
while True :
    sleep(500)
    if button_b.was_pressed() :
        break
    if button_a.was_pressed() :
        monBool = not monBool
    if flag :
        print(accelerometer.get_x())
    else :
        print(accelerometer.get_values())

Capteur de lumière¶

En s'inversant, la matrice de LEDs devient un capteur de lumière basique qui permet de détecter la luminosité ambiante.

Le module display possède donc une méthode qui renvoie une valeur entière comprise entre 0 et 255 représentative d'un niveau de luminosité :

In [ ]:

display.read_light_level()

Plus d'informations sur le capteur de lumière du BBC micro:bit :¶

https://microbit-micropython.readthedocs.io/en/latest/display.html#microbit.display.read_light_level

Capteur de température¶

Le processeur du BBC micro:bit dispose d'un capteur de température interne intégré.

Le module microbit possède donc une méthode qui renvoie une valeur représentant une estimation de la température ambiante en degré Celsius :

In [ ]:

temperature()

Plus d'informations sur le capteur de température du BBC micro:bit :¶

Broche d'entrée logique, Tout Ou Rien (TOR), digital input :¶

Les 19 broches du BBC micro:bit peuvent être utiliser en tant qu'entrée logique pour faire fonctionner des capteurs tels qu'une fourche optique, un Interrupteur à Lame Souple, un contact de fin de course, un bouton poussoir supplémentaire...

Chaque broches est associées à un objet pinN, instance de la class pin, ou Ncorrespond au numéro attribué à la broche de 0 à 16 ainsi que 19 et 20.

Si ces broches sont utilisées en tant que sortie alors leurs autres fonctionnalités potentielles ne sont plus disponibles. Par exemple les broches pin3, pin4, pin6, pin7, pin9 et pin10 sont utilisées pour la matrice de LEDs, il faut donc désactiver l'affichage pour les utiliser à autre chose...

Pour pouvoir utiliser ces broches il faut aussi les raccorder physiquement à d'autres composants électoniques par l'intermédiaire de fils à connecteur bannane ou à pince crocodile ou encore avec des straps sur une breadboard via un connecteur...

bread:bit

On peut connaitre l’état d’une entrée logique avec la méthode read_digital() qui retourne un entier égal à 0 si le niveau de tension sur l'entrée est bas ou 1 si le niveau de tension sur l'entrée est haut.

In [ ]:

pinN.read_digital()

Plus d'informations sur les broches d'entrées logiques du BBC micro:bit :¶

Broches d'entrée analogiques (CAN) :¶

Le microcontroleur du BBC micro:bit contient un Convertisseur Analogique Numérique (CAN), Analogue to Digital Converter (ADC) en Anglais, dont la résolution est de 10bits. Il convertit proportionnelement un niveau de tension variant de 0 à 3,3V en une valeur entière comprise entre 0 et 1023. La plus petite variation de tension que l'on peut mesurer est donc égale au $quantum = {3,3 \over 1023} = 3,2 mV$

Le BBC micro:bit possède 6 broches sur lesquels on peut lire une valeur d'entrée analogique.

Elles sont représentés par les instances pin0, pin1, pin2, pin3, pin4, pin10.

La méthode read_analog() renvoie une valeur entière correspondante au niveau de tension mesuré :

In [ ]:

pinN.read_analog()

A faire vous-même - défi n°3 :

Raccorder une LED sur la sortie P0 et un potentiomètre sur l'entrée P1 et programmer le niveau d'intensité lumineuse de la LED selon le réglage de la position du potentiomètre...

Plus d'informations sur les broches d'entrées analogiques du BBC micro:bit :¶

Communication :¶

La communication c'est ce qui va permettre à tous ces systèmes embarqués de devenir des objets connectés.

Même si d'évidence un système n'est pas connecté avec l'extérieur, il se peut très bien qu'en interne, pour réduire la connectique, certains capteurs et actionneurs sont organisés en réseau avec l'unité de traitement sur un bus de terrain (I²C, SPI, RS485 (DMX), CAN, ...)

De très nombreuses solutions existent pour établir une communication chacune mieux adapté qu'une autre pour répondre à un besoin particulier.

Série :¶

Par l'intermédiaire de ses broches, le BBC micro:bit va permettre d'expérimenter facilement une communication point à point filaire :

USB, UART :¶

La communication Point à Point d'un BBC microbit vers un PC par la liaison USB est particulièrement simplifé en MicroPython puisqu'il suffit d'une simple instruction print(message) dans le programme de la carte pour récupérer le message sur le PC dans le REPL de l'éditeur Mu par exemple ou tout autre terminal série :

https://www.isnbreizh.fr/1nsi/activity/microbitSerial/index.html

Le module UART va permettre de gérer une communication série filaire bidirectionnelle entre le BBC micro:bit et le PC :

https://microbit-micropython.readthedocs.io/en/latest/uart.html

Radio :¶

C'est là une de ces originalités très intéressante, le BBC micro:bit est bien adapté pour expérimenter une communication radio et ainsi constituer un réseau :

A faire vous-même - défi n°4 :

Raccorder une LED sur la sortie P0 d'une carte et un potentiomètre sur l'entrée P1 d'une autre carte et programmer le niveau d'intensité lumineuse de la LED selon le réglage de la position du potentiomètre...

I2C, SPI :¶

Les bus I2C ( Inter Integrated Circuit ), développé par Philips, et SPI (Synchronous Peripheral Interface), développé par Motorola, sont des protocoles de communication imaginés pour pouvoir connecter de très nombreux composants à des microcontroleurs en série sur un même réseau filaire (un bus de terrain) plustôt qu'en parallèle afin de réduire la connectique :

Bluetooth :¶

L'espace mémoire du BBC micro:bit n'est pas suffisant pour héberger un module MicroPython pour de la communication Bluetooth :

https://microbit-micropython.readthedocs.io/en/latest/ble.html

Wifi :¶

BBC micro:bit :¶

La carte BBC micro:bit ne possède pas de possibilité de connexion en Wifi. Mais de nombreus autres solutions de SBC sont équipées de Wifi à commencer par le Raspberry Pi.

ESP :¶

Certains microcontroleurs comme les ESP8266 et ESP32 embarquent en dur des modules wifi et sont programmables en MicroPython :

La documentation officielle est là :
- ESP8266 http://docs.micropython.org/en/latest/esp8266/tutorial/
- ESP32 http://docs.micropython.org/en/latest/esp32/quickref.html
Série de tutoriels : https://randomnerdtutorials.com/micropython-programming-with-esp32-and-esp8266/
Tutoriel et source pour développer en jupyter notebook :

Autres composants :¶

Servomoteur :¶

La carte BBC micro:bit permet d'alimenter un petit servomoteur en le branchant en direct aux broches. Mais compte tenu de la tension et du courant d'alimentation necessaire au bon fonctionnement d'un servomoteur classique, il est préférable de connecter au BBC mcro:bit une carte intermédiaire qui distibuera depuis une alimentation externe l'énergie utile pour alimenter à la fois les servomoteurs et la carte BBC micro:bit.

Voici un example de code pour un servomoteur raccordé au pin2 :

from microbit import *

def set_servo_angle(pin, angle):
    duty = 26 + (angle * 102) / 180
    pin.write_analog(duty)

angle = 90
set_servo_angle(pin2, angle)

while True:
    if button_a.was_pressed() and angle >= 10:
        angle -= 10
        set_servo_angle(pin2, angle)
    if button_b.was_pressed() and angle <= 170:
        angle += 10
        set_servo_angle(pin2, angle)

source : https://www.monkmakes.com/mb_servo/

Quelques solutions :

https://www.gotronic.fr/cat-commandes-de-moteurs-1704.htm
un montage à base d'ULN2803...

Sonar, Capteur à ultrason :¶

Voici un exemple de code pour mesurer une distance à partir d'un capteur à ultrason connecté à une carte BBC micro:bit :

from microbit import *
from utime import ticks_us, sleep_us

sonar = pin2

def getDistance():
    sonar.write_digital(1)  # Send 10us Ping pulse
    sleep_us(10)
    sonar.write_digital(0)
    while sonar.read_digital() == 0: # ensure Ping pulse has cleared from receiver
        pass
    start = ticks_us()  # define starting time
    while sonar.read_digital() == 1:  # wait for Echo pulse to return
        pass
    end = ticks_us()    # define ending time
    echo = end-start
    distance = int(0.01715 * echo)  # Calculate cm distance
    return distance

def note(duree):
    for i in range(10*duree):
        pin0.write_digital(1)
        sleep_us(1136)
        pin0.write_digital(0)
        sleep_us(1136)


while True:
    note(10)
    sleep_us(getDistance()*1000)
    print(getDistance())
````