Livre: Programmez un Raspberry Pi, par Simon Monk

Programmez un Raspberry Pi
Initiation avec Python
par Simon Monk
Publié en 2014 par les Éditions Dunod, collection ETSF

Comme le titre l'indique, cette traduction en Français du livre "Programming the Raspberry Pi, Getting Started with Python", dont la version originale avait été publiée en 2012 chez McGraw-Hill, s'adresse aux débutants qui désirent apprendre à réaliser des programmes en langage Python sur un Raspberry Pi.

Dès la lecture du sommaire, une constatation s'impose:  même si le livre ne fait que 175 pages, l'auteur a tenté de couvrir très large. On vous explique tout d'abord ce qu'est un Raspberry Pi (dans un chapitre devenu quelque peu désuet depuis la sortie des modèles A+ et B+),  puis on vous initie aux rudiments de Linux (en  8 pages...si votre objectif est de devenir un expert en Linux, ce livre n'est pas pour vous!).

On aborde ensuite la programmation en Python 3, incluant la programmation orientée objet (modules, classes et méthodes), l'utilisation de Tkinter pour la création d'interfaces graphiques et la programmation de jeux avec Pygame.

Sauf à la toute fin du livre, lorsqu'on utilise enfin les pins GPIO pour construire une horloge et un robot, les programmes présentés n'ont rien de spécifique au Raspberry Pi et pourraient être réalisés sur n'importe quel ordinateur et système d'exploitation.

Bien entendu, la maîtrise de chacun des sujets précédemment mentionnés nécessiterait l'étude assidue de livres beaucoup plus volumineux; n'allez donc pas croire que ce petit livre fera de vous un expert de la conception de robots en Raspberry Pi, ou que vous y trouverez les réponses à toutes vos questions,

Mais dans les circonstances, Simon Monk ne se débrouille pas trop mal.  J'aime bien son approche directe basée sur des projets concrets  qui permettent d'intégrer plusieurs connaissances essentielles. Bien conscient que son livre ne fait qu'effleurer le sujet, l'auteur n'hésite pas à fournir de nombreuses adresses qui nous permettront de trouver des informations supplémentaires sur le web (références peut-être un peu trop souvent en anglais, toutefois).

Finalement, je m'en voudrais de passer sous silence une tendance irritante à encourager l'achat d'accessoires parfois coûteux qui ne sont pas à ce point essentiels:  le  Pi Face, le Slice of PI/O,  le GertBoard, le Pi Cobbler, le PI Plate, le Humble Pi... :  ce n'est plus du DIY, c'est du BIY (buy it yourself)!   Et à mon avis, l'auteur se place clairement en conflit d'intérêt lorsqu'il préconise de construire le projet final du livre  au moyen du  RaspiRobotBoard ($30) qu'il a lui-même conçu.

Anecdote amusante:  l'auteur nous conseille même d'acheter une carte SD comportant un système d'exploitation pré-installé, sous prétexte qu'installer soi-même le système d'exploitation est une tâche très délicate!  (Je suppose que le livre avait été écrit avant la mise au point de NOOBS)

En résumé:  une bonne lecture si vous maîtrisez déjà assez bien Linux, mais que vous connaissez peu (ou pas du tout) le langage Python.

Yves Pelletier (Twitter: @ElectroAmateur)

Cours en ligne: BerkeleyX: EE40LX Electronic Interfaces

Ça faisait un certain temps que je n'avais pas suivi un MOOC, mais BerkeleyX: EE40LX Electronic Interface, qui a démarré officiellement il y a quelques jours, s'annonce tellement amusant que je n'ai pas pu m'empêcher de m'inscrire.

Pendant 15 semaines, plus de 20 000 étudiants vont tenter de construire un petit robot sauteur en suivant les directives de Michel M. Maharbiz et Tom J. Zajdel de l'Université de Californie à Berkeley, tout en faisant l'apprentissage de quelques notions de base en électronique.

Ce sera mon premier robot sauteur, et ça semble une excellente occasion de renouer avec Energia et le MSP430 Launchpad, que je n'avais pas utilisés depuis un bon moment...




Yves Pelletier (Twitter: @ElectroAmateur)

Accéléromètre MMA7455 et Raspberry Pi (python)

Il y a quelques semaines, j'avais utilisé mon accéléromètre MMA7455 avec un Arduino.  Grâce à une bibliothèque réalisée par Moritz Kemper, le processus s'était révélé relativement simple.

Pour le raspberry Pi, je n'ai pas trouvé de bibliothèque python spécifique au MMA7455.  Quelques articles m'ont servi de point de départ (en particulier celui-ci), mais j'ai dû apporter pas mal de modifications au script pour qu'il se comporte comme je le désirais.

1)  Activation du protocole I²C

D'abord, si ce n'est pas déjà fait, il faut activer l'I²C sur le Raspberry Pi.  Ça tombe bien:  j'ai justement publié un article à ce sujet.

2)  Branchements du breakout MMA7455

J'espère que votre accéléromètre MMA7455 se trouve sur un breakout facile à brancher, comme celui qui est représenté sur la photo ci-contre.  Sinon, il est possible de faire des soudures sur le minuscule circuit intégré (comme dans ce projet), mais il faut être diablement habile!

Comme pour tous les périphériques utilisant le protocole I²C, vous devez branchez la pin SDA ("serial data") de l'accéléromètre à la pin 3 (BOARD) / GPIO 2 (BCM) du Raspberry Pi, et la pin SCL ("serial clock") de l'accéléromètre à la pin 5 (BOARD) / GPIO 3 (BCM) du Raspberry Pi.

De plus, il faut alimenter notre accéléromètre en branchant sa pin VCC à une des pins de 3,3 V du Rasbperry Pi, et la pin GND de l'accéléromètre à une des pins GND du Raspberry Pi.

En principe, les périphérique I²C nécessitent une résistance de tirage entre SDA et 3,3 V, et une autre résistance de tirage entre SCL et 3,3 V, mais je n'ai pas eu besoin d'en mettre.



3)  Programme en python

Le script ci-dessous mesure les composantes x, y et z de l'accélération.  Puisque l'accéléromètre a été réglé à une résolution lui permettant de mesurer des valeurs étalées entre -2g et +2g, une accélération de -2g retourne une valeur brute de -127, une accélération nulle retourne 0, et une accélération de +2g retourne 127.

Attention:  l'accéléromètre ne fait aucune différence entre une accélération et la gravité:  si votre accéléromètre est immobile, la force gravitationnelle provoquera une mesure de 63, qui est la valeur qui correspond à 1g (alors que si votre accéléromètre est en chute libre, vous devriez mesurer une valeur de 0 sur tous les axes).

Donc, si votre accéléromètre immobile et horizontal, bien à plat sur une table, vous devriez mesurer une valeur de 0 selon x, 0 selon y et 63 selon z (à cause de la gravité).  Si ce n'est pas le cas, modifiez les valeurs des variables ajustx, ajusty et ajustz.

Le script applique également le théorème de Pythagore afin d'afficher la grandeur de l'accélération totale.

De plus, il affiche l'inclinaison de l'accéléromètre:   l'angle en degrés que fait son axe des x par rapport à l'horizontale, l'angle que fait l'axe des y par rapport à l'horizontale, et l'angle que fait l'axe des z par rapport à la verticale.

Yves Pelletier   (Twitter:  @ElectroAmateur)

Activation des pins I2C du Raspberry Pi

Mise à jour (11 janvier 2019): Lors de la publication de cet article, en janvier 2015, l'activation du protocole i2c sur le Rasbperry Pi était beaucoup plus complexe qu'elle ne l'est maintenant: il était nécessaire d'éditer manuellement le fichier /etc/modules ainsi que le fichier raspi-blacklist/conf ... Vous lisez présentement une nouvelle version mise à jour, qui décrit la nouvelle procédure, beaucoup plus simple...


1)  Réglage des préférences

Ouvrez "Configuration du Raspberry Pi" dans le menu "Préférence" de Raspbian.

Dans l'onglet "Interfaces", vous vous assurez que I2C est activé.

2)  Installation de i2c-tools

i2c-tools contient les librairies essentielles pour accéder aux broches i2c dans nos scripts en Python. Elles sont maintenant incluses par défaut dans Raspbian et cette étape est donc devenue superflue mais, à tout hasard, voici la commande pour l'installation:

sudo apt-get install python-smbus i2c-tools

3)  Redémarrage du Raspberry Pi

sudo reboot

4)  Vérifications

Suite au redémarrage, on peut vérifier que l'I²C fonctionne en tapant:

sudo i2cdetect -y 1

(ou "sudo i2cdetect -y 0" s'il s'agit du Raspberry Pi modèle A, "sudo i2cdetect -y 2" s'il s'agit d'un Banana Pi M2 Berry )

...qui vous retourne une réponse de ce genre:

Alors qu'aucun périphérique n'est branché:

     0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f
00:          -- -- -- -- -- -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- UU -- -- -- --
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
70: -- -- -- -- -- -- -- --  

Après branchement d'un accéléromètre MMA7455:

     0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f
00:          -- -- -- -- -- -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- UU -- 1d -- --
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
70: -- -- -- -- -- -- -- --  

...ce qui indique que l'adresse I²C de mon accéléromètre (en hexadécimal) est 1D.

Suite à l'ajout d'un deuxième périphérique:  une horloge temps réel (RTC) DS1307:

     0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f
00:          -- -- -- -- -- -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- UU -- 1d -- --
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50: 50 -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: -- -- -- -- -- -- -- -- 68 -- -- -- -- -- -- --
70: -- -- -- -- -- -- -- --    

On voit s'ajouter l'adresse I²C de l'horloge (68) ainsi que de la mémoire (EEPROM) qui lui est associée (50).

Vos périphériques I²C sont maintenant prêts à être utilisés!

Source

Yves Pelletier (Twitter: @ElectroAmateur)

Amplificateurs opérationnels (8): Oscillateur à pont de Wien

Après une pause de plusieurs semaines, nous continuons aujourd'hui notre exploration des innombrables applications de l'amplificateur opérationnel.  Nous avions déjà transformé notre UA741 en oscillateur:  d'abord pour produire un signal en créneau (onde carrée), et ensuite pour produire un signal périodique de forme triangulaire.  Aujourd'hui, au moyen d'un circuit à peine plus compliqué, nous allons produire un signal de forme sinusoïdale.

Notre oscillateur à pont de Wien est une variante du circuit mis au point en 1939 par William Hewlett, cofondateur de la célèbre compagnie Hewlett-Packard.


Pour expérimenter, j'ai utilisé un circuit proposé dans un protocole de laboratoire de Virginia Tech.  Cette version de l'oscillateur utilise deux diodes comme dispositif de stabilisation de l'amplitude (Hewlett utilisait une ampoule incandescente, d'autres circuits utilisent un thermistor, une photorésistance ou un transistor à effet de champ).

Le pont de Wien proprement dit est la partie supérieure du circuit schématisé ci-dessous.  Il est constitué de deux résistances "R" identiques entre elles et de deux condensateurs "C" identiques entre eux.  Un des condensateur est relié en parallèle avec une des résistances, et cette paire est placé en série avec l'autre condensateur et l'autre résistance.

La fréquence du signal sinusoïdal produit par ce circuit dépend strictement de la valeur de "R" et "C":      f = 1 / (2πRC).   Par exemple, si vous utilisez deux condensateurs de 100 nF et deux résistances de 1 kΩ, la fréquence devrait être 1,6 kHz.    Pour augmenter la fréquence, vous diminuez la valeur de R ou de C.

Pour le reste, j'ai utilisé un amplificateur opérationnel UA741 alimenté par une alimentation ATX d'ordinateur.  Mes diodes étaient des 1N4002, mais je ne vois aucune raison de ne pas utiliser un autre modèle à la place.  Le potentiomètre permet de contrôler l'amplitude, et  il est parfois nécessaire de tourner son bouton pour démarrer l'oscillation.

Voici ce que ça donne à l'écran de l'oscilloscope:

Article suivant:  Amplificateurs opérationnels (9):  filtres 

Article précédent:  Amplificateurs opérationnels (7):  source de courant

Yves Pelletier (Twitter:  @ElectroAmateur)

Mesurez votre rythme cardiaque avec Arduino

Aujourd'hui, je vous livre un compte-rendu de mes récentes expériences de photopléthysmographie, une méthode qui consiste à détecter les battements du coeur en mesurant le volume de sang dans les tissus au moyen d'une source de lumière et d'un détecteur.

Comme matériel, j'ai utilisé une LED infrarouge (TSAL7400) et un phototransistor sensible à l'infrarouge (TOPS-050), un double amplificateur opérationnel (LM358), un transistor 2N3904, mon fidèle Arduino Uno, et quelques condensateurs et résistances que j'énumérerai de façon plus détaillée plus loin dans cet article.

Mon point de départ a été ce tutoriel publié par MAKE magazine.  J'ai commencé par reproduire le plus exactement possible le circuit qui y était proposé, pour en arriver à une absence totale de résultats:  pas la moindre pulsation cardiaque en vue.  Conclusion:  ou bien ce circuit correspondait mal au matériel que j'utilisais, ou bien j'étais récemment décédé, sans que qui que ce soit n'ait pris la peine de m'en avertir!


L'article de du magazine MAKE propose de la photopléthysmographie par réflexion:  la source de lumière (la LED infrarouge) et le détecteur (le phototransistor) sont placés côte à côte.  Lorsqu'on appuie cette paire émetteur-récepteur sur la surface de la peau, au bout d'un doigt, la quantité de rayonnement infrarouge réfléchi vers le récepteur est supposé changer en fonction du volume de sang qui circule sous la peau.

Bon...je ne sais pas si c'est parce que ma peau est plus réfléchissante qu'elle le devrait, mais je n'ai rien obtenu de probant en procédant de cette façon.

Par contre, j'ai obtenu des résultats beaucoup plus intéressants en plaçant la source de lumière (la LED infrarouge) et le détecteur de lumière (le phototransistor) de part et d'autre de mon doigt.  De cette façon, le détecteur mesure maintenant le rayonnement qui a traversé le doigt.  Plus le volume de sang est élevé dans les vaisseaux, plus le doigt est opaque et absorbe une grande quantité de la lumière transmise par la LED:  c'est de la photopléthysmographie par transmission.

La lumière ambiante et les mouvements du doigt par rapport à la paire émetteur-détecteur peuvent facilement fausser les résultats, j'ai donc construit une petite boîte de forme étroite et allongée dans laquelle j'insère un doigt.  La LED infrarouge et le phototransistor se situent au fond de la boîte, de part et d'autre de l'extrémité de mon doigt.

J'ai aussi constaté que mon phototransistor avait une meilleure sensibilité si je le couplait à une résistance de 10K plutôt qu'à une résistance de 39K.  C'est probablement dû au fait que mon modèle de phototransistor n'est pas identique à celui qui était proposé dans le tutoriel de MAKE.

(Plusieurs personnes affirment avoir eu du succès en utilisant une photorésistances plutôt qu'un phototransistor: je n'ai pas essayé.)

À cette étape, j'obtenais un signal tout à fait satisfaisant:  mes pulsations cardiaques provoquaient un changement de tension très net à la sortie du circuit (le graphique ci-dessous représente 5 secondes de pulsations cardiaques):

 Je me suis malgré tout interrogé sur deux aspects du circuit:

1)  Le tutoriel de MAKE magazine proposait l'utilisation d'un LM324, qui comporte 4 amplificateurs opérationnels.   Traitez-moi de pingre si vous voulez, mais je ne vois pas tellement l'intérêt d'installer un circuit intégré comportant deux fois plus d'amplificateurs que nécessaire, et de laisser la moitié de ses pins inutilisées.  J'ai donc essayé avec un LM358, et ça a parfaitement fonctionné.

2)  Le tutoriel spécifiait que les deux condensateurs de 1 µF devaient être au tantale, mais était-ce bien nécessaire?  Je les ai remplacé par des condensateurs électrolytiques, pour constater que la qualité des résultats en souffrait:  fréquemment, de façon aléatoire, la tension chutait pendant une pulsation, ce qui pouvait donner l'illusion qu'il y avait eu deux pulsations distinctes plutôt qu'une seule.  Alors j'ai gardé les condensateurs au tantale.

Voici donc le schéma du circuit que j'ai finalement utilisé (cliquez-le pour l'agrandir):

Attention, plusieurs des composants ne sont pas réversibles:

• LED infrarouge: la tige la plus courte à GND
• Phototransistor:  la tige la plus longue à GND
• Condensateurs au tantale:  le signe + indique l'armature +
• Transistor 2N3904:

Voici un premier sketch qui enregistre les données brutes dans le moniteur série pendant une durée de 5 secondes.




Ces données sont utiles pour, d'une part, vérifier le bon fonctionnement du circuit et, d'autre part, définir un seuil qui servira de critère pour détecter le début d'une pulsation. 

J'ai copié ces données à partir du moniteur série de l'IDE Arduino, et je les ai copiées dans un tableur pour les mettre en graphique.  J'ai ainsi pu constater que la valeur alternait entre un peu moins de 600, puis un peu plus de 700.  J'ai donc décidé qu'une pulsation commence au moment où la valeur monte en traversant un seuil de 650.

À partir de cette information, j'ai mis au point un deuxième sketch qui, chaque fois qu'une pulsation est détectée, affiche dans le moniteur série le rythme cardiaque en pulsations par minute.



Voici le résultat:

Conclusion:  mon rythme cardiaque est un peu rapide.  Il faut que je songe sérieusement à diminuer ma consommation de café...

Yves Pelletier (Twitter: @ElectroAmateur)

Cartes SD et STM32 Nucleo

Aujourd'hui, nous expérimentons l'écriture de de fichiers sur une carte SD au moyen de la carte STM32 Nucleo.

Matériel:

J'ai utilisée la carte Nucleo F030R8 et un lecteur de carte SD fabriqué par LC Studio, le modèle de base qu'on trouve partout pour vraiment pas cher.

Connexions:

Un premier avantage évident du Nucleo, c'est qu'il communique avec un niveau logique de 3,3 V qui convient parfaitement aux cartes SD.  Contrairement à l'Arduino, nous n'aurons donc pas besoin d'utiliser un 4050 pour abaisser le niveau logique de 5 V à 3,3 V:  les connexions sont directes.

Le lecteur de carte SD utilise le protocole SPI.  6 connexions sont nécessaires et, puisque la carte est compatible avec les shields Arduino, les pins SPI du Nucleo sont les mêmes que sur un Arduino:

• Pin  GND du lecteur SD  :  Pin GND du Nucleo
• Pin +3.3 du lecteur SD:   Pin 3V3 du Nucleo
• Pin CS du lecteur SD: Pin D10 du Nucleo
• Pin MOSI du lecteur SD:  Pin D11 du Nucleo
• Pin SCK du lecteur SD:  Pin D13 du Nucleo
• Pin MISO du lecteur SD:  Pin D12 du Nucleo

Pour utiliser pleinement le sketch que je vous propose ci-dessous, vous branchez également un potentiomètre à l'entrée A0 (prenez garde d'alimenter ce potentiomètre avec 3,3 volts et non avec 5 volts).


Importation des bibliothèques

La meilleure méthode que j'ai trouvée pour importer toutes les bibliothèques nécessaires dans mon espace de travail mbed, c'est d'importer le programme intitulé "Seeed_SDCard_Shield".

Dans mbed, vous cliquez sur le bouton "Imports", vous sélectionnez l'onglet "Programs", vous faites une recherche pour "SDCard", vous choisissez dans la liste "Seeed_SDCard_Shield", puis vous cliquez sur le bouton "Import!".

Dans la boîte de dialogue qui apparaît ensuite, ne cochez pas "Update all libraries with latest revision":  étrangement, j'avais des erreurs de compilation si je cochais cette case!

Mon sketch

Le programme que vous avez importé devrait fonctionner correctement:  il écrit un message dans un fichier sur la carte SD.  Si le fichier existe déjà, il l'efface pour en créer un nouveau.

Je vous propose ci-dessous un sketch un peu différent, qui me semble plus utile  (vous pourrez le copier dans le fichier main.c pour remplacer l'autre programme):  chaque fois que vous appuyez sur  le bouton reset (le bouton noir sur la carte Nucleo), la valeur analogique lue sur l'entrée A0 sera ajoutée dans un fichier intitulé Nucleo.txt.  Si le fichier n'existait pas déjà, il sera créé.  S'il existait déjà, les données qu'il contenait ne seront pas effacées:  les nouvelles données sont simplement ajoutées à celles qui s'y trouvaient déjà.

Voilà une excellente base pour construire un data logger avec votre carte Nucleo!


Yves Pelletier (@ElectroAmateur)

Une boîte qui crie quand elle tombe

Aujourd'hui, nous poursuivons notre exploration de l'accéléromètre MMA7455.  Au cours des derniers jours, nous avons fabriqué un appareil qui mesure avec quelle intensité il est secoué, et nous avons construit un inclinomètre.  Cette fois-ci, nous allons construire un détecteur de chute libre.  Pour ce faire, nous allons mettre dans une petite boîte un Arduino Uno, un accéléromètre et un haut-parleur:  le haut-parleur va émettre un son chaque fois que la boîte sera en chute libre (si vous préférez, vous pouvez utiliser le même principe pour construire un ballon qui devient lumineux aussitôt qu'il se trouve dans les airs).


Si vous avez suivi quelques cours de physique, vous savez que l'accélération d'un objet en chute libre est de 9,8 m/s² vers le bas.  Et, bien entendu, l'accélération d'un objet qui repose sagement immobile est nulle.

Notre accéléromètre, toutefois, ne fait aucune différence entre la gravité et l'accélération:  lorsqu'il est immobile, il mesure une accélération vers le haut égale à 9,8 m/s², et lorsqu'il est en chute libre il mesure une accélération nulle (c'est assez logique:  dans l'espace intersidéral, si vous désirez que les passagers d'un vaisseau spatial subissent une gravité artificielle identique à celle de la terre, vous devrez faire subir au vaisseau une accélération de 9,8 m/s²).

Les branchements

En supposant que vous utilisez le même breakout MMA7455 que moi (celui qui est illustré ci-contre), c'est tout simple:

• Vcc du breakout au 5V de l'Arduino 
• GND du breakout au GND de l'Arduino.
• SCL du breakout à l'entrée analogique A5 de l'Arduino.
• SDA du breakout à l'entrée analogique A4 de l'Arduino.

Il faut aussi brancher le haut-parleur à l'Arduino:  un fil à la pin 9, et l'autre à une pin GND de l'Arduino.

Ensuite, vous mettez tout ça dans une boîte, avec un peu de papier journal froissé pour éviter que les divers composants se déplacent l'un par rapport à l'autre dans la boîte (et pour les protéger lors du choc de la boîte sur le plancher).

Le mieux, c'est d'alimenter votre Arduino au moyen d'une pile (dans mon prototype, je me suis contenté de faire passer mon câble USB par un trou dans la boîte).


Bibliothèque MMA7455

À moins que ce ne soit déjà fait, vous installez la bibliothèque mise au point par Moritz Kemper pour utiliser ce genre d'accéléromètre avec l'Arduino.


Le sketch

Rien de bien compliqué ici:  nous utilisons la fonction "Tone" pour émettre un son lorsque l'accéléromètre mesure une valeur nulle.  Nous avons tout de même une assez grande marge de manoeuvre entre la situation où l'accéléromètre est immobile (il indique alors une accélération de 63) et celui où il est en chute libre.  Pour tenir compte des incertitudes de mesure,  je me contente de détecter une accélération inférieure à 15.

Pour une meilleure fiabilité, prenez la peine de calibrer votre accéléromètre en modifiant les valeurs de calibrateOffset pour que les valeurs affichées par l'accéléromètre quand il est immobile, bien à plat sur une table soient de 0 en x, 0 en y et 63 en z.

Il ne vous reste plus qu'à tester le dispositif:  laissez tomber la boîte, ou lancez-là dans les airs:  aussitôt qu'elle quitte vos mains (et jusqu'à ce qu'elle touche au sol), elle émet un beep.


Yves Pelletier (Twitter:  @ElectroAmateur)

Mesurer un angle d'inclinaison avec un accéléromètre

Aujourd'hui, nous construisons un inclinomètre, c'est à dire un appareil qui mesure sa propre inclinaison par rapport à l'horizontale.

Pour ce faire, nous utiliserons encore une fois un breakout basé sur l'accéléromètre MMA7455 relié à un Arduino Uno.

Puisqu'un accéléromètre sert à mesurer une accélération, il peut être un peu surprenant d'apprendre qu'on peut s'en servir pour mesurer l'inclinaison d'un objet immobile...   La raison, c'est qu'un accéléromètre ne fait pas la différence entre l'accélération et la gravité.  Lorsqu'il est immobile, l'accéléromètre mesure, en fait, le champ gravitationnel.

Pour être plus précis, l'accéléromètre mesure la composante de la force de gravité selon 3 axes:  l'axe des x (orienté selon le sens de la longueur du breakout), l'axe des y (orienté selon le sens de la largeur du breakout) et l'axe des z (orienté perpendiculairement à la surface du breakout).

Par exemple, si votre accéléromètre repose à plat sur la surface d'une table, l'axe des x et l'axe des y sont horizontaux, et l'axe des z est vertical:  toute la force gravitationnelle est orientée selon l'axe des z et l'accéléromètre affichera:

x:  0    y : 0     z: 63

... ce qui est l'équivalent de:

x:  63 sin 0°       y: 63 sin 0°     z: 63 cos 0°

(63 est la valeur correspondant à une accélération de 1 g, lorsque l'accéléromètre a été réglé pour mesurer des valeurs allant de -2g à +2g).

Supposons maintenant que vous inclinez  l'accéléromètre de 30°, de façon que l'axe des x ne soit plus parfaitement horizontal, et que l'axe des z ne soit plus parfaitement vertical.  La force gravitationnelle se répartit maintenant sur deux axes, avec une composante x et une composante z:

x: 63 sin 30°            y = 0      z = 63 cos 30°

Donc, pour mesurer l'angle d'inclinaison du breakout, il s'agit de mesurer les 3 composantes de l'accélération (x, y et z) et de faire un peu de trigonométrie.

Les branchements

Notre breakout sera branché pour être utilisé en mode I2C:

• Vcc du breakout au 5 V de l'Arduino (car le breakout que j'utilise comporte un régulateur de tension:  si le vôtre n'en comporte pas, ou si vous n'êtes pas certain qu'il en comporte un, commencez par le brancher à 3,3V).
• GND du breakout au GND de l'Arduino
• SCL du breakout à l'entrée analogique A5 de l'Arduino
• SDA du breakout à l'entrée analogique A4 de l'Arduino

Mon breakout semble déjà comporter des résistances de tirage à SCL et SDA, ainsi qu'à CS (pour activer le mode I2C).  Ces résistances peuvent être nécessaires si votre breakout est différent du mien.

Bibliothèque MMA7455

Si ce n'est pas déjà fait, installez la bibliothèque MMA7455 de Moritz Kemper.

Le sketch

Ce court sketch utilise les composantes x, y et z mesurées par l'accéléromètre pour calculer:

- l'angle que fait l'axe des x du breakout par rapport à l'horizontale
- l'angle que fait l'axe des y du breakout par rapport à l'horizontale
- l'angle que fait l'axe des z du breakout par rapport à la verticale, peu importe que cette inclinaison soit causée par une inclinaison de l'axe des x, ou par une inclinaison de l'axe des y, ou  par une combinaison des deux.



Conclusion:

Les mesures sont plausibles, mais il y a du bruit:  en laissant l'accéléromètre parfaitement immobile (donc son inclinaison ne change pas), la valeur mesurée peut varier de quelques degrés;  je m'attendais à mieux.

Yves Pelletier (Twitter: @ElectroAmateur)