Publié le 23 mai 2016 - par

Pi Mediacenter OSMC pilotant un Arduino en mode « esclave »

arduino esclave d'un pi media centerBesoin de ports GPIO supplémentaires en 5 Volts ?
Un Arduino « esclave » de votre pi peut vous aider ! Alimentez-le en USB et profitez de 200 milli-ampères disponible en 5 Volts, …

Dans ce projet, je détaille pas à pas la réalisation d’un éclairage LED d’appoint connecté à mon média center OSMC et piloté depuis la télécommande de celui-ci.

Contexte

Le Raspberry Pi dispose de ports GPIO alimentés en 3.3 Volts et est donc limité à cette tension (sauf si vous utilisez l’unique port 5Volts qui ne peut pas être contrôlé (on/off).

Je souhaitais ajouter un petit éclairage d’ambiance derrière mon écran plat et pour disposer de suffisamment de lumière, il me fallait la possibilité d’alimenter des LEDs en 5 Volts.

Par ailleurs, disposant d’un simple clone « Arduino UNO », je voulais pouvoir piloter cet éclairage d’appoint depuis la télécommande de mon Pi configuré en tant que « MediaCenter » (OSMC / Kodi).

Pour ce projet, j’ai donc choisi de connecter un clone Arduino UNO avec mon Pi via un port USB.

Retour d’expérience personnelle

J’ai commencé à écrire cet article bien avant sa publication car en cours de rédaction je me suis rendu compte d’une erreur de compréhension sur la réalisation des connexions entre l’Arduino et les LEDs (ça c’est quand on regarde un peu partout des exemples sans fiabilité assurée publiés par n’importe qui pour s’inspirer et réaliser son propre projet).

En effet, sur base de mes recherches, j’étais persuadé que comme l’Arduino dispose d’un convertisseur supportant jusque 1 Ampère, je pouvais disposer sans soucis de 700~800 milliampères pour alimenter des LEDs directement depuis les ports GPIO de l’Arduino.

D’essais en essai, j’ai pu constater que l’intensité lumineuse n’était pas bonne et je me demandais pourquoi …

Après avoir cherché plus précisément pendant un long moment sur plusieurs sites, j’ai découvert que l’Arduino ne donnait pas plus de 40 milliampères par port GPIO. Et que la puce ATMEGA328 ne pouvait pas dépasser un total maximal de 200 milliampères tous ports GPIO confondus. Ces valeurs étant des maximales, j’ai aussi découvert qu’il ne fallait pas pousser la bête dans ses retranchements au risque de raccourcir sa durée de vie pour cause de surchauffe excessive.

J’ai donc du adapter ma première réalisation qui alimentait plusieurs LEDs sur 2 ports pour passer à un schéma ou chaque LED est alimentée par un port unique.

Pour protéger chaque LED, il semble communément admis qu’en cas de manque de documentation technique spécifique, nous pouvons considérer qu’une LED peut consommer jusqu’à 20 milliampères mais qu’il est conseillé de limiter ce « maximum » par l’ajout d’une résistance de 330 ohms ayant pour effet de laisser passer au maximum 15 milliampères.

Pour ne pas atteindre la limite des 200 milliampères, j’ai aussi volontairement limité mon montage à 7 LEDs soit, un peu plus de la moitié de 200 milliampères (7*15, +/- 105 maximum)

LED jauneJe vous détaille donc ci-après un montage tenant compte de ces limites qui préserveront la durée de vie de nos petits circuits.

Pré-requis

Matériel

  • Un Raspberry Pi installé avec la dernière version d’OSMC (Kodi)
  • Un Arduino Uno (ou un clone ATMEGA328P pour 2~3 dollars sur les sites chinois)
  • Quelques LEDs jaunes (ou autres couleurs mais je recommande le jaune/orange pour un éclairage « doux »)
  • Une plaque d’essai (Breadboard)
  • Des résistances de 330 Ohms

Logiciel

Construction du circuit « LEDS » sur votre « plaque d’essai » (Breadboard ou « planche à pain » selon google traduction et aliexpress 🙂

Voici l’exemple du circuit que j’ai créé pour ce projet.

nanpy-pcb-schema

Installation de NANPY sur votre Arduino UNO

NANPY… C’est quoi ?

Nanpy est un ensemble de code prévu pour être utilisé sur un Arduino uno piloté par un système d’exploitation utilisant Python. Le code, une fois envoyé dans l’Arduino, s’exécute en mode « écoute » pour recevoir des ordres externes en vue, par exemple, d’activer/désactiver des ports GPIO de l’Arduino.

Envoyer NANPY dans l’Arduino

  1. Rendez vous sur le site : https://pypi.python.org/pypi/nanpy
  2. Cliquez sur « Downloads »
  3. Téléchargez la version 0.9.6
  4. Décompressez le fichier téléchargé
  5. Démarrer l’environnement intégré de développement (IDE) Arduino
  6. Connectez votre Arduino à votre PC
  7. Chargez la libraire « ZIP » de NANPY téléchargée à l’étape 2 dans l’environnement de développement Arduino :
    charger-nanpy-lib
  8. Dans l’environnement de développement, sélectionnez le bon port de communication (port COM) et le bon type d’Arduino que vous utilisez
  9. Chargez le « sketch » NANPY.ino que vous pourrez trouver dans le répertoire de décompression créé à l’étape 4
  10. Modifiez le fichier de « configuration » de NANPY (cfg.h) qui est stocké dans les librairies Arduino (dans mon cas: C:\Users\username\Documents\Arduino\Nanpy)
  11. Ce fichier de configuration détermine les librairies que vous allez devoir charger dans votre Arduino.
  12. Si le fichier n’existe pas, créez le avec un éditeur de texte du type Notepad++

Voici celui que j’ai utilisé (cfg.h):

#pragma once
 
#define BAUDRATE 115200
 
// info about existence of other features
#define USE_Info                                    1
 
// definitions: MCU type, frequency, Arduino version,
// EEPROM size, RAM size, pin count, build time,..
#define USE_Define                                  1
 
// low level mapping of pins and ports
#define USE_ArduinoCore                             1
 
// read, write RAM
#define USE_RAM                                     1
 
// read, write EEPROM
#define USE_EEPROM                                  1
 
// read, write AVR registers
#define USE_Register                                0
 
// watchdog and reset
#define USE_Watchdog                                0
 
#define USE_Tone                                    0
 
#define USE_LiquidCrystal                           0
 
// I2C
#define USE_Wire                                    0
 
#define USE_Servo                                   0
 
#define USE_Stepper                                 0
 
// frequency counter,  USE_Tone should be off!
#define USE_Counter                                 0
 
///////////////////////////////////////////////////////////////////////
// external libraries should be installed for the following features:
///////////////////////////////////////////////////////////////////////
 
// https://github.com/PaulStoffregen/OneWire
#define USE_OneWire                                 0
 
// https://github.com/milesburton/Arduino-Temperature-Control-Library
#define USE_DallasTemperature                       0
 
 
#define USE_CapacitiveSensor                        0
 
// https://github.com/adafruit/DHT-sensor-library
#define USE_DHT                                     0
 
// https://bitbucket.org/fmalpartida/new-liquidcrystal
#define USE_LiquidCrystal_I2C                       0
 
// https://www.adafruit.com/products/1429
#define USE_TLC5947                                 0
  1. Dans l’environnement Arduino, vérifiez que le code est complet en cliquant sur le bouton V ou via le menu « Sketch », sélectionnez « Verify/Compile »
  2. Une fois le code vérifié avec succès, envoyez le code dans votre Arduino via le menu « Sketch », sélectionnez « Upload »
  3. Si l’envoi se passe bien, votre Arduino Uno est maintenant prêt à être connecté au Raspberry Pi. Vous pouvez le déconnecter de votre PC et passer à l’étape suivante.

Installation de NANPY sur le Raspberry Pi

  1. Connectez vous à votre raspberry pi via SSH en utilisant par exemple … Putty
  2. Installez NANPY en exécutant la commande suivante : sudo pip install nanpy
  3. En principe, à l’installation de NANPY, vous aurez remarqué que pip à également installé Pyserial qui est la libraire qui assurera la communication via le port USB entre le Pi et l’Arduino.
  4. Connectez l’Arduino au Raspberry Pi via un câble USB

Testez le tout depuis votre Pi avec un script Python

Allumer les LEDS

voici un script que vous pouvez sauver sur votre Raspberry Pi en donnant le nom de fichier arduion.py

Pour l’exécuter, petit rappel, sudo python arduion.py

Remarque: dans le code ci-dessous, j’ai remplacé la première ligne de code par une image car je ne pouvais pas sauvegarder l’article avec le code en texte.

 usrenvpython
# Original Author: Andrea Stagi <stagi.andrea@gmail.com>
# Modified version Author: Jean-Jacques Guazzo <jjguazzo@hotmail.com>
# Original Description: keeps your led blinking
# Modified Description: put external leds and the internal led on pin 13 on
# Dependencies: None
 
from nanpy import (ArduinoApi, SerialManager)
from time import sleep
 
connection = SerialManager()
a = ArduinoApi(connection=connection)
 
a.pinMode(8, a.OUTPUT)
a.pinMode(7, a.OUTPUT)
a.pinMode(13, a.OUTPUT)
a.digitalWrite(8,1)
a.digitalWrite(7,1)
a.digitalWrite(13,0)

Eteindre les LEDS

Voici un script que vous pouvez sauver sur votre Raspberry Pi en donnant le nom arduioff.py

Pour l’exécuter, petit rappel, sudo python arduioff.py

Remarque: dans le code ci-dessous, j’ai remplacé la première ligne de code par une image car je ne pouvais pas sauvegarder l’article avec le code en texte.

 usrenvpython
# Author: Andrea Stagi <stagi.andrea@gmail.com>
# Modified version Author: Jean-Jacques Guazzo <jjguazzo@hotmail.com>
# Original Description: keeps your led blinking
# Modified Description: put external leds and the internal led on pin 13 off
# Dependencies: None
 
from nanpy import (ArduinoApi, SerialManager)
from time import sleep
 
connection = SerialManager()
a = ArduinoApi(connection=connection)
 
a.pinMode(8, a.OUTPUT)
a.pinMode(7, a.OUTPUT)
a.pinMode(13, a.OUTPUT)
a.digitalWrite(8,0)
a.digitalWrite(7,0)
a.digitalWrite(13,0)

OSMC

Pour cette partie, vous devez disposer d’une installation fonctionnelle d’OSMC et d’une télécommande fonctionnelle avec OSMC.

Placer les scripts Arduino dans le bon dossier

Par défaut, l’utilisateur de Kodi ne peut pas exécuter directement des scripts dans votre dossier « home« , vous devez les placer dans un dossier spécifique et leur donner les droits adéquats.

Voici la procédure à suivre:

  1. Exécutez: mkdir scripts (dans votre dossier « home« , l’endroit ou vous arrivez par défaut après connexion en SSH)
  2. copiez vos scripts (arduioff.py et arduion.py) dans le dossier scripts
  3. Exécutez: sudo chown OSMC scripts
  4. Exécutez: cd scripts
  5. Exécutez: sudo chmod u+x *.*
  6. Exécutez: ls -l et vérifiez que vos scripts on bien le x présent dans les droits (ou sont listés en vert et donc exécutables)

Installation de « Keymap Editor »

Depuis Kodi, ajoutez l’extension « programme » appelée « Keymap Editor ». Elle permet de modifier les associations entre les touches du clavier (et de la télécommande) et les fonctions de Kodi (play, pause, ….)
Démarrez « Keymap Editor » et assignez une fonction peu utilisée à une touche de votre télécommande (celle que vous utiliserez pour allumer les LEDs), recommencez l’opération pour la touche d’extinction des LEDs.
Cette action a pour effet de créer un fichier sur le Raspberry Pi. C’est ce fichier qu’il faut modifier par la suite pour exécuter les scripts arduion.py et arduioff.py

Modification de la configuration « Keymap Editor »

Connectez vous a votre pi en SSH.

  • Une fois connecté, exécutez : cd .Kodi/userdata/keymaps/ pour changer de dossier et modifier le fichier de configuration.
  • Exécutez la commande sudo nano gen.xml pour ouvrir le fichier de configuration. Si le fichier qui s’ouvre est vide c’est que vous avez mal effectué les modifications expliquées à l’étape précédente (installation de keymap editor)
  • Dans le fichier gen.xml, vous devez trouver la fonction que vous avez assigné à chacune des touches de votre télécommande. Exemple de fonction assignée:
    <key id= »61478″>contextmenu</key> (la touche correspond donc à l’id 61478)
  • Remplacez « contextemenu » par RunScript(/home/OSMC/scripts/arduion.py) pour avoir le résultat suivant :
    <key id= »61478″>RunScript(/home/OSMC/scripts/arduion.py)</key>
  • Recommencez l’opération pour l’autre touche et le script arduioff.py
  • Quittez l’éditeur nano (Ctrl+X) en prenant soin de sauvegarder le fichier modifié.
  • Redémarrez votre Pi complètement (en laissant bien l’Arduino connecté)

Mise en pratique

Si vous avez respecté les étapes décrites ci-avant et que vous n’avez pas rencontré de problème, une fois Kodi chargé, pressez les touches de votre télécommande pour éteindre ou allumer les LEDS.

Problèmes les plus plausibles :

  • vous n’avez pas de dossier script avec les autorisations correctes
  • vous n’avez pas testé « manuellement » les scripts

Conclusions

Ce petit projet paraît simpliste mais il vous permet de mettre en place une chaîne complexe d’exécution avec deux micro-contrôleurs différents. Ce type de configuration est utilisé dans des projets plus complexes car elle vous permet de disposer de ports 5 volts ou tout simplement de ports supplémentaires.

Share Button

À propos Jean-Jacques Guazzo

Autodidacte, curieux et passionné, je suis à l'origine un professionnel de l'IT notamment dans les grandes infrastructures réseau, les environnements virtuels et dans les technologies qui touchent à Internet. Mes autres domaines de prédilection sont l'analyse de processus métier, l'analyse de grands volumes de données (big data) et la relation avec ceux qui savent comment fonctionne le business et sans qui je n'existerai pas, ... les utilisateurs (oui, ceux sans qui on aurait bien moins de problèmes techniques ridicules à gérer ;-). Je me suis lancé dans les microcontrôleurs par hasard, par curiosité et par défi car je ne connaissais rien à ce petit monde d'experts pointus et en bon autodidacte je me suis dit que je pourrai y arriver aussi ! Je transforme mes lacunes en théorie électronique en une force d'innovation car je ne m'encombre pas de réflexion poussée ou de limites théoriques avant d'essayer quelque chose au risque de faire brûler quelques composants ... mais ça, tant pis ! :-)

18 réflexions au sujet de « Pi Mediacenter OSMC pilotant un Arduino en mode « esclave » »

  1. Bub

    La partie pilotage Arduino est intéressante. Mais n’est-ce pas un peu « overkill » d’utiliser un Arduino pour alimenter une poignée de LED? Je sais bien que ces bestioles ne coûtent rien financièrement, mais quand même…

    Il suffit de relier chaque LED a un transistor branché sur une broche d’alim et qui donnera à la diode tout le courant voulu, sans aucune autre limitation en courant que celle de l’alimentation. Ce genre de montage par exemple : http://www.electronique-radioamateur.fr/elec/schema/commande-led.php

    En plus avec le Pi on a le choix entre 3,3 V et 5 V. Pour de nombreuses LED, le 3,3 V suffit amplement ce qui permet de baisser la valeur de la résistance et par conséquent de réduire les pertes par effet joule (c’est dommage quand la résistance bouffe plus que la LED !) Personnellement j’utilise ce genre de montage avec des LED dont le point de fonctionnement typique tourne autour de 2 V / 20 mA (pour une luminosité de 150 mcd ou plus). Des résistances de l’ordre de 50 Ω font parfaitement l’affaire, soit une dissipation de 20 mW. Si on veut réduire la luminosité, on peut utiliser de la PWM plutôt que de changer le point de fonctionnement, c’est plus efficace.

    Répondre
    1. François MOCQ

      bonjour
      je pense qu’il faut le voir comme un exemple de liaison Arduino < ==> RasPi et ne pas s’arrêter au simple allumage de LEDs
      le courant maxi sur le 3v3 est de 50mA… (http://elinux.org/RPi_Low-level_peripherals#General_Purpose_Input.2FOutput_.28GPIO.29)
      chaque port GPIO peut piloter une charge E ou S de 2 à 16 mA
      le courant total de tous les ports est limité à 50mA (http://www.thebox.myzen.co.uk/Raspberry/Understanding_Outputs.html)
      c’est pourquoi à moins d’utiliser 1 ou 2 LEDs sur le RasPi il est recommandé de bufferiser les sorties…
      cordialement
      François

      Répondre
      1. Bub

        Oui tu as raison sur le Pi le courant sur le 3,3 V est limité. Mais mon propos était surtout de dire qu’on pouvait faire plus simple et économe qu’un Arduino comme buffer.

        Répondre
        1. msg

          Un ULN280x ou un ULN200x suffit pour protéger les Pin du RPi .
          Ou aussi un registre à décalage à commande I2c ou SPI .
          Mais apparamment , le but de la manœvre n’est pas là .

          Répondre
    2. Jean-Jacques Guazzo Auteur de l’article

      Bonsoir Bub,

      Effectivement, comme l’a mentionné François mon premier objectif était de piloter un arduino depuis un pi. Pour essayer j’ai décidé d’allumer simplement quelques LEDS .

      Autre avantage plus « personnel », au prix d’un clone arduino, vu que je suis débutant dans le domaine, si je me plante dans mes expérimentations, je préfère griller un arduino qu’un raspberry 🙂

      La prochaine fois, je commande depuis un pi un arduino qui commande un pi pour allumer 1 LED … et le tout en wifi avec un ESP8266 ! 😉

      Répondre
      1. msg

        C’est intéressant , mais pas très écologique tout ça .
        Et en cas de panne ou disfonctionnement , bonjour le dépannage .

        Répondre
        1. Jean-Jacques Guazzo Auteur de l’article

          Sur le point écologique, d’accord si c’est juste pour allumer 7 leds du point de vue dépannage, personnellement, je ne vois rien de bien complexe que du contraire, ça laisse le pi faire son job principal (mediacenter) et toute les connexions « externes » sont gérées sur l’arduino (qui peut d’ailleurs recevoir sa propre alimentation) et ainsi, chacun fait sont job dédié.

          Répondre
  2. Michel

    bonjour et merci pour le tuto. j’amerais savoir quel fichier utiliser: avec ou sans firmware disponible sur le site nanpy ? Cordialement

    Répondre
    1. Jean-Jacques Guazzo Auteur de l’article

      dans le fichier: nanpy-0.9.6.tar.gz (md5) il n’y a pas le sketch arduino (en .ino) alors que dans le fichier nanpy-firmware-0.9.6.tar.gz (md5) il y est bien.
      Le deuxième contient donc tout ce dont il y a besoin et c’est celui-là qu’il faut utiliser.
      Attention au fichier cfg.h pour lequel il existe des tutos mais je n’ai pas réussi à le générer en les suivant.

      Répondre
  3. Ping : Réalisations à ce jour – Le Labo du roizzo

  4. Syl20

    Si tu veux utiliser plus de leds sans te soucier de l’intensité délivrée par l’arduino, tu peux utiliser en sortie d’arduino un ou plusieurs ULN2003 branchés avec les anodes communes.
    De là, tu y branches un bête chargeur 5V pour alimenter tes leds. Tu seras donc limité par l’intensité délivrée par le chargeur et pas par l’arduino.

    Répondre
    1. Jean-Jacques Guazzo Auteur de l’article

      Bonsoir,
      Merci pour l’info, je ne connaissais pas ce fameux ULN2003 et je viens de regarder la doc technique (http://www.ti.com/lit/ds/symlink/uln2003a.pdf) mais ils parlent d’une limite totale par ensemble « d’émetteurs » à 2 Ampères … juste ou pas ?
      Que ce soit oui ou non, c’est quand même vachement sympa comme composant ! 🙂
      pff plus j’en découvre et plus il y en a à découvrir ! mais c’est pour ça que je me suis lancé dans ce sujet ! 😉

      Répondre
      1. Syl20

        Si tu pars sur une alim 5V 2A et que tu estimes ta consommation de courant à 30ma par led, tu pourrais alors piloter 66,66 leds.
        Ça ferait un joli sapin de Noël non?

        Répondre
  5. Ping : Pilotage d’un Arduino UNO depuis un Pi Media Center OSMC – Le Labo du roizzo

  6. Ping : Pilotage d’un Arduino UNO depuis un Pi Media Center OSMC – Le Labo du roizzo

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Complétez ce captcha SVP * Time limit is exhausted. Please reload CAPTCHA.