Jim Bennett
2 years ago
committed by
GitHub
commit
f40cb40f9a
@ -0,0 +1,266 @@
|
||||
# Une meilleure immersion dans l'IoT
|
||||
|
||||
|
||||
|
||||
> Sketchnote par [Nitya Narasimhan](https://github.com/nitya). Cliquez sur l'image pour l'agrandir.
|
||||
|
||||
Cette leçon a été dispensée dans le cadre de la [série Hello IoT](https://youtube.com/playlist?list=PLmsFUfdnGr3xRts0TIwyaHyQuHaNQcb6-) de [Microsoft Reactor](https://developer.microsoft.com/reactor/?WT.mc_id=academic-17441-jabenn). La leçon a été dispensée sous forme de deux vidéos - une leçon d'une heure et une heure aux heures de bureau pour approfondir certaines parties de la leçon et répondre aux questions.
|
||||
|
||||
[](https://youtu.be/t0SySWw3z9M)
|
||||
|
||||
[](https://youtu.be/tTZYf9EST1E)
|
||||
|
||||
> 🎥 Cliquez sur les images ci-dessus pour regarder les vidéos
|
||||
|
||||
## Quiz préalable
|
||||
|
||||
[Quiz préalable](https://black-meadow-040d15503.1.azurestaticapps.net/quiz/3)
|
||||
|
||||
## Introduction
|
||||
|
||||
Cette leçon approfondit certains des concepts abordés dans la dernière leçon.
|
||||
|
||||
Dans cette leçon, nous couvrirons :
|
||||
|
||||
* [Les composants d'une application IoT](#les-composants-d'une-application-iot)
|
||||
* [Approfondissement des microcontrôleurs](#approfondissement-des-microcontrôleurs)
|
||||
* [Approfondissement des ordinateurs monocartes](#approfondissement-des-ordinateurs-monocartes)
|
||||
|
||||
## Les composants d'une application IoT
|
||||
|
||||
Les deux composants d'une application IoT sont l' *Internet* et l' *objet* (the thing). Examinons ces deux composants de manière un peu plus détaillée.
|
||||
|
||||
### L'objet (The Thing)
|
||||
|
||||
|
||||
|
||||
La partie **Objet** (**Thing** en anglais) de l'IOT (Internet Of Thing) fait référence à un dispositif qui peut interagir avec le monde physique. Ces appareils sont généralement des ordinateurs de petite taille, peu coûteux, fonctionnant à faible vitesse et consommant peu d'énergie - par exemple, de simples microcontrôleurs dotés de kilooctets de RAM (par opposition aux gigaoctets d'un PC) et fonctionnant à seulement quelques centaines de mégahertz (par opposition aux gigahertz d'un PC), mais consommant parfois si peu d'énergie qu'ils peuvent fonctionner pendant des semaines, des mois, voire des années sur des piles.
|
||||
|
||||
Ces dispositifs interagissent avec le monde physique, soit en utilisant des capteurs pour recueillir des données sur leur environnement, soit en contrôlant des sorties ou des actionneurs pour apporter des changements physiques. L'exemple type est celui du thermostat intelligent, un appareil doté d'un capteur de température, d'un moyen de régler la température souhaitée (cadran ou écran tactile) et d'une connexion à un système de chauffage ou de refroidissement qui peut être activé lorsque la température détectée est en dehors de la plage souhaitée. Le capteur de température détecte que la pièce est trop froide et un actionneur met le chauffage en marche.
|
||||
|
||||
|
||||
|
||||
Il existe un large éventail d'objets différents qui peuvent agir comme des dispositifs IoT, du matériel dédié qui détecte une seule chose, aux appareils à usage général, même votre smartphone ! Un smartphone peut utiliser des capteurs pour détecter le monde qui l'entoure et des actionneurs pour interagir avec ce monde, par exemple en utilisant un capteur GPS pour détecter votre position et un haut-parleur pour vous donner des instructions de navigation vers une destination.
|
||||
|
||||
✅ Pensez à d'autres systèmes que vous avez autour de vous et qui lisent les données d'un capteur et les utilisent pour prendre des décisions. Un exemple serait le thermostat d'un four. Pouvez-vous en trouver d'autres ?
|
||||
|
||||
### L'Internet
|
||||
|
||||
Le côté **Internet** d'une application IoT (Internet Of Thing) se compose d'applications auxquelles le dispositif IoT peut se connecter pour envoyer et recevoir des données, ainsi que d'autres applications qui peuvent traiter les données du dispositif IoT et aider à prendre des décisions sur les demandes à envoyer aux actionneurs du dispositif IoT.
|
||||
|
||||
Une configuration typique consisterait à avoir une sorte de service cloud auquel le dispositif IoT se connecte, et ce service cloud gèrerait des aspect comme la sécurité, ainsi que la réception et le renvoi de messages au dispositif IoT. Ce service cloud se connecte ensuite à d'autres applications qui peuvent traiter ou stocker les données des capteurs, ou utiliser ces données avec celles d'autres systèmes pour prendre des décisions.
|
||||
|
||||
Par ailleurs, les appareils ne se connectent pas toujours directement à l'internet via des connexions WiFi ou filaires. Certains appareils utilisent un réseau maillé pour communiquer entre eux par le biais de technologies telles que le Bluetooth, en se connectant via un hub qui dispose d'une connexion Internet.
|
||||
|
||||
Dans l'exemple d'un thermostat intelligent, le thermostat se connecterait via le WiFi domestique à un service en nuage s'éxecutant dans le cloud. Il enverrait les données de température à ce service en nuage, et de là, elles seraient écrites dans une sorte de base de données permettant au propriétaire de vérifier les températures actuelles et passées à l'aide d'une application téléphonique. Un autre service cloud saura quelle température le propriétaire souhaite et enverra des messages à l'appareil IoT via le service cloud pour demander au système de chauffage de s'allumer ou de s'éteindre.
|
||||
|
||||
|
||||
|
||||
Une version encore plus intelligente pourrait utiliser l'IA dans le cloud avec des données provenant d'autres capteurs connectés à d'autres appareils IoT, tels que des capteurs d'occupation qui détectent quelles pièces sont utilisées, ainsi que des données telles que la météo et même votre calendrier, pour prendre des décisions sur la façon de régler la température de manière intelligente. Par exemple, il pourrait éteindre votre chauffage s'il lit dans votre calendrier que vous êtes en vacances, ou éteindre le chauffage pièce par pièce en fonction des pièces que vous utilisez, apprenant des données pour être de plus en plus précis au fil du temps.
|
||||
|
||||
|
||||
|
||||
✅ Quelles autres données pourraient contribuer à rendre un thermostat connecté à Internet plus intelligent ?
|
||||
|
||||
### IoT on the Edge
|
||||
|
||||
Bien que le "I" dans IoT soit l'abréviation d'Internet, ces dispositifs n'ont pas besoin de se connecter à l'Internet. Dans certains cas, les appareils peuvent se connecter à des appareils 'périphériques', c'est-à-dire des appareils représentant des passerelles qui fonctionnent sur votre réseau local, ce qui signifie que vous pouvez traiter des données sans passer par l'Internet. Cela peut être plus rapide lorsque vous avez beaucoup de données ou une connexion Internet lente, cela vous permet de fonctionner hors ligne lorsque la connectivité Internet n'est pas possible, comme sur un navire ou dans une zone sinistrée pour répondre à une crise humanitaire, et cela vous permet de garder les données privées. Certains appareils contiendront un code de traitement créé à l'aide d'outils en nuage et l'exécuteront localement pour recueillir des données et y répondre sans utiliser de connexion Internet pour prendre une décision.
|
||||
|
||||
Il s'agit par exemple d'un appareil domestique intelligent tel que le HomePod d'Apple, l'Alexa d'Amazon ou le Google Home, qui écoutera votre voix à l'aide de modèles d'IA formés dans le nuage, mais exécutés localement sur l'appareil. Ces appareils 's'activent' lorsqu'un certain mot ou une certaine phrase est prononcé(e) et n'envoient qu'après celà votre voix sur Internet pour la traiter. L'appareil cessera d'envoyer la parole à un moment approprié, par exemple lorsqu'il détectera une pause dans votre discours. Tout ce que vous dites avant de réveiller l'appareil avec le mot de réveil, et tout ce que vous dites après que l'appareil a cessé d'écouter, ne sera pas envoyé via internet au fournisseur de l'appareil, et sera donc privé.
|
||||
|
||||
✅ Pensez à d'autres scénarios dans lesquels la confidentialité est importante, de sorte que le traitement des données serait mieux fait à la périphérie plutôt que dans le cloud. À titre d'indication - pensez aux appareils IoT dotés de caméras ou d'autres dispositifs d'imagerie.
|
||||
|
||||
### La sécurité dans l'IoT
|
||||
|
||||
Avec toute connexion Internet, la sécurité est une considération importante. Une vieille plaisanterie dit que 'le S de IoT signifie sécurité' - il n'y a pas de 'S' dans IoT, ce qui implique qu'il n'est pas sécurisé.
|
||||
|
||||
Les appareils IoT se connectent à un service cloud et sont donc aussi sécuriés que ce dernier. Si votre service cloud permet à n'importe quel appareil de se connecter, des données malveillantes peuvent être envoyées ou des attaques virales peuvent avoir lieu. Cela peut avoir des conséquences très concrètes dans la mesure où les dispositifs IoT interagissent et contrôlent d'autres dispositifs. Par exemple, le [ver Stuxnet](https://wikipedia.org/wiki/Stuxnet) a manipulé les valves des centrifugeuses pour les endommager. Des pirates ont également profité d'une [sécurité insuffisante pour accéder à des moniteurs pour bébé](https://www.npr.org/sections/thetwo-way/2018/06/05/617196788/s-c-mom-says-baby-monitor-was-hacked-experts-say-many-devices-are-vulnerable) et à d'autres dispositifs de surveillance domestique.
|
||||
|
||||
> 💁 Parfois, les appareils IoT et les périphériques fonctionnent sur un réseau complètement isolé d'Internet afin de préserver la confidentialité et la sécurité des données. C'est ce qu'on appelle l'[air-gapping](https://wikipedia.org/wiki/Air_gap_(networking)).
|
||||
|
||||
## Approfondissement des microcontrôleurs
|
||||
|
||||
Dans la dernière leçon, nous avons présenté les microcontrôleurs. Nous allons maintenant approfondir cette technologie.
|
||||
|
||||
### Le processeur (CPU)
|
||||
|
||||
Le processeur est le 'cerveau' du microcontrôleur. C'est le processeur qui exécute votre code et qui peut envoyer et recevoir des données de n'importe quel appareil connecté. Les CPU peuvent contenir un ou plusieurs noyaux - essentiellement un ou plusieurs CPU qui peuvent travailler ensemble pour exécuter votre code.
|
||||
|
||||
Les processeurs s'appuient sur une horloge qui ticote plusieurs millions ou milliards de fois par seconde. Chaque tic, ou cycle, synchronise les actions que l'unité centrale peut entreprendre. À chaque tic, l'unité centrale peut exécuter une instruction d'un programme, par exemple pour récupérer des données d'un périphérique externe ou effectuer un calcul mathématique. Ce cycle régulier permet de terminer toutes les actions avant de traiter l'instruction suivante.
|
||||
|
||||
Plus le cycle d'horloge est rapide, plus le nombre d'instructions pouvant être traitées chaque seconde est important, et donc plus le CPU est rapide. Les vitesses des processeurs sont mesurées en [Hertz (Hz)](https://wikipedia.org/wiki/Hertz), une unité standard où 1 Hz signifie un cycle ou un tic d'horloge par seconde.
|
||||
|
||||
> 🎓 Les vitesses des processeurs sont souvent indiquées en MHz ou en GHz. 1MHz correspond à 1 million de Hz, 1GHz à 1 milliard de Hz.
|
||||
|
||||
> 💁 Les CPU exécutent des programmes en utilisant le [cycle de récupération-décodage-exécution](https://wikipedia.org/wiki/Instruction_cycle). Pour chaque tic d'horloge, le CPU va chercher l'instruction suivante dans la mémoire, la décode, puis l'exécute, par exemple en utilisant une unité arithmétique et logique (UAL) pour additionner 2 nombres. Certaines exécutions prennent plusieurs ticks pour être exécutées, le cycle suivant sera donc exécuté au prochain tick après la fin de l'instruction.
|
||||
|
||||
|
||||
|
||||
Les microcontrôleurs ont des vitesses d'horloge beaucoup plus faibles que les ordinateurs de bureau ou portables, ou même que la plupart des smartphones. Le terminal Wio, par exemple, possède un processeur qui fonctionne à 120 MHz, soit 120 000 000 de cycles par seconde.
|
||||
|
||||
✅ Un PC ou un Mac moyen possède une unité centrale avec plusieurs cœurs fonctionnant à plusieurs GigaHertz, ce qui signifie que l'horloge tique des milliards de fois par seconde. Recherchez la vitesse d'horloge de votre ordinateur et comparez combien de fois il est plus rapide que le terminal Wio.
|
||||
|
||||
Chaque cycle d'horloge consomme de l'énergie et génère de la chaleur. Plus les tic-tac sont rapides, plus la consommation d'énergie et la production de chaleur sont importantes. Les PC sont équipés de dissipateurs thermiques et de ventilateurs pour évacuer la chaleur, sans quoi ils surchaufferaient et s'arrêteraient en quelques secondes. Les microcontrôleurs n'ont souvent ni l'un ni l'autre, car ils sont beaucoup plus froids et donc beaucoup plus lents. Les PC fonctionnent sur le secteur ou sur de grosses batteries pendant quelques heures, alors que les microcontrôleurs peuvent fonctionner pendant des jours, des mois, voire des années sur de petites batteries. Les microcontrôleurs peuvent également avoir des cœurs qui fonctionnent à des vitesses différentes, passant à des cœurs plus lents et de faible puissance lorsque la demande de l'unité centrale est faible afin de réduire la consommation d'énergie.
|
||||
|
||||
> 💁 Certains PC et Mac adoptent le même mélange de cœurs rapides à haute puissance et de cœurs plus lents à faible puissance, en basculant pour économiser la batterie. Par exemple, la puce M1 des derniers ordinateurs portables d'Apple peut basculer entre 4 cœurs de performance et 4 cœurs d'efficacité pour optimiser la durée de vie de la batterie ou la vitesse en fonction de la tâche exécutée.
|
||||
|
||||
✅ Faites un peu de recherche : Renseignez-vous sur les processeurs sur le site [Wikipedia CPU article](https://wikipedia.org/wiki/Central_processing_unit)
|
||||
|
||||
#### Tâche
|
||||
|
||||
Examinez le terminal Wio.
|
||||
|
||||
Si vous utilisez un terminal Wio pour ces leçons, essayez de trouver l'unité centrale. Consultez la section *Vue d'ensemble du matériel* de la [page produit du terminal Wio](https://www.seeedstudio.com/Wio-Terminal-p-4509.html) pour obtenir une image des composants internes, et essayez de trouver l'unité centrale à travers la fenêtre en plastique transparent située à l'arrière.
|
||||
|
||||
### Mémoire
|
||||
|
||||
Les microcontrôleurs disposent généralement de deux types de mémoire : la mémoire de programme et la mémoire vive (RAM).
|
||||
|
||||
La mémoire de programme est non volatile, ce qui signifie que tout ce qui y est écrit est conservé lorsque l'appareil n'est pas alimenté. C'est la mémoire qui stocke votre code de programme.
|
||||
|
||||
La RAM est la mémoire utilisée par le programme pour s'exécuter, contenant les variables allouées par votre programme et les données recueillies auprès des périphériques. La RAM est volatile, lorsque l'alimentation est coupée, son contenu est perdu, ce qui a pour effet de réinitialiser votre programme.
|
||||
|
||||
> 🎓 La mémoire de programme stocke votre code et se conserve lorsqu'il n'y a pas d'alimentation.
|
||||
|
||||
> 🎓 La mémoire vive est utilisée pour exécuter votre programme et est réinitialisée lorsqu'il n'y a pas d'alimentation.
|
||||
|
||||
Comme pour l'unité centrale, la mémoire d'un microcontrôleur est plusieurs fois plus petite que celle d'un PC ou d'un Mac. Un PC typique peut avoir 8 gigaoctets (Go) de RAM, ou 8 000 000 000 d'octets, chaque octet étant suffisant pour stocker une seule lettre ou un nombre de 0 à 255. Un microcontrôleur n'aurait que des kilo-octets (Ko) de RAM, un kilo-octet étant égal à 1 000 octets. Le terminal Wio mentionné ci-dessus possède 192 Ko de RAM, soit 192 000 octets - plus de 40 000 fois moins qu'un PC moyen!
|
||||
|
||||
Le diagramme ci-dessous montre la différence de taille relative entre 192KB et 8GB - le petit point au centre représente 192KB.
|
||||
|
||||
! [Une comparaison entre 192KB et 8GB - plus de 40 000 fois plus grand](../../../../images/ram-comparison.png)
|
||||
|
||||
Le stockage des programmes est également plus petit que dans un PC. Un PC typique peut avoir un disque dur de 500 Go pour le stockage des programmes, alors qu'un microcontrôleur peut n'avoir que des kilo-octets ou peut-être quelques méga-octets (Mo) de stockage (1 Mo correspond à 1 000 Ko, ou 1 000 000 d'octets). Le terminal Wio dispose de 4 Mo de mémoire de programme.
|
||||
|
||||
✅ Faites une petite recherche : De quelle quantité de mémoire vive et de stockage dispose l'ordinateur que vous utilisez pour lire ces lignes? Comment cela se compare-t-il à un microcontrôleur?
|
||||
|
||||
### Les entrée / Les sortie (Input/Output)
|
||||
|
||||
Les microcontrôleurs ont besoin de connexions d'entrée et de sortie (E/S) pour lire les données des capteurs et envoyer des signaux de commande aux actionneurs. Ils contiennent généralement un certain nombre de broches d'entrée/sortie à usage général ('general-purpose input/output' ou GPIO en anglais). Ces broches peuvent être configurées par logiciel pour être des entrées (c'est-à-dire qu'elles reçoivent un signal) ou des sorties (elles envoient un signal).
|
||||
|
||||
🧠⬅️ Les broches d'entrée sont utilisées pour lire les valeurs des capteurs.
|
||||
|
||||
🧠➡️ Les broches de sortie envoient des instructions aux actionneurs.
|
||||
|
||||
Vous en apprendrez plus à ce sujet dans une prochaine leçon.
|
||||
|
||||
#### Tâche
|
||||
|
||||
Examinez le terminal Wio.
|
||||
|
||||
Si vous utilisez un terminal Wio pour ces leçons, trouvez les broches GPIO. Trouvez la section *Pinout diagram* de la [page produit du terminal Wio](https://www.seeedstudio.com/Wio-Terminal-p-4509.html) pour savoir à quoi correspondent les broches. Le terminal Wio est livré avec un autocollant que vous pouvez apposer à l'arrière avec les numéros de broches, alors ajoutez-le maintenant si vous ne l'avez pas encore fait.
|
||||
|
||||
### Taille physique
|
||||
|
||||
Les microcontrôleurs sont généralement de petite taille, le plus petit étant un [Freescale Kinetis KL03 MCU est assez petit pour tenir dans la cavité d'une balle de golf](https://www.edn.com/tiny-arm-cortex-m0-based-mcu-shrinks-package/). L'unité centrale d'un PC peut mesurer 40 mm x 40 mm, sans compter les dissipateurs thermiques et les ventilateurs nécessaires pour que l'unité centrale puisse fonctionner pendant plus de quelques secondes sans surchauffe, ce qui est nettement plus grand qu'un microcontrôleur complet. Le kit de développement du terminal Wio, qui comprend un microcontrôleur, un boîtier, un écran et une série de connexions et de composants, n'est pas beaucoup plus grand qu'un processeur Intel i9 nu, et beaucoup plus petit qu'un processeur avec un dissipateur thermique et un ventilateur!
|
||||
|
||||
| Appareil | Taille |
|
||||
| ------------------------------- | --------------------- |
|
||||
| Freescale Kinetis KL03 | 1.6mm x 2mm x 1mm |
|
||||
| Terminal Wio | 72mm x 57mm x 12mm |
|
||||
| Processeur Intel i9, dissipateur de chaleur et ventilateur | 136mm x 145mm x 103mm |
|
||||
|
||||
### Frameworks et systèmes d'exploitation
|
||||
|
||||
En raison de leur faible vitesse et de la taille de leur mémoire, les microcontrôleurs n'utilisent pas de système d'exploitation (OS) au sens bureautique du terme. Le système d'exploitation qui fait fonctionner votre ordinateur (Windows, Linux ou macOS) a besoin de beaucoup de mémoire et de puissance de traitement pour exécuter des tâches qui sont totalement inutiles pour un microcontrôleur. N'oubliez pas que les microcontrôleurs sont généralement programmés pour exécuter une ou plusieurs tâches très spécifiques, contrairement à un ordinateur à usage général comme un PC ou un Mac qui doit prendre en charge une interface utilisateur, lire de la musique ou des films, fournir des outils pour écrire des documents ou du code, jouer à des jeux ou naviguer sur l'internet.
|
||||
|
||||
Pour programmer un microcontrôleur sans système d'exploitation, vous avez besoin d'un outil qui vous permette de construire votre code de manière à ce que le microcontrôleur puisse fonctionner, en utilisant des API qui peuvent communiquer avec tous les périphériques. Chaque microcontrôleur étant différent, les fabricants prennent normalement en charge des frameworks standards qui vous permettent de suivre une 'recette' standard pour créer votre code et le faire fonctionner sur n'importe quel microcontrôleur qui prend en charge ce framework.
|
||||
|
||||
Vous pouvez programmer les microcontrôleurs à l'aide d'un système d'exploitation - souvent appelé système d'exploitation en temps réel ('real-time operating system' ou RTOS en anglais), car il est conçu pour gérer l'envoi de données vers et depuis des périphériques en temps réel. Ces systèmes d'exploitation sont très légers et offrent des fonctionnalités telles que :
|
||||
|
||||
* Le multithreading, qui permet à votre code d'exécuter plus d'un bloc de code en même temps, soit sur plusieurs cœurs, soit en se relayant sur un cœur.
|
||||
* la mise en réseau, qui permet de communiquer en toute sécurité sur l'internet
|
||||
* des composants d'interface utilisateur graphique (GUI) pour construire des interfaces utilisateur (UI) sur des appareils dotés d'écrans.
|
||||
|
||||
✅ Renseignez-vous sur les différents RTOS : [Azure RTOS](https://azure.microsoft.com/services/rtos/?WT.mc_id=academic-17441-jabenn), [FreeRTOS](https://www.freertos.org), [Zephyr](https://www.zephyrproject.org)
|
||||
|
||||
#### Arduino
|
||||
|
||||
|
||||
|
||||
[Arduino](https://www.arduino.cc) est probablement le microcontrôleur le plus populaire, en particulier parmi les étudiants, les amateurs et les créateurs. Arduino est une plateforme électronique open source combinant logiciel et matériel. Vous pouvez acheter des cartes compatibles Arduino auprès d'Arduino ou d'autres fabricants, puis coder à l'aide de la structure Arduino.
|
||||
|
||||
Les cartes Arduino sont codées en C ou en C++. L'utilisation de C/C++ permet de compiler un code très petit et de l'exécuter rapidement, ce qui est nécessaire sur un dispositif contraignant tel qu'un microcontrôleur. Le cœur d'une application Arduino est appelé sketch et est un code C/C++ avec 2 fonctions - `setup` et `loop`. Lorsque la carte démarre, le code du framework Arduino exécute la fonction `setup` une fois, puis il exécute la fonction `loop` encore et encore, l'exécutant continuellement jusqu'à ce que l'alimentation soit coupée.
|
||||
|
||||
Vous écrirez votre code d'installation dans la fonction `setup`, comme la connexion aux services WiFi et cloud ou l'initialisation des broches pour l'entrée et la sortie. Votre code de boucle contiendrait alors le code de traitement, comme la lecture d'un capteur et l'envoi de la valeur au nuage. Vous devez normalement inclure un délai dans chaque boucle, par exemple, si vous voulez que les données du capteur soient envoyées toutes les 10 secondes, vous devez ajouter un délai de 10 secondes à la fin de la boucle pour que le microcontrôleur puisse dormir, économisant ainsi de l'énergie, puis exécuter la boucle à nouveau lorsque cela est nécessaire 10 secondes plus tard.
|
||||
|
||||
|
||||
|
||||
✅ Cette architecture de programme est connue sous le nom de *boucle d'événements* ou *boucle de messages*. De nombreuses applications l'utilisent en arrière plan et c'est la norme pour la plupart des applications de bureau qui fonctionnent sur des systèmes d'exploitation comme Windows, macOS ou Linux. La `boucle` ('loop') écoute les messages provenant des composants de l'interface utilisateur tels que les boutons, ou des périphériques tels que le clavier, et y répond. Pour en savoir plus, consultez cet [article sur la boucle d'événements](https://wikipedia.org/wiki/Event_loop).
|
||||
|
||||
Arduino fournit des bibliothèques standard pour interagir avec les microcontrôleurs et les broches d'I/O (Entrée/Sorties), avec différentes implémentations en arrière plan pour fonctionner sur différents microcontrôleurs. Par exemple, la [fonction `delay`](https://www.arduino.cc/reference/en/language/functions/time/delay/) met le programme en pause pendant une période donnée, la [fonction `digitalRead`](https://www.arduino.cc/reference/en/language/functions/digital-io/digitalread/) lit une valeur `HIGH` ou `LOW` sur la broche donnée, quelle que soit la carte sur laquelle le code est exécuté. Ces bibliothèques standard signifient que le code Arduino écrit pour une carte peut être recompilé pour n'importe quelle autre carte Arduino et fonctionnera, en supposant que les broches sont les mêmes et que les cartes supportent les mêmes fonctionnalités.
|
||||
|
||||
Il existe un vaste écosystème de bibliothèques Arduino tierces qui vous permettent d'ajouter des fonctionnalités supplémentaires à vos projets Arduino, telles que l'utilisation de capteurs et d'actionneurs ou la connexion à des services cloud IoT.
|
||||
|
||||
##### Tâche
|
||||
|
||||
Étudiez le terminal Wio.
|
||||
|
||||
Si vous utilisez un terminal Wio pour ces leçons, relisez le code que vous avez écrit dans la dernière leçon. Trouvez les fonctions `setup` et `loop`. Surveillez la sortie série pour voir si la fonction loop est appelée de façon répétée. Essayez d'ajouter du code à la fonction `setup` pour écrire sur le port série et observez que ce code n'est appelé qu'une seule fois à chaque redémarrage. Essayez de redémarrer votre appareil avec l'interrupteur d'alimentation sur le côté pour montrer que ce code est appelé à chaque redémarrage de l'appareil.
|
||||
|
||||
## Approfondissement des ordinateurs monocartes
|
||||
|
||||
Dans la dernière leçon, nous avons présenté les ordinateurs monocartes. Nous allons maintenant les étudier plus en détail.
|
||||
|
||||
### Raspberry Pi
|
||||
|
||||
|
||||
|
||||
La [Raspberry Pi Foundation](https://www.raspberrypi.org) est une organisation caritative britannique fondée en 2009 pour promouvoir l'étude de l'informatique, en particulier dans les écoles. Dans le cadre de cette mission, elle a développé un ordinateur monocarte, appelé Raspberry Pi. Les Raspberry Pis sont actuellement disponibles en trois variantes : une version pleine grandeur, le Pi Zero, plus petit, et un module de calcul qui peut être intégré dans votre appareil IoT final.
|
||||
|
||||
|
||||
|
||||
La dernière itération du Raspberry Pi grandeur nature est le Raspberry Pi 4B. Il dispose d'un processeur quadricœur (4 cœurs) cadencé à 1,5 GHz, de 2, 4 ou 8 Go de RAM, d'un réseau Ethernet gigabit, du WiFi, de 2 ports HDMI supportant les écrans 4k, d'un port de sortie audio et vidéo composite, de ports USB (2 USB 2.0, 2 USB 3.0), de 40 broches GPIO, d'un connecteur pour un module caméra Raspberry Pi, et d'un emplacement pour carte SD. Le tout sur une carte de 88 mm x 58 mm x 19,5 mm, alimentée par une alimentation USB-C de 3A. Ces cartes sont proposées à partir de 35 dollars, bien moins chères qu'un PC ou un Mac.
|
||||
|
||||
> 💁 Il existe également un ordinateur tout-en-un Pi400 avec un Pi4 intégré dans un clavier.
|
||||
|
||||
|
||||
|
||||
Le Pi Zero est beaucoup plus petit et moins puissant. Il dispose d'un processeur à cœur unique de 1 GHz, de 512 Mo de RAM, du WiFi (dans le modèle Zero W), d'un port HDMI unique, d'un port micro-USB, de 40 broches GPIO, d'un connecteur pour un module caméra Raspberry Pi et d'un emplacement pour carte SD. Il mesure 65 mm x 30 mm x 5 mm et consomme très peu d'énergie. Le Zero coûte 5 dollars, la version W avec WiFi 10 dollars.
|
||||
|
||||
> 🎓 Les processeurs de ces deux appareils sont des processeurs ARM, par opposition aux processeurs Intel/AMD x86 ou x64 que l'on trouve dans la plupart des PC et des Mac. Ces processeurs sont similaires à ceux que l'on trouve dans certains microcontrôleurs, ainsi que dans presque tous les téléphones portables, la Surface X de Microsoft et les nouveaux Mac d'Apple basés sur le silicium.
|
||||
|
||||
Toutes les variantes du Raspberry Pi utilisent une version de Debian Linux appelée Raspberry Pi OS. Cette version est disponible en version allégée sans bureau, ce qui est parfait pour les projets 'headless' où vous n'avez pas besoin d'écran, ou en version complète avec un environnement de bureau complet, avec un navigateur web, des applications de bureau, des outils de codage et des jeux. Le système d'exploitation étant une version de Debian Linux, vous pouvez installer n'importe quelle application ou outil fonctionnant sous Debian et conçu pour le processeur ARM du Pi.
|
||||
|
||||
#### Tâche
|
||||
|
||||
Étudiez le Raspberry Pi.
|
||||
|
||||
Si vous utilisez un Raspberry Pi pour ces leçons, renseignez-vous sur les différents composants matériels de la carte.
|
||||
|
||||
* Vous pouvez trouver des détails sur les processeurs utilisés sur la [page de documentation sur le matériel du Raspberry Pi](https://www.raspberrypi.org/documentation/hardware/raspberrypi/). Renseignez-vous sur le processeur utilisé dans le Pi que vous utilisez.
|
||||
* Localisez les broches GPIO. Pour en savoir plus, consultez la [documentation GPIO du Raspberry Pi](https://www.raspberrypi.org/documentation/hardware/raspberrypi/gpio/README.md). Utilisez le [Guide d'utilisation des broches GPIO](https://www.raspberrypi.org/documentation/usage/gpio/README.md) pour identifier les différentes broches de votre Pi.
|
||||
|
||||
### Programmation d'ordinateurs monocartes
|
||||
|
||||
Les ordinateurs monocartes sont des ordinateurs à part entière, dotés d'un système d'exploitation complet. Cela signifie qu'il existe un large éventail de langages de programmation, de cadres et d'outils que vous pouvez utiliser pour les coder, contrairement aux microcontrôleurs qui dépendent de la prise en charge de la carte dans des cadres tels qu'Arduino. La plupart des langages de programmation disposent de bibliothèques qui peuvent accéder aux broches GPIO pour envoyer et recevoir des données de capteurs et d'actionneurs.
|
||||
|
||||
✅ Quels sont les langages de programmation qui vous sont familiers? Sont-ils pris en charge par Linux?
|
||||
|
||||
Le langage de programmation le plus courant pour créer des applications IoT sur un Raspberry Pi est Python. Il existe un vaste écosystème de matériel conçu pour le Pi, et presque tous incluent le code nécessaire à leur utilisation sous forme de bibliothèques Python. Certains de ces écosystèmes sont basés sur des `chapeaux` (ou `hat` en anglais), ainsi appelés parce qu'ils se placent sur le Pi comme un chapeau et se connectent aux 40 broches GPIO à l'aide d'une grande prise. Ces chapeaux offrent des fonctionnalités supplémentaires, telles que des écrans, des capteurs, des voitures télécommandées ou des adaptateurs permettant de brancher des capteurs à l'aide de câbles standardisés.
|
||||
|
||||
### Utilisation d'ordinateurs monocartes dans les déploiements professionnels de l'IoT
|
||||
|
||||
Les ordinateurs monocartes sont utilisés pour les déploiements IoT professionnels, et pas seulement comme kits de développement. Ils peuvent constituer un moyen puissant de contrôler le matériel et d'exécuter des tâches complexes telles que l'exécution de modèles d'apprentissage automatique. Par exemple, il existe un [module de calcul Raspberry Pi 4 ](https://www.raspberrypi.org/blog/raspberry-pi-compute-module-4/) qui offre toute la puissance d'un Raspberry Pi 4, mais dans un format compact et moins cher, sans la plupart des ports, conçu pour être installé dans du matériel personnalisé.
|
||||
|
||||
---
|
||||
|
||||
## 🚀 Défi
|
||||
|
||||
Le défi de la dernière leçon consistait à dresser une liste du plus grand nombre possible d'appareils IoT présents chez vous, à l'école ou sur votre lieu de travail. Pour chaque appareil de cette liste, pensez-vous qu'ils sont construits autour de microcontrôleurs ou d'ordinateurs monocartes, ou même d'un mélange des deux ?
|
||||
|
||||
## Quiz de validation des connaissances
|
||||
|
||||
[Quiz de validation des connaissances](https://black-meadow-040d15503.1.azurestaticapps.net/quiz/4)
|
||||
|
||||
## Révision et auto-apprentissage
|
||||
|
||||
* Lire le [Guide de démarrage Arduino](https://www.arduino.cc/en/Guide/Introduction) pour en savoir plus sur la plateforme Arduino.
|
||||
* Lire [l'introduction au Raspberry Pi 4](https://www.raspberrypi.org/products/raspberry-pi-4-model-b/) pour en savoir plus sur les Raspberry Pis.
|
||||
* Apprenez-en plus sur certains concepts et acronymes dans l'article [What the FAQ are CPUs, MPUs, MCUs, and GPUs article in the Electrical Engineering Journal](https://www.eejournal.com/article/what-the-faq-are-cpus-mpus-mcus-and-gpus/).
|
||||
|
||||
✅ Utilisez ces guides, ainsi que les coûts indiqués en suivant les liens dans le [guide du matériel](../../../../hardware.md) pour décider de la plate-forme matérielle que vous souhaitez utiliser, ou si vous préférez utiliser un dispositif virtuel.
|
||||
|
||||
## Affectation
|
||||
|
||||
[Comparez les microcontrôleurs et les ordinateurs monocartes](assignment.fr.md)
|
||||
@ -0,0 +1,217 @@
|
||||
# Interagir avec le monde physique à l'aide de capteurs et d'actionneurs
|
||||
|
||||
|
||||
|
||||
> Sketchnote de [Nitya Narasimhan](https://github.com/nitya). Cliquez sur l'image pour l'agrandir.
|
||||
|
||||
Cette leçon a été enseignée dans le cadre de la [série Hello IoT](https://youtube.com/playlist?list=PLmsFUfdnGr3xRts0TIwyaHyQuHaNQcb6-) du [Microsoft Reactor](https://developer.microsoft.com/reactor/?WT.mc_id=academic-17441-jabenn). La leçon a été enseignée sous forme de deux vidéos - une leçon d'une heure et une heure de bureau pour approfondir certaines parties de la leçon et répondre aux questions.
|
||||
|
||||
[](https://youtu.be/Lqalu1v6aF4)
|
||||
|
||||
[](https://youtu.be/qR3ekcMlLWA)
|
||||
|
||||
> 🎥 Cliquez sur les images ci-dessus pour visionner les vidéos
|
||||
|
||||
## Quiz préalable
|
||||
|
||||
[Quiz préalable](https://black-meadow-040d15503.1.azurestaticapps.net/quiz/5)
|
||||
|
||||
## Introduction
|
||||
|
||||
Cette leçon présente deux concepts importants pour votre appareil IoT : les capteurs et les actionneurs. Vous en ferez une prise en main en ajoutant un capteur de lumière à votre projet IoT, puis en ajoutant une LED contrôlée par les niveaux de lumière, ce qui vous permettra de développer une veilleuse.
|
||||
|
||||
Dans cette leçon, nous aborderons les points suivants
|
||||
|
||||
* [Qu'est-ce qu'un capteur?](#quest-ce-quun-capteur)
|
||||
* [Utiliser un capteur](#utiliser-un-capteur)
|
||||
* [Les types de capteurs](#les-types-de-capteurs)
|
||||
* [Qu'est-ce que les actionneurs?](#quest-ce-que-les-actionneurs)
|
||||
* [Utiliser un actionneur](#utiliser-un-actionneur)
|
||||
* [Les types d'actionneurs](#les-types-dactionneurs)
|
||||
|
||||
## Qu'est-ce qu'un capteur?
|
||||
|
||||
Les capteurs sont des dispositifs matériels qui détectent le monde physique, c'est-à-dire qu'ils mesurent une ou plusieurs propriétés autour d'eux et envoient l'information à un dispositif IoT. Les capteurs couvrent une vaste gamme d'appareils car il y a beaucoup de choses qui peuvent être mesurées, des propriétés naturelles telles que la température de l'air aux interactions physiques telles que le mouvement.
|
||||
|
||||
Les capteurs les plus courants sont les suivants :
|
||||
|
||||
* Capteurs de température - ils détectent la température de l'air ou la température de ce dans quoi ils sont immergés. Pour les amateurs et les développeurs, ces capteurs sont souvent combinés avec la pression atmosphérique et l'humidité dans un seul capteur.
|
||||
* Boutons - ils détectent le moment où ils ont été pressés.
|
||||
* Capteurs de lumière : ils détectent les niveaux de lumière et peuvent concerner des couleurs spécifiques, la lumière UV, la lumière IR ou la lumière visible en général.
|
||||
* Les caméras : elles détectent une représentation visuelle du monde en prenant une photo ou en diffusant une vidéo.
|
||||
* Accéléromètres : ils détectent les mouvements dans plusieurs directions.
|
||||
* Microphones - ils détectent les sons, qu'il s'agisse de niveaux sonores généraux ou de sons directionnels.
|
||||
|
||||
✅ Faites des recherches. Quels sont les capteurs de votre téléphone ?
|
||||
|
||||
Tous les capteurs ont un point commun : ils convertissent ce qu'ils détectent en un signal électrique qui peut être interprété par un appareil IoT. La manière dont ce signal électrique est interprété dépend du capteur, ainsi que du protocole de communication utilisé pour communiquer avec l'appareil IoT.
|
||||
|
||||
## Utiliser un capteur
|
||||
|
||||
Suivez le guide approprié ci-dessous pour ajouter un capteur à votre appareil IoT :
|
||||
|
||||
* [Arduino - Terminal Wio](wio-terminal-sensor.fr.md)
|
||||
* [Ordinateur monocarte - Raspberry Pi](pi-sensor.fr.md)
|
||||
* [Ordinateur monocarte - Dispositif virtuel](virtual-device-sensor.fr.md)
|
||||
|
||||
## Les types de capteurs
|
||||
|
||||
Les capteurs sont soit analogiques, soit numériques.
|
||||
|
||||
### Capteurs analogiques
|
||||
|
||||
Les capteurs analogiques comptent parmi les capteurs les plus élémentaires. Ces capteurs reçoivent une tension de l'appareil IoT, les composants du capteur ajustent cette tension et la tension renvoyée par le capteur est mesurée pour donner la valeur du capteur.
|
||||
|
||||
> 🎓 La tension ("Voltage" en anglais) est une mesure de la force exercée pour déplacer l'électricité d'un endroit à un autre, par exemple de la borne positive d'une pile à la borne négative. Par exemple, une pile AA standard a une tension de 1,5V (V est le symbole des volts) et peut pousser l'électricité avec une force de 1,5V de sa borne positive à sa borne négative. Par exemple, une LED peut s'allumer avec une tension de 2 à 3V, alors qu'une ampoule à filament de 100W nécessite une tension de 240V. Pour en savoir plus sur la tension, consultez la [page sur la tension sur Wikipédia](https://wikipedia.org/wiki/Voltage).
|
||||
|
||||
Le potentiomètre en est un exemple. Il s'agit d'un cadran que l'on peut faire tourner entre deux positions et dont le capteur mesure la rotation.
|
||||
|
||||
.
|
||||
|
||||
L'appareil IoT envoie un signal électrique au potentiomètre à une tension, par exemple 5 volts (5V). Lorsque le potentiomètre est ajusté, il modifie la tension qui sort de l'autre côté. Imaginez que vous ayez un potentiomètre étiqueté comme un cadran qui va de 0 à [11](https://wikipedia.org/wiki/Up_to_eleven), comme le bouton de volume d'un amplificateur. Lorsque le potentiomètre est en position complètement désactivée (0), 0V (0 volt) sort. Lorsqu'il est en position d'activation totale (11), 5V (5 volts) sont émis.
|
||||
|
||||
> 🎓 Il s'agit d'une simplification excessive, et vous pouvez en savoir plus sur les potentiomètres et les résistances variables sur la [page Wikipédia sur les potentiomètres](https://wikipedia.org/wiki/Potentiometer).
|
||||
|
||||
La tension qui sort du capteur est alors lue par l'appareil IoT, qui peut alors y répondre. Selon le capteur, cette tension peut être une valeur arbitraire ou correspondre à une unité standard. Par exemple, un capteur de température analogique basé sur une [thermistance](https://wikipedia.org/wiki/Thermistor) modifie sa résistance en fonction de la température. La tension de sortie peut alors être convertie en température en Kelvin, et donc en °C ou °F, par des calculs en code.
|
||||
|
||||
✅ Que pensez-vous qu'il se passe si le capteur renvoie une tension plus élevée que celle qui a été envoyée (par exemple en provenance d'une alimentation externe)? ⛔️ NE TESTEZ PAS cela.
|
||||
|
||||
#### Conversion analogique-numérique (CAN)
|
||||
|
||||
Les appareils IoT sont numériques - ils ne peuvent pas fonctionner avec des valeurs analogiques, ils ne fonctionnent qu'avec des 0 et des 1. Cela signifie que les valeurs analogiques des capteurs doivent être converties en un signal numérique avant de pouvoir être traitées. De nombreux appareils IoT sont équipés de convertisseurs analogique-numérique (CAN) (ou analog-to-digital converters abrégé en "ADC" en anglais) pour convertir les entrées analogiques en représentations numériques de leur valeur. Les capteurs peuvent également fonctionner avec des convertisseurs analogiques-numériques par l'intermédiaire d'une carte de connexion. Par exemple, dans l'écosystème Seeed Grove avec un Raspberry Pi, les capteurs analogiques se connectent à des ports spécifiques sur un 'chapeau' ('hat' en anglais) qui se trouve sur le Pi connecté aux broches GPIO du Pi, et ce chapeau a un CAN pour convertir la tension en un signal numérique qui peut être envoyé hors des broches GPIO du Pi.
|
||||
|
||||
Imaginez que vous ayez un capteur de lumière analogique connecté à un dispositif IoT qui utilise 3,3V et renvoie une valeur de 1V. Cette valeur de 1V ne signifie rien dans le monde numérique et doit donc être convertie. La tension sera convertie en valeur analogique à l'aide d'une échelle qui dépend de l'appareil et du capteur. Le capteur de lumière Seeed Grove, par exemple, émet des valeurs comprises entre 0 et 1023. Pour ce capteur fonctionnant à 3,3V, une sortie de 1V correspondrait à une valeur de 300. Un appareil IoT ne peut pas traiter 300 comme une valeur analogique, donc la valeur serait convertie en `0000000100101100`, la représentation binaire de 300 par le chapeau Grove. Cette valeur serait ensuite traitée par l'appareil IoT.
|
||||
|
||||
✅ Si vous ne connaissez pas le binaire, faites quelques recherches pour apprendre comment les nombres sont représentés par des 0 et des 1. La [leçon d'introduction au binaire de BBC Bitesize](https://www.bbc.co.uk/bitesize/guides/zwsbwmn/revision/1) est un excellent point de départ.
|
||||
|
||||
Du point de vue du codage, tout cela est généralement géré par les bibliothèques fournies avec les capteurs, de sorte que vous n'avez pas à vous préoccuper de cette conversion vous-même. Pour le capteur de lumière Grove, vous devez utiliser la bibliothèque Python et appeler la propriété `light`, ou utiliser la bibliothèque Arduino et appeler `analogRead` pour obtenir une valeur de 300.
|
||||
|
||||
### Capteurs numériques
|
||||
|
||||
Les capteurs numériques, comme les capteurs analogiques, détectent le monde qui les entoure en utilisant les changements de tension électrique. La différence est qu'ils émettent un signal numérique, soit en mesurant seulement deux états, soit en utilisant un CAN intégré. Les capteurs numériques sont de plus en plus courants pour éviter d'avoir à utiliser un CAN, que ce soit sur une carte de connexion ou sur l'appareil IoT lui-même.
|
||||
|
||||
Le capteur numérique le plus simple est un bouton ou un interrupteur. Il s'agit d'un capteur à deux états, marche ou arrêt.
|
||||
|
||||
|
||||
|
||||
Les broches des appareils IoT, telles que les broches GPIO, peuvent mesurer ce signal directement sous la forme d'un 0 ou d'un 1. Si la tension envoyée est la même que la tension renvoyée, la valeur lue est 1, sinon la valeur lue est 0. Il n'est pas nécessaire de convertir le signal, il ne peut être que 1 ou 0.
|
||||
|
||||
> 💁 Les tensions ne sont jamais exactes, en particulier parce que les composants d'un capteur ont une certaine résistance, et il y a donc généralement une tolérance. Par exemple, les broches GPIO d'un Raspberry Pi fonctionnent sur 3,3V et lisent un signal de retour supérieur à 1,8V comme un 1, inférieur à 1,8 V comme un 0.
|
||||
|
||||
* 3,3V entrent dans le bouton. Le bouton étant éteint, 0V en sort, ce qui donne une valeur de 0
|
||||
* 3,3V entrent dans le bouton. Le bouton est allumé, donc 3,3V sort, ce qui donne une valeur de 1
|
||||
|
||||
Les capteurs numériques plus avancés lisent les valeurs analogiques, puis les convertissent en signaux numériques à l'aide de convertisseurs analogiques/numériques embarqués. Par exemple, un capteur de température numérique utilise toujours un thermocouple de la même manière qu'un capteur analogique et mesure toujours la variation de tension causée par la résistance du thermocouple à la température actuelle. Au lieu de renvoyer une valeur analogique et de compter sur l'appareil ou la carte de connexion pour la convertir en un signal numérique, un CAN intégré au capteur convertira la valeur et l'enverra sous la forme d'une série de 0 et de 1 à l'appareil IoT. Ces 0 et 1 sont envoyés de la même manière que le signal numérique d'un bouton, 1 étant la pleine tension et 0 étant 0v.
|
||||
|
||||
|
||||
|
||||
L'envoi de données numériques permet aux capteurs de devenir plus complexes et d'envoyer des données plus détaillées, voire des données cryptées pour les capteurs sécurisés. L'appareil photo en est un exemple. Il s'agit d'un capteur qui capture une image et l'envoie sous forme de données numériques contenant cette image, généralement dans un format compressé tel que JPEG, pour qu'elle soit lue par l'appareil IoT. Il peut même diffuser de la vidéo en capturant des images et en envoyant soit l'image complète image par image, soit un flux vidéo compressé.
|
||||
|
||||
## Qu'est-ce que les actionneurs?
|
||||
|
||||
Les actionneurs sont l'opposé des capteurs : ils convertissent un signal électrique provenant de votre appareil IoT en une interaction avec le monde physique, par exemple en émettant une lumière ou un son, ou en faisant bouger un moteur.
|
||||
|
||||
Les actionneurs les plus courants sont les suivants
|
||||
|
||||
* LED - elles émettent de la lumière lorsqu'elles sont allumées.
|
||||
* Haut-parleur : il émet un son en fonction du signal qui lui est envoyé, qu'il s'agisse d'un simple buzzer ou d'un haut-parleur audio capable de diffuser de la musique.
|
||||
* Moteur pas à pas : il convertit un signal en une quantité définie de rotation, par exemple en tournant un cadran de 90°.
|
||||
* Relais : il s'agit d'interrupteurs qui peuvent être activés ou désactivés par un signal électrique. Ils permettent à une petite tension provenant d'un appareil IoT d'activer des tensions plus importantes.
|
||||
* Écrans - il s'agit d'actionneurs plus complexes qui affichent des informations sur un écran à segments multiples. Les écrans varient d'un simple affichage LED à des moniteurs vidéo haute résolution.
|
||||
|
||||
✅ Faites des recherches. Quels sont les actionneurs de votre téléphone ?
|
||||
|
||||
## Utiliser un actionneur
|
||||
|
||||
Suivez le guide ci-dessous pour ajouter un actionneur à votre appareil IoT, contrôlé par le capteur, afin de créer une veilleuse IoT. Elle recueillera les niveaux de lumière du capteur de lumière et utilisera un actionneur sous la forme d'une LED pour émettre de la lumière lorsque le niveau de lumière détecté est trop faible.
|
||||
|
||||
|
||||
|
||||
* [Arduino - Terminal Wio](wio-terminal-actuator.fr.md)
|
||||
* [Ordinateur monocarte - Raspberry Pi](pi-actuator.fr.md)
|
||||
* [Ordinateur monocarte - Dispositif virtuel](virtual-device-actuator.fr.md)
|
||||
|
||||
## Les types d'actionneurs
|
||||
|
||||
Comme les capteurs, les actionneurs sont soit analogiques, soit numériques.
|
||||
|
||||
### Actionneurs analogiques
|
||||
|
||||
Les actionneurs analogiques prennent un signal analogique et le convertissent en une sorte d'interaction, où l'interaction change en fonction de la tension fournie.
|
||||
|
||||
Un exemple est celui d'une lampe à intensité variable, comme celles que vous avez peut-être dans votre maison. La quantité de tension fournie à la lampe détermine sa luminosité.
|
||||
|
||||
|
||||
|
||||
Comme pour les capteurs, l'appareil IoT proprement dit fonctionne avec des signaux numériques et non analogiques. Cela signifie que pour envoyer un signal analogique, l'appareil IoT a besoin d'un convertisseur numérique-analogique (CNA), soit directement sur l'appareil IoT, soit sur une carte de connexion. Cela convertira les 0 et les 1 de l'appareil IoT en une tension analogique que l'actionneur peut utiliser.
|
||||
|
||||
✅ À votre avis, que se passe-t-il si l'appareil IoT envoie une tension plus élevée que celle que l'actionneur peut gérer ?
|
||||
⛔️ NE PAS tester cela.
|
||||
|
||||
#### Modulation de largeur d'impulsion (ou Pulse-Width Modulation en anglais abrégé en PWM)
|
||||
|
||||
Une autre option pour convertir les signaux numériques d'un appareil IoT en un signal analogique est la modulation de largeur d'impulsion. Il s'agit d'envoyer de nombreuses impulsions numériques courtes qui agissent comme s'il s'agissait d'un signal analogique.
|
||||
|
||||
Par exemple, vous pouvez utiliser la modulation de largeur d'impulsion pour contrôler la vitesse d'un moteur.
|
||||
|
||||
Imaginez que vous contrôliez un moteur avec une alimentation de 5V. Vous envoyez une brève impulsion à votre moteur, en faisant passer la tension à un niveau élevé (5V) pendant deux centièmes de seconde (0,02s). Pendant ce temps, votre moteur peut effectuer un dixième de tour, soit 36°. Le signal s'interrompt ensuite pendant deux centièmes de seconde (0,02 s), envoyant un signal bas (0V). Chaque cycle de marche puis d'arrêt dure 0,04s. Le cycle se répète ensuite.
|
||||
|
||||
|
||||
|
||||
Cela signifie qu'en une seconde, 25 impulsions de 5V de 0,02s font tourner le moteur, chacune étant suivie d'une pause de 0V de 0,02s qui ne fait pas tourner le moteur. Chaque impulsion fait tourner le moteur d'un dixième de tour, ce qui signifie que le moteur effectue 2,5 rotations par seconde. Vous avez utilisé un signal numérique pour faire tourner le moteur à 2,5 tours par seconde, soit 150 [tours par minute](https://wikipedia.org/wiki/Revolutions_per_minute) (une mesure non standard de la vitesse de rotation).
|
||||
|
||||
```sortie
|
||||
25 pulses per second x 0.1 rotations per pulse = 2.5 rotations per second
|
||||
2.5 rotations per second x 60 seconds in a minute = 150rpm
|
||||
```
|
||||
|
||||
> 🎓 Lorsqu'un signal PWM est activé pendant la moitié du temps et désactivé pendant l'autre moitié, on parle d'un [cycle de service de 50 %](https://wikipedia.org/wiki/Duty_cycle). Les rapports cycliques sont mesurés en pourcentage du temps pendant lequel le signal est activé par rapport au temps pendant lequel il est désactivé.
|
||||
|
||||
|
||||
|
||||
Vous pouvez modifier la vitesse du moteur en changeant la taille des impulsions. Par exemple, avec le même moteur, vous pouvez conserver le même temps de cycle de 0,04 s, en réduisant de moitié l'impulsion de marche à 0,01 s et en augmentant l'impulsion d'arrêt à 0,03 s. Vous avez le même nombre d'impulsions par seconde (25), mais chaque impulsion de marche est réduite de moitié. Vous avez le même nombre d'impulsions par seconde (25), mais chaque impulsion de marche est deux fois moins longue. Une impulsion de demi-longueur ne fait tourner le moteur que d'un vingtième de tour, et à 25 impulsions par seconde, le moteur effectue 1,25 rotation par seconde, soit 75 tours par minute. En modifiant la vitesse d'impulsion d'un signal numérique, vous avez réduit de moitié la vitesse d'un moteur analogique.
|
||||
|
||||
```sortie
|
||||
25 pulses per second x 0.05 rotations per pulse = 1.25 rotations per second
|
||||
1.25 rotations per second x 60 seconds in a minute = 75rpm
|
||||
```
|
||||
|
||||
✅ Comment assurer la fluidité de la rotation du moteur, en particulier à faible vitesse ? Utilisez-vous un petit nombre d'impulsions longues avec de longues pauses ou un grand nombre d'impulsions très courtes avec de très courtes pauses?
|
||||
|
||||
> 💁 Certains capteurs utilisent également le PWM pour convertir les signaux analogiques en signaux numériques.
|
||||
|
||||
> 🎓 Pour en savoir plus sur la modulation de largeur d'impulsion, consultez la page consacrée à [la modulation de largeur d'impulsion sur Wikipédia](https://wikipedia.org/wiki/Pulse-width_modulation).
|
||||
|
||||
### Actionneurs numériques
|
||||
|
||||
Les actionneurs numériques, comme les capteurs numériques, ont soit deux états contrôlés par une tension haute ou basse, soit un convertisseur numérique-analogique intégré qui permet de convertir un signal numérique en un signal analogique.
|
||||
|
||||
Un actionneur numérique simple est une LED. Lorsqu'un dispositif envoie un signal numérique de 1, une haute tension est envoyée et allume la LED. Lorsqu'un signal numérique de 0 est envoyé, la tension chute à 0V et la LED s'éteint.
|
||||
|
||||
|
||||
|
||||
✅ À quels autres actionneurs simples à deux états pouvez-vous penser ? Un exemple est le solénoïde, qui est un électro-aimant qui peut être activé pour faire des choses comme déplacer un pêne de porte qui verrouille/déverrouille une porte.
|
||||
|
||||
Les actionneurs numériques plus avancés, tels que les écrans, exigent que les données numériques soient envoyées dans certains formats. Ils sont généralement livrés avec des bibliothèques qui facilitent l'envoi des données correctes pour les contrôler.
|
||||
|
||||
---
|
||||
|
||||
## 🚀 Challenge
|
||||
|
||||
Le défi des deux dernières leçons consistait à dresser la liste du plus grand nombre possible d'appareils IoT présents chez vous, à l'école ou sur votre lieu de travail, et de déterminer s'ils sont construits autour de microcontrôleurs ou d'ordinateurs monocartes, ou même d'un mélange des deux.
|
||||
|
||||
Pour chaque appareil que vous avez répertorié, à quels capteurs et actionneurs sont-ils connectés? Quelle est l'utilité de chaque capteur et actionneur connecté à ces dispositifs?
|
||||
|
||||
## Quiz de validation des connaissances
|
||||
|
||||
[Quiz de validation des connaissances](https://black-meadow-040d15503.1.azurestaticapps.net/quiz/6)
|
||||
|
||||
## Révision et auto-apprentissage
|
||||
|
||||
* En apprendre plus sur l'électricité et les circuits sur [ThingLearn](http://thinglearn.jenlooper.com/curriculum/).
|
||||
* Pour en savoir plus sur les différents types de capteurs de température, consultez le [guide des capteurs de température de Seeed Studios](https://www.seeedstudio.com/blog/2019/10/14/temperature-sensors-for-arduino-projects/)
|
||||
* Pour en savoir plus sur les LED, consultez [la page LED de Wikipédia](https://wikipedia.org/wiki/Light-emitting_diode)
|
||||
|
||||
## Affectation
|
||||
|
||||
[Recherche sur les capteurs et les actionneurs](assignment.fr.md)
|
||||
@ -0,0 +1,17 @@
|
||||
# Recherche sur les capteurs et actionneurs
|
||||
|
||||
## Instructions
|
||||
|
||||
Cette leçon a porté sur les capteurs et les actionneurs. Recherchez et décrivez un capteur et un actionneur pouvant être utilisés avec un kit de développement IoT :
|
||||
|
||||
* Sa fonction
|
||||
* L'électronique/le matériel utilisé à l'intérieur
|
||||
* Est-il analogique ou numérique ?
|
||||
* Quelles sont les unités et la gamme d'entrées ou de mesures?
|
||||
|
||||
## Rubrique
|
||||
|
||||
| Critères | Exemplaire | Adéquat | Besoin d'amélioration |
|
||||
| -------- | --------- | -------- | ----------------- |
|
||||
| Décrire un capteur | Décrire un capteur en détaillant les 4 sections énumérées ci-dessus. | Avoir pu décrire un capteur, mais n'avoir pu fournir que 2 ou 3 des sections ci-dessus. | Avoir pu décrire un capteur, mais n'avoir pu fournir qu'une seule des sections ci-dessus. |
|
||||
| Décrire un actionneur | Description d'un actionneur comprenant des détails pour les 4 sections énumérées ci-dessus. | Avoir décrit un actionneur, mais n'avoir pu fournir que 2 ou 3 des sections ci-dessus. | Avoir décrit un actionneur, mais n'avoir pu fournir qu'une seule des sections ci-dessus. |
|
||||
@ -0,0 +1,116 @@
|
||||
# Créer une veilleuse - Raspberry Pi
|
||||
|
||||
Dans cette partie de la leçon, vous allez ajouter une LED à votre Raspberry Pi et l'utiliser pour créer une veilleuse.
|
||||
|
||||
## Matériel
|
||||
|
||||
La veilleuse a maintenant besoin d'un actionneur.
|
||||
|
||||
L'actionneur est une **LED**, une [diode électroluminescente](https://wikipedia.org/wiki/Light-emitting_diode) qui émet de la lumière lorsqu'elle est traversée par un courant. Il s'agit d'un actionneur numérique qui a deux états, marche et arrêt (`on` et `off` en anglais). L'envoi d'une valeur de 1 allume la LED et celle de 0 l'éteint. La LED est un actionneur Grove externe et doit être connectée au chapeau Grove Base du Raspberry Pi.
|
||||
|
||||
La logique de la veilleuse en pseudo-code est la suivante :
|
||||
|
||||
```sortie
|
||||
Vérifier le niveau de lumière.
|
||||
Si la lumière est inférieure à 300
|
||||
Allumer la LED
|
||||
Sinon
|
||||
Eteindre la LED
|
||||
```
|
||||
|
||||
### Connecter la LED
|
||||
|
||||
Le Grove LED se présente sous la forme d'un module avec une sélection de LED, ce qui vous permet de choisir la couleur.
|
||||
|
||||
#### Tâche - connecter la LED
|
||||
|
||||
Connectez la LED.
|
||||
|
||||
|
||||
|
||||
1. Choisissez votre LED préférée et insérez les pattes dans les deux trous du module LED.
|
||||
|
||||
Les LEDs sont des diodes électroluminescentes, et les diodes sont des dispositifs électroniques qui ne peuvent transporter le courant que dans un sens. Cela signifie que la LED doit être connectée dans le bon sens, sinon elle ne fonctionnera pas.
|
||||
|
||||
L'une des pattes de la LED est la broche positive, l'autre est la broche négative. La LED n'est pas parfaitement ronde et est légèrement plus plate d'un côté. Le côté légèrement plus plat est la broche négative. Lorsque vous connectez la LED au module, assurez-vous que la broche du côté arrondi est connectée à la prise marquée **+** à l'extérieur du module, et que le côté plus plat est connecté à la prise plus proche du milieu du module.
|
||||
|
||||
1. Le module LED est doté d'un bouton rotatif qui vous permet de contrôler la luminosité. Pour commencer, réglez-le à fond en le tournant dans le sens inverse des aiguilles d'une montre jusqu'à la butée à l'aide d'un petit tournevis cruciforme.
|
||||
|
||||
1. Insérez l'une des extrémités d'un câble Grove dans la prise du module LED. Il ne peut être inséré que dans un seul sens.
|
||||
|
||||
1. Le Raspberry Pi étant hors tension, connectez l'autre extrémité du câble Grove à la prise numérique marquée **D5** sur le chapeau de base Grove attaché au Pi. Cette prise est la deuxième en partant de la gauche, sur la rangée de prises à côté des broches GPIO.
|
||||
|
||||
|
||||
|
||||
## Programmer la veilleuse
|
||||
|
||||
La veilleuse peut maintenant être programmée à l'aide du capteur de lumière Grove et de la LED Grove.
|
||||
|
||||
### Tâche - programmer la veilleuse
|
||||
|
||||
Programmez la veilleuse.
|
||||
|
||||
1. Allumez le Pi et attendez qu'il démarre
|
||||
|
||||
1. Ouvrez le projet nightlight que vous avez créé dans la partie précédente de ce travail dans VS Code, soit en l'exécutant directement sur le Pi, soit en le connectant à l'aide de l'extension Remote SSH.
|
||||
|
||||
1. Ajoutez le code suivant au fichier `app.py` pour vous connecter à l'importation d'une bibliothèque requise. Il doit être ajouté en haut, en dessous des autres lignes `import`.
|
||||
|
||||
```python
|
||||
from grove.grove_led import GroveLed
|
||||
```
|
||||
|
||||
L'instruction `from grove.grove_led import GroveLed` importe la bibliothèque `GroveLed` des bibliothèques Grove Python. Cette bibliothèque contient du code pour interagir avec une LED Grove.
|
||||
|
||||
1. Ajoutez le code suivant après la déclaration `light_sensor` pour créer une instance de la classe qui gère la LED :
|
||||
|
||||
```python
|
||||
led = GroveLed(5)
|
||||
```
|
||||
|
||||
La ligne `led = GroveLed(5)` crée une instance de la classe `GroveLed` qui se connecte à la broche **D5** - la broche digitale Grove à laquelle la LED est connectée.
|
||||
|
||||
> 💁 Toutes les prises ont des numéros de broches uniques. Les broches 0, 2, 4 et 6 sont des broches analogiques, les broches 5, 16, 18, 22, 24 et 26 sont des broches numériques.
|
||||
|
||||
1. Ajoutez une vérification à l'intérieur de la boucle `while`, et avant le `time.sleep` pour vérifier les niveaux de lumière et allumer ou éteindre la LED :
|
||||
|
||||
```python
|
||||
if light < 300:
|
||||
led.on()
|
||||
else:
|
||||
led.off()
|
||||
```
|
||||
|
||||
Ce code vérifie la valeur de `light`. Si elle est inférieure à 300, il appelle la méthode `on` de la classe `GroveLed` qui envoie une valeur numérique de 1 à la LED, l'allumant ainsi. Si la valeur de la lumière est supérieure ou égale à 300, il appelle la méthode `off`, qui envoie une valeur numérique de 0 à la LED, pour l'éteindre.
|
||||
|
||||
> 💁 Ce code doit être indenté au même niveau que la ligne `print('Light level:', light)` pour être à l'intérieur de la boucle while !
|
||||
|
||||
> 💁 Lors de l'envoi de valeurs numériques à des actionneurs, une valeur 0 correspond à 0V, et une valeur 1 correspond à la tension maximale de l'appareil. Pour le Raspberry Pi avec les capteurs et actionneurs Grove, la tension 1 est de 3,3V.
|
||||
|
||||
1. Depuis le terminal VS Code, exécutez ce qui suit pour lancer votre application Python :
|
||||
|
||||
```sh
|
||||
python3 app.py
|
||||
```
|
||||
|
||||
Les valeurs de lumière seront affichées dans la console.
|
||||
|
||||
```output
|
||||
pi@raspberrypi:~/nightlight $ python3 app.py
|
||||
Light level: 634
|
||||
Light level: 634
|
||||
Light level: 634
|
||||
Light level: 230
|
||||
Light level: 104
|
||||
Light level: 290
|
||||
```
|
||||
|
||||
1. Couvrez et découvrez le capteur de lumière. Remarquez que la LED s'allume si le niveau de lumière est inférieur ou égal à 300, et s'éteint lorsque le niveau de lumière est supérieur à 300.
|
||||
|
||||
> 💁 Si la LED ne s'allume pas, assurez-vous qu'elle est connectée dans le bon sens et que le bouton de rotation est réglé sur "full on".
|
||||
|
||||
|
||||
|
||||
> 💁 Vous trouverez ce code dans le dossier [code-actuator/pi](../code-actuator/pi).
|
||||
|
||||
😀 Votre programme de veilleuse est un succès!
|
||||
@ -0,0 +1,96 @@
|
||||
# Construire une veilleuse - Raspberry Pi
|
||||
|
||||
Dans cette partie de la leçon, vous allez ajouter un capteur de lumière à votre Raspberry Pi.
|
||||
|
||||
## Matériel
|
||||
|
||||
Le capteur utilisé pour cette leçon est un **capteur de lumière** qui utilise une [photodiode](https://wikipedia.org/wiki/Photodiode) pour convertir la lumière en un signal électrique. Il s'agit d'un capteur analogique qui envoie une valeur entière de 0 à 1000 indiquant une quantité relative de lumière qui ne correspond à aucune unité de mesure standard telle que le [lux](https://fr.wikipedia.org/wiki/Lux_(unit%C3%A9)).
|
||||
|
||||
Le capteur de lumière est un capteur Grove et doit être connecté au chapeau de base Grove sur le Raspberry Pi.
|
||||
|
||||
### Connecter le capteur de lumière
|
||||
|
||||
Le capteur de lumière Grove utilisé pour détecter les niveaux de lumière doit être connecté au Raspberry Pi.
|
||||
|
||||
#### Tâche - connecter le capteur de lumière
|
||||
|
||||
Connecter le capteur de lumière
|
||||
|
||||
|
||||
|
||||
1. Insérez une extrémité d'un câble Grove dans la prise du module du capteur de lumière. Il ne peut être inséré que dans un seul sens.
|
||||
|
||||
1. Le Raspberry Pi étant éteint, connectez l'autre extrémité du câble Grove à la prise analogique marquée **A0** sur le chapeau de base Grove fixé au Pi. Cette prise est la deuxième en partant de la droite, sur la rangée de prises à côté des broches GPIO.
|
||||
|
||||
|
||||
|
||||
## Programmer le capteur de lumière
|
||||
|
||||
L'appareil peut maintenant être programmé à l'aide du capteur de lumière Grove.
|
||||
|
||||
### Tâche - programmer le capteur de lumière
|
||||
|
||||
Programmez l'appareil.
|
||||
|
||||
1. Allumez le Pi et attendez qu'il démarre
|
||||
|
||||
1. Ouvrez le projet nightlight dans VS Code que vous avez créé dans la partie précédente de ce travail, soit en l'exécutant directement sur le Pi, soit en le connectant à l'aide de l'extension Remote SSH.
|
||||
|
||||
1. Ouvrez le fichier `app.py` et supprimez tout le code qu'il contient.
|
||||
|
||||
1. Ajoutez le code suivant au fichier `app.py` pour importer certaines bibliothèques nécessaires :
|
||||
|
||||
```python
|
||||
import time
|
||||
from grove.grove_light_sensor_v1_2 import GroveLightSensor
|
||||
```
|
||||
|
||||
L'instruction `import time` importe le module `time` qui sera utilisé plus tard dans ce travail.
|
||||
|
||||
L'instruction `from grove.grove_light_sensor_v1_2 import GroveLightSensor` importe le module `GroveLightSensor` des bibliothèques Grove Python. Cette bibliothèque contient du code pour interagir avec un capteur de lumière Grove, et a été installée globalement lors de l'installation du Pi.
|
||||
|
||||
1. Ajoutez le code suivant après le code ci-dessus pour créer une instance de la classe qui gère le capteur de lumière :
|
||||
|
||||
```python
|
||||
light_sensor = GroveLightSensor(0)
|
||||
```
|
||||
|
||||
La ligne `light_sensor = GroveLightSensor(0)` crée une instance de la classe `GroveLightSensor` se connectant à la broche **A0** - la broche analogique Grove à laquelle le capteur de lumière est connecté.
|
||||
|
||||
1. Ajoutez une boucle infinie après le code ci-dessus pour interroger la valeur du capteur de lumière et l'imprimer sur la console :
|
||||
|
||||
```python
|
||||
while True:
|
||||
light = light_sensor.light
|
||||
print('Light level:', light)
|
||||
```
|
||||
|
||||
Ceci va lire le niveau de lumière actuel sur une échelle de 0-1023 en utilisant la propriété `light` de la classe `GroveLightSensor`. Cette propriété lit la valeur analogique de la broche. Cette valeur est ensuite imprimée sur la console.
|
||||
|
||||
1. Ajoutez une petite mise en veille d'une seconde à la fin de la `boucle` (`loop`) car les niveaux de lumière n'ont pas besoin d'être vérifiés en permanence. Une mise en veille réduit la consommation d'énergie de l'appareil.
|
||||
|
||||
```python
|
||||
time.sleep(1)
|
||||
```
|
||||
|
||||
1. Depuis le terminal VS Code, exécutez la commande suivante pour lancer votre application Python :
|
||||
|
||||
```sh
|
||||
python3 app.py
|
||||
```
|
||||
|
||||
Les valeurs lumineuses sont transmises à la console. Couvrez et découvrez le capteur de lumière, et les valeurs changeront :
|
||||
|
||||
```output
|
||||
pi@raspberrypi:~/nightlight $ python3 app.py
|
||||
Light level: 634
|
||||
Light level: 634
|
||||
Light level: 634
|
||||
Light level: 230
|
||||
Light level: 104
|
||||
Light level: 290
|
||||
```
|
||||
|
||||
> 💁 Vous trouverez ce code dans le dossier [code-sensor/pi](../code-sensor/pi).
|
||||
|
||||
😀 L'ajout d'un capteur à votre programme de veilleuse a été un succès!
|
||||
@ -0,0 +1,110 @@
|
||||
# Créer une veilleuse - Matériel IoT virtuel
|
||||
|
||||
Dans cette partie de la leçon, vous allez ajouter une LED à votre dispositif IoT virtuel et l'utiliser pour créer une veilleuse.
|
||||
|
||||
## Matériel virtuel
|
||||
|
||||
La veilleuse a besoin d'un actionneur, créé dans l'application CounterFit.
|
||||
|
||||
L'actionneur est une **LED**. Dans un dispositif IoT physique, il s'agirait d'une [diode électroluminescente](https://wikipedia.org/wiki/Light-emitting_diode) qui émet de la lumière lorsqu'elle est traversée par un courant. Il s'agit d'un actionneur numérique qui a deux états : allumé (`on`) et éteint (`off`). L'envoi d'une valeur de 1 allume la diode et celle de 0 l'éteint.
|
||||
|
||||
La logique de la veilleuse en pseudo-code est la suivante :
|
||||
|
||||
```sortie
|
||||
Vérifier le niveau de lumière.
|
||||
Si la lumière est inférieure à 300
|
||||
Allumer la LED
|
||||
Sinon
|
||||
Eteindre la LED
|
||||
```
|
||||
|
||||
### Ajouter l'actionneur à CounterFit
|
||||
|
||||
Pour utiliser une LED virtuelle, vous devez l'ajouter à l'application CounterFit.
|
||||
|
||||
#### Tâche - ajouter l'actionneur à CounterFit
|
||||
|
||||
Ajoutez la LED à l'application CounterFit.
|
||||
|
||||
1. Assurez-vous que l'application web CounterFit est en cours d'exécution depuis la partie précédente de ce travail. Si ce n'est pas le cas, démarrez-la et ajoutez à nouveau le capteur de lumière.
|
||||
|
||||
1. Créez une LED :
|
||||
|
||||
1. Dans la case *Créer un actionneur* du volet *Actionneur*, dérouler la case *Type d'actionneur* et sélectionner *LED*.
|
||||
|
||||
1. Réglez la *broche* sur *5*
|
||||
|
||||
1. Sélectionnez le bouton **Ajouter** pour créer la LED sur la broche 5.
|
||||
|
||||
|
||||
|
||||
La LED sera créée et apparaîtra dans la liste des actionneurs.
|
||||
|
||||
|
||||
|
||||
Une fois la LED créée, vous pouvez changer sa couleur en utilisant le sélecteur *Color*. Sélectionnez le bouton **Set** pour modifier la couleur après l'avoir sélectionnée.
|
||||
|
||||
### Programmer la veilleuse
|
||||
|
||||
La veilleuse peut maintenant être programmée à l'aide du capteur de lumière et de la LED CounterFit.
|
||||
|
||||
#### Tâche - programmer la veilleuse
|
||||
|
||||
Programmez la veilleuse.
|
||||
|
||||
1. Ouvrez le projet de veilleuse dans VS Code que vous avez créé dans la partie précédente de ce travail. Fermez et recréez le terminal pour vous assurer qu'il fonctionne en utilisant l'environnement virtuel si nécessaire.
|
||||
|
||||
1. Ouvrez le fichier `app.py`
|
||||
|
||||
1. Ajoutez le code suivant au fichier `app.py` pour vous connecter à l'importation d'une bibliothèque requise. Ceci doit être ajouté en haut, en dessous des autres lignes `import`.
|
||||
|
||||
```python
|
||||
from counterfit_shims_grove.grove_led import GroveLed
|
||||
```
|
||||
|
||||
L'instruction `from counterfit_shims_grove.grove_led import GroveLed` importe la `GroveLed` des bibliothèques Python de CounterFit Grove shim. Cette bibliothèque contient du code pour interagir avec une LED créée dans l'application CounterFit.
|
||||
|
||||
1. Ajoutez le code suivant après la déclaration `light_sensor` pour créer une instance de la classe qui gère la LED :
|
||||
|
||||
```python
|
||||
led = GroveLed(5)
|
||||
```
|
||||
|
||||
La ligne `led = GroveLed(5)` crée une instance de la classe `GroveLed` se connectant à la broche **5** - la broche CounterFit Grove à laquelle la LED est connectée.
|
||||
|
||||
1. Ajoutez une vérification à l'intérieur de la boucle `while`, et avant le `time.sleep` pour vérifier les niveaux de lumière et allumer ou éteindre la LED :
|
||||
|
||||
```python
|
||||
if light < 300:
|
||||
led.on()
|
||||
else:
|
||||
led.off()
|
||||
```
|
||||
|
||||
Ce code vérifie la valeur de `light`. Si cette valeur est inférieure à 300, il appelle la méthode `on` de la classe `GroveLed` qui envoie une valeur numérique de 1 à la LED, l'allumant ainsi. Si la valeur de la lumière est supérieure ou égale à 300, elle appelle la méthode `off`, qui envoie une valeur numérique de 0 à la LED, l'éteignant.
|
||||
|
||||
> 💁 Ce code doit être indenté au même niveau que la ligne `print('Light level:', light)` pour être à l'intérieur de la boucle while!
|
||||
|
||||
1. Depuis le terminal VS Code, exécutez ce qui suit pour lancer votre application Python :
|
||||
|
||||
```sh
|
||||
python3 app.py
|
||||
```
|
||||
|
||||
Les valeurs de lumière seront affichées sur la console.
|
||||
|
||||
```sortie
|
||||
(.venv) ➜ GroveTest python3 app.py
|
||||
Light level: 143
|
||||
Light level: 244
|
||||
Light level: 246
|
||||
Light level: 253
|
||||
```
|
||||
|
||||
1. Modifiez les paramètres *Value* ou *Random* pour faire varier le niveau d'éclairage au-dessus et au-dessous de 300. La LED s'allume et s'éteint.
|
||||
|
||||
|
||||
|
||||
> 💁 Vous trouverez ce code dans le dossier [code-actuator/virtual-device](../code-actuator/virtual-device).
|
||||
|
||||
😀 Votre programme de veilleuse a été réalisé avec succès!
|
||||
@ -0,0 +1,110 @@
|
||||
# Créer une veilleuse - Matériel IoT virtuel
|
||||
|
||||
Dans cette partie de la leçon, vous allez ajouter un capteur de lumière à votre dispositif IoT virtuel.
|
||||
|
||||
## Matériel virtuel
|
||||
|
||||
La veilleuse a besoin d'un actionneur, créé dans l'application CounterFit.
|
||||
|
||||
Le capteur est un **capteur de lumière**. Dans un dispositif IoT physique, il s'agirait d'une [photodiode](https://wikipedia.org/wiki/Photodiode) qui convertit la lumière en un signal électrique. Les capteurs de lumière sont des capteurs analogiques qui envoient une valeur entière indiquant une quantité relative de lumière, qui ne correspond à aucune unité de mesure standard telle que le [lux](https://wikipedia.org/wiki/Lux).
|
||||
|
||||
### Ajouter les capteurs à CounterFit
|
||||
|
||||
Pour utiliser un capteur de lumière virtuel, vous devez l'ajouter à l'application CounterFit.
|
||||
|
||||
#### Tâche - ajouter les capteurs à CounterFit
|
||||
|
||||
Ajoutez le capteur de lumière à l'application CounterFit.
|
||||
|
||||
1. Assurez-vous que l'application web CounterFit est en cours d'exécution depuis la partie précédente de ce travail. Si ce n'est pas le cas, démarrez-la.
|
||||
|
||||
1. Créez un capteur de lumière :
|
||||
|
||||
1. Dans la case *Create sensor* du volet *Sensors*, déroulez la case *Sensor type* et sélectionnez *Light*.
|
||||
|
||||
1. Laissez les *Unités* (*Units* en anglais) réglées sur *NoUnits*
|
||||
|
||||
1. Assurez-vous que l'option *Pin* est réglée sur *0*.
|
||||
|
||||
1. Sélectionnez le bouton **Add** pour créer le capteur de lumière sur la broche 0.
|
||||
|
||||
|
||||
|
||||
Le capteur de lumière sera créé et apparaîtra dans la liste des capteurs.
|
||||
|
||||
|
||||
|
||||
## Programmer le capteur de lumière
|
||||
|
||||
L'appareil peut maintenant être programmé pour utiliser le capteur de lumière intégré.
|
||||
|
||||
### Tâche - programmer le capteur de lumière
|
||||
|
||||
Programmez l'appareil.
|
||||
|
||||
1. Ouvrez le projet nightlight dans VS Code que vous avez créé dans la partie précédente de ce travail. Fermez et recréez le terminal pour vous assurer qu'il fonctionne en utilisant l'environnement virtuel si nécessaire.
|
||||
|
||||
1. Ouvrez le fichier `app.py`
|
||||
|
||||
1. Ajouter le code suivant au début du fichier `app.py` avec le reste des déclarations `import` pour se connecter à l'importation de certaines bibliothèques requises :
|
||||
|
||||
```python
|
||||
import time
|
||||
from counterfit_shims_grove.grove_light_sensor_v1_2 import GroveLightSensor
|
||||
```
|
||||
|
||||
L'instruction `import time` importe le module Python `time` qui sera utilisé plus tard dans ce travail.
|
||||
|
||||
L'instruction `from counterfit_shims_grove.grove_light_sensor_v1_2 import GroveLightSensor` importe le `GroveLightSensor` des bibliothèques Python CounterFit Grove shim. Cette bibliothèque contient du code pour interagir avec un capteur de lumière créé dans l'application CounterFit.
|
||||
|
||||
1. Ajoutez le code suivant au bas du fichier pour créer des instances de classes qui gèrent le capteur de lumière :
|
||||
|
||||
```python
|
||||
light_sensor = GroveLightSensor(0)
|
||||
```
|
||||
|
||||
La ligne `light_sensor = GroveLightSensor(0)` crée une instance de la classe `GroveLightSensor` se connectant au pin **0** - le pin du CounterFit Grove auquel le capteur de lumière est connecté.
|
||||
|
||||
1. Ajoutez une boucle infinie après le code ci-dessus pour interroger la valeur du capteur de lumière et l'imprimer sur la console :
|
||||
|
||||
```python
|
||||
while True:
|
||||
light = light_sensor.light
|
||||
print('Light level:', light)
|
||||
```
|
||||
|
||||
Ceci permet de lire le niveau de lumière actuel en utilisant la propriété `light` de la classe `GroveLightSensor`. Cette propriété lit la valeur analogique de la broche. Cette valeur est ensuite imprimée sur la console.
|
||||
|
||||
1. Ajoutez une petite mise en veille d'une seconde à la fin de la boucle `while` car les niveaux de lumière n'ont pas besoin d'être vérifiés continuellement. Une mise en veille réduit la consommation d'énergie de l'appareil.
|
||||
|
||||
```python
|
||||
time.sleep(1)
|
||||
```
|
||||
|
||||
1. Depuis le terminal VS Code, exécutez les commandes suivantes pour lancer votre application Python :
|
||||
|
||||
```sh
|
||||
python3 app.py
|
||||
```
|
||||
|
||||
Les valeurs lumineuses seront affichées sur la console. Initialement, cette valeur sera de 0.
|
||||
|
||||
1. Depuis l'application CounterFit, changez la valeur du capteur de lumière qui sera lue par l'application. Vous pouvez le faire de deux façons :
|
||||
|
||||
* Saisissez un nombre dans la case *Value* du capteur de lumière, puis sélectionnez le bouton **Set**. Le nombre que vous saisissez sera la valeur renvoyée par le capteur.
|
||||
|
||||
* Cochez la case *Aléatoire* et entrez une valeur *Min* et *Max*, puis cliquez sur le bouton **Set**. Chaque fois que le capteur lira une valeur, il lira un nombre aléatoire entre *Min* et *Max*.
|
||||
|
||||
Les valeurs que vous avez définies seront affichées sur la console. Modifiez les paramètres *Value* ou *Random* pour modifier la valeur.
|
||||
|
||||
```sortie
|
||||
(.venv) ➜ GroveTest python3 app.py
|
||||
Light level: 143
|
||||
Light level: 244
|
||||
Light level: 246
|
||||
Light level: 253
|
||||
```
|
||||
|
||||
> 💁 Vous trouverez ce code dans le dossier [code-sensor/virtual-device](../code-sensor/virtual-device).
|
||||
|
||||
😀 Votre programme de veilleuse a été un succès!
|
||||
@ -0,0 +1,110 @@
|
||||
# Créer une veilleuse - le terminale Wio
|
||||
|
||||
Dans cette partie de la leçon, vous ajouterez une LED à votre terminal Wio et l'utiliserez pour créer une veilleuse.
|
||||
|
||||
## Matériel
|
||||
|
||||
La veilleuse a maintenant besoin d'un actionneur.
|
||||
|
||||
L'actionneur est une **LED**, une [diode électroluminescente](https://wikipedia.org/wiki/Light-emitting_diode) qui émet de la lumière lorsqu'elle est traversée par un courant. Il s'agit d'un actionneur numérique qui a deux états : allumé (`on`) et éteint (`off`). L'envoi d'une valeur de 1 allume la LED et de 0 l'éteint. Il s'agit d'un actionneur Grove externe qui doit être connecté au terminal Wio.
|
||||
|
||||
La logique de la veilleuse en pseudo-code est la suivante :
|
||||
|
||||
```sortie
|
||||
Vérifier le niveau de lumière.
|
||||
Si la lumière est inférieure à 300
|
||||
Allumer la LED
|
||||
Sinon
|
||||
Eteindre la LED
|
||||
```
|
||||
|
||||
### Connecter la LED
|
||||
|
||||
La LED Grove est livrée sous forme de module avec une sélection de LED, ce qui vous permet de choisir la couleur.
|
||||
|
||||
#### Tâche - connecter la LED
|
||||
|
||||
Connecter la LED.
|
||||
|
||||
|
||||
|
||||
1. Choisissez votre LED préférée et insérez les pattes dans les deux trous du module LED.
|
||||
|
||||
Les LEDs sont des diodes électroluminescentes, et les diodes sont des dispositifs électroniques qui ne peuvent transporter le courant que dans un sens. Cela signifie que la LED doit être connectée dans le bon sens, sinon elle ne fonctionnera pas.
|
||||
|
||||
L'une des pattes de la LED est la broche positive, l'autre est la broche négative. La LED n'est pas parfaitement ronde, elle est légèrement plus plate d'un côté. Le côté légèrement plus plat est la broche négative. Lorsque vous connectez la LED au module, assurez-vous que la broche du côté arrondi est connectée à la prise marquée **+** à l'extérieur du module, et que le côté plus plat est connecté à la prise plus proche du milieu du module.
|
||||
|
||||
1. Le module LED est doté d'un bouton rotatif qui vous permet de contrôler la luminosité. Pour commencer, réglez-le à fond en le tournant dans le sens inverse des aiguilles d'une montre jusqu'à la butée à l'aide d'un petit tournevis cruciforme.
|
||||
|
||||
1. Insérez l'une des extrémités d'un câble Grove dans la prise du module LED. Il ne peut être inséré que dans un seul sens.
|
||||
|
||||
1. Le terminal Wio étant déconnecté de votre ordinateur ou de toute autre source d'alimentation, connectez l'autre extrémité du câble Grove à la prise Grove du côté droit du terminal Wio lorsque vous regardez l'écran. Il s'agit de la prise la plus éloignée du bouton d'alimentation.
|
||||
|
||||
> 💁 La prise Grove de droite peut être utilisée avec des capteurs et des actionneurs analogiques ou numériques.La prise de gauche est réservée aux capteurs et actionneurs I<sup>2</sup>C et numériques. L'I<sup>2</sup>C sera abordé dans une leçon ultérieure.
|
||||
|
||||
|
||||
|
||||
## Programmer la veilleuse
|
||||
|
||||
La veilleuse peut maintenant être programmée à l'aide du capteur de lumière intégré et de la LED Grove.
|
||||
|
||||
### Tâche - programmer la veilleuse
|
||||
|
||||
Programmer la veilleuse.
|
||||
|
||||
1. Ouvrez le projet de veilleuse dans VS Code que vous avez créé dans la partie précédente de ce devoir
|
||||
|
||||
1. Ajoutez la ligne suivante à la fin de la fonction `setup` :
|
||||
|
||||
```cpp
|
||||
pinMode(D0, OUTPUT);
|
||||
```
|
||||
|
||||
Cette ligne configure la broche utilisée pour communiquer avec la LED via le port Grove.
|
||||
|
||||
La broche `D0` est la broche numérique pour la prise Grove de droite. Cette broche est réglée sur `OUTPUT`, ce qui signifie qu'elle se connecte à un actionneur et que des données seront écrites sur la broche.
|
||||
|
||||
1. Ajoutez le code suivant immédiatement avant le `delay` dans la fonction loop :
|
||||
|
||||
```cpp
|
||||
if (light < 300)
|
||||
{
|
||||
digitalWrite(D0, HIGH);
|
||||
}
|
||||
else
|
||||
{
|
||||
digitalWrite(D0, LOW);
|
||||
}
|
||||
```
|
||||
|
||||
Ce code vérifie la valeur `light`. Si cette valeur est inférieure à 300, il envoie une valeur `HIGH` à la broche numérique `D0`. Ce `HIGH` a une valeur de 1, ce qui allume la LED. Si la lumière est supérieure ou égale à 300, une valeur `LOW` de 0 est envoyée à la broche, ce qui éteint la LED.
|
||||
|
||||
> 💁 Lors de l'envoi de valeurs numériques à des actionneurs, une valeur BASSE correspond à 0 V et une valeur HAUTE correspond à la tension maximale de l'appareil. Pour le terminal Wio, la tension HAUTE ("HIGH" en anglais) est de 3,3V.
|
||||
|
||||
1. Reconnectez le terminal Wio à votre ordinateur et téléchargez le nouveau code comme vous l'avez fait précédemment.
|
||||
|
||||
1. Connectez le moniteur série. Les valeurs lumineuses seront transmises au terminal.
|
||||
|
||||
```sortie
|
||||
> Executing task: platformio device monitor <
|
||||
|
||||
--- Available filters and text transformations: colorize, debug, default, direct, hexlify, log2file, nocontrol, printable, send_on_enter, time
|
||||
--- More details at http://bit.ly/pio-monitor-filters
|
||||
--- Miniterm on /dev/cu.usbmodem101 9600,8,N,1 ---
|
||||
--- Quit: Ctrl+C | Menu: Ctrl+T | Help: Ctrl+T followed by Ctrl+H ---
|
||||
Light value: 4
|
||||
Light value: 5
|
||||
Light value: 4
|
||||
Light value: 158
|
||||
Light value: 343
|
||||
Light value: 348
|
||||
Light value: 344
|
||||
```
|
||||
|
||||
1. Couvrez et découvrez le capteur de lumière. Remarquez que la LED s'allume lorsque le niveau de luminosité est inférieur ou égal à 300, et s'éteint lorsque le niveau de luminosité est supérieur à 300.
|
||||
|
||||
|
||||
|
||||
> 💁 Vous trouverez ce code dans le dossier [code-actuator/wio-terminal](../code-actuator/wio-terminal).
|
||||
|
||||
😀 Votre programme de veilleuse a été un succès!
|
||||
@ -0,0 +1,73 @@
|
||||
# Ajouter un capteur - le terminal Wio
|
||||
|
||||
Dans cette partie de la leçon, vous utiliserez le capteur de lumière sur votre terminal Wio.
|
||||
|
||||
## Matériel
|
||||
|
||||
Le capteur de cette leçon est un **capteur de lumière** qui utilise une [photodiode](https://fr.wikipedia.org/wiki/Photodiode) pour convertir la lumière en un signal électrique. Il s'agit d'un capteur analogique qui envoie une valeur entière comprise entre 0 et 1023 indiquant une quantité relative de lumière qui ne correspond à aucune unité de mesure standard telle que le [lux](https://wikipedia.org/wiki/Lux).
|
||||
|
||||
Le capteur de lumière est intégré au terminal Wio et est visible à travers la fenêtre en plastique transparent située à l'arrière.
|
||||
|
||||
|
||||
|
||||
## Programmer le capteur de lumière
|
||||
|
||||
L'appareil peut maintenant être programmé pour utiliser le capteur de lumière intégré.
|
||||
|
||||
### Tâche
|
||||
|
||||
Programmez l'appareil.
|
||||
|
||||
1. Ouvrez le projet nightlight dans VS Code que vous avez créé dans la partie précédente de ce travail.
|
||||
|
||||
1. Ajoutez la ligne suivante à la fin de la fonction `setup` :
|
||||
|
||||
```cpp
|
||||
pinMode(WIO_LIGHT, INPUT);
|
||||
```
|
||||
|
||||
Cette ligne configure les broches utilisées pour communiquer avec le capteur.
|
||||
|
||||
La broche `WIO_LIGHT` est le numéro de la broche GPIO connectée au capteur de lumière embarqué. Cette broche est réglée sur `INPUT`, ce qui signifie qu'elle se connecte à un capteur et que les données seront lues à partir de la broche.
|
||||
|
||||
1. Effacez le contenu de la fonction `loop`.
|
||||
|
||||
1. Ajoutez le code suivant à la fonction `loop` maintenant vide.
|
||||
|
||||
```cpp
|
||||
int light = analogRead(WIO_LIGHT);
|
||||
Serial.print("Light value: ");
|
||||
Serial.println(light);
|
||||
```
|
||||
|
||||
Ce code lit une valeur analogique sur la broche `WIO_LIGHT`. Il lit une valeur comprise entre 0 et 1023 à partir du capteur de lumière embarqué. Cette valeur est ensuite envoyée au port série afin que vous puissiez la lire dans le Serial Monitor lorsque ce code est exécuté. `Serial.print` écrit le texte sans nouvelle ligne à la fin, de sorte que chaque ligne commence par `Light value:` et se termine par la valeur réelle de la lumière.
|
||||
|
||||
1. Ajoutez un petit délai d'une seconde (1000 ms) à la fin de la `boucle` (`loop` en anglais), car les niveaux de lumière n'ont pas besoin d'être vérifiés en permanence. Un délai réduit la consommation d'énergie de l'appareil.
|
||||
|
||||
```cpp
|
||||
delay(1000);
|
||||
```
|
||||
|
||||
1. Reconnectez le terminal Wio à votre ordinateur et téléchargez le nouveau code comme vous l'avez fait précédemment.
|
||||
|
||||
1. Connectez le moniteur série. Des valeurs lumineuses seront émises vers le terminal. Couvrez et découvrez le capteur de lumière à l'arrière du terminal Wio, et les valeurs changeront.
|
||||
|
||||
```sortie
|
||||
> Executing task: platformio device monitor <
|
||||
|
||||
--- Available filters and text transformations: colorize, debug, default, direct, hexlify, log2file, nocontrol, printable, send_on_enter, time
|
||||
--- More details at http://bit.ly/pio-monitor-filters
|
||||
--- Miniterm on /dev/cu.usbmodem101 9600,8,N,1 ---
|
||||
--- Quit: Ctrl+C | Menu: Ctrl+T | Help: Ctrl+T followed by Ctrl+H ---
|
||||
Light value: 4
|
||||
Light value: 5
|
||||
Light value: 4
|
||||
Light value: 158
|
||||
Light value: 343
|
||||
Light value: 348
|
||||
Light value: 344
|
||||
```
|
||||
|
||||
> 💁 Vous trouverez ce code dans le dossier [code-sensor/wio-terminal](../code-sensor/wio-terminal).
|
||||
|
||||
😀 L'ajout d'un capteur à votre programme de veilleuses a été un succès!
|
||||
Loading…
Reference in new issue