29 917
modifications
Modifications
Sauter à la navigation
Sauter à la recherche
Ligne 140 :
Ligne 140 : − + + + + − The first time you plug a Yún into a Mac, the "Keyboard Setup Assistant" will launch. There's nothing to configure with the Yún; you can close this dialogue by clicking the red button in the top left of the window. + − + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
→Communiquer avec Linino via le "Bridge"
while (!Console);</nowiki>
while (!Console);</nowiki>
== Installing Drivers for the Yún ==
=== 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 ===
=== 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).
{{ARDImage|Arduino Yun-Guide-10.png}}
{{ARDImage|Arduino Yun-Guide-10.png}}
=== Windows ===
=== Windows ===
{{traduction}}
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.
{{ARDImage|Arduino-Yun-Driver-01.png}}
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''").
{{ARDImage|Arduino-Yun-Driver-02.png}}
Tous les éléments sont sélectionnés par défaut. Cela inclus l'IDE, les pilotes (''drivers'') et les raccourcis (''shortcuts'')
{{ARDImage|Arduino-Yun-Driver-03.png}}
Sélectionnez l'endroit où vous désirez installer l'IDE (''environnement de développement'').
{{ARDImage|Arduino-Yun-Driver-04.png}}
Le programme d'installation affiche une barre de progression pendant qu'il extrait et installe les fichiers à l'emplacement correct.
{{ARDImage|Arduino-Yun-Driver-05.png}}
Une fenêtre de confirmation s'affichera si vous décidez d'installer les pilotes (''drivers''). Vous devrez confirmer votre sélection
{{ARDImage|Arduino-Yun-Driver-06.png}}
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 [http://support.apple.com/kb/DL999 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 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'').
{{ARDImage|Arduino-Yun-WirelessConfig-01.png}}
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.
{{ARDImage|Arduino-Yun-WirelessConfig-02.png}}
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.
{{ARDImage|Arduino-Yun-WirelessConfig-03.png}}
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.
{{ARDImage|Arduino-Yun-WirelessConfig-04.png}}
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.<br />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 la[[Arduino Yun-Librairie|librairie Bridge]] (ou bien [http://arduino.cc/en/Reference/YunBridgeLibrary Bridge library reference] Arduino.cc, Anglais).
{{ARDImage|Arduino-Yun-Pres03.jpg|640px}}<small> Traduction par MCHobby.be</small>
== 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.
<nowiki>#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);
}
}
}</nowiki>
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:
<nowiki>ssh root@yourYunsName.local 'telnet localhost 6571'</nowiki>
Puis presser la touche Retour/Entrée.
Note: Si vous utilisez Windows alors vous devrez installer un émulateur de terminal. [http://www.chiark.greenend.org.uk/~sgtatham/putty/ 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 [http://fr.wikipedia.org/wiki/CURL curl] et de télécharger du texte ASCII. Il affiche ensuite le texte sur la connexion série.
<nowiki>#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();
}</nowiki>
== 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 [http://fr.wikipedia.org/wiki/Representational_State_Transfer 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:
* [http://myArduinoYun.local/arduino/digital/13 http://myArduinoYun.local/arduino/digital/13] : effectue un ''digitalRead(13);''
* [http://myArduinoYun.local/arduino/digital/13/1 http://myArduinoYun.local/arduino/digital/13/1] : effectue un ''digitalWrite(13,1);''
* [http://myArduinoYun.local/arduino/analog/9/123 http://myArduinoYun.local/arduino/analog/9/123] : effectue un ''analogWrite(9,123);'' (donc un contrôle PWM en sortie)
* [http://myArduinoYun.local/arduino/analog/2 http://myArduinoYun.local/arduino/analog/2] : effectue un ''analogRead(2);'' pour effectuer une lecture analogique.
* [http://myArduinoYun.local/arduino/mode/13/input http://myArduinoYun.local/arduino/mode/13/input] : effectue un ''pinMode(13, INPUT);'' pour assigner une broche en entrée.
* [http://myArduinoYun.local/arduino/mode/13/output http://myArduinoYun.local/arduino/mode/13/output] : effectue une ''pinMode(13, OUTPUT);'' pour assigner une broche en sortie.
A la place de votre navigateur Web, vous pouvez également utiliser les commandes curl [http://fr.wikipedia.org/wiki/CURL curl] depuis une ligne de commande.
Vous avez besoin d'inclure les bibliothèques Bridge, YunServer et YunClient :
<nowiki>#include <Bridge.h>
#include <YunServer.h>
#include <YunClient.h></nowiki>
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.
<nowiki>void setup() {
Serial.begin(9600);
pinMode(13,OUTPUT);
digitalWrite(13, LOW);
Bridge.begin();
digitalWrite(13, HIGH);</nowiki>
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()'''.
<nowiki> server.listenOnLocalhost();
server.begin();
}</nowiki>
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.
<nowiki>void loop() {
YunClient client = server.accept();
if (client) {
process(client);
client.stop();
}
delay(50);
}</nowiki>
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).
<nowiki>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);
}
}</nowiki>
Créer une fonction qui gère les commandes ''digital'' comme dans l'appel [[http://myArduinoYun.local/arduino/digital/13/1 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.
<nowiki>void digitalCommand(YunClient client) {
int pin, value;</nowiki>
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.
<nowiki> // 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);
}</nowiki>
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.
<nowiki> 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));
}</nowiki>
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 :
<nowiki>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));
}
}</nowiki>
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".
<nowiki>void modeCommand(YunClient client) {
int pin;
// Obtenir le numéro de broche depuis l'URL
pin = client.parseInt();</nowiki>
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
<nowiki> if (client.read() != '/') {
client.println(F("error"));
return;
}</nowiki>
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.
<nowiki> 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);
}</nowiki>
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 ==
{{ARDImage|Arduino-Yun-Temboo-20.png}} <small> traduction par MCHobby.be</small>
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 [http://temboo.com 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 "[https://temboo.com/arduino 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 [http://docs.spacebrew.cc/ 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 [[Arduino Yun-PackageManager|Gestionnaire de paquet Yun]] pour plus d'information.
== Guide en vidéo ==
== Guide en vidéo ==