Initiation au langage CircuitPython et à la puce nRF52840 (Extrait)

é Pr

c fa

ed

a el

a dy

da

livres

Initiation au langage CircuitPython et à la puce nRF52840

en moins de 100 lignes de code par projet avec les cartes Feather Sense et Clue Express d’Adafruit

Michaël Bottin

Initiation au langage CircuitPython et à la puce nRF52840 en moins de 100 lignes de code par projet avec les cartes Feather Sense et Clue Express d'Adafruit

● Michaël Bottin

• Droits de reproduction © 2020 – Publitronic - Elektor International Media • Toute reproduction ou copie, même partielle, de ce livre, et sur quelque support que ce soit, sans l'accord écrit de l'éditeur, est interdite.

•

Le code de la propriété intellectuelle du 1er juillet 1992 interdit expressément la photocopie à usage collectif sans autorisation des ayants droit.

No part of this book may be reproduced, in any form or means whatsoever, without permission in writing from the publisher. While every precaution has been taken in the preparation of this book, the publisher and author assume no responsability for errors or omissions. Neither is any liability assumed for damages resulting from the use of the information contained herein.

La protection du droit d'auteur s'étend aux illustrations, y compris aux circuits imprimés et aux projets y relatifs. En conformité avec l'article 30 de la Loi sur les brevets, les circuits mentionnés ne peuvent être exécutés qu'à des fins particulières ou scientifiques et non pas dans ou pour une entreprise ; ces exécutions et/ou applications se font en dehors de toute responsabilité de l'éditeur.

Conformément au droit d'auteur, ce copyright ne s'applique pas à certains schémas reproduits dans ce livre à titre de citation et d'illustration des propos et de la démarche intellectuelle de l'auteur, avec l'aimable autorisation des ayants droit.

L'éditeur remercie d'avance le lecteur qui prendra la peine de lui signaler les erreurs éventuelles qui auront échappé à sa vigilance (écrire à redaction@elektor.fr).

Adafruit, Feather, Feather Wing, Bluefruit, CircuitPython, NeoPixel et le logo Blinka sont des marques déposées.

• ISBN 978-2-86661-211-5 • 1e édition — 1er tirage - novembre 2020 • Maquette : www.d-vision.nl | Julian van den Berg | Coordination : Mariline Thiebaut-Brodier

Imprimé en Allemagne par Media-Print Informationstechnologie

SOMMAIRE Préface 11 Présentation générale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 Ce que vous allez apprendre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 Quels sont les prérequis ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12 À qui s'adresse ce livre ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12 Quel est le contenu de ce livre ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13 Ressources en téléchargement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14 Préface de Ladyada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 Partie I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17 Chapitre 1 • Qu'est-ce que CircuitPython ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18 1.1 - Historique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18 1.2 – Pourquoi utiliser CircuitPython ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20 1.3 – Ressources CircuitPython . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23 1.4 – Cartes supportant CircuitPython . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24 Chapitre 2 • Carte Adafruit Feather nRF52840 Sense . . . . . . . . . . . . . . . . . . . . . . . 26 2.1 - Présentation de la carte Feather nRF52840 Sense . . . . . . . . . . . . . . . . . . . . . . 26

2.1.2 Brochage de la carte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

2.2 – Quelques mots sur le SoC Nordic nRF52840 . . . . . . . . . . . . . . . . . . . . . . . . . . 33 2.3 - Caractéristiques des capteurs embarqués sur la carte . . . . . . . . . . . . . . . . . . . . 34 Chapitre 3 • Premiers programmes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46 3.1 - Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46 3.2 - Branchement de la carte Feather nRF52840 Sense en USB . . . . . . . . . . . . . . . . 47 3.3 - Mise à jour de la version du microprogramme CircuitPython . . . . . . . . . . . . . . . 47 3.4 - Environnement de développement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52 3.5 - Utilisation de la console (REPL) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57

3.5.1 - Console série . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57

3.5.2 – REPL - Tester quelques instructions . . . . . . . . . . . . . . . . . . . . . . . . . . . 59

3.5.3 – REPL - Obtenir des informations sur la carte . . . . . . . . . . . . . . . . . . . . . 62

3.6 – Premiers programmes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64

3.6.1 – Lancer d'un dé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65

3.6.2 – Lancer d'un dé amélioré . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67

3.6.3 – Calculatrice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68

3.6.4 – Affichage d'une sinusoïde . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69

3.7 – Sortir proprement du mode programmation . . . . . . . . . . . . . . . . . . . . . . . . . . 70 3.8 – Dépannage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71

●5

Initiation au langage CircuitPython et à la puce nRF52840 Chapitre 4 • Bases du langage CircuitPython . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72 4.1 - Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72 4.2 - Programme type en CircuitPython . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72 4.3 - Bases du langage CircuitPython . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73

4.3.1 – Concepts de base pour l'écriture du code . . . . . . . . . . . . . . . . . . . . . . . 73

4.3.2 – Forçage de type (cast) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76

4.3.3 – Instructions d'affichage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76

4.3.4 – Structures de données : listes, tuples et dictionnaires . . . . . . . . . . . . . . 77

4.3.5 – Opérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80

4.3.6 – Instructions conditionnelles et les boucles . . . . . . . . . . . . . . . . . . . . . . 81

4.3.7 – Les fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82

4.3.8 – La notion de module . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83

4.4 – Comprendre l'utilisation des classes d'objets . . . . . . . . . . . . . . . . . . . . . . . . . . 84

4.4.1 - Qu'est-ce qu'un objet ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84

4.4.2 - Qu'est-ce qu'une classe ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84

4.4.3 - Comment accède-t-on aux attributs et aux méthodes d'un objet ? . . . . . 85

4.5 – Limitations du langage CircuitPython . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85 Chapitre 5 • Préparation du matériel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87 5.1 – Quels connecteurs pour la carte Feather nRF52840 Sense ? . . . . . . . . . . . . . . . 87 5.2 – Utilisation d'une platine d'essai (breadboard) . . . . . . . . . . . . . . . . . . . . . . . . . 89 5.3 – Utilisation d'adaptateurs Feather . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91 5.4 – Reste du matériel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92 Partie II . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95 Chapitre 6 • D écouverte du langage CircuitPython par la pratique . . . . . . . . . . . . 96 6.1 – Entrées/sorties numériques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96

6.1.1 – Exemple avec la LED et le bouton internes . . . . . . . . . . . . . . . . . . . . . . 96

6.1.2 – Exemple avec une LED et un bouton extérieurs à la carte . . . . . . . . . . 102

6.1.3 – Application : simple testeur de réflexes . . . . . . . . . . . . . . . . . . . . . . . 105

6.2 – Entrées analogiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107

6.2.1 – Module 'analogio' . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108

6.2.2 – Exemple avec un potentiomètre . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108

6.2.3 – Application : radar de distance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112

6.3 – Sorties PWM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118

6.3.1 – Module 'pulesio' . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120

6.3.2 – Exemple de variation d'intensité lumineuse sur une LED . . . . . . . . . . . 122

6.3.3 – Application : piloter un servomoteur . . . . . . . . . . . . . . . . . . . . . . . . . 126

6.3.4 – Application : mini-piano . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131

6.4 – Entrées tactiles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136

●6

6.4.1 – Module 'touchio' . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137

6.4.2 – Exemple de détection tactile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137

SOMMAIRE

6.4.3 – Application : mini-piano tactile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139

6.5 – Utilisation de bibliothèques supplémentaires . . . . . . . . . . . . . . . . . . . . . . . . . 144

6.5.1 – Installation de nouvelles bibliothèques pour la carte Feather . . . . . . . . 144

6.5.2 – Quelques recommandations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146

6.5.3 – Exemple avec une bibliothèque anti-rebond . . . . . . . . . . . . . . . . . . . . 148

6.5.4 – Exemple avec une bibliothèque servomoteur . . . . . . . . . . . . . . . . . . . 150

6.5.5 – Exemple avec une bibliothèque de génération de tons . . . . . . . . . . . . . 153

6.6 – Les différents capteurs intégrés à la carte Feather . . . . . . . . . . . . . . . . . . . . . 154

6.6.1 – Bibliothèques utiles pour accéder aux capteurs embarqués . . . . . . . . . 155

6.6.2 – Température / Pression / Humidité . . . . . . . . . . . . . . . . . . . . . . . . . . 155

6.6.3 – Indicateur de niveau sonore sur une LED . . . . . . . . . . . . . . . . . . . . . . 157

6.6.4 – Indicateur de niveau sonore sur une LED NeoPixel . . . . . . . . . . . . . . . 160

6.6.5 – Variation de la teinte de la LED NeoPixel par gestes . . . . . . . . . . . . . . 162

6.6.6 – Couleur aléatoire de la LED NeoPixel par accéléromètre . . . . . . . . . . . . 167

6.7 – Bus de communication disponibles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170

6.7.1 – Module 'busio' . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170

6.7.2 – Liaison série asynchrone de type UART . . . . . . . . . . . . . . . . . . . . . . . 171

6.7.3 – Liaison série synchrone de type I2C . . . . . . . . . . . . . . . . . . . . . . . . . . 179

6.7.4 – Liaison série synchrone de type SPI . . . . . . . . . . . . . . . . . . . . . . . . . 183

6.8 – Émulation de périphériques HID . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190

6.8.1 – Module 'usb_hid' . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191

6.8.2 – Émulation d'un clavier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191

6.8.3 – Émulation de la souris . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202

6.9 – Quelques informations sur les autres modules disponibles . . . . . . . . . . . . . . . 209

6.9.1 – Modules 'Core' . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209

6.9.2 – Modules additionnels Adafruit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209

6.9.3 – Modules additionnels autres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 210

6.10 – Comment faire si le module de mon composant n'existe pas ? . . . . . . . . . . . . 211

6.10.1 – Partir d'une bibliothèque Python . . . . . . . . . . . . . . . . . . . . . . . . . . . 211

6.10.2 – Partir d'un code MicroPython . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 217

Chapitre 7 • Projets avec les cartes d'extension FeatherWing . . . . . . . . . . . . . . . 221 7.1 – Qu'est-ce qu'une FeatherWing ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221 7.2 – Préparation des modules FeatherWing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223 7.3 – Alimentation des projets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 225 7.4 – FeatherWing DotStar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 226

7.4.1 Présentation de la carte d'extension . . . . . . . . . . . . . . . . . . . . . . . . . . . 226

7.4.2 Projet de station météo locale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229

7.5 – FeatherWing Adalogger . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 236

7.5.1 Présentation de la carte d'extension . . . . . . . . . . . . . . . . . . . . . . . . . . . 236

7.5.2 Projet d'enregistreur de température . . . . . . . . . . . . . . . . . . . . . . . . . . 239

7.6 – FeatherWing e-Ink . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 246

7.6.1 Présentation de la carte d'extension . . . . . . . . . . . . . . . . . . . . . . . . . . . 246

●7

Initiation au langage CircuitPython et à la puce nRF52840

7.6.2 Description du module displayio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 248

7.6.3 Tutoriel avec le module displayio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 253

7.6.4 Préparation de ses images . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 266

7.6.5 Projet de badge évènementiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 267

7.7 – FeatherWing TFT de 2,4 pouces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 271

7.7.1 Présentation de la carte d'extension . . . . . . . . . . . . . . . . . . . . . . . . . . . 271

7.7.2 Projet de Visionneuse d'images . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272

7.7.3 Projet de thermographe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 278

7.8 – FeatherWing OLED . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 286

7.8.1 Présentation de la carte d'extension . . . . . . . . . . . . . . . . . . . . . . . . . . . 286

7.8.2 Projet de clavier macro pour Windows . . . . . . . . . . . . . . . . . . . . . . . . . 287

7.9 – FeatherWing Prop-Maker . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 297

7.9.1 Présentation de la carte d'extension . . . . . . . . . . . . . . . . . . . . . . . . . . . 297

7.9.2 Projet de voltmètre parlant . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 300

7.9.3 Projet de thermomètre à LED . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 309

7.9.4 Projet de lampe d'ambiance à LED . . . . . . . . . . . . . . . . . . . . . . . . . . . . 315

7.10 – FeatherWing RTC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 321

7.10.1 Présentation de la carte d'extension . . . . . . . . . . . . . . . . . . . . . . . . . . 321

7.10.2 Projet d'horloge NeoPixel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 324

7.11 – FeatherWing RGB Matrix . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 335

7.11.1 Présentation de la carte d'extension . . . . . . . . . . . . . . . . . . . . . . . . . . 335

7.11.2 Projet Pixel Art . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 344

7.11.3 Projet horloge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 348

7.11.4 Projet de radar de recul . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 353

7.12 – FeatherWing Music Maker . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 359

7.12.1 Présentation de la carte d'extension . . . . . . . . . . . . . . . . . . . . . . . . . . 359

7.12.2 Projet d'instrument MIDI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362

7.13 – Utilisation de la Joy FeatherWing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 378

7.13.1 Présentation de la carte d'extension . . . . . . . . . . . . . . . . . . . . . . . . . . 378

7.13.2 Projet de contrôleur de jeu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 379

7.14 – FeatherWing servo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 387

7.14.1 Présentation de la carte d'extension PWM . . . . . . . . . . . . . . . . . . . . . . 387

7.14.2 Projet de tourelle labyrinthe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 390

7.15 – Power Relay FeatherWing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 396

7.15.1 Présentation de la carte d'extension . . . . . . . . . . . . . . . . . . . . . . . . . . 396

7.15.2 Projet de commande à reconnaissance faciale . . . . . . . . . . . . . . . . . . . 399

7.16 – Utilisation des FeatherWing DC motor / RFM69 . . . . . . . . . . . . . . . . . . . . . . 411

7.16.1 Présentation de la carte d'extension DC Motor . . . . . . . . . . . . . . . . . . . 411

7.16.2 Projet de commande de robot roulant . . . . . . . . . . . . . . . . . . . . . . . . . 414

7.16.3 Présentation de la carte d'extension RFM69 . . . . . . . . . . . . . . . . . . . . . 420

7.16.4 Projet de commande de robot à distance . . . . . . . . . . . . . . . . . . . . . . 424

7.17 – Autres FeatherWings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 433

●8

SOMMAIRE 7.18 – Utilisation de la Feather Click Shield . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 433

7.18.1 Présentation des modules Click Boards . . . . . . . . . . . . . . . . . . . . . . . . 435

7.18.2 Présentation de la carte de MikroElektronika . . . . . . . . . . . . . . . . . . . . 436

7.18.3 Projet de télécommande infrarouge . . . . . . . . . . . . . . . . . . . . . . . . . . 437

Partie III . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 445 Chapitre 8 • C arte Adafruit CLUE nRF52840 Express . . . . . . . . . . . . . . . . . . . . . . 446 8.1 - Présentation de la carte CLUE nRF52840 Express . . . . . . . . . . . . . . . . . . . . . . 446

8.1.1 - Principales caractéristiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 447

8.1.2 - Brochage de la carte CLUE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 449

8.1.3 – Caractéristiques des capteurs embarqués sur la carte CLUE . . . . . . . . . 453

8.1.4 - Mise à jour de son micrologiciel CircuitPython . . . . . . . . . . . . . . . . . . . 453

8.2 – Bibliothèque CircuitPython spécialisée pour CLUE . . . . . . . . . . . . . . . . . . . . . . 455 8.3 – Interfaçage matériel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 456 8.4 – Quelques projets avec la carte CLUE nRF52840 . . . . . . . . . . . . . . . . . . . . . . . 459

8.4.1 – Projet de sonomètre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 459

8.4.2 – Projet d'horloge analogique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 464

8.4.3 – Projet de thermomètre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 470

8.4.4 – Projet de thermomètre sans contact . . . . . . . . . . . . . . . . . . . . . . . . . 474

8.4.5 – Projet de taux d'occupation d'une pièce . . . . . . . . . . . . . . . . . . . . . . . 480

8.4.6 – Projet de Pong . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 491

8.4.7 – Projet de radar 2D Laser . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 503

8.4.8 – Projet d'éclairage caméléon . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 512

8.4.9 – Projet de robot autonome détecteur d'obstacles . . . . . . . . . . . . . . . . . 519

8.4.10 – Exemple d'animation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 528

8.5 – Simulation avec Microsoft Visual Studio Code . . . . . . . . . . . . . . . . . . . . . . . . 533 Chapitre 9 • Un projet Bluetooth . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 537 9.1 - Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 537 9.2 – Commande d'éclairage par Bluetooth . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 537 Chapitre 10 • Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 549 Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 551

●9

Initiation au langage CircuitPython et à la puce nRF52840

● 10

Préface Présentation générale CircuitPython est un langage de programmation développé par la société Adafruit dont la première version est sortie en janvier 2017. Il est avant tout basé sur le langage Python et plus précisément, il est dérivé du langage MicroPython (Damien Georges – campagne Kickstarter de 2013).

Le langage MicroPython et le langage CircuitPython sont des portages du langage Python pour le domaine de l'embarqué. Ils tournent sur de petites architectures comme des microcontrôleurs à 32 bits.

La découverte du langage CircuitPython dans cet ouvrage se fera sur deux cartes distinctes proposées par Adafruit : la carte Feather BlueFruit Sense et la carte CLUE. Chacune est basée sur le module NORDIC SoC nRF52840 avec une architecture à 32 bits. Elles supportent bien sûr toutes les deux le langage CircuitPython et sont sorties sur le marché en février 2020.

Ce que vous allez apprendre Le langage CircuitPython est dédié à l'embarqué. J'ai donc fait le choix d'un apprentissage par projets. Vous ne trouverez pas dans ce livre un cours complet sur la programmation orientée objet appliquée à ce langage. L'apprentissage du langage CircuitPython se fera plutôt à travers plus d'une quarantaine d'exemples et de projets.

J'ai volontairement choisi des projets appliqués modestes dont le code final se limitera malgré tout à 100-120 lignes maximum (commentaires compris). L'objectif est de vous faire prendre conscience de la puissance de ce langage, de sa facilité d'écriture et du potentiel offert par ses bibliothèques.

Ce que vous apprendrez dans cet ouvrage : • Installer le langage CircuitPython sur une carte de développement le supportant.

• Programmer en langage CircuitPython pour découvrir de nombreux aspects de ce langage à travers plusieurs dizaines d'exemples et de projets.

• Utiliser deux cartes de développement différentes supportant CircuitPython.

• Comprendre et mettre en œuvre de nombreux composants qui, associés à la carte de développement, permettent de créer des projets intéressants.

Ce que vous n'apprendrez pas dans cet ouvrage : • Maîtriser toutes les possibilités du langage CircuitPython.

• Concevoir une carte à microcontrôleur supportant CircuitPython.

• Développer une version de CircuitPython pour vos propres microcontrôleurs.

Vous ne deviendrez donc pas des experts de la programmation en CircuitPython à la fin de la lecture de cet ouvrage, mais vous en aurez acquis de bonnes notions.

En effet, l'idée directrice qui m'a guidé tout au long de la rédaction de cet ouvrage est de fournir au lecteur une base d'outils autour de ce langage ainsi que de ses cartes associées.

● 11

Initiation au langage CircuitPython et à la puce nRF52840

Avec le bagage proposé dans cet ouvrage, j'espère vous donner l'envie d'aller plus loin, en combinant certaines notions abordées, en en approfondissant d'autres, afin que vous puissiez créer vos propres projets.

Un prochain ouvrage traitera de l'utilisation de CircuitPython pour les communications sans fil et l'internet des objets. On y abordera l'Ethernet, le Wi-Fi, le Bluetooth, le GSM… tout cela avec CircuitPython et les mêmes cartes que celles utilisées dans cet ouvrage.

Quels sont les prérequis ?

Toutes les manipulations abordées sont suffisamment expliquées et les codes abondamment commentés pour que vous puissiez reproduire tous les projets sans réel prérequis.

Toutefois, avec quelques bases en programmation et plus particulièrement en Python ainsi que quelques notions d'électronique, votre apprentissage du langage CircuitPython et de l'utilisation de cartes le supportant s'en trouvera facilité. Vous pourrez plus facilement approfondir les notions abordées et créer plus rapidement vos propres projets.

Elektor propose notamment dans sa boutique plusieurs ouvrages traitant du langage de programmation Python.

À qui s'adresse ce livre ?

• Un lycéen : après avoir utilisé un langage de programmation par bloc au collège (Scratch), les lycéens doivent savoir utiliser un langage de programmation textuel. C'est le langage Python qui a été choisi pour la réforme du lycée. Il sera à terme étudié dans plusieurs matières au lycée général, au lycée technologique et au lycée professionnel. Et bien sûr la nouvelle matière SNT (Sciences Numériques et Technologie) en seconde et la nouvelle spécialité SNI (Numérique et Sciences Informatiques) en première et terminale utiliseront le langage Python dans leurs enseignements.

Apprendre Python sur sa calculatrice ou sous Jupyter Notebook, c'est déjà formidable. Mais pouvoir allumer des LED, mesurer des grandeurs dans son environnement, faire bouger un robot, jouer des sons… tout en utilisant Python, c'est encore mieux !

Pour cela, il y a deux options conviviales : - le langage MicroPython avec une carte comme la BBC micro:bit - le langage CircuitPython de la société Adafruit avec ses cartes et ses modules d'extension à des prix très accessibles.

- Toutes deux peuvent servir d'excellents supports au lycée.

● 12

•U n étudiant à l'université : le langage Python est déjà très souvent abordé dans les domaines scientifiques enseignés à l'université. Dans les enseignements de spécialité, il est également étudié dans le domaine de l'embarqué grâce au nano-ordinateur Raspberry Pi. Et le développement exponentiel de l'IA, du machine learning et de la science des données en fait maintenant un langage incontournable.

Ce langage est également de plus en plus populaire chez les développeurs, car il leur permet de se concentrer sur ce qu'ils font plutôt que sur la façon dont ils le font. Ce principe s'applique également aux étudiants en phase d'apprentissage.

Préface

Dans le domaine de l'embarqué, il y a depuis longtemps le langage C/C++ pour les microcontrôleurs (Arduino/PIC/…) et depuis 2012 le langage Python dans les nano-ordinateurs (Raspberry Pi/ Jetson Nano/…). Le chaînon manquant entre ces deux acteurs de l'embarqué, c'est le portage du langage Python sur des microcontrôleurs à 32 bits (MicroPython/CircuitPython).

C'est une excellente solution pour l'apprentissage d'un langage de programmation orienté objet au service de l'embarqué.

• La communauté des makers : toute personne passionnée ou simplement curieuse d'électronique et de programmation trouvera dans cette combinaison 'CircuitPython-Carte' des possibilités de création incroyables. Ses nombreuses bibliothèques permettent de couvrir un champ d'application très large : robotique, domotique, audio, jeu…

Si vous n'avez jamais touché au langage C/C++ et à l'Arduino, autant commencer directement avec ce livre. La simplicité de mise en œuvre des produits Adafruit avec le langage CircuitPython est impressionnante. Très vite et en peu de lignes de code, vous pourrez donner vie à vos projets.

Quel est le contenu de ce livre ?

Ce livre est organisé en trois grandes sections. Les lignes qui suivent proposent une description rapide du contenu de chacun des chapitres.

Présentation de circuitpython et du matériel Chapitre 1 : qu'est-ce que CircuitPython ?

Ce premier chapitre introduit le langage CircuitPython développé par la société Adafruit.

Chapitre 2 : la carte Adafruit Feather nRF52840 Sense Dans ce chapitre est présentée la carte de développement Adafruit Feather nRF52840 Sense qui servira de principale cible tout au long de cet ouvrage. On y découvrira son anatomie et ses caractéristiques.

Chapitre 3 : premiers programmes Ce chapitre vous fera découvrir comment installer CircuitPython sur un microcontrôleur, mais également l'écriture de vos premiers programmes en CircuitPython dans l'environnement de développement 'Mu'.

Chapitre 4 : les bases du langage Les bases du langage CircuitPython vous seront présentées dans ce chapitre. L'exploration du langage n'y est pas exhaustive et ne constitue pas un cours de programmation orientée objet. Mais ce qui y est abordé est suffisant pour suivre et comprendre le reste de l'ouvrage.

Chapitre 5 : préparation du matériel Avant de démarrer les exemples et les projets appliqués de cet ouvrage, il est important de faire un point sur le matériel. Que faut-il obligatoirement comme matériel pour aborder la suite de l'ouvrage ?

● 13

Initiation au langage CircuitPython et à la puce nRF52840

Apprentissage de circuitpython sur la carte feather nrf52840 sense Chapitre 6 : découverte du langage CircuitPython Dans ce chapitre, on découvre à travers de nombreux exemples l'utilisation du langage CircuitPython sur la carte Feather nRF52840 Sense. Parfois, elle se suffit à elle-même, parfois vous devrez câbler quelques composants sur ses connecteurs. Au fil du chapitre, vous aborderez les bibliothèques CircuitPython les plus courantes et vous apprendrez à utiliser leurs instructions sur des exemples concrets.

Chapitre 7 : utilisation des cartes d'extension Featherwing La carte Feather nRF52840 Sense comporte déjà un certain nombre de capteurs permettant de réaliser plusieurs projets. Mais Adafruit propose également une grande variété de cartes d'extension qui permettent d'étendre les fonctions de la Feather avec très peu de câblage supplémentaire. Ce chapitre explore une quinzaine de cartes d'extension à travers des projets ludiques.

Apprentissage de circuitpython sur la carte clue nrf52840 express Chapitre 8 : présentation de la carte Adafruit CLUE Ce chapitre introduit la seconde carte employée dans cet ouvrage, à savoir la CLUE nRF52840 Express. On y découvre ses caractéristiques ainsi que ses particularités. Vous mettrez également en œuvre une petite dizaine de projets basés sur cette carte.

Chapitre 9 : un exemple d'utilisation du Bluetooth Dans ce dernier chapitre, on abordera enfin la technologie Bluetooth Low Energy en faisant communiquer une carte nRF52840 avec un smartphone. Cela se fera à travers un simple exemple de façon à découvrir l'utilisation du Bluetooth en CircuitPython. Un prochain ouvrage se concentrera davantage sur cette technologie.

Ressources en téléchargement Tous les codes des différents exemples et projets proposés tout au long de cet ouvrage sont disponibles à l'adresse suivante : https://github.com/MBottinIUT/nRF52840-CircuitPython En plus des codes, vous y trouverez pour chaque chapitre les documentations utiles, les sons, les images… tout ce qui m'a servi à construire ce livre.

J'ai également ajouté un dossier qui contient toutes les bibliothèques CircuitPython utilisées dans les différents codes de cet ouvrage.

Tout au long de cet ouvrage, vous aurez accès par le biais de QR-codes à des vidéos de démonstration des différents montages abordés. Elles sont également directement disponibles depuis ma chaîne Youtube : https://www.youtube.com/channel/UCcNFoAvwTfs_tL3C3J6gOCg/videos J'espère que vous prendrez autant de plaisir à lire cet ouvrage que j'en ai eu à l'écrire.

Bonne lecture, Michaël BOTTIN

● 14

Préface de Ladyada, PDG de la société Adafruit Bonjour, et bienvenue dans le monde de CircuitPython !

Vous vous demandez peut-être : c’est quoi CircuitPython ?

Pourquoi apprendre quelque chose de nouveau ? Ai-je besoin d’un livre ? Je réponds à toutes vos questions.

Qu’est-ce que CircuitPython ?

CircuitPython a été conçu pour être un outil puissant mais abordable de programmation des circuits électroniques en Python. Python est un langage interprété, et si vous êtes un lecteur d’Elektor, vous programmez vos montages électroniques probablement en C, C++ ou peut-être même en assembleur. Dans le passé, les puces avaient une mémoire très limitée, donc le code devait être compilé et optimisé pour tenir dans quelques Ko de mémoire Flash ou RAM. Mais avec les nouvelles puces comme la nRF52840, nous avons une puce très rapide avec 256 Ko de RAM et 1 M de Flash - à tel point que nous pouvons stocker notre code en RAM et l’exécuter en temps réel au lieu de le compiler.

Pourquoi apprendre quelque chose de nouveau ?

Ne vous méprenez pas - j’aime et j’écris encore du code C tous les jours. Mais CircuitPython accélèrera considérablement votre « cycle » de développement - le processus « CodeCompile-Burn-Run-Debug » est réduit à « Code-Run-Debug ». Avec les grosses puces, les deux étapes supplémentaires peuvent prendre beaucoup de temps, et ajouter à l’ennui. Si la compilation et le téléchargement prennent deux ou trois minutes (opérations faciles), pour dix cycles de compilation et d’exécution, vous gagnez déjà une demi-heure. Instinctivement, les développeurs commencent à éviter les petites modifications, en écrivant plus de code entre chaque « compilation-téléchargement »... ce qui peut introduire plus de bogues ! Avec CircuitPython, vous pouvez changer quelques caractères ou une couleur de LED et voir instantanément le résultat de la mise à jour du code.

Pourquoi faut-il un livre ?

Même si vous hésitez à apprendre quelque chose de nouveau, je pense que l’apprentissage de Python est vraiment facile. En outre la carte Feather nRF52840 Sense présentée ici offre une multitude de possibilités grâce à ses capteurs embarqués et ses cartes d’extension Featherwing. Ce livre vous sera d’une grande aide pour aborder étape par étape la programmation de toutes ces cartes et vous habituer à la façon unique de les programmer à l’aide du système de fichiers du lecteur CIRCUITPY ou de l’interpréteur de commandes REPL. CircuitPython est conçu pour être convivial et amusant – j’espère que vous prendrez plaisir à apprendre l’électronique avec ce langage moderne !

Limor Ladyada Fried 1er novembre 2020 - NYC, USA

● 15

Initiation au langage CircuitPython et à la puce nRF52840

● 16

Partie I

â—? 17

Chapitre 1 • Qu'est-ce que CircuitPython ?

1.1 - Historique Au début des années 70, Intel travaillait à la mise au point du premier microprocesseur et parallèlement, chez Texas Instruments, Gary Boone et Michael Cochran élaboraient ce qui allait être le premier microcontrôleur au monde.

En 1971 sortait le microcontrôleur TMS1802MC. Il a notamment été intégré dans les premières calculatrices de poche. Sa puce contenait 5000 transistors et il disposait de 3000 bits de mémoire ROM et de 128 bits de mémoire RAM (on ne parlait pas encore d'octets, car son architecture était sur 4 bits !).

En comparaison, la puce du nRF52840 utilisé dans cet ouvrage, dispose de 1 Mo de mémoire ROM (Flash) et de 256 Ko de mémoire RAM, soit respectivement 2700 fois plus et 16.000 fois plus que son ancêtre.

En 1976, Intel sortait les premiers microcontrôleurs à 8 bits : le 8048 et le 8748. Tous deux disposaient de 1 Ko de mémoire ROM (EPROM) et de 64 octets de mémoire RAM. Et en 1980, Intel sortait son célèbre 8051, dont la longévité n'a encore aujourd'hui pas été dépassée ! Il contenait 4 Ko de ROM et 128 octets de RAM. Sa vitesse d'exécution était de 1 Mips (Mega Instructions Per Second).

Ces microcontrôleurs se programmaient en langage machine (assembleur), c'est-à-dire sous la forme d'instructions rudimentaires avec des codes directement compréhensibles par la puce du microcontrôleur. À cette époque, programmer nécessitait une parfaite maîtrise du fonctionnement interne du microcontrôleur. Le hardware et le software étaient intimement liés.

En 1972, parallèlement à cette évolution matérielle, le langage C, créé par Dennis Ritchie des laboratoires Bell, faisait son apparition. D'abord réservé au monde des ordinateurs, il est arrivé dans le monde des microcontrôleurs au début des années 90. Avec ce langage, on ajoutait une couche d'abstraction à la programmation. Des opérations aussi simples qu'une addition ou une multiplication ne nécessitaient plus de travailler au plus près des registres de la machine. On pouvait plus facilement changer de microcontrôleur et faire évoluer son code sans avoir à repartir de zéro. La notion de bibliothèques se généralisait.

Le langage C et son évolution orientée objet C++ ont vite envahi le monde de l'électronique programmable. Encore aujourd'hui, la plupart des microcontrôleurs sont programmés en C/C++ !

Mais un changement s'amorce ces dernières années. À l'origine de ce changement, on trouve indirectement un programmeur : Guido Van Rossum. Il commence le développement du langage Python en 1989. En févier 1991 sort la première version publique numérotée 0.9.0. On est actuellement à la version 3.8.5.

J'ai utilisé le mot « indirectement », car bien sûr, il n'avait pas conscience à l'époque que Python pourrait faire évoluer le domaine de l'électronique embarquée, car ce langage interprété nécessitait beaucoup de puissance de calcul et n'était utilisable que par des ordinateurs.

Mais en 2013, un ingénieur australien, Damien George, eut l'idée sensationnelle de porter le langage Python sur microcontrôleur. Pour financer son développement, il utilisa la plate-

● 18

Chapitre 1 • Qu'est-ce que CircuitPython ?

forme participative Kickstarter. Il commença sur une cible STM32 avant de le proposer en 2015 sur un ESP8266. MicroPython était né !

Fig. 1.1 – Naissance de MicroPython en 2013.

Remarque : Elektor propose un ouvrage sur la programmation de l'ESP8266 en MicroPython si cela vous intéresse (www.elektor.fr/esp8266-and-micropython).

Le cœur du langage MicroPython est très proche de Python 3.x, mais il s'agit d'une version allégée où tous les modules Python inutiles à un microcontrôleur ont été enlevés, car l'espace mémoire est bien évidemment beaucoup plus faible que celui d'un ordinateur.

Actuellement, la version 1.12 est disponible en téléchargement.

Les cartes électroniques qui supportent MicroPython sont celles à base de microcontrôleurs STM32, ESP8266 et ESP32. Deux cartes Pyboard ont également été développées pour MicroPython.

En 2017, la société américaine Microsemi a également porté MicroPython sur des architectures RISC-V à 32 bits et 64 bits (cartes Sipeed MaixPy ou MaixDuino).

Et avec l'arrivée du langage Python dans les programmes de l'éducation nationale, MicroPython est également intégré depuis peu dans les calculatrices Casio, Texas Instruments et Numworks.

Fig. 1.2 – Naissance de CircuitPython en 2016.

CircuitPython est une version dérivée open source de MicroPython. C'est Scott Shawcroft, travaillant pour Adafruit, qui a initié ce projet en 2016. Comme Adafruit proposait un grand nombre de cartes utilisant le microcontrôleur SAMD21 de Microchip, il a commencé son portage vers ce microcontrôleur.

Pourquoi ne pas avoir porté MicroPython sur ces microcontrôleurs plutôt que de créer un autre langage ?

● 19

Initiation au langage CircuitPython et à la puce nRF52840

Les objectifs d'Adafruit et de MicroPython divergeaient. Pour porter Python sur un microcontrôleur, il faut forcément ajouter un module qui gère l'accès aux différents périphériques du microcontrôleur comme les broches GPIO ou le convertisseur analogique-numérique.

Adafruit voulait simplifier au maximum ce module pour le rendre universel, quelle que soit la carte utilisée. Cette volonté de simplification les a poussés à créer un 'fork' (embranchement) de MicroPython qu'ils ont baptisé CircuitPython.

Mais ces deux langages sont extrêmement proches et CircuitPython incorpore les nouveautés de MicroPython environ une fois par mois !

Je n'ai pas de préférence naturelle pour l'un ou l'autre de ces langages, même si je trouve très confortable la simplification qu'a apportée Adafruit à la chaîne de développement. Mais comme des ouvrages existent sur MicroPython et que très peu existent sur CircuitPython, j'ai choisi ce dernier pour cet ouvrage afin de le faire davantage découvrir aux lecteurs d'Elektor.

En tout cas, l'évolution de l'électronique embarquée et l'explosion de l'internet des objets offrent une opportunité pour ces langages (CircuitPython/MicroPython) de prendre une place de choix. Seul l'avenir nous le dira…

1.2 – Pourquoi utiliser CircuitPython ?

Il y a de nombreuses raisons pour qu'un programmeur débutant s'oriente vers les langages MicroPython/CircuitPython ou qu'un programmeur chevronné glisse progressivement du C/ C++ vers MicroPython/CircuitPython.

J'ai essayé de résumer graphiquement les principales raisons sur la figure 1.3.

Fig. 1.3 – Pourquoi utiliser CircuitPython ?

● 20

Chapitre 1 • Qu'est-ce que CircuitPython ?

CircuitPython, c'est du Python C'est effectivement la raison la plus importante qui ferait choisir CircuitPython (ou MicroPython) pour l'embarqué, plutôt qu'une autre solution.

Python est un langage orienté objet de très haut niveau. Il est open source, on peut donc l'utiliser sans restriction dans des projets commerciaux. Il est multiplateforme (portable).

Sa syntaxe se veut simple et claire ce qui rend les programmes écrits en Python compacts et très lisibles même pour un néophyte.

Python est devenu très populaire ces dernières années et tend à devenir un incontournable dans la jungle des langages de programmation.

Google, Spotify (application), Instagram, Facebook, Netflix, Uber, Dropbox, Pinterest…

Tous ces grands acteurs du web utilisent majoritairement Python quand c'est possible.

En observant les requêtes du web, les produits en vente, les offres d'emploi, les cours en ligne… des sites classent les langages suivant leur popularité. Bien sûr, tout est relatif, car il est difficile de déterminer réellement les langages les plus utilisés en observant juste le web, mais cela donne une bonne indication.

Ainsi le site d'IEEE (cf. figure 1.4) classe Python en première position tandis que le site TIOBE (cf. figure 1.5) classe Python en troisième position [sources de juillet 2020] et en deuxième position en novembre 2020 !.

Fig. 1.4 – Classement du langage Python selon IEEE. https://spectrum.ieee.org/at-work/tech-careers/top-programming-language-2020

● 21

Initiation au langage CircuitPython et à la puce nRF52840

Fig. 1.5 – Classement du langage Python selon TIOBE. https://www.tiobe.com/tiobe-index/ CircuitPython permet un cycle de développement court Vous le constaterez très rapidement au cours de cet ouvrage, le temps de développement d'une application est court.

Les raisons qui permettent d'obtenir un cycle de développement court sont nombreuses : • La chaîne de développement est facile à prendre en main et ne nécessite aucun matériel supplémentaire.

• Python et donc CircuitPython sont des langages accessibles par l'autoapprentissage.

• C'est un langage flexible qui limitera les erreurs courantes dans les autres langages.

• Sa syntaxe se veut simple, ce qui rend le code lisible et efficace.

• La gestion des chaînes de caractères, des tableaux et des fichiers est naturellement intégrée au langage et dispose de fonctions de très haut niveau. À titre d'exemple, vous pouvez compter 20 à 30 lignes de code pour traiter et filtrer un tableau en C/C++ mais une seule ligne suffit en CircuitPython.

• De nombreuses bibliothèques CircuitPython sont disponibles ce qui raccourcit encore la durée de développement d'une application.

• Certaines bibliothèques développées pour Python sont directement compatibles avec CircuitPython. Mais ne vous attendez pas tout de même à faire tourner des bibliothèques comme Numpy ou Matplotlib directement sur votre microcontrôleur. Il existe parfois des alternatives (ulab pour Numpy), mais elles ne seront jamais aussi puissantes.

• Si une bibliothèque d'un composant électronique n'existe pas en CircuitPython, mais qu'une version Python est disponible (je pense notamment à tout ce qui existe autour du Raspberry Pi), on peut, avec un peu d'expérience, transposer une petite bibliothèque Python vers CircuitPython. Par petite, comprenez une bibliothèque qui occupe peu d'espace en mémoire.

• On n'a pas à se soucier de pointeurs.

• On dispose d'exceptions pour gérer les erreurs.

• (…)

● 22

Chapitre 1 • Qu'est-ce que CircuitPython ?

J'imagine assez facilement que lire ces arguments en faveur de CircuitPython ne permet pas de vous convaincre aussitôt, mais je suis sûr qu'à la fin de cet ouvrage, vous ne pourrez qu'attester l'efficacité de ce langage et sa facilité d'utilisation.

CircuitPython procure une solution économique pour l'électronique embarquée Actuellement, les cartes d'Adafruit supportant CircuitPython s'échelonnent entre une dizaine d'euros et une quarantaine d'euros, ce qui les place au même rang que les cartes Arduino en ce qui concerne le coût.

On commence à trouver des cartes d'autres fabricants à moins de dix euros.

Adafruit emprunte aussi la voie déjà tracée par Arduino. Pour programmer une de leurs cartes, un simple câble USB suffit.

Pour le logiciel, même si ce n'est pas très confortable, on peut se passer d'un éditeur de code (un simple éditeur de texte peut suffire) et l'on n'a pas besoin de compilateur.

CircuitPython est en évolution permanente CircuitPython est mis à jour régulièrement comme le montre la figure 1.6.

Fig. 1.6 – Frise chronologique de l'évolution de CircuitPython.

De plus, de nombreuses bibliothèques apparaissent régulièrement permettant de prendre en charge de plus en plus de composants externes (écrans, capteurs, actionneurs…).

Vous pouvez déjà vous faire une idée des différents composants supportés par le langage à l'adresse suivante : https://circuitpython.readthedocs.io/projects/bundle/en/latest/

1.3 – Ressources CircuitPython La ressource principale est le site officiel d'Adafruit : www.circuitpython.org (figure 1.7)

● 23

Initiation au langage CircuitPython et à la puce nRF52840

Fig. 1.7 – Site officiel d'Adafruit pour CircuitPython.

Nous y reviendrons dans les prochains chapitres, mais deux pages sont essentielles au démarrage : • https://learn.adafruit.com/welcome-to-circuitpython/ • https://learn.adafruit.com/circuitpython-essentials/circuitpython-essentials Enfin, une page Github tient informée la communauté de toutes les nouveautés autour de ce langage (cartes, évènements, livres, articles du web…) : https://github.com/adafruit/awesome-circuitpython

1.4 – Cartes supportant CircuitPython Dans cette dernière partie, je vais juste évoquer les cartes supportant CircuitPython.

Adafruit est à l'origine du langage et des premières cartes supportant le langage CircuitPython. Depuis de gros acteurs du marché du microcontrôleur ont emboîté le pas. La figure 1.8 vous en présente quelques-uns :

Fig. 1.8 – Sociétés proposant des produits supportant CircuitPython.

Je ne parcourrai pas toutes les cartes existantes, car à l'heure actuelle (juillet 2020), plus de 140 cartes de développement supportent CircuitPython. La plupart sont dédiées à du développement, d'autres sont plus spécialisées (jeu, IoT, commande de LED…). Un échantillon est présenté à la figure 1.9.

● 24

Chapitre 1 • Qu'est-ce que CircuitPython ?

Fig. 1.9 – Échantillon de cartes de développement supportant CircuitPython.

● 25

Initiation au langage CircuitPython et à la puce nRF52840

J Joy FeatherWing joystick analogique

378, 390, 424 184, 202

pull-up 100, 449 pulseio 120 PWM 118, 126, 134, 152, 300, 317, 387,

413

K Keycode

193

L laser LED LED de puissance 298, LiDAR Light Painting lis3dh LIS3MDL 30, 40, LSM6DS33 30, 39,

480 122 315 503 320 317 449 449

M matrice de LED RVB 336 MAX7219 437 mémoire Flash 29 mémoire RAM 34, 147 méthodes 84 microphone MP34DT01-M 449 MIDI 360, 369 MikroBus 435 MicroPython 19, 217 MLX90614 474 module 83 module 'busio' 170 module 'digitalio' 98 module 'displayio' 248 modules 60, 185 , 209 MP34DT01-M 30, 42 Mu Editor 52

R rapport cyclique reconnaissance faciale relais électromécanique REPL résistances de pull-down résistances de pull-up RMS robot Zumo

119, 124 399 396 57 362 32 157 414

S servomoteur 126, 390 , 505 SHT30 30, 36, 155, 212, 230, 449 simpleio 150 SPI 32, 183, 229, 238, 256, 275, 423,

438 SSD1306 252, 288 synthèse vocale 305

T table de caractères 233 tableur 199, 239 TCS34725 512 TF-Luna 503 ToF 180 ToF (Time Of Flight) 503 touchio 137 translateur de tension 513, 539

U UART

32, 171, 401, 503

N NeoPixel 30, 47, 50, 71, 160, 297, 310,

324, 448, 513, 537 NeoPixel WS2812B 43

P périphériques HID photorésistance LDR Power Relay FeatherWing pull-down 32, 100,

● 552

190 481 396 138

V valeur moyenne quadratique 463 Visual Studio Code 533 VL53L0x 491 VL6180X 180, 521

Y YAT

176, 402

books livres

Initiation au langage CircuitPython et à la puce nRF52840 en moins de 100 lignes de code par projet avec les cartes Feather Sense et Clue Express d’Adafruit Le langage de programmation Python est apprécié par les pédagogues parce que sa syntaxe le rend facile à comprendre. Il s’est également imposé chez les informaticiens expérimentés. La société Adafruit a développé une version spéciale de Python pour l’embarquer sur les microcontrôleurs à 32 bits : CircuitPython.

Ce livre permettra au lecteur de s’initier à la programmation en CircuitPython sur deux cartes : Feather BlueFruit Sense (également appelée Feather nRF52840 Sense) et CLUE nRF52840 Express. Chacune est animée par le SoC nRF52840 de NORDIC avec une architecture à 32 bits.

Pour ce voyage dans le monde de la programmation embarquée, l’auteur sort du chemin classique, à savoir un cours complet sur la programmation orientée objet appliquée à ce langage. Il préfère emmener le lecteur directement sur le terrain avec des projets qui mettent en œuvre les cartes et différents périphériques. Plus d’une quarantaine d’exemples et de montages permettent de découvrir la richesse de CircuitPython.

Toutefois l’auteur s’est imposé une limite pour ne pas décourager les novices : le code de chaque projet ne dépasse jamais la centaine de lignes. Pour ce qui est du matériel, là aussi la simplicité domine : aucun programmateur, un simple PC suffit ; aucun soudage grâce au câblage sur platine d’essai. Les cartes d’extension FeatherWing à enficher sur la Feather nRF52840 Sense permettent de démultiplier ses fonctions : matrice de LED, enregistreur de données, écran à encre électronique, écran OLED, écran TFT, commande de moteurs, audio, relais…

Toutes les étapes (assemblage des différents composants, installation des bibliothèques requises, programmation, tests…) sont expliquées en détail. Le code des différents exemples et projets est disponible sur Github.

Le résultat de chaque projet est même présenté sur de courtes vidéos disponibles sur YouTube. À la fin de sa lecture, le nouveau Pythonien pourra facilement approfondir les notions abordées et donner vie à ses propres projets grâce aux outils qu’il aura essayés.

Ce livre s’adresse aux lycéens et étudiants ainsi qu’à toute la communauté des makers.

Le déclic s'est produit au cours de l'année 1990 durant sa formation en DUT génie électrique et informatique industrielle à Lille.

Michaël Bottin n'avait alors que 17 ans lorsqu’il a découvert ce monde nouveau qui lui permettait de comprendre tant de choses autour de lui.

Depuis, il ne s’est jamais éloigné de l'électronique et il n'a pas quitté son fer à souder. La programmation a progressivement pris une place de plus en plus importante dans ses réalisations, d'abord avec le langage C puis avec le langage Python. Il est depuis de nombreuses années enseignant à l'IUT de Rennes où il essaie de transmettre sa passion à ses étudiants en privilégiant un apprentissage par projet.

éditeur : Publitronic SARL diffusion : GEODIF www.elektor.fr 39,95 €