Arduino Yun-Guide

De MCHobby - Wiki
Aller à : navigation, rechercher

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.

Guide de démarrage Arduino Yun

Arduino Yún est une carte Arduino sans ressemblance avec les autres. Même si sa programmation est fort similaire à un Arduino Leonardo (Anglais, Arduino.cc) et qu'elle utilise le même processeur Atmel ATmega32U4, cette carte dispose également d'un processeur additionnel (Atheros AR9331) fonctionnant sous Linux avec un pile Wifi OpenWrt. La programmation du 32U4 via USB est identique à un Arduino Leonardo. Une fois le Yún configuré pour se connecter sur un réseau WiFi, vous pouvez également programmer votre 32U4 par l'intermédiaire du réseau Wifi.

Pour connecter Arduino Yún à votre Ordinateur, vous aurez besoin d'un câble Micro-B USB. Ce câble USB fournit énergie et connexion de donnée à la carte. Pour programmer un Yún, vous devez choisir Arduino Yún dans le menu Outils > Carte (Tools > Board) d'Arduino IDE. Yún est uniquement supporté à partie de la version 1.5.4 d'Arduino IDE.

Différences avec un Arduino Leonardo

Arduino-Yun-Pres02.jpg
Crédit: Arduino arduino.cc

En plus du processeur 32U4, le Yún dispose d'un processeur complémentaire, un Atheros AR9331 qui fonctionne avec la distribution Linux Linino basé sur OpenWrt. OpenWrt est un système Linux pour système embarqué. Linino inclus également une installation complète de Python 2.7.

Le Yún dispose d'un connecteurs et caractéristiques différentes par rapport à un Leonardo. Il dispose d'un connecteur pour carte SD, d'un connecteur Ethernet(réseau filaire), et d'un connecteur USB-A Hôte (Host). Il n'y a pas de connecteur d'alimentation sur le Yún; car il peut être alimenté par le connecteur micro-USB.

Si vous n'alimentez pas le Yun par l'intermédiaire de la connexion micro-USB, vous pouvez appliquer l'alimentation sur les broches Vin et 5V de la carte. Il est recommandé d'alimenter Yún par l'intermédiaire de la connexion USB dès que cela est possible.

Les connecteurs SD, Ethernet et USB-A sont tous physiquement connectés sur le processeur Linux AR9331 et non sur le 32U4.

Les processeur 32U4 du Yún fonctionne de la même façon qu'un Leonardo, excepté que vous ne pouvez pas utiliser Serial1 car il est réservé à la communication avec le processeur AR9331.

Le Yún dispose également d'un module Wifi sur la carte. Il permet de se connecter sur un routeur sans fil (Wifi) mais aussi de devenir un point d'accès (AP). Quand votre Yun est utilisé en point d'accès, la carte devient visible sur le réseau Wifi et vous pouvez vous y connecter avec votre ordinateur... exactement comme vous le faites habituellement avec votre routeur Wifi (un routeur WiFi est forcément un Point d'Accès ;-) ).

Le processeur, WiFi et processeur AR9331 disposent chacun de leur propre bouton "Reset" (bouton de réinitialisation).

Arduino-Yun-Pres11.jpg
Crédit: Arduino arduino.cc Traduction: MCHobby.be

Il y a plusieurs LEDs de statut sur un Yun. Elles indiquent:

  • L'état d'alimentation,
  • La connexion WLAN (réseau Ethernet filaire),
  • La connexion WAN (réseau Wireless... réseau sans fil),
  • Connexion USB.

En outre, la broche 13 est connectée sur une des LED de statut.

Arduino-Yun-Pres10.jpg
Crédit: Arduino arduino.cc Traduction: MCHobby.be

Linino

Le Yún exécute une distribution Linux qui s’appelle Linino, basée sur OpenWrt. Même s'il est possible de configurer les système en ligne de commande, il y a aussi une page WEB qui permet de configurer de nombreuses options parmi toutes celles disponibles. L'interface (appelée LuCi) vous fournit l'accès à la plupart des paramètres nécessaires à la gestion de l'interface WiFi.

L'accès à l'interface WEB est décrit plus loin.

Pour installer des logicielles complémentaires sur Linino, vous utiliserez le gestionnaire de paquet Linux opkg. Pour plus d'information sur le gestionnaire et quelques commandes, voyez la page du gestionnaire de paquet Yún.

Lorsque vous vous interfacez avec le système Linino, vous devez utiliser soit une ligne de commande, soit utiliser la librairie Bridge d'Arduino (Librairie de liaison), soit une connexion SSH. Si vous n'êtes pas familiarisé avec les lignes de commandes, vous pouvez lire cette documentation de base décrivant le principe et quelques programmes couramment utilisés.

Python

Une installation de Python 2.7 est comprise avec Linino. Avec Python, vous pouvez écrire des application ou des scripts.

Pour plus d'information sur Python, visitez:

Si vous apprenez Python pour la première fois, sachez qu'il existe de nombreuses et excellentes ressources sur le Net. Hormis les références ci-dessus, vous pouvez aussi consulter "Learn Python the Hard Way" (Apprendre Python par la pratique, Anglais, learnpythonthehardway.org) qui couvre tout ce que vous avez besoin de savoir pour commencer vos propres scripts.

Stockage externe sur Yún

Il n'est pas conseillé d'utiliser la mémoire non-volatile interne du Yún pour vos opérations de stockage parce qu'elle a un nombre limité de cycle d'écriture.

Vous pouvez utiliser une mémoire externe comme une carte microSD ou une clé USB pour stocker vos données, scripts, page web, etc.

Si vous voulez que le 32U4 de votre Yún stocke ou accède à ce périphérique, vous aurez besoin d'y créer un répertoire nommé arduino dans la racine du volume.

Services WEB

Pour les clients et serveurs "Service WEB", Linino supporte REST. REST est l'acronyme de "Representational State Transfer" (difficilement traduisible). C'est une architecture logiciel qui expose les différentes parties du matériel Arduino par l'intermédaire d'URL.

Par défaut, les accès à l'interface de programmation REST (REST API) est protégé par un mot de passe. Il est possible de modifier l'accès à ce service afin de ne pas utiliser de mot de passe. Pour modifier ce paramètre, entrer dans le panneau de configuration de votre Yún. Vous trouverez l'interface permettant de basculer cette option d'accès en bas de la page.

{{{2}}}
Crédit: Arduino arduino.cc
Accès aux API (interface de programmation) REST.
"Open" signifie que l'interface est ouverte donc librement accessible. "With Password" signifie qu'elle est protégée par un mot de passe.

Une chouette introduction sur les concepts REST peut être trouvé ici (Anglais, StackOverflow.com) .

Sur le Yún, il y a deux point d'accès REST (REST end points) reconnu:

  • /arduino
  • /data

Le répertoire "/arduino" n'est pas pré-configuré. Tout ce qui est ajouté dans l'URL derrière le point d'accès est transféré par le Serveur Web au sketch/croquis fonctionnant sur le 32U4. Vous pouvez définir vos propres interfaces de programmation (API) à l'intérieur de votre sketch/croquis. Consultez les exemples "Bridge" pour comment il est possible d'offrir un accès à une broche Arduino via l'interface REST.

"/data" est utilisé pour fournir un accès à un stockage interne de type Clé/Valeur (key/value). Les appels possible sont:

  • /put/KEY/VALUE : stocke une valeur value pour le clé key.
  • /get/KEY : obtenir la valeur de la clé KEY. Retour au format JSON
  • /get : Otenir une liste de éléments stockés au format JSON.
  • /delete : efface le contenu du stockage intene

Reset des processeurs (AR9331, WiFi et 32U4)

Reset Linino

Pour redémarrer la processeur AR9331, qui redémarre Linino, presser le bouton reset "YÚN RST" qui se trouve à côté des entrées analogiques et des LEDs (sur la carte).

Reset Arduino

Pour redémarrer le 32U4 et redémarrer votre sketch/croquis Arduino, pressez le bouton à côté du port Ethernet deux fois.

Reset WiFi

Le bouton reset du WiFi se trouve près du connecteur USB-A. Lorsque vous pressez ce bouton, la LED WLAN commence à clignoter.

Si vous passez sur un réseau différent et que vous ne pouvez plus accéder à votre Yún par l'intermédiaire de sont interface Web, vous pouvez faire une réinitialisation (reset) de la configuration réseau en pressant le bouton reset Wifi pendant plus de 5 secondes mais moins que 30 secondes.

La configuration WiFi sera réinitialisée et le Yún redémarrera son propre réseau wiFi Yún-XXXXXXXXXXXX. Toutes les autres modifications/configuration seront conservées.

Réinstallation Linino

Pour réinitialiser la distribution Linino à sa configuration d'usine (dit default state), pressez le bouton reset WiFi pendant au moins 30 secondes.

La carte reviendra alors à sa configuration d'origine, celle qu'elle avait à sa sortie de la boite (où la dernière que vous auriez reflashé). Cette opération, entre autre chose, effacera tous les fichiers installés ainsi que la configuration réseau.

Ré-énumération série au Reset

Etant donné que le Yún ne dispose pas d'un composant dédicacé à la gestion de la communication série, cela implique que le port série est virtuel -- Cette communication série est assuré par des routines logicielles sur la carte et sur votre ordinateur.

Cela fonctionne exactement comme lorsque vous connectez n'importe quel Arduino sur votre ordinateur; l'ordinateur crée une instance du pilote de port série virtuel ET le 32u4 crée une instance de "port série" lorsqu'il démarre son bootloader. La carte devient alors une instance du pilote USB's Connected Device Class (CDC).

Cela signifie que la connexion USB sera systématiquement perdue et ré-établie à chaque fois qu'il y a un reset du processeur 32U4. La carte disparaitra de la liste des ports séries et cette liste sera ré-énumérée. Tous les programmes disposant d'une connexion série ouverte sur le Yun perdra cette connexion. Cela est fort différent d'un Arduino UNO où il est possible de faire un reset du processeur principal (the ATmega328P) sans perdre la connexion USB (qui est maintenu par un second processeur ATmega8U2 ou ATmega16U2).

Ces différences ont des implications pour l'installation de pilotes, pour le téléversement et la communication.

Pas de reset à l'ouverture du port série

Le Yún ne redémarrera pas votre sketch/croquis lorsque vous ouvrez le port série sur votre ordinateur. Cela signifie que vous ne verrez pas les données séries qui ont déjà été envoyés par la carte vers l'ordinateur. Cela comprend forcement la plupart des informations envoyées par la fonction setup().

Cela s'applique également à la Console, décrite ci-dessous.

Cela signifie que si vous utiliser n'importe quelle fonction Série (Serial) ou console avec print(), println() ou write() dans la fonction setup(), ces dernières n'afficherons rien lorsque vous offrirez le moniteur série ou une connexion Console.

Pour contourner ce problème, vous pouvez vérifier si le port est ouvert à l'aide de:

// Arrêter le programme jusqu'à ce que le moniteur série soit ouvert
while (!Serial);

ou

// Stopper le programme jusqu'à ce qu'une Console soit ouverte
while (!Console);

Qu'est ce que la Console

La Console, basée sur le Bridge, vous permet d'envoyer des informations depuis un Yún vers un ordinateur comme vous le feriez avec le moniteur série, mais en connexion sans fil.

Installer les pilotes pour Yún

OSX

La première fois que vous connectez un Yún sur un Mac, l'assistant d'installation de clavier (Keyboard Setup Assistant) démarre. Il n'y a rien à configurer avec un Yún; vous pouvez fermer cette boite de dialogue en cliquant sur le bouton rouge à haut à gauche (de la fenêtre).

{{{2}}}
Crédit: Arduino arduino.cc

Windows

Windows dispose maintenant d'un programme d'installation pour l'IDE (environnement de développement) et les pilotes (drivers).

Téléchargez le programme d'installation "Arduino IDE 1.5.4" ou plus récent et double cliquez sur l'icone d'installation.

{{{2}}}
Crédit: Arduino arduino.cc

Une fois que vous avez pris connaissance de la licence, et que vous êtes en accord avec elle, cliquez sur le bouton "I agree" ("Je suis d'accord").

{{{2}}}
Crédit: Arduino arduino.cc

Tous les éléments sont sélectionnés par défaut. Cela inclus l'IDE, les pilotes (drivers) et les raccourcis (shortcuts)

{{{2}}}
Crédit: Arduino arduino.cc

Sélectionnez l'endroit où vous désirez installer l'IDE (environnement de développement).

{{{2}}}
Crédit: Arduino arduino.cc

Le programme d'installation affiche une barre de progression pendant qu'il extrait et installe les fichiers à l'emplacement correct.

{{{2}}}
Crédit: Arduino arduino.cc

Une fenêtre de confirmation s'affichera si vous décidez d'installer les pilotes (drivers). Vous devrez confirmer votre sélection

{{{2}}}
Crédit: Arduino arduino.cc

Lorsque l'installation est terminée, vous pouvez presser le bouton "Close" (Fermer ou Terminer).

NB: Yún utilise le service Bonjour pour permettre sa détection automatique sur les réseaux WiFi. Ce service n'est pas inclus par défaut dans les distributions de Windows. Si bonjour n'est pas encore installé sur votre système, vous pouvez le télécharger ici. Si vous disposez d'un logiciel anti-virus ou logiciel firewall, configurez le pour ne pas bloquer les communications sur le port 5353.

Linux

Il n'est pas nécessaire d'installer de pilotes pour Ubuntu 10.0.4 ou suivant.

Configuration du WiFi de la carte

Le Yún a la possibilité d'agir comme un point d'accès (Access Point) mais il peut également se connecter sur un réseau existant. Ces instructions vous guide entre les différentes étapes vous permettant de connecter votre Yún sur un réseau sans fil. Le Yún peut se connecter sur des réseaux non protégés (non cryptés) ainsi que sur des réseaux supportant l’encryption WEP, WPA et WPA2.

Lorsque vous mettez votre Yùn sous tension la première fois, il va créer un réseau WiFi nommé ArduinoYun-XXXXXXXXXXXX. Connectez votre ordinateur sur ce réseau.

Une fois que vous avez obtenu un adresse IP, ouvrez un navigateur Internet et entrez l'adresse http://arduino.local ou 192.168.240.1 dans la barre d'adresse. Au bout d'un moment, une page Web doit s'afficher, elle vous demande un mot de passe d'accès (password). Entrer "arduino" et clicker sur le bouton "Log In" (se connecter).

{{{2}}}
Crédit: Arduino arduino.cc

Vous trouverez alors une page contenant des informations de diagnostiques relative aux connexions réseaux actuelles. En premier l'interface Wifi et en second votre connexion Ethernet. Pressez le bouton "Configuration" pour continuer.

{{{2}}}
Crédit: Arduino arduino.cc

Vous configurerez votre Yùn sur cette nouvelle page, lui donnant un nom unique et en identifiant le réseaux sur lequel vous voulez vous connecter.

Placez le nom de votre Yùn dans le champ NAME, donnant ainsi un nom unique (qui n'existe pas encore sur le réseau) à votre Arduino. Vous l'utiliserez par la suite pour vous connecter sur votre Yùn.

Choisissez un mot de passe pour votre Arduino, il doit avoir au moins 8 caractères. Si vous laissez cette zone vide, le système maintiendra le mot de passe par défaut de votre Arduino.

Si vous le désirez, vous pouvez également configurez la fuseau horaire (Timezone en anglais) et le pays (country). Il est recommandé de configurer ces options puisqu'elles peuvent faciliter la connexion sur votre réseau Wifi local. Sélectionner un fuseau horaire (timezone) permet de présélectionner le domaine de réglementation qui y est applicable (country's regulatory domain).

Entrez le nom du réseau WiFi sur lequel vous désirez vous connecter dans la zone "Wireless Name".

Sélectionnez le type de sécurité (security type) et entrez le mot de passe (password) applicable à cette connexion Wifi.

{{{2}}}
Crédit: Arduino arduino.cc

Lorsque vous pressez le bouton "Configure & Restart", votre Arduino va se réinitialiser tout seul et se connecter sur le réseau spécifié. Le réseau Arduino (le point d'access) va s'interrompre au bout d'un moment.

Note: Pressez le bouton "Discard" si vous ne désirez pas appliquer ces nouveau paramètres sur votre Yùn.

{{{2}}}
Crédit: Arduino arduino.cc

Le message "Configuration Saved!" indique que votre Yùn a enregistré les nouveaux paramètres. Ce message vous indique qu'il fait également le nécessaire pour se connecter sur le réseau que vous avez mentionné.

Maintenant, vous pouvez vous connecter sur le réseau que vous avez assigné à votre Yùn.

Programmer le 32U4 via WiFi

Si votre Yún est situé sur le même réseau que votre ordinateur alors vous pouvez programmer votre Yun via le réseau sans fil.

Après la configuration de votre Yún, il se connecte sur le réseau sans fil que vous avez spécifié dans ses paramètres.

Ouvrez alord votre Arduino IDE.

  • Dans le menu Outils > Port (Tools > Port), vous devriez voir une ou plusieurs entrées énumérant vos Yùn présent sur le réseau (avec le nom des Yùn et leurs adresses IP). Sélectionnez votre Yùn.
  • Sélectionnez la carte "Arduino Yùn" dans le menu Outils > Cartes (Tools > Board).
  • Ouvrez l'exemple Blink (via le menu Fichier > Exemples > 01Basics > Blink) et téléversez/téléchargez le croquis sur la carte.
    Le mot de passe administrateur du Yùn vous sera demandé durant cette opération. utilisez simplement le mot de passe que vous avez configuré durant le paramètrage de votre Yun.

Le processeur 32u4 redémarre après le téléversement du programme. Vous devriez voir clignoter la LED branchée sur la broche 13.

Utiliser le connecteur Ethernet

Lorsque vous connectez un Yùn sur un réseau filaire à l'aide d'un câble Ethernet, Yùn essayera de se connecter automatiquement via DHCP. La carte sera visible dans le menu Port série d'Arduino IDE comme il le ferait avec la connexion WiFi.

Si vous désirez connecter directement votre Yun sur votre ordinateur, vous devez configurer votre ordinateur pour avoir soit une adresse IP statique, soit pour agir comme un serveur DHCP.

Note: l'interface Ethernet est eth1 et non eth0

Communiquer avec Linino via le "Bridge"

La librairie "Bridge" (signifiant litérallement "pont") permet la communication entre Arduino et Linino. Il y a plusieurs classes utilitaires qui facilite différents type de communication entre ces deux environnements. Ces classes sont décrites plus bas mais aussi plus en profondeur dans les pages de lalibrairie Bridge (ou bien Bridge library reference Arduino.cc, Anglais).

Arduino-Yun-Pres03.jpg
Crédit: Arduino arduino.cc Traduction par MCHobby.be

La Console

La Console, basée sur Bridge, permet d'envoyer des informations depuis Yún vers un ordinateur exactement comme si vous utilisez le moniteur série sauf que c'est sans fil. La Console crée une connexion SSH sécurisée entre Yùn et votre ordinateur.

Téléversez le Croquis suivant sur votre Yún : Les interfaces WiFi et Ethernet, le port USB et support de carte SD sont tous connectés sur le AR9331. La librairie Bridge vous permet de travailler avec ces périphériques, d'exécuter des scripts et de communiquer avec des WebServices.

#include <Console.h>

const int ledPin = 13; // La broche sur laquelle la LED est branchée
int incomingByte;      // Une variable pour lire les données séries entrantes

void setup() {
  // Initialisation de la communication série:
  Bridge.begin();
  Console.begin();

  while (!Console){
    ; //Attendre la connexion du port Console.
  }
  Console.println("Vous etes connecté sur la Console!!!!");
  // Initialiser la broche de la LED comme sortie:
  pinMode(ledPin, OUTPUT);
}

void loop() {
  // Vérifier s'il y a une donnée entrante:
  if (Console.available() > 0) {
    // Lire le byte (l'octet) le plus vieux stocké dans 
    // la mémoire tampon série (serial buffer):
    incomingByte = Console.read();
    // Si c'est un H majuscule (ASCII 72), allumer la LED:
    if (incomingByte == 'H') {
      digitalWrite(ledPin, HIGH);
    }
    // Si c'est un L (ASCII 76), éteindre la LED:
    if (incomingByte == 'L') {
      digitalWrite(ledPin, LOW);
    }
  }
}

Pour voir la Console, sélectionner le nom de votre Yun (+ son adresse IP) dans le menu "Ports".

Le Yún ne s'affiche dans le menu "Ports" que si votre ordinateur est sur le même réseau (LAN) que votre Yùn. Vous ne verrez pas la carte dans le menu "Ports série" si votre carte Yùn se trouve sur un réseau différent.

Ouvrez le Moniteur (rebaptisé "Port Monitor" plutôt que "Serial Monitor"). Vous serez inviter à entrer le mot de passe de votre Yùn.

Vous pouvez également accéder à la Console en ouvrant une fenêtre terminal et en tapant la commande:

ssh root@yourYunsName.local 'telnet localhost 6571'

Puis presser la touche Retour/Entrée.

Note: Si vous utilisez Windows alors vous devrez installer un émulateur de terminal. PuTTY est un choix raisonnable mais vous devrez entrer les deux commandes ci-dessus séparément.

Tapez 'H' pour allumer la LED sur la broche 13 et 'L' pour l'éteindre.

Les commandes Process

Les commandes Process permettent d'exécuter des processus Linux sur Linino par l'intermédiaire d'Arduino.

Dans l'exemple uivant, Linino va se connecter sur un serveur en utilisant curl et de télécharger du texte ASCII. Il affiche ensuite le texte sur la connexion série.

#include <Process.h>

void setup() {
  // Initialisation du Bridge
  Bridge.begin();

  // Initialisation du port série
  Serial.begin(9600);

  // Attendre qu'un moniteur série soit connecté.
  while (!Serial);

  // Executer les différents processus d'exemple
  runCurl();
}

void loop() {
  // Rien à faire.
}

void runCurl() {
  // Execute la commande "curl" et obtenir un logo Arduino en "ascii art" depuis le Net
  // curl est un programme en ligne de commande pour transférer des données en utilisant
  //    différents protocols Internet
  Process p;        // Créer un processus et appellons le "p"
  p.begin("curl");  // Processus qui démarre la commande "curl"
  p.addParameter("http://arduino.cc/asciilogo.txt"); // Ajouter le parametre URL à "curl"
  p.run();      // Exécuter le processus et attendre sa fin d'exécution

  // Afficher le logo Arduino sur le port série
  // La sortie d'un processus (''process output'') peut être lut à laide
  //    des méthodes de streaming (gestion de flux)
  while (p.available()>0) {
    char c = p.read();
    Serial.print(c);
  }
  // S'assurer que les derniers bits de données soit bien envoyés
  Serial.flush();
}

Bridge = échange entre les processeurs

le Bridge permet de passer des information entre les deux processeurs en utilisant des paires clé/valeur (dénommé "key/value pairing" en anglais).

Cet exemple montre comment utiliser la bibliothèque Bridge pour accéder aux broches analogiques et digitales de la carte par l'intermédiaire d'appels REST (Wikipedia.fr). Il montre comment créer votre propre API en utilisant le style REST pour faire des appels par l'intermédiaire du navigateur internet.

Assurez-vous que votre ordinateur partage le même réseau que votre Yùn.

Lorsque la carte est programmée, vous pouvez: demander la valeur d'une broche, écrire une valeur sur une broche et configurer une broches soit comme entrée ou sortie.

Lorsque le mot de passe REST est désactivé, vous pouvez naviguer sur les URL structurées suivantes en utilisant votre navigateur:

A la place de votre navigateur Web, vous pouvez également utiliser les commandes curl curl depuis une ligne de commande.

Vous avez besoin d'inclure les bibliothèques Bridge, YunServer et YunClient :

#include <Bridge.h>
#include <YunServer.h>
#include <YunClient.h>

Instancier un YunServer (donc un "serveur", dit "server" en anglais) permet au Yun d'écouter les clients connectés.

YunServer server;

Dans la fonction setup(), démarrer la communication série pour faire du débogage et activer les LED branchée sur la broches 13 lors du démarrage du bridge ("Bridge begins" en anglais). Bridge.begin() est bloquant, et devrait prendre environ 2 secondes pour s'achever. Une fois que le "Bridge" est démarré, la LED est éteinte.

void setup() {
  Serial.begin(9600);
  pinMode(13,OUTPUT);
  digitalWrite(13, LOW);
  Bridge.begin();
  digitalWrite(13, HIGH);

Dans la seconde partie de setup(), informer l'instance du YunServer d'écouter les connexions entrantes depuis localhost (uniquement). Les connextion effectuées sur Linino seront passée au processeur 32U4 pour les opérations de 'parsing' et de contrôle des broches. Cela se passe sur le port 5555. Demarrer le serveur avec server.begin().

  server.listenOnLocalhost();
  server.begin();
}

Dans la fonction loop(), vous allez créer une instance de YunClient pour gérer la connexion. Si un client se connecte, la requête est traitée ("processed" en anglais) par une fonction dédiée nommée process et clôture ensuite la connexion lorsqu'il à terminé.

Placer une instruction delay (délais) a la fin de loop() sera utile pour éviter que le processeur ne travaille trop.

void loop() {
  YunClient client = server.accept();

  if (client) {
    process(client);
    client.stop();
  }

  delay(50);
}

Créer ensuite une fonction nommée process ("traitement") qui accepte un YunClient comme argument. Lit la commande et stocke l'information entrante dans une chaine de caractère. Parse/décompose la commande REST en fonction de sa fonctionnalité (digital, analog et mode) et passe l'information à la sous fonction de traitement adéquate (et nommée de façon intelligible).

void process(YunClient client) {
  // Extraction de la commande. 
  // readStringUntil() signifie Lire_chaine_jusqu'a()
  // Donc extraire ce qui se trouve "http://myArduinoYun.local/arduino/" 
  //   et avant le "/" suivant!
  String command = client.readStringUntil('/');

  if (command == "digital") {
    digitalCommand(client);
  }
  if (command == "analog") {
    analogCommand(client);
  }
  if (command == "mode") {
    modeCommand(client);
  }
}

Créer une fonction qui gère les commandes digital comme dans l'appel [http://myArduinoYun.local/arduino/digital/13/1.

La fonction accepte un client comme argument. Créer quelques variables locales pour maintenir la broche ("pin" en anglais) et la valeur ("value" en anglais) de la commande.

void digitalCommand(YunClient client) {
  int pin, value;

Fait un parsing (découpage) de la requête client pour obtenir la broche ("pin") à utiliser à l'aide de la fonction client.parseInt().

Si le caractère après la broche est un "/", cela signifie que l'URL devrait aussi contenir une valeur de 1 ou 0 (après le "/"). Cette valeur initialisera la "valeur de la broche" en plaçant sont état à HIGH ou LOW. S'il n'y a pas de "/" après le numéro de broche alors nous lisons la valeur de la broche spécifiée.

  // extraction du numéro de broche (un nombre entier)
  pin = client.parseInt();
  
  // S'il y a un "/" après l'entier du numéro de 
  //    broche comme dans ".../arduino/digital/13/1"
  if (client.read() == '/') {
    // Alors lire un autre entier après le "/"
    // cette valeur est l'état de la broche
    // 1 = HIGH, 0 = LOW
    value = client.parseInt();
    digitalWrite(pin, value);
  }
  else {
    // Sinon, sans "/" après ne numéro de broche 
    //     comme dans ".../arduino/digital/13", il
    //     faut simplement lire l'état de l'entrée.
    value = digitalRead(pin);
  }

Affiche/envoi la valeur de vers le client et fait une mise-à-jour de la clé dans le datastore avec la valeur de la broche.

En enrobant la valeur renvoyée au client avec l'appel à la fonction F(), vous pouvez afficher/renvoyer du texte provenant de la mémoire Flash. Cela permet d'économiser de la mémoire SRAM, très précieuse pour traiter de longues chaines de caractères tel que des URLs.

La clé (key en anglais) du datastore sera le numéro de broche et le type (analogique ou digitale). Par exemple, D2 sera clé pour sauver la valeur de la broche digitale #2. La valeur correspondant à la clé sera soit la valeur actuelle de la broche, soit la valeur que l'on assigne volontairement à la broche.

  client.print(F("Pin D"));
  client.print(pin);
  client.print(F(" set to "));
  client.println(value);

  // Clé pour le DataStore
  String key = "D";
  key += pin;
  // Stocker la ''clé = valeur'' dans le datastore du Bridge.
  Bridge.put(key, String(value));
}

Mettre en place une fonction qui gère les appels analogique. Cette fonction est fort similaire à celle qui gère les appels digitaux, excepté que la clé utilise un A à la place d'un D pour stocker la valeur dans de la broche d'entrée dans le DataStore :

void analogCommand(YunClient client) {
  int pin, value;
  // Obtenir le numéro de broche depuis l'URL
  pin = client.parseInt();

  // S'il y a une "/" après...
  if (client.read() == '/') {
    // cela signifie que l'on fixe la valeur de la broche 
    value = client.parseInt();
    analogWrite(pin, value);

    // renvoyer une réponse au client
    client.print(F("Pin D"));
    client.print(pin);
    client.print(F(" set to analog "));
    client.println(value);

    // Valeur de la clé pour le DataStore
    String key = "D";
    key += pin;
    // Stockage de la "Clé = Valeur" dans le DataStore
    Bridge.put(key, String(value));
  }
  else {
    // Si pas de "/" après le numéro de broche, c'est que 
    // l'on désire lire la valeur de la broche
    value = analogRead(pin);

    // renvoyer une réponse au client
    client.print(F("Pin A"));
    client.print(pin);
    client.print(F(" reads analog "));
    client.println(value);

    // Stockage de la "Clé = Valeur" dans le DataStore
    String key = "A";
    key += pin;
    Bridge.put(key, String(value));
  }
}

Créer une ou plusieurs fonctions pour gérer les changement de mode des broches. Accepter un YunClient comme argument, et créer une variable locale pour maintenir le numéro de broches. Lire la valeur de la broche comme nous l'avons fait dans les fonctions de traitement des commandes "digital" et "analog".

void modeCommand(YunClient client) {
  int pin;
  // Obtenir le numéro de broche depuis l'URL
  pin = client.parseInt();

Vérifier que l'URL est bien valide. Il fait absolument un paramètre en plus, et donc un "/" après le numéro de broche

  if (client.read() != '/') {
    client.println(F("error"));
    return;
  }

Et si l'URL est correcte alors extraire le mode (jusqu'à la fin de l'URL qui se termine par un retour clavier... donc \r). Si le mode est input (entrée) ou output (sortie) alors configurer la broche comme demandé et informer le client. Si la chaine de caractère "mode" ne contient pas l'une de ces valeurs alors il faut informer le client qu'il y a une erreur.

  String mode = client.readStringUntil('\r');
  if (mode == "input") {
    // configurer la broche en entrée
    pinMode(pin, INPUT);
    // Informer le client
    client.print(F("Pin D"));
    client.print(pin);
    client.print(F(" configured as INPUT!"));
    return;
  }

  if (mode == "output") {
    // configurer la broche comme sortie
    pinMode(pin, OUTPUT);
    // informer le client
    client.print(F("Pin D"));
    client.print(pin);
    client.print(F(" configured as OUTPUT!"));
    return;
  }

  // Si cette portion de code est exécuter alors
  // la valeur de mode est ni "input" ni "output".
  // Si c'est le cas, alors il y a une erreur
  client.print(F("error: invalid mode "));
  client.print(mode);
}

Vous pouvez trouver plus de détails sur cet exemple dans les page d'exemples dédiés aux "exemples Bridge".

Connecting to internet services with Temboo

{{{2}}}
Crédit: Arduino arduino.cc traduction par MCHobby.be

Yún dispose de nombreuses aptitudes réseaux, mais certains des aspects les plus excitants sont certainement ceux permettant d'interagir avec des plateformes en-ligne (online). Arduino à développé un partenariat avec Temboo pour rendre la connexion à vos services favoris aussi simple que possible. Temboo fournit un accès normalisé à plus de 100 APIs depuis un simple point de contact vous permettant ainsi de mixer et coupler des données provenant de plusieurs plateformes (par exemple Twitter, Facebook, Foursquare mais aussi FedEx ou PayPal).

Il y a de nombreux exemples dans le répertoire Fichier > Exemples > Bridge > Temboo, c'est un bon point de départ pour commencer à utiliser un Yùn sur le cloud. Vous pouvez en apprendre plus sur l'intégration de Temboo et Arduino dans les pages "Temboo getting started" (Temboo.com, anglais).

Spacebrew

Spacebrew est "une façon simple de connecter ensemble des objets interactifs". Spacebrew repose sur le modèle client/serveur et utilise un WebSockets pour établir la communication entre les deux éléments. Il fait fonctionner un web serveur customisé en python sur le Yún pour faciliter la communication.

Il y a plusieurs exemples concernant Spacebrew sur le Yún inclus dans la logiciel. Pour plus d'information sur Spacebrew, voyez les pages de documentation du projet.

Installer des logiciels sur Linux

Yún dispose de plusieurs éléments logiciels pré-installer sur Linino, incluant "curl" et "python". Vous pourriez avoir besoin d'installer d'autre logiciel sur Yún. Sur un système Linux, d'autres logiciels additionnels peuvent être installés à l'aide d'un outils que l'on appelle un "un système de gestion de paquet" (package management system). Référez vous au Gestionnaire de paquet Yun pour plus d'information.

Guide en vidéo

Voici une vidéo YouTube "Getting started with Yun" réalisée par Arduino.



Source: Arduino Yun, Guide to the Arduino Yún. Crédit: Arduino.cc, licence Creative Common Attribution ShareAlike.

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.