29 917
modifications
Modifications
Sauter à la navigation
Sauter à la recherche
Ligne 183 :
Ligne 183 : − There is no need to install drivers for Ubuntu 10.0.4 and later. + − + − The Yún has the ability to act as an Access Point, but it can also connect to an existing network. These instructions walk you through connecting your Yún to a wireless network. The Yún can connect to unencrypted networks, as well as networks that support WEP, WPA, and WPA2 encryption.+ − When you first power on the Yún, it will create a WiFi network called ArduinoYun-XXXXXXXXXXXX. Connect your computer to this network.+ − Once you've obtained an IP address, open a web browser, and enter [http://arduino.local http://arduino.local] or 192.168.240.1 in the address bar. After a few moments, a web page will appear asking for a password. Enter "arduino" and click the Log In button. + − You will find a page with some diagnostic information about the current network connections. The first is your WiFi interface, the second is your ethernet connection. Press the Configuration button to proceed. + − On the new page, you will configure your Yún, giving it a unique name and identifying what network you want to connect to.+ − In the Yún NAME field, give your Arduino a unique name. You'll use this to refer to it in the future.+ − Choose a password of 8 or more characters for your Arduino. If you leave this field blank, the system retains the default password of arduino+ − If you wish, you can set the timezone and country. It is recommended to set these options as it may help connecting to local WiFi networks. Setting the local timezone also selects the country's regulatory domain.+ − Enter the name of the wiFi network you wish to connect to.+ − Select the security type, and enter the password. + − When you press the Configure & Restart button, the Arduino will reset itself and join the specified network. The Arduino network will shut down after a few moments. + + + − You can now join the network you assigned to the Yún. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + − == Programming the 32U4 over WiFi ==+ − {{traduction}}
→Communiquer avec Linino via le "Bridge"
=== Linux ===
=== Linux ===
Il n'est pas nécessaire d'installer de pilotes pour Ubuntu 10.0.4 ou suivant.
== Configuring the onboard WiFi ==
== 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}}
{{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}}
{{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}}
{{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}}
{{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 ==