Microcontrôleurs et python - Le numérique au lycée-378511

préliminaires présentation

Note de la présentation sur les microcontrôleurs et python - mai 2019

N'hésiter pas à corriger les erreurs,
On va manipuler tout.

À retenir

Code python

Remarque non approfondie

Important

microcontroleurs-généralités

Les microcontrôleurs

Généralités

Un microcontrôleur est un circuit intégré qui rassemble les éléments essentiels d'un ordinateur :

processeur,
mémoires (mémoire morte et mémoire vive),
interfaces d'entrées-sorties.

Les entrées sorties peuvent recevoir des signaux numériques ou analogiques grâce à

les convertisseurs analogiques-numériques
les générateurs de signaux à modulation de largeur d'impulsion
les contrôleurs de bus de communication (UART, I2C, SSP, CAN, FlexRay, USB, etc.)...

Carte de développement

Regroupe

un microcontrôleur
un système de gestion de alimentation,
un accès facile aux broches du microcontrôleurs
dans notre cadre, un port USB permettant le transfert d'information et l'alimentation
des leds (au moins une pour indiquer le fonctionnement)
des boutons (au moins un pour le reset)
Divers autres élèments permettant le bon fonctionnement ou l'extension des possibilités...

Programmation

Un microcontrôleur nécessite une programmation et peut donc permettre une entrée dans la programmation.

C'est un objet numérique complet.

microcontroleurs - micro:bit

Les microcontrôleurs

micro:bit

Plus d'information sur https://microbit.org/fr/guide/features/

microcontroleurs- un exemple et des langages

Les microcontrôleurs

Un exemple de programme avec micro:bit et divers langages

Les étapes d'un programme sont similaires pour les microcontrôleurs présentés ici.
1. On branche le microcontrôleur à l'ordinateur (par un cable USB qui fournit alimentation et permet de communiquer avec le microcontrôleur )

Le micro:bit est reconnu comme si c'était une clé USB de stockage

2. On utilise un logiciel pour programmer

Pour programmer le micro:bit, on peut utiliser un navigateur est une application en ligne !
- Il existe une application pour programmer en blocs https://makecode.microbit.org/ . Cette application dispose également d'un émulateur de micro:bit
- et une application pour programmer en python. https://python.microbit.org/

# On a besoin du module python microbit
from microbit import *

while True:
    if button_a.is_pressed():
        for i in range(5):
            display. set_pixel (i, 2, 9)
    elif button_b.is_pressed():
        for i in range(5):
            display. set_pixel (i, 2, 0)

3. On envoie le programme au microcontrôleur

Si on utilise un navigateur, on télécharge fichier contenant le programme, puis on l'envoie sur le micro:bit comme si c'était une clé USB.

Remarque : On choisit d'utiliser une boucle permanente plutôt que le bloc :
Remarque : On pourra s'intéresser à la différence entre les méthodes : is_pressed(), was_pressed() et get_presses()

microcontroleurs - programmer en python

Les microcontrôleurs

Utiliser python

En mode console

On va ici utiliser la console, c'est un accès direct au microcontrôleur.
L'ordinateur sert pour le clavier et l'affichage.
Il faut utiliser un IDE (Environnement de développement) qui de plus facilitera la programmation

Le mode console est très utile pour une première approche de python.
L'utilisation d'un IDE pour micro:bit est recommandé pour un travail final plus simple.

Avec une carte micro:bit
On peut utiliser l'IDE mu (lien dans les ressources)
On peut voir des calculs mathématiques avec le python dans le micro:bit
Et on peut suivre les actions sur les leds.

Avec un ESP8266 (c'est le nom d'un autre microcontrôleur)
On peut utiliser l'IDE thonny (lien dans les ressources)
On peut voir des calculs mathématiques avec le python dans l'ESP.
L'action sur la led interne est un peu plus compliqué car on la commande par la broche 2.

En mode fichier

On enregistre un fichier contenant un programme dans le microcontrôleur, il l'exécute au démarrage ou si on appuie sur le bouton reset

Avec une carte type arduino
On utilise l'IDE Arduino (lien dans les ressources)
On peut suivre les actions sur la led intégrée à la carte dans la boucle loop.

Avec une cartemicro:bit
Dans cet exemple, on utliser la broche 0.

from microbit import *

while True:
    pin0.write_digital(1)
    sleep(20)
    pin0.write_digital(0)
    sleep(480)

Le langage utilisé par la carte arduino est du C++, le langage utilisé par la carte micro:bit et l' ESP3266 est du python

Une fois programmé, le micro:bit peut fonctioner avec des piles.

Dans un contexte de classes, il faut utiliser des cables usb assez long pour être sur la table, à acheter selon la position de l'unité centrale.
Attention, les cables vendus à l'unité sont parfois des cables alimentation seuls. il faut acheter des cables qui permettent le transport de données.

Pour utiliser la microbit avec les modes console (REPL) ou fichier, ou graphique il faut qu'un driver (qui gère la liaison ordinateur carte) soit installé.
Pour utiliser l'arduino, l'ESP8266, il faut qu'un driver (qui gère la liaison ordinateur carte) soit installé.

Voir dans les ressources pour trouver les drivers s'ils ne sont pas installés (l'installation est à faire une fois)

Remarque 1 : le langage utilisé pour ces micontroleurs est en fait du micro-python. Pour notre utilisation, cela ne fat pas de changement.
Remarque 2 : le nom ESP8266 correspond au nom du microcontrôleur. La carte a subi une préparation particulière pour utiliser le python.
Remarque 3 : Le mode console n'est pas disponible pour l'arduino car le C++ est un langage compilé (traduit pour la machine)

python-micropython

Python - micropython

Python est le langage de programmation mis en avant dans tous les programmes du lycée général et technologique pour la rentrée 2019.
Un programme fonctionne sur le principe entrées ->traitements -> sorties

Il est import d'habituer les élèves à utiliser des fonctions comme dans l'exemple suivant

Un même programme et plusieurs environnement de travail.

def triangle_rectangle(coté1,coté2,pluslongcoté):
    if coté1**2+coté2**2==pluslongcoté**2 :
        return "le triangle est rectangle"
    else :
        return "le triangle n'est pas rectangle pour le sommet supposé"

On lance dans la console triangle_rectangle(3,4,5)

Thonny

On utilise ici la version de python installé sur l'ordianteur.

Calculatrice Numworks

Émulateur numworks

Il faut être enregistré sur le site https://workshop.numworks.com/ pour utiliser l'émulateur.
On peut alors transférer les programme sur la calculatrice.
Cependant on peut voir de nombreux exemples sans être connecté à l'adresse https://workshop.numworks.com/python

Des exemples de programmes sont testables en ligne
https://workshop.numworks.com/python

Remarque : la version actuelle de python est la version 3.7
Remarque : la calculatrice Numworks utilise un microcontrôleur et micropython
Remarque : le python de la calculatrice Numworks d'accepte pas les caractères accentués. Python accepte tous les caractères (UTF8)

microcontrôleurs - entrée analogique

Les microcontrôleurs

Entrée analogique

Utiliser une potentiomètre, une photorésistance

Certaines broches peuvent lire la tension qui leur est appliqué et renvoyé un entier entre 0 (signifiant 0V) et 1023 (signifiant 3.3V).
On met en place le schéma équivalent suivant.

Le micro:bit comme tous les microcontôleurs présentés ici possède un CAN (Convertisseur Analogique Numérique)

Le micro:bit comme tous les microcontôleurs présentés ici ne possède un vrai CNA (Convertisseur Numérique Analogique) mais une sortie pseudo analogique : Modulation de largeur d'impulsion (MLI, PWN en anglais)

from microbit import *

# Définition de la fonction affichant la ligne numéroligne
def affiche_ligne(numéroligne) :
    for i in range(5):
        display. set_pixel(i, numéroligne, 9)
    sleep(1000)
    for i in range(5):
        display. set_pixel(i, numéroligne, 0)

while True :
    #lecture de la tension à la broche 0
    potentiometre = pin0.read_analog()
    if potentiometre < 341 :
        affiche_ligne(4)
    elif potentiometre >682 :
        affiche_ligne(2)
    else :
        affiche_ligne(3)

    #lecture de la tension à la broche 1
    photorésistance = pin1.read_analog()
    if photorésistance < 400 :
        display. set_pixel(0,0,9)
    else :
        display. set_pixel(0,0,0)

Remarque: Dans cet exemple ce n'est pas très pédagogique puisque qu'il y a 2 manips différentes et sans lien sur la même carte et dans le même programme...
Remarque : il serait préférable d'écrire 2 fonctions qui utiliserait en entrée le numéro de la broche. Par exemple def affichagepontentiometre(broche) et def journuit(broche)
Remarque : L'utilisation d'une platine d'expérimentation est plus efficace en utilisant un adaptateur pour la micro:bit. Par exemple la pin:bit https://shop.pimoroni.com/products/pin-bit

Les microcontrôleurs - i2c

Les microcontrôleurs

Bus I2C

Le bus I2C est un bus informatique qui permet de rlier un microcontrôleur est divers composants.
L'exemple donné est ici celui d'un afficheur.
On peut trouver de très nombreux composants : par exemple un capteur de température et d'humidité DHT12 (avec bus I2C)

# On a besoin de modules pour utiliser certains composants
# On utilise l'afficheur SSD1306 par le bus i2c
from ssd1306 import initialize, clear_oled
from ssd1306_text import add_text
from microbit import *

initialize()
clear_oled()
add_text(3, 0, "ne pas")
add_text(3, 1, "presser")
add_text(1, 2, "le bouton")
add_text(3, 3, "merci")
# initialisation de la broche1 par une première lecture
# pour les spécialistes, c'est en mode pull-up
# pour les novices, il est plus simple d'utiliser les boutons de microbit
pin1.read_digital()

while True:
   if pin1.read_digital() == 1:
       clear_oled()
       add_text(4, 0, "il ne")
       add_text(1, 1, "fallait pas")
       add_text(3, 2, "presser")
       add_text(2, 3, "le bouton")
       #on sort de la boucle
       break

Important : le micro:bit fonctionne en 3,3V. Le circuit d'alimentation incorporé ne peut fournir que quelques dizaines de mA.
Les bibliothèques nécessaires sont disponibles en moins grand nombre que pour l'arduino (qui est en 5V) mais leur nombre est en augmentation constante.

Les microcontrôleurs - Quelques compléments

Les microcontrôleurs

Quelques compléments

Seuls quelques aspects des microcontrôleurs ont été abordés :

- le micro:bit dispose d'un mode communication radio entre micro:bit, d'un module bluetooth
- l'ESP8266 peut communiquer en WIFI : en mode station pour se connecter à un WIFI existant ou en mode point d'accès.

Un des ESP8266 de la salle est configuré pour créer un réseau wifi du nom de ESP8266 et avec le mot de passe 12345678.
À l'aide d'un téléphone portable, on peut se connecter sur ce réseau puis ouvrir dans un navigateur l'adresse 192.168.4.1
Le programme python est disponible esp8266-point-accès-wifi-serveur-http-dth22.py[lien]

- Le micro:bit dispose de capteurs intégrés (accéléromètre, compas)

microcontroleurs - ressources

Microcontrôleurs python - ressources

Microcontrôleur

La page wikipédia https://fr.wikipedia.org/wiki/Microcontr%C3%B4leur

Micro:bit

Le site principal : https://microbit.org/fr/
L'environnement de travail mu pour programmer micro:bit en python : https://codewith.mu/
La documentation de micropython pour microbit avec des exemples : https://microbit-micropython.readthedocs.io/
Les modules python spécifiques à micro:bit https://microbit-micropython.readthedocs.io/en/v1.0.1/microbit_micropython_api.html
Un adaptateur pour utiliser les plaques d'éxpérimentation (il y en existe d'autres): https://shop.pimoroni.com/products/pin-bit
Haut-parleur pour micro:bit (TP 2de) : https://shop.pimoroni.com/products/speaker-for-micro-bit
Le driver nécessaire au mode REPL(console) https://microbit-micropython.readthedocs.io/en/latest/devguide/repl.html
Les modules nécessaires au fonctionnement de l'afficheur ssd1306 https://github.com/fizban99/microbit_ssd1306

Pour retrouver le programme initial de la micro:bit : https://support.microbit.org/support/solutions/articles/19000021613-reset-the-micro-bit-to-factory-defaults

ESP8266

La documentation de micropython pour ESP8266 avec des exemples : https://docs.micropython.org/en/latest/esp8266/quickref.html
En particulier la méthode de flashage initial : https://docs.micropython.org/en/latest/esp8266/tutorial/intro.html#intro
Le driver signé par microsoft à installer (Cliquer sur le carré bleu) : http://www.wch.cn/download/CH341SER_EXE.html

Un environnement de travail pour programmer l'ESP8266 en python (thonny) : https://thonny.org/

Python

L'environnement de développement installé au lycée (thonny) : https://thonny.org/
Un travail très intéressant par des profs de maths du lycée autour de python : https://pydiderot.readthedocs.io/formation/enseignants/
Pour passer du code en blocks à python, un traducteur : https://blockly-demo.appspot.com/static/demos/code/index.html?lang=fr#6d6adm

Arduino

Les ressources sur l'arduino sont très nombreuses, voici les tutos officiels : https://www.arduino.cc/en/Tutorial/HomePage

Exemples de prix

Le kit microbit basique https://amzn.to/2HvQ1hD
Le kit micro:bit club de 10 micro:bit avec cables USB et boitiers piles beaucoup plus avantageux https://amzn.to/2W5likY
L'esp8266 (c'est celui qui m'amuse le plus et il est pas cher du tout) https://amzn.to/2HtsM7Y
Une copie d'arduino https://amzn.to/2JLWp7a
Les plaques d'expérimentation et les fils https://amzn.to/2WaMRcv
L'écran d'affichage ssd13016 https://amzn.to/2WehFsQ
boitier transparent micro:bit : https://amzn.to/2VKPjat

Numworks

Un tuto python sur le site numworks : https://www.numworks.com/fr/ressources/python/premiers-pas/
La liste des modules disponibles dans la numworks : https://www.numworks.com/fr/ressources/manuel/python/#modules
Des exemples de programmes python pour la numworks avec un émulateur pour pouvoir faire fonctionner le code : https://workshop.numworks.com/python

Authentification Sécurisée