Arduino Yún

par dolivier

Arduino Yún

Un des reproches que l’on peut faire aux Arduinos de base est le manque de connectivité et pour avoir essayé le shield wifi en plus d’être encombrant c’est un peu galère surtout si vous rêvez d’un internet des objets facile à configurer et utiliser. De plus il faut souvent lutter contre la place consommée. L’Arduino Yún apporte une solution intéressante. Il s’agit d’un Arduino avec WiFi intégré et un second microprocesseur qui permet d’avoir une version légère de Linux ainsi que le langage Python préinstallé.

Nous allons commander par wifi des LEDs. Cela constitue une base qu’il est ensuite possible de réutiliser pour réaliser des choses plus sophistiquées. Dans un premier temps nous allons passer en revue les différentes étapes de mise à jour et de configuration.

J’utilise linux sous une distribution archlinux.

Anatomie

Les resets du Yún

Les éléments importants sont :

  • Le processeur ATmega 32U4 il pilote les broches comme d’habitude ;
  • Le processeur Atheros AR9331 qui pemet d’avoir du Wifi et un linux embarqué. La distribution est OpenWRT ;
  • Trois ports : l’USB standard, un micro USB et ethernet ;
  • Trois boutons resets (arduino, wifi, linux) ;
  • Un emplacement pour une carte micro SD.

IL n’y a pas de régulateur 5V intégré. Donc attention à bien l’alimenter avec une tension correcte, si vous le faite autrement que par le câble USB connecté à votre ordinateur.

Livre de reset

  • Le reset Linux redémarre l’AR9331 ;
  • Pour redémarrer le 32U4 et relancer le dernier programme téléversé dans l’Arduino, pressez deux fois le reset de l’Arduino ;
  • Lorsque vous pressez le reset Wifi, la led WLAN se met à clignoter. Si vous changez de réseau et ne pouvez plus vous connecter par wifi au Yún en passant par l’interface web. Réinitialisez la configuration réseau du Yún en appuyant sur le reset du WiFi plus de 5 secondes et moins de 30. L’AR9331 redémarrera et la configuration WiFi sera réinitialisée. Le Yún crée alors son propre réseau WiFi Arduino Yun-XXXXXXXXXXXX ;
  • Si vous voulez revenir à la configuration d’usine, appuyez sur le bouton reset du Wifi pendant au moins 30 secondes. Bien sur si vous avez fait une mise à jour de linux, vous la conserverez.

Yún et le wifi

Le Yún se comporte comme un point d’accès wifi. Il est donc assez facile de se connecter à ce dernier et de le configurer de façon à ce qu’il se connecte ensuite au réseau wifi de chez vous, par exemple.

Connection au Yún.

Une fois connecté vous pouvez utilisez votre navigateur pour interroger votre Yún. Normalement l’url est la suivante arduino.local. Si vous n’y arrivez pas route peut vous aider :

% route
Kernel IP routing table
Destination     Gateway         Genmask         Flags Metric Ref    Use Iface
default         Duinuy.lan      0.0.0.0         UG    600    0        0 wlo1
192.168.240.0   *               255.255.255.0   U     600    0        0 wlo1

C’est donc Duinuy.lan mais surtout on a l’adresse en dur 192.168.240.1. Il suffit donc de l’utiliser. Vous devrez voir normalement la page suivante :

Login au Yún.

Le mot de passe par défaut est arduino. Connectez vous. Vous arriverez alors sur une page d’information.

Page d'information du Yún.

Cliquez ensuite sur configure et rentrez les informations concernant votre réseau.

Configuration du wifi du Yún.

Cliquez ensuite sur configure and restart.

Sauvegarde et redémarrage.

Votre Yún en principe redémarre et se connecte au wifi comme un grand. Cependant j’ai rencontré quelques problèmes, une solution est donc de débrancher et rebrancher votre Yún. En principe vous devez trouver votre protégé à l’adresse <le_nom_que_vous_lui_avez donne>.local. Ma bestiole refuse ! Si vous aussi, nmap peut vous rendre service.

% sudo nmap -T4 -sP 192.168.0.0/24

Starting Nmap 7.01 ( https://nmap.org ) at 2015-12-27 11:31 CET
Nmap scan report for 192.168.0.21
Host is up (0.0037s latency).
MAC Address: 00:00:00:00:D0:66 (Synology Incorporated)
Nmap scan report for 192.168.0.23
Host is up (0.079s latency).
MAC Address: 00:00:00:00:D0:66 (Nintendo)
Nmap scan report for 192.168.0.24
Host is up (0.079s latency).
MAC Address: 00:00:00:00:D0:66 (Hon Hai Precision Ind.)
Nmap scan report for 192.168.0.27
Host is up (0.12s latency).
MAC Address: 90:A2:DA:F2:0A:6B (Gheo SA)
Nmap scan report for 192.168.0.254
Host is up (0.0028s latency).
MAC Address: 00:00:00:00:D0:66 (Freebox SAS)
Nmap scan report for 192.168.0.16
Host is up.
Nmap done: 256 IP addresses (6 hosts up) scanned in 3.14 seconds

À l’aide de nmap on a scanné toutes les adresses comprises entre 192.168.0.0 et 192.168.0.255. Il faut bien sur remplacer cela par votre adresse de base. Ici mon Yún est à l’adresse 192.168.0.27 (Gheo SA). Une fois l’adresse connue on peut vérifier les ports ouverts.

% sudo nmap -F 192.168.0.27
Starting Nmap 7.01 ( https://nmap.org ) at 2015-12-27 11:38 CET
Nmap scan report for 192.168.0.27
Host is up (0.0029s latency).
Not shown: 97 closed ports
PORT    STATE SERVICE
22/tcp  open  ssh
80/tcp  open  http
443/tcp open  https
MAC Address: 90:A2:DA:F2:0A:6B (Gheo SA)

En utilisant mon navigateur j’obtiens à l’adresse 192.168.0.25 la page suivante :

Yun connecté

zeroconf

L’utilisation de zeroconf vous permettra de résoudre peut-être vos éventuels problèmes de résolution de nom. Sous archlinux il faut installer avahi et nss-mdns si ce n’est déjà fait.

% yaourt -S avahi nss-mdns

Lancer le service au démarrage :

% sudo systemctl enable avahi-daemon.service

et modifier le fichier /etc/nsswitch.conf en changeant la ligne hosts en :

hosts: files mdns4_minimal [NOTFOUND=return] dns mdns4 leNomDeVotreMachine

Carte SD et MAJ

La mémoire Flash interne du Yún à un nombre limité d’écritures possibles. Il est préférable d’utiliser une carte microSD (ou une clé USB) comme mémoire externe pour sauvegarder données, pages web, etc. Nous allons de plus l’utiliser pour une mise à jour d’OpenWRT. Les opérations que je décris ici, se font sous linux. J’utilise une distribution archlinux.

Carte SD

On va tout d’abord formater la carte SD. La première chose est d’identifier le device. Vous pouvez utiliser lsblk ou encore dmesg.

% dmesg | tail[281710.917862]
[281710.917862] mmc0: card aaaa removed
[281713.208108] mmc0: cannot verify signal voltage switch
[281713.311768] mmc0: new ultra high speed SDR104 SDHC card at address aaaa
[281713.311867] mmcblk0: mmc0:aaaa SE16G 14.8 GiB
[281713.320446]  mmcblk0: p1 p2  

Le device correspondant est donc mmcblk0 que l’on va pouvoir formater, mais avant on vérifie les partitions déjà présentes.

% sudo fdisk /dev/mmcblk0

Bienvenue dans fdisk (util-linux 2.27.1).
Les modifications resteront en mémoire jusqu'à écriture.
Soyez prudent avant d'utiliser la commande d'écriture.


Commande (m pour l'aide) : p
Disque /dev/mmcblk0 : 14,9 GiB, 15931539456 octets, 31116288 secteurs
Unités : secteur de 1 × 512 = 512 octets
Taille de secteur (logique / physique) : 512 octets / 512 octets
taille d'E/S (minimale / optimale) : 512 octets / 512 octets
Type d'étiquette de disque : dos
Identifiant de disque : 0x00000000

Périphérique   Amorçage Début      Fin Secteurs Taille Id Type
/dev/mmcblk0p1              16   250047   250032 122,1M  b W95 FAT32
/dev/mmcblk0p2          250048 15564799 15314752   7,3G 83 Linux

Il y a deux partitions sur ma carte. Je vais donc les supprimer pour en recréer une seule.

Commande (m pour l'aide) : d
Numéro de partition (1,2, 2 par défaut) :

La partition 2 a été supprimée.

Commande (m pour l'aide) : d
Partition 1 sélectionnée
La partition 1 a été supprimée.

On crée une partition primaire

Commande (m pour l'aide) : n
Type de partition
  p   primaire (0 primaire, 0 étendue, 4 libre)
  e   étendue (conteneur pour partitions logiques)
Sélectionnez (p par défaut) : p
Numéro de partition (1-4, 1 par défaut) :
Premier secteur (2048-31116287, 2048 par défaut) :
Dernier secteur, +secteurs ou +taille{K,M,G,T,P} (2048-31116287, 31116287 par défaut) :

Une nouvelle partition 1 de type « Linux » et de taille 14,9 GiB a été créée. On termine en modifiant le type de partition (fat32).

Commande (m pour l'aide) : t

Partition 1 sélectionnée
Type de partition (taper L pour afficher tous les types) : c
Type de partition « Linux » modifié en «  W95 FAT32 (LBA) ».

Commande (m pour l'aide) : w
La table de partitions a été altérée.
Appel d'ioctl() pour relire la table de partitions.
Synchronisation des disques.

On formate ensuite :

% sudo mkfs.vfat /dev/mmcblk0p1

Mise à jour

La première chose à faire est de récupérer la dernière version OpenWRT pour votre arduino et désarchiver.

% unzip  YunSysupgradeImage_v1.5.3.zip
Archive:  YunSysupgradeImage_v1.5.3.zip
 inflating: openwrt-ar71xx-generic-yun-16M-squashfs-sysupgrade.bin

Il faut copier openwrt-ar71xx-generic-yun-16M-squashfs-sysupgrade.bin à la racine de la carte SD. La commande mount ou votre navigateur de fichier vous permettent de connaitre le chemin.

% mount

/dev/mmcblk0p1 on /run/media/damien/9502-4341 type vfat (rw,nosuid,nodev,relatime,uid=1000,gid=100,fmask=0022,dmask=0022,codepage=437,iocharset=iso8859-1,shortname=mixed,showexec,utf8,flush,errors=remount-ro,uhelper=udisks2)

On copie

% cp openwrt-ar71xx-generic-yun-16M-squashfs-sysupgrade.bin /run/media/damien/9502-4341/
% sync
% sudo umount /run/media/damien/9502-4341/

Il reste à éjecter la carte SD et la mettre dans l’emplacement prévu du Yún.

Cliquez sur Reset et attendez ! Vous pourrez utiliser votre carte SD ensuite pour stocker vos fichiers.

Première connexion ssh

% ssh root@192.168.0.27
The authenticity of host '192.168.0.27 (192.168.0.27)' can't be established.
RSA key fingerprint is SHA256:XABfo7n6k8pTRyb4EoE6p9TgQOmWPBk0NKvuARfp/wM.
Are you sure you want to continue connecting (yes/no)? yes
Warning: Permanently added '192.168.0.27' (RSA) to the list of known hosts.
root@192.168.0.27's password:


BusyBox v1.19.4 (2014-11-13 19:03:47 CET) built-in shell (ash)
Enter 'help' for a list of built-in commands.

 _______                     ________        __
|       |.-----.-----.-----.|  |  |  |.----.|  |_
|   -   ||  _  |  -__|     ||  |  |  ||   _||   _|
|_______||   __|_____|__|__||________||__|  |____|
         |__| W I R E L E S S   F R E E D O M
-----------------------------------------------------

Il faut ensuite mettre à jour les différents packages :

root@Duinuy:~# opkg update
Downloading http://downloads.arduino.cc/openwrtyun/1/packages/Packages.gz.
Updated list of available packages in /var/opkg-lists/attitude_adjustment.
Downloading http://downloads.arduino.cc/openwrtyun/1/packages/Packages.sig.
Signature check passed.

Si vous avez une carte SD que vous avez formatté en suivant les indications précédentes vous pouvez déterminer son point de montage :

root@Duinuy:~# mount
rootfs on / type rootfs (rw)
/dev/root on /rom type squashfs (ro,relatime)
proc on /proc type proc (rw,noatime)
sysfs on /sys type sysfs (rw,noatime)
tmpfs on /tmp type tmpfs (rw,nosuid,nodev,noatime,size=30560k)
tmpfs on /dev type tmpfs (rw,noatime,size=512k,mode=755)
devpts on /dev/pts type devpts (rw,noatime,mode=600)
/dev/mtdblock3 on /overlay type jffs2 (rw,noatime)
overlayfs:/overlay on / type overlayfs (rw,relatime,lowerdir=/,upperdir=/overlay)
debugfs on /sys/kernel/debug type debugfs (rw,relatime)
/dev/sda1 on /mnt/sda1 type vfat  (rw,sync,relatime,fmask=0022,dmask=0022,codepage=cp437,iocharset=iso8859-1,shortname=mixed,errors=remount-ro)
none on /proc/bus/usb type usbfs (rw,relatime)

Elle est donc accessible en /mnt/sda1 et on va supprimer le fichier de maj.

root@Duinuy:~# rm /mnt/sda1/openwrt-ar71xx-generic-yun-16M-squashfs-sysupgrade.bin

L’étape suivante consiste à créer un répertoire arduino qui pourra être monté automatiquement sous /mnt/sd et utilisable dans vos programmes “sketch arduino” (.ino).

root@Duinuy:~# mkdir /mnt/sda1/arduino
root@Duinuy:~# chmod 777 /mnt/sda1/arduino

Il faut également créer un répertoire www qui sera automatiquement lié à /www.

root@Duinuy:~# mkdir /mnt/sda1/arduino/www

Programmation

Je vous propose de faire comme d’habitude d’allumer et d’éteindre une led ….

L’aide d’une LED

Cet exemple est tiré du tutorial associé à l’arduino Yún. On se contente d’allumer et d’éteindre la led 13 intégrée par l’intermédiaire de la console accessible par le wifi.

/*
  Exemple adapté de
  http://arduino.cc/en/Tutorial/ConsolePixel
*/

#include <Console.h> // On inclut la librarie Console qui est l'équivalent de Serial mais en Wifi...

const unsigned int broche = 13; // On définit une constance entière pour nommer le pin de la led
char valeur_entree;             // On crée un variable pour stocker les valeurs que l'on enverra via la console

void setup() {
  // Initialisation de la console et attente de l'ouverture du port
  Bridge.begin();            // On démarre Bridge qui permet la communication entre Arduino et Linux
  Console.begin();           // On démarre la console (remplace le moniteur série)
  // Pensez à configure l'IDE arduino en conséquence outil->port->le wifi du Yun
  pinMode(broche, OUTPUT);   // On définit la broche 13 en sortie
  while (!Console);          // On attend que la console se connecte
}


void loop() {
  static boolean unique = true;
  if (unique) {
    Console.println("Tapez A ou E pour (A)llumer ou (E)teindre led 13");
    unique = false;
  }

  valeur_entree = Console.read();      // On lit la console
  if (valeur_entree > 90) valeur_entree -= 32;  // Minuscules -> majuscules
  if (valeur_entree == 'A') {
    digitalWrite(broche, HIGH);        // On allume
  }
  if (valeur_entree == 'E') {
    digitalWrite(broche, LOW);         // On éteint la led
  }
}

Commande d’une led RGB au travers du web

Pour cela on utilise l’architecture REST (REpresentational State Transfer) qui permet de rendre accessible par exemple les broches par l’intermédiaire d’une URI. REST repose sur le protocole HTTP et on accède donc à une ressource grace à son URI unique. On peut réaliser diverses opérations (GET lecture / POST écriture / PUT modification / DELETE suppression).

Les services web sont associés à ce que REST appelle un point terminal. Le Yún en connait deux (remplacer duinuy par le nom de votre Yún) :

  1. http://duinuy.local/arduino
  2. http://duinuy.local/data

Tout ce que vous ajouterez après http://duinuy.local/arduino sera communiqué au serveur web s’exécutant sous linino au sketch tournant sur la partie arduino (32U4). La partie http://duinuy.local/data sert à stocker des données de type Clef/Valeur. Les appels possibles sont :

  • http://duinuy.local/data/put/CLEF/VALEUR : stocke une VALEUR pour la CLEF.
  • http://duinuy.local/data/get/CLEF : obtenir la valeur de la CLEF. Le format de retour et au format JSON
  • http://duinuy.local/data/delete : efface ce qui est stocké en interne.
pont linux arduino
Le pont entre la partie Linux et Arduino (source)

L’exemple du tutorial arduino met cela en œuvre et d’ailleurs ce que nous proposons dans ce qui suit en est très largement inspiré, puisque ce n’est qu’une version allégée.

Le montage

Il vous faut :

  • Une led RGB avec en commun l’anode ;
  • 3 résistances de 330Ω ;
  • Quelques fils.

montage

Le code

/*
  D'après Arduino Yun Bridge example
  Version allégée
  http://arduino.cc/en/Tutorial/Bridge

  Utilisation des appels REST utilisable à l'aide d'un navigateur.
*/


#ifdef DEBUG
#include <Console.h> // On inclut la librarie Console qui est l'équivalent de Serial mais en Wifi...
#endif
#include <Bridge.h>
#include <YunServer.h>
#include <YunClient.h>

const unsigned int lesBroches[] = {9, 10, 11};
YunServer serveur;

void setup() {
  Bridge.begin();           // On démarre Bridge entre linino et arduino
#ifdef DEBUG
  Console.begin();
  while (!Console);
  Console.println("Initialization du Yun réalisée");
#endif
  pinMode(13, OUTPUT);      // Broche 13 en sortie
  digitalWrite(13, LOW);    // On etteint la led 13
  digitalWrite(13, HIGH);   // On allume la led 13 quand bridge est lancé
  unsigned int i;
  for (i = 0; i < sizeof(lesBroches) / sizeof(int) ; i++) {
    pinMode(lesBroches[i], OUTPUT);
  }
#ifdef DEBUG
  Console.println("Lancement du serveur");
#endif
  serveur.listenOnLocalhost(); // On n'accepte que les connexions venant du même réseau
  serveur.begin();             // On lance le serveur
#ifdef DEBUG
  Console.println("Serveur lancé");
#endif
}

void loop() {
  YunClient client = serveur.accept();      // On accepte les connexions
  if (client) {                             // Si il y a un nouveau client
    gestion_requete(client);                // On traite la requete du client
    client.stop();                          // Sinon on ferme la connexion et on libère des ressources
  }
  delay(50); // On fait cela toutes les 50 millisecondes
}

/*
   Gestion des requètes.
   Sous la forme http://<nomDuYun>/arduino/<numeroDeLaLed>/<luminosité>
   Ex : http://duinuy.local/arduino/11/167
*/
void gestion_requete(YunClient client)
{
  int broche = client.parseInt(), valeur;
  if (client.read() == '/')
  {
    valeur = client.parseInt();
    digitalWrite(broche, valeur);

    // On envoie des indications au client pour dire que tout va bien
    // HTML activé
    client.println("Status: 200");
    client.println("Content-type: text/html; charset=UTF-8");
    client.println();
    client.println("<B><Center>");
    client.print("Broche ");
    client.print(broche);
    client.print(" reglée à ");
    client.println(valeur);
    client.println("</B></Center>");

    // On met à jour la valeur entrée dans la mémoire du linino sous la clef D
    // On peut la consulter par  http://<nomDuYun>/data/get/D
    // Ex : http://duinuy.local/data/get
    String clef = "D";
    clef += broche;
    Bridge.put(clef, String(valeur));
  }
  else client.println("ERREUR");
}

Ce code ouvre en mode déverminage une console qui permet de tracer le programme au travers du wifi. Pour cela il faut définir une macro sous la forme d’un #define DEBUG en première ligne. Les lignes 13,14 et 15 déclarent les headers nécessaires, le bridge (Bridge.h) qui permet comme on l’a déjà vu la communication entre la partie arduino et linux, le serveur web (YunServer.h) et le client (YunClient.h).

La fonction setup() définit les broches utilisées et lance le serveur ligne 38.

La fonction loop() consiste à accepter les connexions, les requêtes et lorsqu’il y en a, à les traiter. Le traitement est effectué par la fonction void gestion_requete(YunClient client) qui est définie ligne 58. Une requête doit être sous la forme http://<nomDuYun>/arduino/<numeroDeLaLed>/<luminosité> :

  • <nomDuYun> vous remplacez cela par le nom de votre arduino ou son adresse ip.
  • <numeroDeLaLed> correspond à la broche souhaitée.
  • <luminosité> à l’intensité dont la valeur est comprise entre 0 et 255.

Ex : http://duinuy.local/arduino/11/167 led de la broche 11 (B) 167 de luminosité.

Le traitement est simple on récupère la broche ligne 60. parseInt() réalise une analyse lexicale et retourne le premier nombre lu dans la requête, ensuite on vérifie que le caractère non numérique qui suit est un / ligne 61. Il reste à récupérer la valeur et écrire sur la broche correspondante, ligne 64. On renvoie des informations au client sous la forme d’une page html.

Pour http://duinuy.local/arduino/10/255 vous obtiendrez la page web suivante :

<B><Center>
Broche 10 reglée à 255
</B></Center>

La suite du code (81 à 83) met à jour la valeur entrée au niveau du linino sous la clef D. On peut alors la consulter par http://<nomDuYun>/data/get/D<numeroDeLaLed>. Pour notre exemple http://duinuy.local/data/get/D10 on obtient :

{"value":"255","key":"D10","response":"get"}

Vous pouvez aussi essayer http://duinuy.local/data/get qui vous donnera la totalité des valeurs.

{"value":{"D9":"255","D11":"255","D10":"255"},"response":"get"}

Cela peut être utile pour lire des capteurs, par exemple.

Une version plus sophistiquée

L’idée est maintenant d’utiliser javascript et en particulier JQuery pour réaliser une interface web plus interactive et convaincante que celle que nous venons de voir. On écrit tout d’abord le code HTML/Javascript qui va résider sur notre Yún.

<html lang="fr">
<head>
    <title>Manip d'une led RGB</title>
    <link href="http://code.jquery.com/ui/1.11.1/themes/smoothness/jquery-ui.css" rel="Stylesheet"
        type="text/css" />
    <script src="http://code.jquery.com/jquery-1.10.2.js"></script>
    <script type="text/javascript" src="http://code.jquery.com/ui/1.10.4/jquery-ui.js"></script>
    <style type="text/css">
        #output
        {
            width: 100px;
            height: 100px;
            border: solid 1px #ccc;
        }
        #redslide, #greenslide, #blueslide
        {
            height: 15px;
            margin: 10px 0px;
            width: 350px;
        }

        #redslide .ui-slider-range
        {
            background: red;
        }
        #redslide .ui-slider-handle
        {
            border-color: red;
        }
        #greenslide .ui-slider-range
        {
            background: green;
        }
        #greenslide .ui-slider-handle
        {
            border-color: green;
        }
        #blueslide .ui-slider-range
        {
            background: blue;
        }
        #blueslide .ui-slider-handle
        {
            border-color: blue;
        }
    </style>
    <script language="javascript">
        $(document).ready(function () {
            $("#redslide, #greenslide, #blueslide").slider({
                orientation: "horizontal",
                range: "min",
                max: 255,
                value: 127,
                slide: maj,
                change: majLed
            });
            $("#redslide").slider("value", 150);
            $("#greenslide").slider("value", 60);
            $("#blueslide").slider("value", 100);

        });
        function maj() {
            var hexa = getHexaFromRGB($("#redslide").slider("value"),
             $("#greenslide").slider("value"),
             $("#blueslide").slider("value"));
             $("#output").css("background-color", "#" + hexa);    
        }

        function majLed() {
            maj();
            setRGBled($("#redslide").slider("value"), $("#greenslide").slider("value"),$("#blueslide").slider("value") );
        }

        function setRGBled(r, g, b) {
            $.ajax({
                     type: "POST",
                     url:"http://duinuy.local/arduino/changeRGB/" + r + "." + g + "." + b});
        }

        function getHexaFromRGB(r, g, b) {
            var hexa = [r.toString(16), g.toString(16), b.toString(16)];
            $.each(hexa, function (nr, val) {
                if (val.length === 1) {
                    hexa[nr] = "0" + val;
                }
            });
            return hexa.join("").toUpperCase();
        }

    </script>
</head>
<body>
 <h1>Manipulation d'une LED RGB<br></h1>
    <div id="output"></div>
    <div id="redslide"></div>
    <div id="greenslide"></div>
    <div id="blueslide"></div>
</body>
</html>

Je ne vais pas détailler les éléments d’interface et la mise en forme. Par contre il me semble intéressant de noter que tout le travail s’effectue dans

function setRGBled(r, g, b) {
  $.ajax({
	     type: "POST",
	     url:"http://duinuy.local/arduino/changeRGB/" + r + "." + g + "." + b
  });
}

La fonction $.ajax() permet d’envoyer une requête HTTP. Le fichier ciblé est fixé par url et le type de requête par type. On utilise dons l’architecture REST et on poste donc quelque chose qui ressemble à http://duinuy.local/arduino/changeRGB/10.56.234 par exemple. Une fois ce programme réalisé, nous allons le stocker sur la carte SD de notre Yun. Pour cela on crée un répertoire /mnt/sda1/arduino/www/changeRGB :

% ssh root@duinuy.local
root@duinuy.local's password:


BusyBox v1.19.4 (2014-11-13 19:03:47 CET) built-in shell (ash)
Enter 'help' for a list of built-in commands.

 _______                     ________        __
|       |.-----.-----.-----.|  |  |  |.----.|  |_
|   -   ||  _  |  -__|     ||  |  |  ||   _||   _|
|_______||   __|_____|__|__||________||__|  |____|
         |__| W I R E L E S S   F R E E D O M
-----------------------------------------------------


root@Duinuy:~# mkdir /mnt/sd/arduino/www/changeRGB
root@Duinuy:~# exit
Connection to duinuy.local closed.

On copie le fichier html contenant le script

% scp RGB.html root@duinuy.local:/mnt/sd/arduino/www/changeRGB/index.html
root@duinuy.local's password:
RGB.html                                                                                                            100% 2861     2.8KB/s   00:00

On peut maintenant accéder à l’adresse http://duinuy.local/sd/changeRGB/ à la page correspondante.

Manipulation RGB
La page http://duinuy.local/sd/changeRGB/

Le sketch si j’ai été suffisamment clair précédemment ne pose pas de problème. On utilise la même structure de programme.

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

YunServer serveur;

// On fixe les broches de la led RGB suivant le montage
int brocheRouge = 11;
int brocheVerte = 9;
int brocheBleue = 10;

void setup() {
  Bridge.begin();
  serveur.listenOnLocalhost();
  serveur.begin();
}

void loop() {
  unsigned int r, g, b;

  YunClient client = serveur.accept();             // Le serveur accepte les connexions
  if (client) {                                    // S'il y a un client, on traite
    String command = client.readStringUntil('/');
    // La requete est de la forme : changeRGB/<R>.<G>.<B> exemple : changeRGB/10.145.0
    if (command == "changeRGB") {
      r = client.parseInt();
      analogWrite(brocheRouge, r );
      g = client.parseInt();
      analogWrite(brocheVerte, g);
      b = client.parseInt();
      analogWrite(brocheBleue, b);
    }
    // On ferme la connexion
    client.stop();
  }
  delay(25); // Traitement toute les 25ms
}

Vous pouvez donc commander votre led par internet maintenant ! Tout cela pour ça !

Sources

Nous contacter

Vous pouvez nous contacter à cette adresse ou utiliser le formulaire ci-dessous.