Comment commencer – Real Python

Les microcontrôleurs existent depuis longtemps et ils sont utilisés dans tous les domaines, des machines complexes aux appareils ménagers courants. Cependant, leur travail est traditionnellement réservé aux personnes ayant une formation technique formelle, telles que les techniciens et les ingénieurs électriciens. L'émergence de Arduino a rendu la conception d'applications électroniques beaucoup plus accessible à tous les développeurs. Dans ce didacticiel, vous découvrirez comment utiliser Arduino avec Python pour développer vos propres projets électroniques.

Vous allez couvrir les bases d’Arduino avec Python et apprendre à:

• Mise en place de circuits électroniques
• Configurer le protocole Firmata sur Arduino
• Écrire des applications de base pour Arduino en Python
• Contrôle des entrées et sorties analogiques et numériques
• Intégrez des capteurs et des commutateurs Arduino à des applications de niveau supérieur
• Déclenchez des notifications sur votre PC et envoyez des courriels avec Arduino

La plateforme Arduino

Arduino est une plate-forme open source composée de matériel et de logiciels permettant le développement rapide de projets d’électronique interactive. L’émergence d’Arduino a attiré l’attention de professionnels de nombreux secteurs différents, contribuant ainsi au lancement du mouvement Maker.

Avec la popularité croissante du mouvement Maker et le concept de l'Internet des objets, Arduino est devenue l'une des principales plates-formes de prototypage électronique et de développement de MVP.

Arduino utilise son propre langage de programmation, similaire au C ++. Cependant, il est possible d’utiliser Arduino avec Python ou un autre langage de programmation de haut niveau. En fait, les plates-formes comme Arduino fonctionnent bien avec Python, en particulier pour les applications nécessitant une intégration avec des capteurs et d'autres périphériques physiques.

Au total, Arduino et Python peuvent faciliter la mise en place d’un environnement d’apprentissage efficace qui encourage les développeurs à s’intégrer à la conception électronique. Si vous connaissez déjà les bases de Python, vous pourrez commencer à utiliser Arduino en utilisant Python pour le contrôler.

La plate-forme Arduino comprend des produits matériels et logiciels. Dans ce didacticiel, vous utiliserez du matériel Arduino et le logiciel Python pour vous familiariser avec les circuits de base, ainsi que les entrées et sorties numériques et analogiques.

Matériel Arduino

Pour exécuter les exemples, vous devez assembler les circuits en connectant Composants electroniques. Vous pouvez généralement trouver ces articles dans les magasins de composants électroniques ou dans de bons kits de démarrage Arduino. Tu auras besoin:

1. Un Arduino Uno ou autre carte compatible
2. Une LED standard de n'importe quelle couleur
3. Un bouton poussoir
4. Un potentiomètre de 10 KOhm
5. Une résistance de 470 Ohm
6. Une résistance de 10 KOhm
7. Une planche à pain
8. Fils de connexion de différentes couleurs et tailles

Examinons de plus près certains de ces composants.

Le composant 1 est un Arduino Uno ou autre carte compatible. Arduino est un projet qui comprend de nombreuses cartes et modules à des fins différentes, et Arduino Uno est le plus fondamental parmi ceux-ci. Il s’agit également du tableau le plus utilisé et le plus documenté de toute la famille Arduino. C’est donc un excellent choix pour les développeurs qui débutent avec l’électronique.

Les composants 5 et 6 sont résistances. La plupart des résistances sont identifiées par des bandes de couleur selon un code de couleur. En général, les trois premières couleurs représentent le valeur d'une résistance, tandis que la quatrième couleur représente son tolérance. Pour une résistance de 470 Ohm, les trois premières couleurs sont le jaune, le violet et le marron. Pour une résistance de 10 KOhm, les trois premières couleurs sont le marron, le noir et l’orange.

Le composant 7 est un planche à pain, que vous utilisez pour connecter tous les autres composants et assembler les circuits. Si une planche à pain n’est pas nécessaire, il est recommandé de vous en procurer une si vous avez l’intention de commencer à travailler avec Arduino.

Logiciel Arduino

En plus de ces composants matériels, vous devrez installer certains logiciels. La plate-forme inclut l'IDE Arduino, un environnement de développement intégré pour la programmation des périphériques Arduino, entre autres outils en ligne.

Arduino a été conçu pour vous permettre de programmer les cartes avec peu de difficulté. En général, vous allez suivre ces étapes:

1. Connectez la carte à votre PC
2. Installer et ouvrir l'IDE Arduino
3. Configurez les paramètres du tableau
4. Écrivez le code
5. Appuyez sur un bouton de l'IDE pour télécharger le programme sur le tableau

Pour installer l'IDE Arduino sur votre ordinateur, téléchargez la version correspondant à votre système d'exploitation à partir du site Web Arduino. Consultez la documentation pour les instructions d'installation:

• Si vous utilisez Windows, puis utilisez le programme d’installation de Windows pour télécharger les pilotes nécessaires à l’utilisation d’Arduino sous Windows. Consultez la documentation Arduino pour plus de détails.
• Si vous utilisez Linux, vous devrez peut-être ajouter votre utilisateur à certains groupes pour pouvoir utiliser le port série afin de programmer Arduino. Ce processus est décrit dans le guide d'installation Arduino pour Linux.
• Si vous utilisez macOS, vous pouvez ensuite installer Arduino IDE en suivant le guide d’installation Arduino pour OS X.

Maintenant que vous avez installé l'IDE Arduino et réuni tous les composants nécessaires, vous êtes prêt à commencer à utiliser Arduino! Ensuite, vous allez télécharger un programme «Hello, World!» Sur votre forum.

"Bonjour le monde!" Avec Arduino

L'IDE Arduino est livré avec plusieurs exemples croquis vous pouvez utiliser pour apprendre les bases d’Arduino. UNE esquisser est le terme que vous utilisez pour un programme que vous pouvez télécharger sur un tableau. Étant donné que l’Arduino Uno n’a pas d’écran, vous aurez besoin d’un moyen de visualiser la sortie physique de votre programme. Vous utiliserez le Cligner exemple d'esquisse pour faire clignoter une DEL intégrée sur la carte Arduino.

Téléchargement de l'exemple d'esquisse de clignotement

Pour commencer, connectez la carte Arduino à votre PC à l'aide d'un câble USB et démarrez l'IDE Arduino. Pour ouvrir le croquis de l'exemple Blink, accédez au Fichier menu et sélectionnez Exemples, puis 01.Basics et enfin, Cligner:

L'exemple de code Blink sera chargé dans une nouvelle fenêtre de l'EDI. Mais avant de pouvoir télécharger l’esquisse sur le tableau, vous devez configurer l’EDI en sélectionnant votre tableau et son port connecté.

Pour configurer le tableau, accédez au Outils menu puis Planche. Pour Arduino Uno, vous devez sélectionner Arduino / Genuino Uno:

Après avoir sélectionné la carte, vous devez définir le port approprié. Accéder au Outils menu à nouveau, et cette fois sélectionnez Port:

Les noms des ports peuvent être différents, en fonction de votre système d'exploitation. Sous Windows, les ports seront nommés COM4, COM5ou quelque chose de similaire. Sous MacOS ou Linux, vous pouvez voir quelque chose comme: / dev / ttyACM0 ou / dev / ttyUSB0. Si vous rencontrez des problèmes pour configurer le port, consultez la page de dépannage Arduino.

Une fois que vous avez configuré la carte et le port, vous êtes prêt à télécharger l’esquisse sur votre Arduino. Pour cela, il suffit d’appuyer sur le bouton Télécharger bouton dans la barre d’outils IDE:

Quand vous appuyez sur Télécharger, l’EDI compile l’esquisse et l’affiche sur votre tableau. Si vous voulez vérifier les erreurs, vous pouvez appuyer sur Vérifier avant Télécharger, qui ne fera que compiler votre croquis.

Le câble USB fournit une connexion série pour télécharger le programme et alimenter la carte Arduino. Pendant le téléchargement, des voyants clignotent sur la carte. Après quelques secondes, le programme téléchargé s’exécutera et un voyant LED clignotera une fois par seconde:

Une fois le téléchargement terminé, le câble USB continuera d'alimenter la carte Arduino. Le programme est stocké dans la mémoire flash du microcontrôleur Arduino. Vous pouvez également utiliser une batterie ou une autre source d'alimentation externe pour exécuter l'application sans câble USB.

Connexion de composants externes

Dans la section précédente, vous avez utilisé une LED déjà présente sur la carte Arduino. Cependant, dans la plupart des projets pratiques, vous devrez connecter des composants externes à la carte. Pour établir ces connexions, Arduino dispose de plusieurs épingles de différents types:

Bien que ces connexions soient communément appelées épingles, vous pouvez voir qu’ils ne sont pas exactement des broches physiques. Au lieu de cela, les broches sont des trous dans une prise à laquelle vous pouvez connecter des fils de liaison. Dans la figure ci-dessus, vous pouvez voir différents groupes de broches:

• Rectangle orange: Ce sont 13 broches numériques que vous pouvez utiliser comme entrées ou sorties. Ils sont uniquement conçus pour fonctionner avec des signaux numériques, qui ont 2 niveaux différents:
  1. Niveau 0: représenté par la tension 0V
  2. Niveau 1: représenté par la tension 5V
• Rectangle bleu: Ce sont 6 broches analogiques que vous pouvez utiliser comme entrées analogiques. Ils sont conçus pour fonctionner avec une tension arbitraire comprise entre 0V et 5V.
• Rectangle vert: Ce sont 5 broches d'alimentation. Ils sont principalement utilisés pour l’alimentation de composants externes.

Pour commencer à utiliser des composants externes, vous devez connecter un voyant externe pour exécuter l’exemple d’illustration Blink. La LED intégrée est connectée à pin numérique # 13. Alors, connectons un voyant externe à cette broche et vérifions s’il clignote. (Une DEL standard est l’un des composants énumérés précédemment.)

Avant de connecter quoi que ce soit à la carte Arduino, il est recommandé de la déconnecter de l’ordinateur. Avec le câble USB débranché, vous pourrez connecter le voyant à votre carte:

Notez que la figure montre la carte avec les broches numériques face à vous.

Utiliser une planche à pain

Les projets de circuits électroniques impliquent généralement de tester plusieurs idées, en ajoutant de nouveaux composants et en effectuant des ajustements au fur et à mesure. Cependant, il peut être difficile de connecter directement des composants, en particulier si le circuit est volumineux.

Pour faciliter le prototypage, vous pouvez utiliser un planche à pain connecter les composants. Ceci est un appareil avec plusieurs trous qui sont connectés d'une manière particulière afin que vous puissiez facilement connecter des composants à l'aide de fils de liaison:

Vous pouvez voir quels trous sont interconnectés en regardant les lignes colorées. Vous utiliserez les trous sur les côtés de la planche à pain pour alimenter le circuit:

• Connectez un trou sur le ligne rouge à la source d'alimentation.
• Connectez un trou sur le Ligne bleue au sol.

Ensuite, vous pouvez facilement connecter des composants à la source d'alimentation ou à la terre en utilisant simplement les autres trous des lignes rouge et bleue. Les trous au centre de la planche à pain sont reliés comme indiqué par les couleurs. Vous les utiliserez pour établir des connexions entre les composants du circuit. Ces deux sections internes sont séparées par une petite dépression sur laquelle vous pouvez connecter des circuits intégrés (CI).

Vous pouvez utiliser une planche à pain pour assembler le circuit utilisé dans l'exemple d'esquisse Blink:

Pour ce circuit, il est important de noter que la LED doit être connectée en fonction de sa polarité, sinon cela ne fonctionnera pas. La borne positive de la LED est appelée le anode et est généralement le plus long. Le terminal négatif est appelé le cathode et est plus courte. Si vous utilisez un composant récupéré, vous pouvez également identifier les terminaux en recherchant un côté plat sur le voyant lui-même. Cela indiquera la position du terminal négatif.

Lorsque vous connectez une LED à une broche Arduino, vous aurez toujours besoin d’une résistance pour limiter son courant et éviter de l’épuiser prématurément. Pour cela, vous utilisez une résistance de 470 Ohm. Vous pouvez suivre les connexions et vérifier que le circuit est le même:

• La résistance est connectée à la broche numérique 13 de la carte Arduino.
• L'anode à DEL est connectée à l'autre borne de la résistance.
• La cathode à LED est connectée à la terre (GND) via la ligne bleue des trous.

Pour une explication plus détaillée, consultez Comment utiliser une planche à pain.

Une fois la connexion établie, reconnectez l’Arduino au PC et relancez l’esquisse Blink:

Lorsque les deux voyants sont connectés à la broche numérique 13, ils clignotent ensemble lorsque l'esquisse est en cours d'exécution.

“Bonjour le monde!” Avec Arduino et Python

Dans la section précédente, vous avez téléchargé l'esquisse Blink sur votre carte Arduino. Les croquis Arduino sont écrits dans un langage similaire au C ++. Ils sont compilés et enregistrés sur la mémoire flash du microcontrôleur lorsque vous appuyez sur Télécharger. Bien que vous puissiez utiliser un autre langage pour programmer directement le microcontrôleur Arduino, ce n’est pas une mince tâche!

Cependant, vous pouvez utiliser certaines approches pour utiliser Arduino avec Python ou d’autres langages. Une idée consiste à exécuter le programme principal sur un PC et à utiliser la connexion série pour communiquer avec Arduino via le câble USB. L'esquisse serait chargée de lire les entrées, d'envoyer les informations au PC et d'obtenir les mises à jour du PC pour mettre à jour les sorties Arduino.

Pour contrôler Arduino à partir du PC, vous devez concevoir un protocole pour la communication entre le PC et Arduino. Par exemple, vous pouvez envisager un protocole avec des messages tels que:

• LA VALEUR DU PIN 13 EST ÉLEVÉE: utilisé pour informer le PC de l'état des broches d'entrée numérique
• SET PIN 11 LOW: utilisé pour dire à Arduino de définir les états des broches de sortie

Avec le protocole défini, vous pouvez écrire une esquisse Arduino pour envoyer des messages au PC et mettre à jour les états des broches en fonction du protocole. Sur le PC, vous pouvez écrire un programme pour contrôler l’Arduino via une connexion série, en fonction du protocole que vous avez conçu. Pour cela, vous pouvez utiliser le langage et les bibliothèques de votre choix, tels que Python et la bibliothèque PySerial.

Heureusement, il existe des protocoles standard pour faire tout cela! Firmata est l'un d'eux. Ce protocole établit un format de communication série vous permettant de lire les entrées numériques et analogiques, ainsi que d'envoyer des informations aux sorties numériques et analogiques.

L'IDE Arduino comprend des croquis prêts à l'emploi qui piloteront Arduino en Python avec le protocole Firmata. Du côté du PC, il existe des implémentations du protocole dans plusieurs langages, y compris Python. Pour démarrer avec Firmata, utilisons-le pour mettre en œuvre un programme «Hello, World!».

Télécharger l'esquisse du Firmata

Avant d'écrire votre programme Python pour piloter Arduino, vous devez télécharger l'esquisse Firmata afin de pouvoir utiliser ce protocole pour contrôler le tableau. L’esquisse est disponible dans les exemples intégrés de l’EDI Arduino. Pour l'ouvrir, accédez au Fichier menu, puis Exemples, suivi par Firmata, et enfin StandardFirmata:

L'esquisse sera chargée dans une nouvelle fenêtre de l'EDI. Pour le télécharger sur l’Arduino, vous pouvez suivre les mêmes étapes que précédemment:

1. Branchez le câble USB sur le PC.
2. Sélectionnez la carte et le port appropriés sur l'EDI.
3. presse Télécharger.

Une fois le téléchargement terminé, vous ne remarquerez aucune activité sur l’Arduino. Pour le contrôler, vous avez toujours besoin d'un programme capable de communiquer avec la carte via la connexion série. Pour utiliser le protocole Firmata en Python, vous aurez besoin du paquet pyFirmata, que vous pouvez installer avec pépin:

Une fois l'installation terminée, vous pouvez exécuter une application Blink équivalente à l'aide de Python et Firmata:

    1 importation pyfirmata
    2 importation temps
    3 
    4 planche = pyfirmata.Arduino('/ dev / ttyACM0')
    5 
    6 tandis que Vrai:
    sept     planche.numérique[[[[13].écrire(1)
    8     temps.dormir(1)
    9     planche.numérique[[[[13].écrire(0)
dix     temps.dormir(1)

Voici comment fonctionne ce programme. Vous importez pyfirmata et l'utiliser pour établir une connexion série avec la carte Arduino, qui est représentée par le planche objet de la ligne 4. Vous configurez également le port sur cette ligne en passant un argument à pyfirmata.Arduino (). Vous pouvez utiliser l'IDE Arduino pour trouver le port.

board.digital est une liste dont les éléments représentent les broches numériques de l’Arduino. Ces éléments ont les méthodes lis() et écrire(), qui va lire et écrire l’état des pins. Comme la plupart des programmes de périphériques intégrés, ce programme consiste principalement en une boucle infinie:

• À la ligne 7, la broche numérique 13 est activée, ce qui allume le voyant pendant une seconde.
• À la ligne 9, Cette broche est désactivée, ce qui éteint le voyant pendant une seconde.

Maintenant que vous connaissez les bases du contrôle d’un Arduino avec Python, passons en revue certaines applications pour interagir avec ses entrées et ses sorties.

Lecture des entrées numériques

Entrées digitales ne peut avoir que deux valeurs possibles. Dans un circuit, chacune de ces valeurs est représentée par une tension différente. Le tableau ci-dessous présente la représentation des entrées numériques pour une carte Arduino Uno standard:

Pour contrôler la LED, vous utiliserez un bouton poussoir envoyer des valeurs d’entrée numérique à l’Arduino. Le bouton doit envoyer 0V au tableau quand il est relâché et 5V au tableau quand il est enfoncé. La figure ci-dessous montre comment connecter le bouton à la carte Arduino:

Vous remarquerez peut-être que le voyant est connecté à l'Arduino sur la broche numérique 13, comme avant. La broche numérique 10 est utilisée comme entrée numérique. Pour connecter le bouton-poussoir, vous devez utiliser la résistance de 10 KOhm, qui agit comme un abaissement dans ce circuit. UNE tirer vers le bas La résistance garantit que l’entrée numérique reçoit 0 V lorsque le bouton est relâché.

Lorsque vous relâchez le bouton, vous ouvrez la connexion entre les deux fils sur le bouton. Comme il n’ya pas de courant dans la résistance, la broche 10 se connecte simplement à la terre (GND). L'entrée numérique obtient 0V, ce qui représente le 0 (ou faible) Etat. Lorsque vous appuyez sur le bouton, vous appliquez 5V à la fois à la résistance et à l'entrée numérique. Un courant circule dans la résistance et l’entrée numérique reçoit 5V, ce qui représente la 1 (ou haute) Etat.

Vous pouvez également utiliser une planche à pain pour assembler le circuit ci-dessus:

Maintenant que vous avez assemblé le circuit, vous devez exécuter un programme sur le PC pour le contrôler à l’aide de Firmata. Ce programme allumera la DEL en fonction de l’état du bouton-poussoir:

    1 importation pyfirmata
    2 importation temps
    3 
    4 planche = pyfirmata.Arduino('/ dev / ttyACM0')
    5 
    6 il = pyfirmata.util.Itérateur(planche)
    sept il.début()
    8 
    9 planche.numérique[[[[dix].mode = pyfirmata.CONTRIBUTION
dix 
11 tandis que Vrai:
12     sw = planche.numérique[[[[dix].lis()
13     si sw est Vrai:
14         planche.numérique[[[[13].écrire(1)
15     autre:
16         planche.numérique[[[[13].écrire(0)
17     temps.dormir(0,1)

Parcourons ce programme:

• Lignes 1 et 2 importation pyfirmata et temps.
• Ligne 4 les usages pyfirmata.Arduino () pour établir la connexion avec la carte Arduino.
• Ligne 6 assigne un itérateur qui sera utilisé pour lire l'état des entrées du circuit.
• Ligne 7 démarre l'itérateur, qui maintient une boucle en parallèle avec votre code principal. La boucle s'exécute board.iterate () pour mettre à jour les valeurs d'entrée obtenues à partir de la carte Arduino.
• Ligne 9 définit la broche 10 comme entrée numérique avec pyfirmata.INPUT. Cela est nécessaire car la configuration par défaut consiste à utiliser des broches numériques comme sorties.
• Ligne 11 commence un infini tandis que boucle. Cette boucle lit l’état de la broche d’entrée, la stocke dans sw, et utilise cette valeur pour allumer ou éteindre le voyant en modifiant la valeur de la broche 13.
• Ligne 17 attend 0,1 seconde entre les itérations du tandis que boucle. Ce n’est pas une nécessité absolue, mais c’est un bon truc pour éviter de surcharger le CPU, qui atteint 100% de la charge quand il n’ya pas de commande wait dans la boucle.

pyfirmata offre également une syntaxe plus compacte pour travailler avec les broches d’entrée et de sortie. Cela peut être une bonne option lorsque vous travaillez avec plusieurs broches. Vous pouvez réécrire le programme précédent pour avoir une syntaxe plus compacte:

    1 importation pyfirmata
    2 importation temps
    3 
    4 planche = pyfirmata.Arduino('/ dev / ttyACM0')
    5 
    6 il = pyfirmata.util.Itérateur(planche)
    sept il.début()
    8 
    9 entrée numérique = planche.get_pin('d: 10: je')
dix LED = planche.get_pin('d: 13: o')
11 
12 tandis que Vrai:
13     sw = entrée numérique.lis()
14     si sw est Vrai:
15         LED.écrire(1)
16     autre:
17         LED.écrire(0)
18     temps.dormir(0,1)

Dans cette version, vous utilisez board.get_pin () créer deux objets. entrée numérique représente l'état de l'entrée numérique, et LED représente l'état de la LED. Lorsque vous exécutez cette méthode, vous devez passer un argument de chaîne composé de trois éléments séparés par des deux points:

1. Le type de la broche (une pour analogique ou ré pour le numérique)
2. Le nombre de la broche
3. La mode de la broche (je pour l'entrée ou o pour la sortie)

Puisque entrée numérique est une entrée numérique utilisant la broche 10, vous passez l'argument 'd: 10: je'. L’état des voyants est défini sur une sortie numérique à l’aide de la broche 13; LED l'argument est 'd: 13: o'.

Quand vous utilisez board.get_pin (), il n’est pas nécessaire de configurer explicitement la broche 10 comme entrée comme vous le faisiez auparavant avec pyfirmata.INPUT. Une fois les broches définies, vous pouvez accéder au statut d’une broche d’entrée numérique à l’aide de lis()et définir l’état d’une broche de sortie numérique avec écrire().

Les entrées numériques sont largement utilisées dans les projets électroniques. Plusieurs capteurs fournissent des signaux numériques, tels que des capteurs de présence ou de porte, qui peuvent être utilisés comme entrées de vos circuits. Cependant, dans certains cas, vous devrez mesurer des valeurs analogiques, telles que la distance ou des quantités physiques. Dans la section suivante, vous apprendrez à lire les entrées analogiques à l’aide d’Arduino avec Python.

Lecture des entrées analogiques

Contrairement aux entrées numériques, qui peuvent uniquement être activées ou désactivées, entrées analogiques sont utilisés pour lire les valeurs dans une certaine plage. Sur l’Arduino Uno, la tension d’une entrée analogique est comprise entre 0V et 5V. Des capteurs appropriés sont utilisés pour mesurer des quantités physiques, telles que des distances. Ces capteurs sont responsables du codage de ces quantités physiques dans la plage de tension appropriée, de sorte qu'elles puissent être lues par l'Arduino.

Pour lire une tension analogique, l’Arduino utilise une convertisseur analogique-numérique (ADC), qui convertit la tension d’entrée en un nombre numérique avec un nombre fixe de bits. Cela détermine la résolution de la conversion. L'Arduino Uno utilise un CAN 10 bits et peut déterminer 1024 niveaux de tension différents.

La plage de tension d’une entrée analogique est codée pour des nombres compris entre 0 et 1023. Lorsque 0V est appliqué, l’Arduino le code pour le nombre 0. Lorsque 5V est appliqué, le nombre codé est 1023. Toutes les valeurs de tension intermédiaires sont codées proportionnellement.

Un potentiomètre est une résistance variable que vous pouvez utiliser pour définir la tension appliquée à une entrée analogique Arduino. Vous allez le connecter à une entrée analogique pour contrôler la fréquence d’un voyant clignotant:

Dans ce circuit, la LED est configurée comme avant. Les bornes du potentiomètre sont connectées à la terre (GND) et aux broches 5V. De cette façon, le terminal central (le curseur) peut avoir n'importe quelle tension dans la plage 0V à 5V en fonction de sa position, qui est connectée à l'Arduino sur la broche analogique A0.

En utilisant une planche à pain, vous pouvez assembler ce circuit comme suit:

Avant de contrôler la LED, vous pouvez utiliser le circuit pour vérifier les différentes valeurs lues par Arduino, en fonction de la position du potentiomètre. Pour ce faire, lancez le programme suivant sur votre PC:

    1 importation pyfirmata
    2 importation temps
    3 
    4 planche = pyfirmata.Arduino('/ dev / ttyACM0')
    5 il = pyfirmata.util.Itérateur(planche)
    6 il.début()
    sept 
    8 analog_input = planche.get_pin('a: 0: i')
    9 
dix tandis que Vrai:
11     valeur_analogique = analog_input.lis()
12     impression(valeur_analogique)
13     temps.dormir(0,1)

En ligne 8, vous configurez analog_input comme broche d'entrée analogique A0 avec l'argument 'a: 0: i'. À l'intérieur de l'infini tandis que boucle, vous lisez cette valeur, stockez-le dans valeur_analogiqueet afficher la sortie sur la console avec impression(). Lorsque vous déplacez le potentiomètre pendant l'exécution du programme, vous devez générer une sortie similaire à celle-ci:

0.0
0,0293
0,1056
0,1838
0,2717
0,3705
0,4428
0.5064
0,5797
0,6315
0,6764
0,7243
0,7859
0,8446
0.9042
0,9677
1,0
1,0

Les valeurs imprimées changent, allant de 0 lorsque la position du potentiomètre est à une extrémité à 1 quand il est à l’autre. Notez qu'il s'agit de valeurs flottantes pouvant nécessiter une conversion en fonction de l'application.

Pour changer la fréquence du voyant clignotant, vous pouvez utiliser le bouton valeur_analogique pour contrôler la durée d'activation ou de désactivation du voyant:

    1 importation pyfirmata
    2 importation temps
    3 
    4 planche = pyfirmata.Arduino('/ dev / ttyACM0')
    5 il = pyfirmata.util.Itérateur(planche)
    6 il.début()
    sept 
    8 analog_input = planche.get_pin('a: 0: i')
    9 LED = planche.get_pin('d: 13: o')
dix 
11 tandis que Vrai:
12     valeur_analogique = analog_input.lis()
13     si valeur_analogique est ne pas Aucun:
14         retard = valeur_analogique + 0,01
15         LED.écrire(1)
16         temps.dormir(retard)
17         LED.écrire(0)
18         temps.dormir(retard)
19     autre:
20         temps.dormir(0,1)

Ici, vous calculez retard comme valeur analogique + 0.01 pour éviter d'avoir retard égal à zéro. Sinon, il est courant d’obtenir un valeur_analogique de Aucun au cours des premières itérations. Pour éviter d’obtenir une erreur lors de l’exécution du programme, vous utilisez une ligne conditionnelle de la ligne 13 pour vérifier si: valeur_analogique est Aucun. Ensuite, vous contrôlez la période du clignotement de la LED.

Essayez de lancer le programme et de changer la position du potentiomètre. Vous remarquerez la fréquence des changements de voyant clignotants:

Vous avez maintenant vu comment utiliser les entrées numériques, les sorties numériques et les entrées analogiques de vos circuits. Dans la section suivante, vous verrez comment utiliser les sorties analogiques.

Utilisation de sorties analogiques

Dans certains cas, il est nécessaire d’avoir un sortie analogique pour piloter un appareil nécessitant un signal analogique. Arduino n’inclut pas de sortie analogique réelle, une sortie dans laquelle la tension pourrait être réglée sur une valeur comprise dans une certaine plage. Cependant, Arduino comprend plusieurs Modulation de largeur d'impulsion (PWM) sorties.

Le PWM est une technique de modulation dans laquelle une sortie numérique est utilisée pour générer un signal à puissance variable. Pour ce faire, il utilise un signal numérique de fréquence constante, dans lequel le cycle de service est changé en fonction de la puissance désirée. Le rapport cyclique représente la fraction de la période pendant laquelle le signal est réglé sur haute.

Toutes les broches numériques Arduino ne peuvent pas être utilisées comme sorties PWM. Ceux qui peuvent être identifiés sont identifiés par un tilde (~):

Plusieurs dispositifs sont conçus pour être pilotés par des signaux PWM, y compris certains moteurs. Il est même possible d’obtenir un signal analogique réel à partir du signal PWM si vous utilisez des filtres analogiques. Dans l'exemple précédent, vous utilisiez une sortie numérique pour allumer ou éteindre un voyant. Dans cette section, vous utiliserez PWM pour contrôler la luminosité d’une LED, en fonction de la valeur d’une entrée analogique donnée par un potentiomètre.

Lorsqu'un signal PWM est appliqué à une LED, sa luminosité varie en fonction du cycle de service du signal PWM. Vous allez utiliser le circuit suivant:

Ce circuit est identique à celui utilisé dans la section précédente pour tester l’entrée analogique, à une différence près. Comme il n’est pas possible d’utiliser PWM avec la broche 13, la broche de sortie numérique utilisée pour la LED est la broche 11.

Vous pouvez utiliser une planche à pain pour assembler le circuit comme suit:

Une fois le circuit assemblé, vous pouvez contrôler la LED à l’aide de PWM avec le programme suivant:

    1 importation pyfirmata
    2 importation temps
    3 
    4 planche = pyfirmata.Arduino('/ dev / ttyACM0')
    5 
    6 il = pyfirmata.util.Itérateur(planche)
    sept il.début()
    8 
    9 analog_input = planche.get_pin('a: 0: i')
dix LED = planche.get_pin('d: 11: p')
11 
12 tandis que Vrai:
13     valeur_analogique = analog_input.lis()
14     si valeur_analogique est ne pas Aucun:
15         LED.écrire(valeur_analogique)
16     temps.dormir(0,1)

Il existe quelques différences par rapport aux programmes que vous avez utilisés précédemment:

1. Dans la ligne 10, vous définissez LED en mode PWM en passant l'argument 'd: 11: p'.
2. À la ligne 15, tu appelles led.write () avec valeur_analogique comme argument. C'est une valeur comprise entre 0 et 1, lue à partir de l'entrée analogique.

Vous pouvez voir ici le comportement de la LED lorsque le potentiomètre est déplacé:

Un oscilloscope est branché sur la broche 11 pour indiquer les modifications du rapport cyclique. Lorsque le potentiomètre est à zéro, vous pouvez voir que la DEL est éteinte, car la broche 11 a 0V en sortie. Lorsque vous tournez le potentiomètre, la DEL devient plus lumineuse à mesure que le facteur de marche PWM augmente. Lorsque vous tournez le potentiomètre à fond, le facteur de marche atteint 100%. La LED est allumée en permanence à la luminosité maximale.

Avec cet exemple, vous avez abordé les bases de l’utilisation d’un Arduino et de ses entrées et sorties numériques et analogiques. Dans la section suivante, vous verrez une application permettant d’utiliser Arduino avec Python pour gérer des événements sur le PC.

Utilisation d'un capteur pour déclencher une notification

Firmata est un bon moyen de se familiariser avec Arduino avec Python, mais le recours à un PC ou à un autre périphérique pour exécuter l’application peut être coûteux et cette approche peut ne pas être pratique dans certains cas. Cependant, lorsqu'il est nécessaire de collecter des données et de les envoyer à un PC à l'aide de capteurs externes, Arduino et Firmata forment une bonne combinaison.

Dans cette section, vous utiliserez un bouton-poussoir connecté à votre Arduino pour imiter un capteur numérique et déclencher une notification sur votre machine. Pour une application plus pratique, vous pouvez considérer le bouton-poussoir comme un capteur de porte qui déclenchera une notification d'alarme, par exemple.

Pour afficher la notification sur le PC, vous allez utiliser Tkinter, la boîte à outils graphique standard de Python. Cela affichera une boîte de message lorsque vous appuierez sur le bouton. Pour une introduction détaillée à Tkinter, consultez la documentation de la bibliothèque.

Vous devrez assembler le même circuit que vous avez utilisé dans l'exemple d'entrée numérique:

Après avoir assemblé le circuit, utilisez le programme suivant pour déclencher les notifications:

    1 importation pyfirmata
    2 importation temps
    3 importation tkinter
    4 de tkinter importation messagerie
    5 
    6 racine = tkinter.Tk()
    sept racine.se désister()
    8 
    9 planche = pyfirmata.Arduino('/ dev / ttyACM0')
dix 
11 il = pyfirmata.util.Itérateur(planche)
12 il.début()
13 
14 entrée numérique = planche.get_pin('d: 10: je')
15 LED = planche.get_pin('d: 13: o')
16 
17 tandis que Vrai:
18     sw = entrée numérique.lis()
19     si sw est Vrai:
20         LED.écrire(1)
21         messagerie.showinfo("Notification", "Le bouton a été appuyé")
22         racine.mise à jour()
23         LED.écrire(0)
24     temps.dormir(0,1)

Ce programme est similaire à celui utilisé dans l'exemple d'entrée numérique, avec quelques modifications:

• Lignes 3 et 4 bibliothèques d'importation nécessaires pour configurer Tkinter.
• Ligne 6 crée la fenêtre principale de Tkinter.
• Ligne 7 indique à Tkinter de ne pas afficher la fenêtre principale à l’écran. Pour cet exemple, il vous suffit de voir la boîte de message.
• Ligne 17 commence le tandis que boucle:
  1. Lorsque vous appuyez sur le bouton, le voyant s’allume et messagebox.showinfo () affiche une boîte de message.
  2. La boucle s'interrompt jusqu'à ce que l'utilisateur appuie sur D'accord. De cette façon, le voyant reste allumé tant que le message est affiché.
  3. Après que l'utilisateur appuie D'accord, root.update () efface la boîte de message de l'écran et le voyant est éteint.

Pour étendre l'exemple de notification, vous pouvez même utiliser le bouton poussoir pour envoyer un email lorsque vous appuyez dessus:

    1 importation pyfirmata
    2 importation temps
    3 importation smtplib
    4 importation ssl
    5 
    6 def send_email():
    sept     Port = 465  # Pour SSL
    8     smtp_server = "smtp.gmail.com"
    9     sender_email = ""
dix     destinataire_email = ""
11     mot de passe = ""
12     message = "" "Objet: Notification Arduino n    L'interrupteur était allumé. "" "
13 
14     le contexte = ssl.create_default_context()
15     avec smtplib.SMTP_SSL(smtp_server, Port, le contexte=le contexte) comme serveur:
16         impression("Envoi d'email")
17         serveur.s'identifier(sender_email, mot de passe)
18         serveur.envoyer un mail(sender_email, destinataire_email, message)
19 
20 planche = pyfirmata.Arduino('/ dev / ttyACM0')
21 
22 il = pyfirmata.util.Itérateur(planche)
23 il.début()
24 
25 entrée numérique = planche.get_pin('d: 10: je')
26 
27 tandis que Vrai:
28     sw = entrée numérique.lis()
29     si sw est Vrai:
30         send_email()
31         temps.dormir(0,1)

Vous pouvez en apprendre plus sur send_email () dans l'envoi d'emails avec Python. Ici, vous configurez la fonction avec les informations d'identification du serveur de messagerie, qui seront utilisées pour envoyer le courrier électronique.

Avec ces exemples d’applications, vous avez vu comment utiliser Firmata pour interagir avec des applications Python plus complexes. Firmata vous permet d'utiliser n'importe quel capteur relié à l'Arduino pour obtenir des données pour votre application. Ensuite, vous pouvez traiter les données et prendre des décisions dans l'application principale. Vous pouvez même utiliser Firmata pour envoyer des données aux sorties Arduino, en contrôlant des commutateurs ou des périphériques PWM.

Si vous souhaitez utiliser Firmata pour interagir avec des applications plus complexes, essayez certains de ces projets:

• Un moniteur de température pour vous alerter lorsque la température devient trop élevée ou trop basse
• Un capteur de lumière analogique capable de détecter une ampoule grillée
• Un capteur d'eau pouvant activer automatiquement les arroseurs lorsque le sol est trop sec

Conclusion

Les plates-formes de microcontrôleurs sont en hausse, grâce à la popularité croissante du mouvement Maker et de l'internet des objets. Des plateformes comme Arduino retiennent particulièrement l’attention, car ils permettent aux développeurs comme vous d’utiliser leurs compétences et de plonger dans des projets électroniques.

Vous avez appris à:

• Développer des applications avec Arduino et Python
• Utiliser le protocole Firmata
• Contrôle des entrées et sorties analogiques et numériques
• Intégration de capteurs dans des applications Python de niveau supérieur

You also saw how Firmata may be a very interesting alternative for projects that demand a PC and depend on sensor data. Plus, it’s an easy way to get started with Arduino if you already know Python!

Further Reading

Now that you know the basics of controlling Arduino with Python, you can start working on more complex applications. There are several tutorials that can help you develop integrated projects. Here are a few ideas:

• REST APIs: These are widely used to integrate different applications. You could use REST with Arduino to build APIs that get information from sensors and send commands to actuators. To learn about REST APIs, check out Python REST APIs With Flask, Connexion, and SQLAlchemy.

• Alternate GUIs: In this tutorial, you used Tkinter to build a graphical application. However, there are other graphical libraries for desktop applications. To see an alternative, check out How to Build a Python GUI Application With wxPython.

• Threading: The infinite tandis que loop that you used in this tutorial is a very common feature of Arduino applications. However, using a thread to run the main loop will allow you to execute other tasks concurrently. To learn how to use threads, check out An Intro to Threading in Python.

• Face Detection: It’s common for IoT apps to integrate machine learning and computer vision algorithms. With these, you could build an alarm that triggers a notification when it detects faces on a camera, for example. To learn more about facial recognition systems, check out Traditional Face Detection With Python.

Lastly, there are other ways of using Python in microcontrollers besides Firmata and Arduino:

• pySerial: Arduino Uno cannot run Python directly, but you could design your own Arduino sketch and use pySerial to establish a serial connection. Then you can control Arduino with Python using your own protocol.

• MicroPython: If you’re interested in running Python directly on a microcontroller, then check out the MicroPython project. It provides an efficient implementation of Python to be executed on some microcontrollers such as the ESP8266 and ESP32.

• SBCs: Another option is to use a single board computer (SBC) such as a Raspberry Pi to run Python. SBCs are complete, Arduino-sized computers that can run a Linux-based operating system, allowing you to use vanilla Python. As most SBCs provide General-purpose input and output pins, you can use it to replace an Arduino on most applications.