29 917
modifications
Modifications
Sauter à la navigation
Sauter à la recherche
Ligne 245 :
Ligne 245 : − + Ligne 394 :
Ligne 394 : − In '''loop()''', you'll create an instance of the YunClient for managing the connection. If the client connects, process the requests in a custom function (described below) and close the connection when finished.+ − Putting a delay at the end of '''loop()''' will be helpful in keeping the processor from doing too much work. + Ligne 409 :
Ligne 409 : − Create a function named '''process''' that accepts the YunClient as its argument. Read the command by creating a string to hold the incoming information. Parse the REST commands by their functionality (digital, analog, and mode) and pass the information to the appropriately named function. + + + + + Ligne 425 :
Ligne 429 : − Create a function to deal with ''digital'' commands. Accept the client as the argument. Create some local variables to hold the pin and value of the command. + + + − Parse the client's request for the pin to work with using '''client.parseInt()'''.+ − If the character after the pin is a "/", it means the URL is going to have a value of 1 or 0 following. This value will assign a value to the pin, turning it HIGH or LOW. If there is no trailing "/", read the value from the specified pin. + − − <nowiki> pin = client.parseInt(); + + + + + + + + + + + − Print the value to the client and update the datastore key with the current pin value.+ − By wrapping the value to the client in '''F()''', you'll be printing form the flash memory. This helps conserve space in SRAM, which is useful when dealing with long strings like URLs.+ − The key will be the pin, and type. For example ''D2'' will be saved for for digital pin 2. The value will be whatever value the pin is currently set to, or was read from the pin. + Ligne 455 :
Ligne 470 : + + − Set up a function to handle analog calls in the same fashion, except setting the key to A instead of D when working with the analog input pins : + − + + + − + Ligne 477 :
Ligne 496 : + + + + + Ligne 489 :
Ligne 513 : + Ligne 495 :
Ligne 520 : − Create one more function to handle pin mode changes. Accept the YunClient as the argument, and create a local variable to hold the pin number. Read the pin value just as you did in the digital and analog functions. + + − Check to make sure the URL is valid + Ligne 508 :
Ligne 534 : − If it's a valid URL, store the URL as a string. If the mode is an ''input'' or ''output'', configure the pin and report it to client. If the string doesn't match those values, return an error. + − + + + − + Ligne 520 :
Ligne 548 : + − + Ligne 528 :
Ligne 557 : + + + − You can find more details on this example on the Bridge Example page.+ Ligne 538 :
Ligne 570 : − The Yún has a number of built-in capabilities for networking, but some of the most exciting aspects are working with other online platforms. Arduino has partnered with [http://temboo.com Temboo] to make connecting to your favorite services easy as possible. Temboo provides normalized access to 100+ APIs from a single point of contact allowing you to mix and match data coming from multiple platforms (for example Twitter, Facebook, Foursquare but even FedEx or PayPal).+ − There are a number of examples in the ''File > Examples > Bridge > Temboo'' folder, these are a great place to get started working with your Yún in the cloud. you can learn more about the integration of Temboo and Arduino on the [https://temboo.com/arduino Temboo getting started pages].+ − + − There are a number of examples for Spacebrew on the Yún included in the software. For more on Spacebrew, see the [http://docs.spacebrew.cc/ project documentation pages].+ − + − The Yún comes with several pieces of software pre-installed on Linino, including "curl" and "python". You may want to install other software on the Yún. On Linux systems, additional software can be installed using a tool called the "package management system". For more information, refer to the [[Arduino Yun-PackageManager|Gestionnaire de paquet Yun]].+
→Communiquer avec Linino via le "Bridge"
== Communiquer avec Linino via le "Bridge" ==
== 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 tupe 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).
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>
{{ARDImage|Arduino-Yun-Pres03.jpg|640px}}<small> Traduction par MCHobby.be</small>
}</nowiki>
}</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() {
<nowiki>void loop() {
}</nowiki>
}</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) {
<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('/');
String command = client.readStringUntil('/');
}</nowiki>
}</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) {
<nowiki>void digitalCommand(YunClient client) {
int pin, value;</nowiki>
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() == '/') {
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();
value = client.parseInt();
digitalWrite(pin, value);
digitalWrite(pin, value);
}
}
else {
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);
value = digitalRead(pin);
}</nowiki>
}</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"));
<nowiki> client.print(F("Pin D"));
client.println(value);
client.println(value);
// Clé pour le DataStore
String key = "D";
String key = "D";
key += pin;
key += pin;
// Stocker la ''clé = valeur'' dans le datastore du Bridge.
Bridge.put(key, String(value));
Bridge.put(key, String(value));
}</nowiki>
}</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) {
<nowiki>void analogCommand(YunClient client) {
int pin, value;
int pin, value;
// Obtenir le numéro de broche depuis l'URL
pin = client.parseInt();
pin = client.parseInt();
// S'il y a une "/" après...
if (client.read() == '/') {
if (client.read() == '/') {
// cela signifie que l'on fixe la valeur de la broche
value = client.parseInt();
value = client.parseInt();
analogWrite(pin, value);
analogWrite(pin, value);
// Send feedback to client
// renvoyer une réponse au client
client.print(F("Pin D"));
client.print(F("Pin D"));
client.print(pin);
client.print(pin);
client.println(value);
client.println(value);
// Valeur de la clé pour le DataStore
String key = "D";
String key = "D";
key += pin;
key += pin;
// Stockage de la "Clé = Valeur" dans le DataStore
Bridge.put(key, String(value));
Bridge.put(key, String(value));
}
}
else {
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);
value = analogRead(pin);
// renvoyer une réponse au client
client.print(F("Pin A"));
client.print(F("Pin A"));
client.print(pin);
client.print(pin);
client.println(value);
client.println(value);
// Stockage de la "Clé = Valeur" dans le DataStore
String key = "A";
String key = "A";
key += pin;
key += pin;
}</nowiki>
}</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) {
<nowiki>void modeCommand(YunClient client) {
int pin;
int pin;
// Obtenir le numéro de broche depuis l'URL
pin = client.parseInt();</nowiki>
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() != '/') {
<nowiki> if (client.read() != '/') {
}</nowiki>
}</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> if (mode == "input") {
<nowiki> String mode = client.readStringUntil('\r');
if (mode == "input") {
// configurer la broche en entrée
pinMode(pin, INPUT);
pinMode(pin, INPUT);
// Send feedback to client
// Informer le client
client.print(F("Pin D"));
client.print(F("Pin D"));
client.print(pin);
client.print(pin);
if (mode == "output") {
if (mode == "output") {
// configurer la broche comme sortie
pinMode(pin, OUTPUT);
pinMode(pin, OUTPUT);
// Send feedback to client
// informer le client
client.print(F("Pin D"));
client.print(F("Pin D"));
client.print(pin);
client.print(pin);
}
}
// 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(F("error: invalid mode "));
client.print(mode);
client.print(mode);
}</nowiki>
}</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 ==
== Connecting to internet services with Temboo ==
{{ARDImage|Arduino-Yun-Temboo-20.png}} <small> traduction par MCHobby.be</small>
{{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 ==
Spacebrew is "a simple way to connect interactive things to one another." It relies on a client/server model and uses WebSockets to communicate between the two. It runs a custom webserver on the Yún in python that allows for easy communication.
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].
== Install additional software on Linux ==
== 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 ==