RPI-ShieldBridge-FirmData

De MCHobby - Wiki
Sauter à la navigation Sauter à la recherche


MCHobby investit du temps et de l'argent dans la réalisation de traduction et/ou documentation. C'est un travail long et fastidieux réalisé dans l'esprit Open-Source... donc gratuit et librement accessible.
SI vous aimez nos traductions et documentations ALORS aidez nous à en produire plus en achetant vos produits chez MCHobby.


Firmata? Kaséko?

Firmata (Firmata.org) est un protocole permettant à un ordinateur de communiquer avec des microcontroleurs. Il est donc possible de contrôler simplement un Arduino depuis un ordinateur ou Raspberry en utilisant Firmata.

Il existe une implémentation de Firmata en Python... que quoi permettre à notre Pi de contrôler facilement votre Arduino.

Ceci est un petit guide Firmata et Raspberry Pi basé sur un article du MagPi N°7.

Selon Firmata.org:
Firmata est un protocol générique permettant à programme sur un ordinateur de communiquer avec un microcontroleur. Firmata est prévu pour fonctionner avec avec n'importe quel type de logiciel et depuis n'importe quel ordinateur. En ce moment, il existe un objet correspondant dans de nombreux languages. Il est facile d'ajouter d'autres objets pour d'autres logiciels (langage) utilisant ce protocol.

Fondamentalement, ce firmware établit un protocole communiquant avec un Arduino depuis un logiciel fonctionnant sur un ordinateur. Le but est de permettre au gens de complètement contrôler un Arduino depuis un logiciel fonctionnant sur un PC.

Préparer votre Arduino / RPi-ShieldBridge

Le première opération consiste à téléverser le croquis/sketch Firmata sur l'Arduino compatible du RPi-ShieldBridge.

Vous pouvez réaliser cette opération de deux façons différentes:

  1. Via le port FTDI
    permettant de programmer directement l'Arduino compatible du RPi-ShieldBridge depuis votre ordinateur.
  2. Via votre Raspberry-Pi
    en utilisant l'interface série sur le port GPIO du Pi (voir section Installer Arduino IDE sur Raspberry Pi).

Téléverser Firmata via FTDI

Le connecteur FTDI permet de programmer l'Arduino compatible du RPi-ShieldBridge comme s'il s'agissait d'un vrai Arduino.

FTDI-Friend.jpg

Vous pouvez le programmer soit depuis votre ordinateur, soit depuis votre Pi (via le convertisseur FTDI).

RPI-ShieldBridge-FTDI-10.jpg

  • Téléchargez et installer Arduino IDE sur votre ordinateur ou sur votre Raspberry-Pi.
  • Si vous voulez alimenter le RPi-ShieldBridge via le connecteur FTDI (si programmé depuis un PC) alors fermez le cavalier JVCC près du connecteur FTDI ... ou bien mettez votre Pi sous tension (si vous programmez RPi-ShieldBridge depuis le Pi).
  • Connectez le convertisseur FTDI (5V) sur le port FTDI du RPi-ShieldBridge.
  • Connectez le port USB du convertisseur FTDI sur votre ordinateur (ou Raspberry Pi).
  • Demarrez Arduino IDE.
  • Selectionnez la carte Arduino Uno dans le menu Outils -> Carte (Tools -> Board).
  • Selectionnez le port série correspondant au convertisseur FTDI dans le menu Outils -> Port série (Tools -> Serial Port).
  • Ouvrez le croquis/sketch Firmata accessible dans le menu Fichier -> Exemples -> Firmata -> StandardFirmata (File->Examples->Firmata->StandardFirmata).
  • Téléversez le croquis/sketch sur le RPi-ShieldBridge.
    Si vous éprouvez un problème de téléversement, vérifiez la présence de la résistance pull-down (10k-47k Ohm) entre le GPIO18 (le cavalier JBL) et la masse.
  • Quittez ensuite Arduino IDE.

Téléverser Firmata via GPIO du PI

Il est également possible d'utiliser la connexion série matérielle du Raspberry Pi pour téléverser le Croquis/Sketch Firmata sur le RPi-ShieldBridge.

RPI-ShieldBridge-Intro.jpg

Voyez aussi notre section Installer Arduino IDE sur Raspberry Pi pour les instructions ci-dessous Conformément aux instructions du tutoriel:

  • Fermez les cavaliers JTX, JRX and JBL sur le RPi-ShieldBridge.
  • Installez Arduino sur votre Raspberry Pi.
  • Executez Arduino IDE.

Pour téléverser Firmata

  • Selectionnez Arduino Uno dans le menu Outils -> Carte (Tools -> Board).
  • Sélectionnez le port série matériel (/dev/ttyAMA0 ou le lien symbolique) sous le menu Outils -> Port Série (Tools -> Serial Port).
  • Ouvrez le croquis/sketch Firmata dans le menu Fichier -> Exemple -> Firmata -> StandardFirmata (File -> Examples -> Firmata -> StandardFirmata).
  • Téléversez le croquis/sketch.
  • Vous pouvez maintenant quitter Arduino IDE.

Préparé votre Pi

Grâce à Firmata, il sera possible de contrôler les entrées/sorties du compatible Arduino (RPi-ShieldBridge) à partie de votre Raspberry-Pi par l'intermédiaire d'une connexion série (entre Pi et RPi-ShieldBridge).

Il faut donc disposer d'une connexion série entre les deux éléments, ensuite, nous pourrons nous attaquer au code en Python (ou Node.js)

Vous pouvez vous connecter sur l'Arduino du RPi-ShieldBridge et communiquer avec ce dernier de deux façons:

Connexion USB (via convertisseur FTDI)

  • Placer le RPi-ShieldBridge sur votre Raspberry Pi.
  • Connectez l'adaptateur FTDI (5V) sur le port USB du Raspberry Pi et enfichez l'adaptateur FTDI sur le connecteur FTDI du RPi-ShieldBridge.
  • Le nom du périphérique USB sera /dev/ttyUSB0 (si vous avez défini le lien symbolique) ou /dev/ttyACM0

Note de MCHobby:
Etant donné que le RPi-ShieldBridge est connecté sur le GPIO, ce dernier est alimenté par l'intermédiaire du +5V du GPIO. Dans pareil cas, il n'est pas nécessaire d'alimenter le RPi-ShieldBridge par l'intermédiaire du connecteur FTDI. Les deux potentiels devrait être idéalement de pile à 5V. Cependant, dans la vie réelle, vous pourriez avoir deux tensions légèrements différentes (ex: 5.00v au GPIO et 4.95v causé par une perte sur le fils USB) provoquant une circulation de courant entre les deux potentiels. Pas franchement souhaitable.

Dans ce cas, nous conseillons de ne pas ponter le cavalier JVCC (ou ne pas raccorder la broche VCC du connecteur FTDI).

Connexion UART (port série matériel)

  • Close the Jumpers JTX and JRX on the RPi-ShieldBridge.
  • Put the RPi-ShieldBridge on the Raspberry Pi.
  • Disable Linux serial console.
  • Device name: /dev/ttyAMA0

Contrôle avec Python

Maintenant:

  1. que Firmata est téléversé et actif sur RPi-ShieldBridge,
  2. que nous disposons d'une connexion série entre Raspberry-Pi et RPi-ShieldBridge

Nous allons pouvoir nous attaquer au reste.

Installer pySerial, pyFirmata et pip

Installer: 

$ sudo apt-get update
$ sudo apt-get install python-serial
$ sudo pip install pyfirmata

Script de test

Créer le script firmatatest.pu 

nano firmatatest.py

et tapez le script suivant: 

#!/usr/bin/env python
# -*- coding: latin-1 -*-

import time
import RPi.GPIO as GPIO
import pyfirmata
GPIO.setmode(GPIO.BOARD)
GPIO.setup(12, GPIO.OUT)   # GPIO18 (broche 12) en mode sortie (OUTPUT)
GPIO.output(12, GPIO.LOW)  # GPIO18 LOW (niveau bas) -> désactivé du Reset Arduino
# Démarrer la connection avec Arduino UNO
#  USB: /dev/ttyUSB0 ou /dev/ttyACM0
#  UART: /dev/ttyAMA0
board = pyfirmata.Arduino('/dev/ttyUSB0')
board.digital[13].write(1) # activer la LED sur la broche 13
time.sleep(3)              # delai de 3s
board.digital[13].write(0) # Eteindre la LED
time.sleep(3)              # delai de 3s
board.exit()

Exécuter le script

pour exécuter le script, taper simplement la commande suivante dans un terminal. 

$ python firmatatest.py

Contrôle avec Node.JS

Installation

Pour utiliser Firmata et Node.js, vous devrez installer: 

$ sudo mkdir /opt/node
$ wget http://nodejs.org/dist/v0.10.12/node-v0.10.12-linux-arm-pi.tar.gz
$ tar zxf node-v0.10.12-linux-arm-pi.tar.gz
$ sudo cp -r node-v0.10.12-linux-arm-pi/* /opt/node
$ sudo nano /etc/profile

# add these lines before *export PATH*
PATH="$PATH:/opt/node/bin"

$ sudo /opt/node/bin/npm install -g firmata

$ sudo /opt/node/bin/npm install -g rpio

Créer le script firmatatest.js

Créer le fichier firmatatest.js en utilisant la commande 

nano firmatatest.js

Et y copier le code suivant: 

var rpio = require('rpio');
var firmata = require('firmata');

// GPIO18 low = Niveau bas -> Reset Arduino désactivé
rpio.setOutput(12);
rpio.write(12, rpio.LOW);

// Démarrer une connexion avec Arduino
//  USB: /dev/ttyUSB0 ou /dev/ttyACM0 (via convertisseur FTDI)
//  UART: /dev/ttyAMA0 (via GPIO)
var board = new firmata.Board('/dev/ttyUSB0', function(err)
{
  if(err)
  {
    console.log(err);
    return;
  }
  console.log('connexion etablie');
  board.pinMode(13, board.MODES.OUTPUT);
  // Allumer la LED
  board.digitalWrite(13, board.HIGH);
  // eteindre la LED après 3s
  setTimeout(function()
  {
    board.digitalWrite(13, board.LOW);
    process.exit(0);
  }, 3000);
});

Exécuter le script

Taper la commande suivante dans un terminal pour exécuter le script 

$ sudo node firmatatest.js

Source: RPi-ShieldBridge
Créé par Stephan Watterott pour Watterott.

Traduction réalisée et augmenté par Meurisse D pour MCHobby.be.

Toute référence, mention ou extrait de cette traduction doit être explicitement accompagné du texte suivant : «  Traduction par MCHobby (www.MCHobby.be) - Vente de kit et composants » avec un lien vers la source (donc cette page) et ce quelque soit le média utilisé.

L'utilisation commercial de la traduction (texte) et/ou réalisation, même partielle, pourrait être soumis à redevance. Dans tous les cas de figures, vous devez également obtenir l'accord du(des) détenteur initial des droits. Celui de MC Hobby s'arrêtant au travail de traduction proprement dit.

Traduction et documentation réalisées avec l'autorisation expresse de Stephan Watterott - Documentation and translation built with authorization of Stephan Watterott.

Récupérée de « https://wiki.mchobby.be/index.php?title=RPI-ShieldBridge-FirmData&oldid=9192 »