Firmata et Arduino (3): PWM en python

Nous continuons  donc cette série d'articles sur la façon d'utiliser le protocole Firmata pour contrôler une carte Arduino au moyen d'un script en python qui s'exécute sur un ordinateur hôte.  La dernière fois, nous avions vu comment régler l'état des sorties numériques de l'Arduino.  Cette fois, nous allons contrôler un signal modulé en largeur d'impulsion (PWM).

Qu'est-ce que le PWM?

La modulation par largeur d'impulsion (ou pulse width modulation, d'où l'acronyme PWM) est une succession de signaux logiques 0 ou 1 (donc 0 V et 5 V dans le cas de l'Arduino).  Lorsque le rapport cyclique (duty cycle) est de 0%, le signal est toujours à 0 V.  Lorsque le rapport cyclique est de 100%, le signal est toujours à 5 V.  Si le rapport cyclique est de 25%, le signal est haut pendant 25% du temps, et bas pendant les 75% restants...

Et à quoi ça sert, le PWM?

Au moyen d'un filtre passs-bas, un signal PWM peut être transformé en une tension analogique continue dont la valeur se situe entre 0 et 5 V.  On peut aussi utiliser un signal PWM pour contrôler la vitesse d'un moteur.  Dans cet article, nous utiliserons le signal PWM pour contrôler la luminosité d'une LED (plus le rapport cyclique sera élevé, plus la lumière émise par la LED sera intense).

Le circuit

Le circuit sera évidemment très simple:  une LED et une résistance de protection (220 ohms, par exemple), reliée à une des pins PWM de l'Arduino  (3, 5, 6, 9, 10, 11 sur l'Arduino Uno).  Les scripts présentés ci-dessous supposent que la LED est branchée à la pin 11.

Bibliothèque PyFirmata, etc.

Nous supposons que le sketch "StandardFirmata" a été téléversé dans votre Arduino, et que la bibliothèque pyFirmata a déjà été installée sur l'ordinateur hôte (si ce n'est pas le cas, référez-vous à l'article précédent pour plus de détails sur la façon de procéder).

Rédaction d'un script en python

L'utilisation du PWM avec pyFirmata nécessite deux étapes:

1) Le réglage d'une pin de l'Arduino en mode PWM, au début du programme, au moyen de la méthode "get_pin":

       LEDpin = board.get_pin('d:11:p')

À prime abord, la syntaxe peut sembler un peu nébuleuse: nous créons un objet de type PIN nommé "LEDpin".  Les arguments de get_pin indiquent que la pin numérique  numéro 11 est en mode PWM (le "d" est pour "digital" et le "p" est pour "PWM").

2)  Le réglage du rapport cyclique du signal PWM, chaque fois qu'on désire le modifier:

       board.digital[LEDpin.pin_number].write(rapport_cyclique)

Le rapport cyclique doit être un nombre se situant entre 0 (rapport cyclique de 0%) et 1 (rapport cyclique de 100%).  Par exemple, pour émettre sur la pin numéro 5 un signal PWM dont le rapport cyclique sera de 30%, on pourrait écrire:

       board.digital[5].write(0.3)

Premier exemple de script (interface en mode texte)

Dans ce premier exemple, l'utilisateur doit écrire un nombre (entre 0 et 100) pour régler le rapport cyclique (et, par conséquent, la luminosité de la LED).

	#!/usr/bin/env python
	# -*- coding: latin-1 -*-
	'''
	Contrôle de la luminosité d'une LED l'Arduino
	à partir d'un PC au moyen du protocole Firmata
	Version simple en mode texte
	Pour plus de détails:
	http://electroniqueamateur.blogspot.com/2015/06/firmata-et-arduino-3-pwm-en-python.html
	'''
	import pyfirmata
	port = 'COM3' #windows
	#port = '/dev/ttyACM0' #linux
	board = pyfirmata.Arduino(port)
	LEDpin = board.get_pin('d:11:p') ## d = digital, 11 = numéro de la pin, p = PWM
	print "-------------- CONTROLE DE LEDS ----------------"
	print "En tout temps, vous pouvez quitter le programme en répondant par 'q'."
	while True:
	print "Luminosité désirée pour la LED:"
	luminosite = raw_input("De 0 à 100 (ou q): ")
	if (luminosite == 'q'):
	board.exit();
	print "Au revoir!"
	break;
	board.digital[LEDpin.pin_number].write(float(luminosite)/100.0)

view raw PWMLEDText.py hosted with ❤ by GitHub

Deuxième exemple de script (interface graphique)

Ici, nous utilisons Tkinter pour faire apparaître un curseur qui contrôle le rapport cyclique.

	#!/usr/bin/python
	# -*- coding: utf-8 -*-
	"""
	Contrôle de la luminosité d'une LED l'Arduino
	à partir d'un PC au moyen du protocole Firmata
	Interface graphique (Tkinter)
	Pour plus d'infos:
	http://electroniqueamateur.blogspot.com/2015/06/firmata-et-arduino-3-pwm-en-python.html
	"""
	from Tkinter import *
	import pyfirmata
	pin1 = 2
	pin2 = 3
	pin3 = 4
	port = 'COM3' #windows
	#port = '/dev/ttyACM0' #linux
	board = pyfirmata.Arduino(port)
	LEDpin = board.get_pin('d:11:p') #on règle la pin 11 en mode PWM
	# S'exécute lors d'un changement du slider:
	def reglageLED(valeur):
	board.digital[LEDpin.pin_number].write(float(valeur)/100.0)
	class Example(Frame):
	def __init__(self, parent):
	Frame.__init__(self, parent)
	self.parent = parent
	self.initUI()
	def initUI(self):
	self.parent.title("LED") #titre de la fenêtre
	self.pack(fill=BOTH, expand=1)
	# Label (le texte dans la fenêtre):
	w = Label(self, wraplength = 200, pady = 10, text="Veuillez glisser le curseur pour contrôler la luminosité de la LED")
	w.pack()
	# Curseur:
	self.var1 = IntVar()
	w2 = Scale(self, from_=0, to=100, orient=HORIZONTAL, command = reglageLED)
	w2.pack()
	def main():
	root = Tk()
	root.geometry("250x200+300+300") # dimension et position initiale de la fenêtre
	app = Example(root)
	root.mainloop()
	if __name__ == '__main__':
	main()

view raw PWMLEDgui.py hosted with ❤ by GitHub

Yves Pelletier   (Twitter, Facebook)

Firmata et Arduino (2): allumons des LEDs en python

Dans un récent article, nous nous sommes amusés à contrôler les sorties de l'Arduino au moyen d'un ordinateur, en utilisant le protocole Firmata.  Nous avions alors utilisé un logiciel général déjà existant (Firmata Test Program).

Dans ce second article (et dans ceux qui suivrons), nous allons voir comment procéder pour concevoir nos propres programmes en Python qui permettront à l'ordinateur hôte de contrôler les sorties de l'Arduino au moyen du protocole Firmata.

1) Préparation de l'Arduino

Téléchargez dans l'Arduino le sketch "StandardFirmata" (Menu Fichier - Exemples - Firmata - StandardFirmata).

2) Installation de la bibliothèque PyFirmata

Nous supposons que Python est déjà installé sur votre ordinateur, ainsi que "pip", le logiciel qui permet d'ajouter facilement des modules supplémentaires à Python.

Notez que pip est installé par défaut lors de l'installation de Python depuis les versions 2.7.9 et 3.4.0. Sous Windows, il m'a semblé plus simple de remplacer ma version 2.7.7 de Python par la version 2.7.9 plutôt que d'installer pip séparément (car à première vue, ça semblait un peu compliqué).  Sous Linux, il s'agit d'écrire "sudo apt-get install python-pip" et le tour est joué.

Pour installer PyFirmata, vous écrivez cette ligne de commande dans le terminal (si vous êtes dans Windows, vous faites:  Menu démarrer - Tous les programmes - Accessoires - Invite de Commande):

   pip install pyfirmata

(Sous Linux, je crois que j'ai dû écrire "sudo pip install pyfirmata" pour que ça fonctionne, ce qui bien sûr ne surprendra personne).

Si tout va comme prévu, ça devrait vous confirmer que PyFirmata a été installé avec succès.


3)  Construction d'un circuit constitué de 3 LEDs

À titre de démonstration, nous allons écrire un programme en Python qui contrôle l'état des sorties numériques de l'Arduino, ce qui aura pour effet d'allumer et d'éteindre des LEDs (bien entendu, rien ne vous empêche de remplacer les LEDs par autre chose comme, par exemple, des relais).

Nous branchons donc une LED a chacune des sorties 2, 3 et 4 de l'Arduino, chaque LED étant protégée par une résistance (220 Ω, par exemple).

4)  Script Python simple (interface en mode texte)

Voici un premier script en Python qui permet à l'utilisateur de contrôler l'état des LEDs à partir de l'ordinateur auquel est branché l'Arduino.

Pour modifier l'état d'une sortie numérique (l'équivalent d'un digitalWrite en langage Arduino), la syntaxe est la suivante:

     board.digital[numéro_de_pin].write(0_ou_1)

Ce programme est en mode texte:  c'est probablement plus facile à programmer (surtout si vous êtes novices en Python), mais c'est loin d'être idéal pour l'utilisateur, qui doit patiemment répondre aux questions qu'on lui pose au moyen d'une lettre ou d'un nombre.

Notez que pour que ça fonctionne correctement, vous devez  assigner la valeur appropriée à la variable "port".  Sous Windows ce sera probablement quelque chose comme "COM3", sous Linux ce sera plutôt "/dev/ttyACM0".  Il se peut que vous deviez démarrer l'IDE Arduino pour connaître le nom du port série correspondant à votre Arduino.

	#!/usr/bin/env python
	# -*- coding: latin-1 -*-
	'''
	Contrôle de LEDs branchées à l'Arduino à partir
	d'un PC au moyen du protocole Firmata
	Version simple en mode texte
	Pour plus de détails:
	http://electroniqueamateur.blogspot.com/2015/06/firmata-et-arduino-2-allumons-des-leds.html
	'''
	import pyfirmata
	port = 'COM3' #windows
	#port = '/dev/ttyACM0' #linux
	board = pyfirmata.Arduino(port)
	print "-------------- CONTROLE DE LEDS ----------------"
	print "En tout temps, vous pouvez quitter le programme en répondant par 'q'."
	while True:
	print "Indiquez le numéro de la pin de l'Arduino dont vous désirez modifier l'état (2-13)"
	pin = raw_input("Numéro de pin (ou q): ")
	if (pin == 'q'):
	print "Au revoir!"
	break;
	print "Indiquez si vous désirez allumer la LED (1) ou l'éteindre (0)"
	etat = raw_input("0 ou 1 (ou q): ")
	if (etat == 'q'):
	print "Au revoir!"
	break;
	board.digital[int(pin)].write(int(etat))

view raw ControleLEDTexte.py hosted with ❤ by GitHub

5)  Script Python avec interface graphique (Tkinter)

Le programme sera beaucoup plus convivial s'il comporte une interface graphique.  Le sketch présenté ci-dessous utilise Tkinter, qui semble être la solution la plus répendue pour produire des interfaces graphiques en Python.  En général, Tkinter est déjà installé par défaut avec Python.

Pour l'utilisateur, il s'agit de cocher ou décocher les cases pour allumer ou éteindre les LEDs branchées à l'Arduino.

	#!/usr/bin/python
	# -*- coding: utf-8 -*-
	"""
	Contrôle de LEDs branchées à l'Arduino à partir
	d'un PC au moyen du protocole Firmata
	Interface graphique (Tkinter)
	Pour plus d'informations:
	http://electroniqueamateur.blogspot.com/2015/06/firmata-et-arduino-2-allumons-des-leds.html
	"""
	from Tkinter import *
	import pyfirmata
	pin1 = 2
	pin2 = 3
	pin3 = 4
	port = 'COM3' #windows
	#port = '/dev/ttyACM0' #linux
	board = pyfirmata.Arduino(port)
	class Example(Frame):
	def __init__(self, parent):
	Frame.__init__(self, parent)
	self.parent = parent
	self.initUI()
	def initUI(self):
	self.parent.title("Contrôleur de LEDs") #titre de la fenêtre
	self.pack(fill=BOTH, expand=1)
	# Label (le texte dans la fenêtre):
	w = Label(self, wraplength = 200, pady = 10, text="Veuillez cliquer ces boutons pour allumer et éteindre les LEDs")
	w.pack()
	# Premier bouton:
	self.var1 = IntVar()
	cb = Checkbutton(self, text="LED 1",
	variable=self.var1, command=self.onClick1)
	cb.pack()
	# Deuxième bouton:
	self.var2 = IntVar()
	cb = Checkbutton(self, text="LED 2",
	variable=self.var2, command=self.onClick2)
	cb.pack()
	# Troisième bouton:
	self.var3 = IntVar()
	cb = Checkbutton(self, text="LED 3",
	variable=self.var3, command=self.onClick3)
	cb.pack()
	# S'exécute lors d'un clic sur le premier bouton:
	def onClick1(self):
	board.digital[pin1].write(self.var1.get())
	# S'exécute lors d'un clic sur le deuxième bouton:
	def onClick2(self):
	board.digital[pin2].write(self.var2.get())
	# S'exécute lors d'un clic sur le troisième bouton:
	def onClick3(self):
	board.digital[pin3].write(self.var3.get())
	def main():
	root = Tk()
	root.geometry("250x200+300+300") # dimension et position initiale de la fenêtre
	app = Example(root)
	root.mainloop()
	if __name__ == '__main__':
	main()

view raw ControleLEDgui.py hosted with ❤ by GitHub

Vous savez maintenant comment contrôler l'état des sorties numériques de l'Arduino à partir d'un ordinateur au moyen d'un script en Python.  Tel que mentionné dans le précédent article, le protocole Firmata permet également de lire l'état des entrées (numériques ou analogiques), produire un signal PWM et contrôler un servomoteur:  ce sera le sujet des prochains articles...


Yves Pelletier   (Twitter, Facebook)

Firmata (1): l'Arduino comme périphérique d'un ordinateur

Vous désirez contrôler des relais à partir d'un ordinateur?  Interroger des capteurs afin d'accumuler les données dans un ordinateur (datalogging)?  Dans ce genre d'application, où l'Arduino est utilisé comme un périphérique USB plutôt que comme un dispositif autonome, Firmata peut s'avérer très utile.

Firmata est un protocole qui vise à faciliter la communication entre un ordinateur et un microcontrôleur.   Les messages échangés par l'ordinateur et le microcontrôleur sont similaire à ceux du protocole MIDI, utilisé dans le domaine des instruments de musique électroniques.

Dans ce premier article, je  vous invite à effectuer une petite expérimentation qui, en moins de 5 minutes, devrait vous convaincre de la pertinence, de l'efficacité et de la simplicité du protocole.

1) Préparation de l'Arduino

Sans grande surprise, votre Arduino doit être branché à l'ordinateur hôte, au moyen d'un câble USB.

Nous n'avons pas à installer la bibliothèque Firmata, puisqu'elle est incluse dans l'IDE Arduino. Notre tâche consistera simplement à téléverser dans la carte Arduino l'exemple "StandardFirmata" (Menu Fichier - Exemples - Firmata - StandardFirmata).

Votre Arduino est maintenant prêt à recevoir des messages en provenance de l'ordinateur, et à les interpréter correctement.

2) Préparation de l'ordinateur

Rendez-vous ensuite sur cette page web consacrée à Firmata et téléchargez le logiciel "Firmata Test Program" dans la version appropriée pour votre système d'exploitation (Linux, MacOS ou Windows).

Au démarrage, cette application vous demandera de sélectionner le port série correspondant à votre carte Arduino (menu "Port").  Une fois ce port sélectionné, la fenêtre affiche la liste des entrées/sorties de votre Arduino (sauf les pins 0 et 1, qui sont déjà  utilisées pour la communication série par USB entre l'ordinateur et la carte).

3)  Communication entre l'ordinateur et l'Arduino

À partir de ce logiciel, vous pouvez régler individuellement chaque pin de l'Arduino en entrée numérique (Input) ou en sortie (Output).  Lorsqu'elles en sont capables, certaines pins peuvent également être réglées en entrée analogique (Analog), pour émettre un signal en modulation de largeur d'impulsion (PWM) ou pour commander un servomoteur (Servo).

• Si vous avez réglé la pin en entrée numérique (Input), son état logique (Low ou High) est affiché.
• Si vous avez réglé la pin en sortie numérique (Output), un bouton vous permet de régler son état logique à Low ou High (par exemple, la LED de la carte Arduino s'allumera si vous réglez la pin 13 à High).
• Si vous avez réglé la pin en entrée analogique (possible pour les pins 14 à 19, qui sont les entrées A0 à A5), leur valeur entre 0 et 1023 est affichée.
• Si vous avez réglé la pin en mode "Servo", un curseur vous permet de régler la position du servomoteur.
• Si vous avez réglé la pin en mode "PWM", un curseur vous permet de régler le rapport cyclique du signal émis.

Admettez que ce petit programme peut se révéler très pratique, ne serait-ce que pour tester le bon fonctionnement de toutes les pins de votre Arduino, vérifier le fonctionnement correct d'un servomoteur, etc.

Dans un prochain article, nous verrons comment utiliser Firmata dans nos propres programme en Python, qui s'exécuteront sur l'ordinateur hôte.

Yves Pelletier   (Twitter, Facebook)

Le gagnant du concours

Le concours est maintenant terminé et, tel que prévu, j'ai utilisé l'application "Pick a Winner" de Woobox pour choisir un gagnant au hasard parmi tous ceux qui avaient cliqué sur "J'aime" ou laissé un commentaire sur l'annonce du concours sur notre page Facebook.

Et le gagnant est...Marsellus Wallace, qui se mérite pour 25 € de composants électroniques chez Composant Électronique Pas Cher.

Bravo au gagnant, et merci à tous les participants, ainsi qu'à notre sponsor "Composant Électronique pas Cher".

Clavier MIDI Arduino, version 2.0

Objectif de ce projet: construire un contrôleur MIDI en utilisant un clavier récupéré d'un vieil orgue électronique des années '70 et un Arduino Uno.  Il ne s'agit pas d'un instrument autonome, mais plutôt d'un dispositif qui envoi des messages MIDI vers un deuxième appareil qui transformera ces instructions en musique audible (ce deuxième appareil peut être, par exemple, un deuxième clavier MIDI, ou un ordinateur équipé des logiciels appropriés, etc.).

Ce projet n'est pas totalement nouveau:  c'est une amélioration d'un projet que j'avais réalisé 3 ans plus tôt.

Ce que l'ancienne version pouvait déjà faire:

• envoyer par l'entremise d'un câble MIDI des messages "note on" et "note off" correspondant aux notes appuyées par le musicien.  
• augmenter ou diminuer l'octave de la note jouée, grâce à une paire de boutons poussoir ("octave up" et "octave down"), question de compenser la faible étendue du  clavier utilisé (3 octaves...).
• modifier le  programme, c'est à dire la sonorité de l'instrument (piano, trompette, etc.) au moyen d'une autre paire de bouton

Cette nouvelle version comporte les améliorations suivantes:

• Ajout d'un registre à décalage HC165, afin d'économiser quelques entrées sur l'Arduino.
• Grâce aux pins libérées sur l'Arduino, ajout d'un afficheur LCD.
• Ajout d'un dispositif anti-rebond pour les boutons qui permettent le changement d'octave et le changement de programme.
• Ajout d'un potentiomètre permettant le contrôle de la vélocité (le volume sonore).
• Ajout d'un joystick permettant de contrôler le "pitch bend".

Le clavier:

Il  provient d'un orgue Yamaha Electone fabriqué en 1980 ou à peu près, presque identique à celui qui est représenté sur la photographie ci-contre.

Mon clavier n'est pas sensible à la vélocité de la touche: il réagira de la même façon peu importe que le musicien enfonce la touche tout doucement, ou brusquement.  C'est un inconvénient pour le musicien (ça donne une musique moins expressive) mais d'un point de vue technique, ça va nous faciliter les choses.

Les touches d'un clavier sont connectées de façon à former une matrice, qui permet de détecter la ou  les touches enfoncées sans qu'il soit nécessaire que chaque touche soit reliée de façon indépendante à son propre circuit.  Grâce à cette matrice, je peux tester chacune des 37 touches du clavier au moyen de 16 connecteurs seulement.  Ces connecteurs sont visibles sur la photo ci-dessous, dans le coin supérieur gauche du clavier.

Au moyen d'un  multimètre, j'ai pu constater que, lorsque j'appuie sur la touche "sol" la plus grave du clavier, le connecteur "Sol" sur la photo ci-dessous est mis en contact avec le connecteur "Octave 1". Si j'appuie sur la touche "sol" située un octave plus haut sur le clavier, le connecteur "Sol" sera maintenant en contact avec le connecteur "Octave 2", et ainsi de suite.  Il n'y a qu'une note sur le 4e octave:  FA (mon clavier commence par un FA, et se termine également par un FA).   Notez bien qu'il s'agit de la description de la matrice du clavier que j'ai utilisé:  il y a de très fortes chances que le clavier que vous utiliserez ait une matrice différente.

Le schéma ci-dessous illustre la matrice pour les touches "sol" et "la" du premier octave, et pour les touches "sol" et "la" du deuxième octave.  Pour plus de clarté, je n'ai pas illustré la totalité des 37 touches...   Comme vous pouvez le constater, chaque touche du clavier est accompagnée d'une diode.