cedricAbonnel/abonnel-siteweb
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Initialisation

Browse Source
This commit is contained in:
Cédric Abonnel
2024-01-07 10:02:35 +01:00
commit b7291133a3
4418 changed files with 169147 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

177
data/pages/electronique/arduino/100-presentation-et-principe-de-l-arduino.txt Normal file
View File

@@ -0,0 +1,177 @@
====== Présentation et principe de l'Arduino ======
===== - Généralités =====
Un Arduino représente des cartes électroniques regroupant plusieurs composants électroniques afin de réaliser des objets électroniques interactifs. Il peut être vu comme un ordinateur.
On retrouve de la **mémoire** sous deux types :
* la mémoire morte, qui contiendra les instructions que l'Arduino devra exécuter
* la mémoire vive, contenant les informations qui changent : les variables
On aura également un **calculateur** qui traitera et exécutera les instructions.
Tous ces éléments sont contenu dans un micro contrôleur. Il est d'architecture soit **AVR** soit d'architecture **ARM** comme le Cortex m3.
Les cartes Arduino sont construits autour d'un microcontrôleur **Atmel AVR** pour les modèles :
* ATmega328,
* ATmega32u4,
* ATmega2560,
* ATmega168,
* ATmega1280
* ATmega8
D'autres cartes Arduino sont construits autour des microcontroleur **Cortex** d'architecture **ARM**. C'est la société **STMicroelectronics** qui se lance dans l'aventure en mai 2016 avec les modèles **STM32** ((https://www.st.com/content/st_com/ja/about/media-center/press-item.html/t3829.html))
Les schémas des cartes électroniques Arduino sont publiés en licence libre. Le microcontrôleur peut analyser et produire des signaux électriques de format analogique ou de format numérique. On utilisera les entrées sortie de la carte électronique.
Pour le programmer, il faut utiliser la prise USB qui permettra de le relier à l'ordinateur. Elle permet également d'alimenter l'Arduino. Plus tard, l'alimentation s’effectuera sur la broche **+Vin (7-12 V)** et **0V**.
Une fois programmé, l'Arduino sera relié par un prise secteur ou une batterie via le port d'alimentation.
Les broches sont des entrées/sorties qui permettent de relier des capteurs, des LED, des moteurs ou des cartes d'extension. Cela permet le contrôle des appareils domestiques - éclairage, chauffage…, le pilotage d'un robot, de l'informatique embarquée, etc.
Les cartes Arduino et les schémas de ces cartes sont publiés en licence libre.
===== - Principe général =====
Les différentes versions des Arduino fonctionnent sous le même principe général :
{{ electronique:arduino:mooc:programmer_avec_un_objet_arduino:brochagearduino.png?nolink |}}
Les broches de **1** à **13**, ce sont les broches dites numériques (**0** ou **1**) ou « tout ou rien » ; elles offrent en sortie du 5 V et acceptent en entrée du 5 V sur le même principe.
Dans le code, on utilise les fonctions ''digitalWrite()'' et ''digitalRead()''.
Les broches de **14** à **19**, ce sont les broches dites analogiques, valeur entre **0 V** et **5 V**.
Dans le code, on utilise les fonctions ''analogWrite()'' et ''analogRead()''
Enfin, on y trouve également les différentes broches d'alimentation :
* Rouge : sortie 5 V (+5V)
* Orange : sortie 3,3 V (+3V3)
* Bleue : les masses (0V)
* Saumon : entrée reliée à l'alimentation de **+Vin (7-12V)**
Il y a des variations entre les différentes cartes (par exemple : UNO, la patte 13 est équipée d'une résistance).
Les tensions admises des entrées/sorties sont strictement comprise entre **0 V** et **5 V**. Pas de tension négative !
Il existe plein de variantes de cartes Arduino :
* Arduino Nano
* Arduino NanoPro
* Arduino NanoPro mini
* Arduino NanoMega
* Arduino NanoDiecimila
* Arduino NanoDuemilanove
* Arduino NanoLeonardo
* Arduino NanoDue
* Arduino NanoFio
===== - Présentation de l'Arduino Uno =====
L'**Arduino Uno** est basé sur un microcontrôleur ATMEL 1502 de 32 registres, cadencé à 166 MHz (un cycle de 6ns).
{{ electronique:arduino:arduino_explications.png?nolink |}}
//Crédit image : Mines Telecom - Programmer un objet avec Arduino, cours 04017 //
L'**Arduino Uno** propose :
* 14 entrées numériques
* 6 entrées analogiques
* 1 sortie 5 V à 500 mA
* 1 sortie 3,3 V à 50 mA
* 1 ports série Rx/Tx avec Led indépendantes
* 1 port USB, qui sert également d'alimentation et de connexion série
* 1 alimentation complémentaire (Vin 7 à 12 V)
On notera la présence d'une LED connectée sur la broche 13.
Les broches **Rx** et **Tx** de l'Arduino permettent d'effectuer une communication série. On veillera à ne pas utiliser ces broches pour brancher des LED ou d'autres composants.
{{ :electronique:arduino:pasted:20220128-105101.png |Schéma Arduino UNO Pinout by bq.com}}
===== - Utiliser une plaque de prototypage =====
Pour tester ses branchements directement sur l'Arduino sans soudure, il faut utiliser une platine d'essai (ou breadboard, plaque d’essai, plaque de montage rapide).
La platine d'essai est composée d'une multitude de trous. La plupart d'entre eux sont reliés. Voici une représentation :
{{ electronique:arduino:mooc:programmer_avec_un_objet_arduino:breadboard.jpg?nolink |}}
En position portrait (comme sur la photo), la plaque est divisée à la verticale en 2 parties égales. Les 5 trous d'une ligne, d'une partie sont interconnectés. C'est-à-dire qu'il y a une liaison électrique pour les trous **a, b, c, d, et e** de la ligne 1, indépendante des lignes voisines et de l'autre partie de la plaque.
Sur notre plaque d'essai, nous avons 30 x 2 lignes de connexion. L'espace entre les deux parties et standardisé afin de positionner la plupart des circuits intégrés et de pouvoir leurs câbler toutes les broches.
Enfin, tous les trous de la colonne ''+'' d'une partie de la plaque sont interconnectés entre eux. Ceci représente une ligne d'alimentation et il faudra l'utiliser tel quel. Il en va de même pour la colonne ''-'' et l'autre partie de la plaque.
Sur la partie gauche de la photo:
* (trait rouge) à gauche, tous les trous de la colonne **+** sont reliés entre eux
* (trait bleu) tous les trous de la colonne **-**, sont reliés entre eux
* (trait jaune) tous les trous de la ligne 1 sont reliés entre eux, sur 5 colonnes (a, b, c, d et e). On peut reproduire ce schéma sur les 29 autres lignes.
* la partie de droite, reproduit le même schéma par effet mirroir, avec un axe de symétrie vertical coupant la plaque en deux moitié égale.
Par convention, je branche l'alimentation 5 V sur la colonne **+** et la masse (0 V) sur la colonne **-**.
===== - Logiciel de programmation d'un Arduino =====
Pour programmer un **Arduino** ou une carte programmable, il faut un éditeur qui fonctionne sur un ordinateur et un programme qui permettra de téléverser le code vers la carte.
Le programme libre de droit **Arduino Software (IDE)** permet d'écrire du code et de le téléverser dans la carte. C'est l'outil privilégié si vous avez acheté du matériel. Il fonctionne sous Windows, Mac OS X, et Linux. Le [[105-installation-du-logiciel-arduino-ide|guide d'installation du logiciel IDE Arduino sous Linux]] permet de mieux appréhender une installation de la dernière version en date.
Il existe également un simulateur appelé **Tinkercad circuits** qui permet de tester votre code et les montages électroniques virtuellement.
===== - Principe de programmation Arduino =====
Le langage Arduino est basé sur les langages C et C++. Les programmes Arduino sont intégrés dans un schéma (scketch) **setup** / **loop**. Il s'agit de deux blocs de fonctions obligatoirement présents dans tous programmes Arduino.
Un bloc commence par le symbole ''{'' et se termine par le symbole ''}''. Le nom d'une fonction est toujours suivie par les symboles ''()''.
La fonction **setup()** est appelée systématiquement au démarrage de l'Arduino, une seule fois, après un **reset** ou **une mise sous tension**. Il est utilisé pour initialiser des variables, démarrer des librairies, modifier le paramétrage des broches, etc...
Après avoir utilisé la fonction **setup()**, la fonction **loop()** exécute de manière infinie le code à l’intérieur de ce bloc afin de répondre aux interactions demandées.
Afin de rendre plus intelligible le code écrit, il est possible d'écrire du texte qui ne sera pas interpréter comme du code. Une ligne de commentaire commencera par les symboles ''<nowiki>//</nowiki>'' alors qu'un bloc de commentaires sera encadré par les symboles ''/*'' et ''*/''.
Par exemple :
<code C>
void setup() {
// Ceci est une ligne de commentaire
}
void loop() {
/*
Voici un bloc
de commentaire
sur plusieurs lignes
*/
}
</code>
On peut utiliser d'autres fonctions qui permettent d’exécuter une ou plusieurs actions. Les fonctions sont définies avec :
* un nom représentant l'utilité du bloc.
* une ou plusieurs entrées. Il s'agit de paramètres ou arguments placés entre parenthèses.
* une sortie qui est le résultat de la fonction.
Par exemple, prenons le code suivant ''pinMode(buttonPin, INPUT)''. Dans ce cas, la fonction est **pinMode** qui contient deux variables : **buttonPin** et **INPUT**.
<code C>
int buttonPin = 3;
void setup() {
Serial.begin(9600);
pinMode(buttonPin, INPUT);
}
void loop() {
// ...
}
</code>
===== - Référentiel des fonctions, variables et structures du Langage Arduino =====
> https://www.arduino.cc/reference/en/

173
data/pages/electronique/arduino/105-installation-du-logiciel-arduino-ide.txt Normal file
View File

@@ -0,0 +1,173 @@
====== Installer le logiciel Arduino IDE sous Linux ======
<WRAP center round tip 100%>
Cet article a été testé avec les distributions suivantes
* **Linux Mint 19 64 bits**
* **Linux Debian 9.6 (stretch) 64 bits**
* **MX Linux 18.3** basé sur Linux Debian 9
* **Zorin OS 16.1** basé sur Linux Debian
Je privilégie une installation "manuelle" de l'application **Arduino IDE** afin d'utiliser une des dernières versions. Certaines options et paramètres n'apparaissent pas dans les versions packagées des distributions. J'ai eu le cas avec **Debian 9.6** où je ne pouvais pas utiliser des cartes ESP 8266.
Date de relecture : 15 août 2022
</WRAP>
Il faut télécharger la version 1.8.19. Vous pouvez vérifier la dernière version disponible depuis le site [[https://www.arduino.cc/en/Main/Software]]. Adaptez les informations ci-dessous suivant les informations trouvées sur le site arduino.cc.
{{ electronique:arduino:arduino_software_1.8.7.png?400 |}}
===== - Télécharger Arduino IDE Software =====
Depuis mon dossier **home** ou un autre dossier personnel, je télécharge le programme **Arduino IDE**. Je préfère l'effectuer depuis une ligne de commande.
<code>
wget -O arduino.tar.xz https://downloads.arduino.cc/arduino-1.8.19-linux64.tar.xz
</code>
{{ electronique:arduino:terminal_install_arduino.png?400 |Téléchargement de l'application **Arduino IDE** dans une fenêtre de Terminal}}
===== - Déployer Arduino IDE Software =====
**ligne 1** : déployer Arduino IDE dans un dossier accessible à tous : ''/opt/''. L'archive **tar** va extraire les fichiers dans un dossier comportant le numéro de version.
**ligne 3** : si un lien ''/opt/arduino/'' existait, détruit le lien sur ''/opt/arduino'' avec **unlink**
**ligne 4** : réaliser un [[informatique:linux:commandes:alias|alias]] vers le dossier ''/opt/arduino''. De cette manière, on s'affranchit du numéro de version. Nous pouvons également déployer de nouvelles versions sans perturber la précédente.
**ligne 5** : exécuter le script ''install.sh'' qui permet de créer un raccourci sur le bureau graphique.
<code BASH [enable_line_numbers="true", start_line_numbers_at="1"]>
sudo tar -xvf arduino.tar.xz -C /opt
sudo chown -R root:root /opt/arduino-1.8.19
sudo unlink /opt/arduino
sudo ln -s /opt/arduino-1.8.19/ /opt/arduino
sudo /opt/arduino/install.sh
</code>
===== - Problèmes rencontrés après le déploiement =====
==== - Droits sur tty et dialout ====
Il faut ajouter l'utilisateur de l'application **Arduino IDE** aux groupes ''tty'' et ''dialout''. L'exemple suivant permet d'ajouter l'utilisateur ''cedric'' aux groupes ''tty'' et ''dialout''.
<code>
sudo usermod -a -G tty $USER
sudo usermod -a -G dialout $USER
</code>
Si vous venez de saisir les lignes de commandes ''usermod'', vous devez redémarrer.
==== - Version de Java incorrecte ====
Le message suivant peut apparaître dans l'application **Arduino IDE** :
<code>
java.lang.NullPointerException thrown while loading gnu.io.RXTXCommDriver
</code>
Il se peut que la version de Java ne soit pas bonne. Vous pouvez le vérifier avec ''java -version''. Toutefois, un java est intégré avec l'application **Arduino IDE**. (''/opt/arduino/java/bin/java -version'' me renvoie la version ''java version "1.8.0_191"'').
Il faudra peut être toutefois changer les paramètres java de l'OS.
J'ai testé avec OpenJDK Java 8 avec succès. Par contre Java 10 et 11 ne sont pas compatibles.
Pour procéder à l'installation de Java 8 et choisir par défaut cette version :
<code>
sudo apt-get update
sudo apt-get install openjdk-8-jdk
sudo update-alternatives --config java
</code>
{{ electronique:arduino:terminal_alternatives_config_java.png?noLink |}}
==== - Serial port not selected ====
Dans certains cas, sous Mint, il faut désinstaller ''brltty''
<code>
sudo apt-get remove brltty
</code>
==== - Aucune carte n'est détectée ====
{{ :electronique:arduino:pasted:20220128-074733.png?250}}
Le câble USB peut être également non cablé pour les données (data)
<WRAP clear/>
Pour rappel, voici le cablage d'un port USB
{{ :electronique:arduino:pasted:20220128-075003.png }}
===== - Exécuter votre premier programme =====
Voici donc notre premier programme (celui qui est décrit dans la vidéo).
Cette suite d'instructions va faire clignoter une LED branchée sur la broche 13 de l'Arduino toutes les secondes.\\
Il n'est pas nécessaire de brancher une LED, car rappelez-vous, la LED sur la carte, mentionnée dans la [[informatique:linux:materiel:arduino:presentation_de_l_arduino]], servira dans notre exemple sans forcément réalisée un montage électronique.
Lorsque vous utilisez le logiciel Arduino, il peut être trouvé en cliquant sur ''Fichier => Exemples => 01.Basics => Blink''.
<WRAP clear/>
Vous pouvez également copier le code suivant dans votre éditeur :
<code C basics-blink.c [enable_line_numbers="true", start_line_numbers_at="1"]>
/*
Clignotement
Allume la LED pendant 1 seconde,
puis l'éteint pendant 0,5 seconde.
*/
// Numéro de la broche à laquelle est
// connectée la LED
int led = 13;
// le code dans cette fonction est exécuté une fois au début
void setup() {
// indique que la broche de la LED une sortie :
// on va modifier sa tension
pinMode(led, OUTPUT);
}
// le code dans cette fonction est exécuté en boucle
void loop() {
digitalWrite(led, HIGH); // allumer la LED (tension 5V sur la broche)
delay(1000); // attendre 1000ms = 1s
digitalWrite(led, LOW); // éteindre la LED (tension 0V sur la broche)
delay(1000); // attendre à nouveau 1seconde
}
</code>
Deux déclaration de fonctions sont obligatoires :
* setup
* loop
Dans ce bout de code, nous appelons trois fonctions :
* digitalWrite
* pinMode
* delay
Pour exécuter ce bout de code, il faudra brancher l'Arduino sur port USB et sélectionner dans le menu ''Outils => Port'', sélectionner ''/dev/ttyACMO''.

145
data/pages/electronique/arduino/couper-la-veille.txt Normal file
View File

@@ -0,0 +1,145 @@
====== Couper la veille avec un Arduino ======
{{ :electronique:arduino:arduino_et_le_capteur:capteur-de-courant-ac-detachable-100a-.jpg?400|}}
Arrêter l'alimentation d'un appareil lorsque celui-ci passe en veille, est-ce possible sans intervention humaine ? L'idée est d'interrompre l'alimentation de l'appareil, de manière automatique, lorsque celui-ce a terminée ça tâche principale. Cet appareil ne pourra par redémarrer sans intervention humaine. On pourra intervenir en appuyant sur un bouton.
On peut appliquer cette idée à :
* un chargeur de téléphone
* un appareil hi-fi
* une télévision
* un chargeur de batterie
* ordinateur
* cafetière
Ci-dessous, je vous propose un épisode audio d’introduction en vous exposant l'idée principale. J'explique lors d'un enregistrement Youtube, l'idée du projet. Cette vidéo Youtube n'existe plus. J'ai gardé une trace audio dans l'épisode mindCast, dont je vous propose le lien ci-desous.
mindCast est un podcast personnel, dont l'un des thèmes est la technologie en générale.
<WRAP center round todo 60%>
[[https://www.abonnel.fr/podcast/?name=2018-10-08_info_09_arduino_capteur_courant.mp3|écouter l'épisode - Arduino et capteur de courant]]
Cet épisode est extrait du podcast [[https://www.abonnel.fr/podcast|mindCast INFO]]
</WRAP>
J'ai eu quelques retours suite à cette vidéo et j'ai pu échanger sur des aspects très intéressant.
Lors des différents échanges, on m'a proposé les idées suivantes :
* L'USB-C permet un échange de données entre chargeur et appareil
* Prise domotisée OSRAM+ avec appli IFTTT sur tel. Par exemple : Si batterie = 100% then coupe la prise.
Je ne les ai pas retenues.
<WRAP clear/>
{{ informatique:couper_la_veille:ansmann_aes3.jpg?150|AES 3}}
Par contre, Nico a trouvé un produit correspondant aux attentes. Il s'agit de [[https://amzn.to/2OdOjYz|ANSMANN AES 3 sur Amazon]]
Ce produit est répond en tout point au besoin initial. Toutefois, on continue le projet, car derrière on va mettre en œuvre des technos qui nous permettront d'enchainer sur d'autres produits. Mais bravo Nico !
N'hésitez pas également à me soumettre vos idées dans les commentaires de cette page.
<WRAP clear/>
===== Principe technique =====
On part à la réalisation d'un montages électroniques avec Arduino, ESP8266, capteurs et actionneurs. Pas besoin de logiciel de PAO, ni de graveur de circuits électroniques, mais un minimum vital comme tout bidouilleur qui se respecte. Il sera nécessaire d'avoir quelques composants (résistance, condensateur, transistor, AOP, circuit logique...), une plaque d'essai, des plaques à souder, un fer à souder, de l'étain.
On va essayer de structurer l'idée principal en algo simplifié.
<code>
// on déclare les constantes
COURANT_VAL_MINI = 30mA
COURANT_SEUIL_DECLENCHEMENT = 30%
// on initialise les variables
courant_instantané = mesurerCourant()
courant_instantané_précédent = courant_instantané
:debut
courant_instantané = mesurerCourant()
si courant_instantané > courant_instantané_précédent
alors courant_instantané_précédent = courant_instantané
sinon si (courant_instantané / courant_instantané_précédent < COURANT_SEUIL_DECLENCHEMENT
et courant_instantané > COURANT_VAL_MINI)
alors couperAlimentation()
sinon
alors courant_instantané_précédent = courant_instantané
aller à :debut
</code>
Nous allons décortiquer cet algorithme. Nous identifions les différents éléments suivants :
On utilise deux variables car au cours de l'algorithme, les valeurs associées aux variables n'ont pas toujours la même valeur :
* courant_instantané
* courant_instantané_précédent
On utilise deux constantes afin d’identifier rapidement des valeurs statiques :
* COURANT_VAL_MINI
* COURANT_SEUIL_DECLENCHEMENT
On utilise deux fonctions afin de réaliser des actions complexes, décentralisé de l'algorithme principal :
* mesurerCourant()
* couperAlimentation()
Les fonctions utilisées font appel a des capteurs et actionneurs. Il s'agit respectivement d'un capteur de courant et d'un relai.
Le capteur de courant permettra d'identifier la présence d'un courant de veille et la présence d'un courant de fonctionnement nominal.
L'actionneur relai permettra de couper l'alimentation.
L'idée globale est la suivante : Nous voulons effectuer un relevé de la consommation électrique, si la valeur chute, alors il faudra couper l'alimentation.
===== Capteur SCT013 =====
Concernant le capteur, j'ai retenu le SCT 013.
<WRAP group>
<WRAP half column>
Mise en oeuvre du capteur SCT013
* [[https://scidle.com/how-to-use-non-invasive-ac-current-sensors-with-arduino/|How to use Non-invasive AC Current Sensors with Arduino]] sur le site **Scidle**
Lors de mes recherches sur Internet je suis tombé sur une solution industrialisée avec ce capteur. Il est possible de brancher plusieurs capteurs à un boitier (appelé emonTX). Celui-ci communique avec une centrale (appelé emonPI). Ces données sont envoyées dans le cloud pour un accès graphique des données (appelé emonCMS) depuis un ordinateur ou un smartphone. Je n'ai pas vu d'actionneur dans cette solution.
* [[https://learn.openenergymonitor.org/electricity-monitoring/ct-sensors/interface-with-arduino |Interface with Arduino]] sur le site **OpenEnergyMonitor**
</WRAP>
<WRAP half column>
{{ electronique:arduino:arduino_et_le_capteur:sct013.jpg?200 |SCT 013 en oeuvre}}
</WRAP>
</WRAP>
<WRAP clear/>
===== Masse flottante =====
Dans l'épisode audio mindCast, j'introduis la notion de masse flottante ou de masse virtuelle.
<WRAP group>
<WRAP half column>
{{ informatique:couper_la_veille:electronique_masse_virtuelle_001.gif?300 |}}
</WRAP>
<WRAP half column>
La masse virtuelle permet d'obtenir deux tensions symétriques, une positive et l'autre négative par rapport à la masse, en partant d'une alimentation simple (mono-tension).
On utilisera des résistances montées en diviseur de tension. Leur valeur doit être identique, et devra être adaptée selon la consommation globale du circuit à alimenter (10Kohms pour 1mA, jusqu'à 100Kohms pour 100uA par exemple). L'unique condensateur C1 sert à "absorber" les variations de courant tant qu'elles ne sont pas trop importantes, et permet d'assurer une certaine stabilité à la tension présente au point 0V' (J4).
[...]
</WRAP>
</WRAP>
A suivre sur https://sonelec-musique.com/electronique_realisations_masses_virtuelles.html
<WRAP clear/>
<WRAP clear/>
----
Merci à Étienne (Youtube), Dominique (real), Gregory (Twitter) et Nico (Twitter).

109
data/pages/electronique/arduino/dht11_nano_mega328_lcd_i2c.txt Normal file
View File

@@ -0,0 +1,109 @@
====== Sonde température et humidité sur Arduino ======
{{ electronique:arduino:dht11_arduinouno_lcd.jpg?nolink&800 |}}
===== Materiel utilisé =====
<WRAP group>
<WRAP third column>
* Arduino Nano
</WRAP>
<WRAP third column>
* sonde de température et d'humidité DHT11
</WRAP>
<WRAP third column>
* écran graphique LCD 2x16 avec bus I2C
</WRAP>
</WRAP>
===== Code =====
Le code suivant permet d'afficher les informations relevées sur la sonde DHT11.
Pour cela j'utilise les méthodes ''dht.readHumidity()'' et ''dht.readTemperature()'' de la bibliothèque ''DHT''.
La fonction ''isnan'' (is Not A Number) permet de faire connaitre une défaillance en cas d'une lecture non numérique des valeurs.
<code c>
#include <Adafruit_Sensor.h>
#include <DHT.h>
#include <LiquidCrystal_I2C.h>
#include <Wire.h>
#define DHTPIN 7
#define DHTTYPE DHT11
DHT dht(DHTPIN, DHTTYPE);
LiquidCrystal_I2C lcd(0x27,16,2); // affecter l'adresse à 0x27 pour 16 caractères et 2 lignes d'affichage
int tim = 1000; //valeur d'attente
void setup()
{
lcd.init(); //initialiser le LCD
lcd.backlight(); //allumer le LCD
lcd.setCursor(0,0);
lcd.print("dht11_test");
lcd.setCursor(0,1);
lcd.print("version 20161203");
delay(5 * tim); //attendre
lcd.clear();
Serial.begin(9600);
dht.begin();
}
void loop()
{
float h = dht.readHumidity(); // lire la valeur de l'humidité
float t = dht.readTemperature(); :: lire la valeur de la température
if (isnan(t) || isnan(h)) { // vérifier le présence d'une valeur numérique
lcd.setCursor(0,0);
lcd.println("Failed to read ");
lcd.setCursor(0,1);
lcd.println("from DHT11 ");
} else {
lcd.setCursor(0,0);
lcd.print("Temp. ");
lcd.print(t);
lcd.print(" *C");
lcd.setCursor(0,1);
lcd.print("Humidi. ");
lcd.print(h);
lcd.print(" %");
}
delay(tim);
}
//
// END OF FILE
//
</code>
===== Bibliographie =====
Capteur de pression
* http://www.diopter.fr/index.php/technique/electro-numerique/43-capteur-de-pression-et-arduino
Autre réalisation avec la sonde DHT11
* https://www.carnetdumaker.net/articles/utiliser-un-capteur-de-temperature-et-dhumidite-dht11-dht22-avec-une-carte-arduino-genuino/
Sonde de température DS18B20
* https://www.carnetdumaker.net/articles/mesurer-une-temperature-avec-un-capteur-1-wire-ds18b20-et-une-carte-arduino-genuino/
Comparatif des sondes DHT 11 et 22
* https://learn.adafruit.com/dht/overview
Kit SunFounder
* https://www.sunfounder.com/learn/Sensor-Kit-v2-0-for-Arduino/lesson-11-humiture-detection-sensor-kit-v2-0-for-arduino.html
Amazon
* sonde DHT 22 - https://www.amazon.fr/gp/product/B00AZG1RBK/ref=ox_sc_act_title_2?ie=UTF8&psc=1&smid=A3I826466U8R8A

80
data/pages/electronique/arduino/display-by-i2c-lcd1602.txt Normal file
View File

@@ -0,0 +1,80 @@
====== Afficher sur écran LCD 1602 par interface I2C ======
===== Code include =====
La bibliothèque ''LiquidCrystal_I2C'' doit être connu de l'IDE.
{{electronique:arduino:idearduino_croquis_includelibrary.png?nolink|}}
===== Cablage =====
{{electronique:arduino:schema_display-by-i2c-lcd1602.png?nolink|}}
===== Code =====
<code C>
/********************************
* nom:I2C LCD1602
* fonction:Afficher sur I2C LCD1602 les caracteres suivants: "Hey ! toi" et "hello, world".
********************************/
/********************************/
// Librairie à inclure
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
/**********************************************************/
char array1[]="Hey ! LuiqidCrystal I2C"; //une chaine a afficher sur le LCD
char array2[]="hello, world! "; //une chaine a afficher sur le LCD
int tim = 250; //valeur d'attente
int lcd_tailleLigne = 16; // nbre Caractères par ligne
// initialiser la librairie
LiquidCrystal_I2C lcd(0x27,16,2); // affecter l'adresse à 0x27 pour 16 caractères et 2 lignes d'affichage
/*********************************************************/
void setup()
{
lcd.init(); //initialiser le LCD
lcd.backlight(); //allumer le LCD
lcd.setCursor(0,0);
lcd.print("123456789012345678901234567890");
lcd.setCursor(0,1);
lcd.print("abonnel.fr");
delay(10 * tim); //attendre
lcd.clear();
}
/*********************************************************/
void loop()
{
lcd.setCursor(lcd_tailleLigne,0); // mettre le curseur en bout de ligne, à droite
for (int positionCounter1 = 0; positionCounter1 < lcd_tailleLigne - 1 + sizeof(array1) - 1; positionCounter1++)
{
lcd.scrollDisplayLeft(); //déplacer l'affichage
// afficher le message ou un " "
if (positionCounter1 >= sizeof(array1)-1) {
lcd.print(" ");
} else {
lcd.print(array1[positionCounter1]); // Afficher le caractere suivant
}
delay(tim); //attendre
}
// Afficher la seconde ligne
lcd.clear(); //effacer l'affichage et repositionner le curseur à 0, 0
lcd.setCursor(lcd_tailleLigne,1); // mettre le curseur en bout de ligne, à droite
for (int positionCounter = 0; positionCounter < lcd_tailleLigne - 1 + sizeof(array2) - 1; positionCounter++)
{
lcd.scrollDisplayLeft(); //déplacer l'affichage
// afficher le message ou un " "
if (positionCounter >= sizeof(array2)-1) {
lcd.print(" ");
} else {
lcd.print(array2[positionCounter]); // Afficher le caractere suivant
}
delay(tim); //attendre
}
lcd.clear(); //effacer l'affichage et repositionner le curseur à 0, 0
}
/************************************************************/
</code>

19
data/pages/electronique/arduino/index.txt Normal file
View File

@@ -0,0 +1,19 @@
====== Arduino ======
{{ :electronique:arduino:arduino.png?nolink&75x75|Arduino}}
<WRAP clear/>
Un Arduino représente des cartes électroniques regroupant plusieurs composants électroniques afin de réaliser des objets électroniques interactifs. Il peut être vu comme un ordinateur.
===== Table des matières =====
* [[.:|Introduction]]
**Pré requis**
* [[electronique:arduino:100-presentation-et-principe-de-l-arduino]]
* [[electronique:arduino:105-installation-du-logiciel-arduino-ide]]
**Exemples de câblage et programmes Arduino**
* [[.:arduino-serial-bridge]]

75
data/pages/electronique/arduino/minuterie-pour-lampe-de-chevet.txt Normal file
View File

@@ -0,0 +1,75 @@
====== Minuterie pour lampe de chevet ======
J'ai créé cette minuterie pour ceux qui lisent au lit et qui s'endorment avec la lumière allumée ou les enfant qui ont peur du noir et réclame qu'on leur laisse un peu de lumière, autre qu'une veilleuse. Cette minuterie obéit au même principe que du "dispositif de l'homme mort".
Son fonctionnement est très simple : par un appui sur le bouton, la minuterie est activée et la lampe s'allume. Après la durée pour laquelle elle a été réglée, la lampe s'éteint d'elle-même. Un appui prolongé permet, à tout moment, d'éteindre la lampe, ce qui évite, si l'on s'endort sur le bouton, que la lumière reste allumée toute la nuit.\\
Cette minuterie permet, en plus de ne pas dormir avec la lumière allumée, ce qui de l'avis de certains n'est pas très bon pour la qualité du sommeil, de réaliser des économies d'énergie. D'une conception minimale et ingénieuse, elle s'appuie sur un micro contrôleur **Arduino**. Tout a été mis en œuvre pour en réduire le coût de fabrication : composants peu nombreux et faciles à trouver ou à recycler. Voilà.
====== Schéma ======
A venir
====== Code ======
<code C button-action.ino>
//Controlling Led By Button
//Turns on and off a LED ,when pressings button attach to pin12
//Website:www.abonnel.fr
//2016.11.27.17.41
/**********************************/
const int keyPin = 13; //the number of the key pin
const int ledPin = 12;//the number of the led pin
int etatRelay = LOW;
const int tempsAllumage = 6; //secondes
int tempsAllumage_cours = 0; //temps en cours
/**********************************/
void setup()
{
pinMode(keyPin,INPUT);//initialize the key pin as input
pinMode(ledPin,OUTPUT);//initialize the led pin as output.
Serial.begin(9600); // initialize serial communications at 9600 bps
}
/**********************************/
void loop() {
int etatButton = digitalRead(keyPin);
if(etatButton == HIGH ) {
// Action quand on appuie sur le bouton
etatRelay = !etatRelay; //actionner le relais
digitalWrite(ledPin,etatRelay); //actionner la LED
delay(1000); // attendre 1 sec
tempsAllumage_cours = 0; // reintialiser le compteur
}
if (etatRelay == HIGH) {
// Action si le relais est collé
if (tempsAllumage - tempsAllumage_cours <= 0) {
// Si le temps est écoulé
etatRelay = LOW; // Eteindre le relais
digitalWrite(ledPin,etatRelay);//Eteindre la LED
delay(1000); // Attendre 1 sec
} else {
// Si le temps n'est pas écoulé
tempsAllumage_cours++;
delay(1000); // attendre 1 sec
}
}
// Afficher les status sur le port Serie
// Serial.print(etatRelay);
// Serial.print(" ");
// Serial.println(tempsAllumage - tempsAllumage_cours);
}
/************************************/
</code>
====== Liens ======
Je me suis honteusement inspiré de l'introduction de l'article de [[http://www.berlioux.com/electronique/minuterie-hm/minuterie-hm-fr.html|Berlioux]] pour rédiger mon introduction. Pour ma défense, je dirai que j'ai fait du recyclage et l'optimisation.

8
data/pages/electronique/arduino/recepteur_bluetooth_amplificateur_audio_50w_swhf01_tda7492p.txt Normal file
View File

@@ -0,0 +1,8 @@
====== Recepteur Bluetooth audio 25 W + 25 W ======
* Alimentation : 8-25 V DC par connecteur basse tension, Ø extérieur: 5.5 mm et Ø intérieur: 2.1 mm
* Alimentation durant les tests et mesures (TDA7492P) = 20 V
* Impédance de charge = 4, 6 et 8 ohms
* Documentation de la puce de contrôle : {{electronique:arduino:tda7492p.pdf|ST TDA7492P}}

2
data/pages/electronique/arduino/sidebar.txt Normal file
View File

@@ -0,0 +1,2 @@
{{page>index#table-des-matieres}}
~~NOCACHE~~

240
data/pages/electronique/arduino/utiliser_le_wifi_du_nodemcu.txt Normal file
View File

@@ -0,0 +1,240 @@
====== Utiliser le Wifi du NodeMCU ======
On va commencer par le début. Récupérer le programme exemple en allant //Fichier//=>//Exemples//=>//ESP8266WiFi//=>//WiFiScan//
<code>
Dans la fonction de configuration setup, on met le module WiFi en mode Station (on aurait pu le mettre aussi en point d'accès). Ne cherchez pas la méthode mode dans la doc Arduino, il s'agit d'une commande spécifique au module ESP (voir ici). La méthode disconnect permet ensuite de déconnecter le module ESP d'un point d'accès, au cas où !
Dans la fonction boucle (loop) on retrouve les instructions qui permettent d'afficher périodiquement les WiFi captés par le module ESP. La méthode scanNetwork permet , comme son nom l'indique, de scanner les différents canaux (fréquences) dédiés au WiFi et retourner le nombre de réseaux trouvés :
int n = WiFi.scanNetworks();
Ainsi, si ce nombre n'est pas nul, ils vont être affichés un par un grâce à une boucle for.
for (int i = 0; i < n; ++i) {
// Print SSID and RSSI for each network found
Serial.print(i + 1);
Serial.print(": ");
Serial.print(WiFi.SSID(i));
Serial.print(" (");
Serial.print(WiFi.RSSI(i));
Serial.print(")");
Serial.println((WiFi.encryptionType(i) == ENC_TYPE_NONE)?" ":"*");
delay(10);
}
La méthode SSID permet d'afficher le nom du réseau WiFi. Dans le vocabulaire Wi-Fi, SSID veut dire Service Set IDentifier, mais bon c'est pas plus limpide ! La méthode RSSI (Received Signal Strength Indication) affiche la puissance du signal reçu. Les box et plus généralement les points d'accès WiFi émettent 10 fois par seconde un message donnant le nom du réseaux Wi-Fi. La méthode scanNetwork écoute toutes les fréquences et récupère tous ces noms.
</code>
Une fois connecté au réseau WiFi, nous ne pouvons pas encore communiquer avec d'autres équipements car nous n'avons pas d'adresse IP.
<code>
Pour obtenir une adresse, nous nous appuyons sur le programme WiFiClient_simple.ino comme son nom l'indique est simple et utilise le WiFi. On retrouve la connexion au réseau WiFi avec la méthode begin :
WiFi.begin(ssid, password); // On se connecte
while (WiFi.status() != WL_CONNECTED) { // On attend
delay(500);
Serial.print(".");
}
La boucle while permet d'attendre que la connexion soit effective et que le serveur DHCP de la box ait fourni les paramètres nécessaires pour se connecter au réseau Internet, qui sont affichés avec le code suivant :
Serial.println(""); // on affiche les paramètres
Serial.println("WiFi connecté");
Serial.print("Adresse IP du module EPC: ");
Serial.println(WiFi.localIP());
Serial.print("Adresse IP de la box : ");
Serial.println(WiFi.gatewayIP());
La gateway correspond à machine vers laquelle notre module ESP va envoyer les informations, c'est-à-dire à l'adresse IP de la box.
</code>
<code>
Le modèle client/serveur
Le web est la huitième merveille du monde, au point qu'on le confond souvent avec l'Internet. Il ne s'agit pourtant que d'un des services possible sur le réseau. Ce qui est remarquable avec le web c'est sa scalabilité. C'est à dire la possibilité de répondre à un nombre très important de requêtes sans perdre en performances. Cela est dû à un ensemble de règles pour la conception des services.
Le Web fonctionne sur le mode client/serveur. Le client veut une information et le serveur obéit en la retournant. Si le serveur devait se rappeler de tout ce qu'il a fait, il serait vite débordé. Alors la première règle fondamentale est que seul le client va garder une mémoire (un état) de ce qui se passe. Le serveur va envoyer ce qu'on lui a demandé et va passer à la demande suivante et ainsi de suite. Comme il y a beaucoup plus de clients que de serveurs, c'est plus facile à gérer. Par exemple, quand une page web est demandée à un serveur, elle va contenir d'autres références. Le client reçoit cette information, va la traiter, l'afficher et demander aux serveurs les éléments qui lui manquent. Ces informations peuvent être sur le même serveur ou sur un autre, ce n'est pas important car les serveurs ne se rappellent de rien après avoir traité la requête. On peut ainsi concevoir un service qui repose sur plusieurs serveurs et ainsi répartir le trafic et le traitement.
Les méta-données
Les éléments traités par un serveur sont appelés ressources. La définition de ressource est très vague. Il s'agit d'une information binaire de taille finie. Cela peut correspondre à du texte, à une image, une vidéo, des données,... En plus des données, on peut mettre des méta-données. C'est à dire des choses qui sont au-dessus des données, comme la méta-physique est au-dessus de la physique ou le métabolisme est au-dessus du bolisme ;).
Les méta-données vont permettre de mieux comprendre les données. Cela peut correspondre à leur date de production, à leur taille ou leur type. Cette dernière information est importante car elle permettra au client de bien les traiter. Dans la réponse d'un serveur, les méta-données (ou l'en-tête) sont séparées des données par une ligne vide, comme l'a montré la réponse qui a été affichée par l'Arduino pour le compteur.
HTTP/1.0 200 OK
Date: Thu, 28 Apr 2016 17:51:07 GMT
Server: WSGIServer/0.1 Python/2.7.9
X-Frame-Options: SAMEORIGIN
Content-Type: text/plain
147
Dans cet exemple, la première ligne donne le statut de la requête, HTTP/1.0 donne la version du protocole. Le second champ, ici 200 va donner le code indiquant le succès ou l'échec du traitement de la requête par le serveur. On a de la chance, 200 signifie que c'est bon. Le premier chiffre donne la nature de la notification :
1XX : indication d'un traitement en cours
2XX : succès
3XX : redirection, il faut interroger un autre serveur pour avoir la réponse
4XX : erreur du coté du client
5XX : erreur du coté du serveur
Ainsi la célèbre erreur 404 indiquant que la page n'est pas trouvée est bien une erreur du client qui pose des questions stupides au serveur. La ligne suivante donne la date, à laquelle la page a été produite par le serveur. La ligne suivante, un peu plus énigmatique, elle indique que notre super page web ne peut pas être incluse dans la page web d'un autre serveur.
La dernière ligne de l'en-tête donne la nature de l'information, ici c'est du texte non formaté.
Ensuite on a une ligne vide suivie de ce qui sera affiché, à savoir la valeur du compteur.
Les URI
Un autre facteur clé pour le succès du Web, en plus de l'utilisation de serveurs simples, est l'utilisation d'une désignation uniforme des ressources. Initialement appelées URL (Uniform Resource Locator), on emploie maintenant plus le terme URI (Uniform Resource Identifier) plus générique et qui peut couvrir d'autres technologies (comme la téléphonie sur Internet). Mais de manière simple, une URI se structure de la manière suivante quand on l'utilise pour le Web ou l'Internet des objets :
schéma://serveur:port/chemin/jusqu/a/la/ressource
Contrairement à l'idée admise, la première information, schéma, ne correspond pas au protocole employé sur le réseau, mais indique comment le reste de l'URI va être structuré. Pour le Web, on retrouve principalement les schémas pour http (ou https pour sa version sécurisée). Il est suivi par le nom d'un serveur (ou son adresse IP), un numéro de port peut être indiqué. Si ce n'est pas le cas, on utilisera le port 80 qui désigne le protocole HTTP. Ensuite on retrouve un chemin interne au serveur qui permet de localiser la ressource.
Ainsi cet URI (qui pointe vers un excellent MOOC) :
https://www.fun-mooc.fr/courses/MinesTelecom/04011S02/session02/about
utilise le schéma de représentation https, il y a donc ensuite un serveur www.fun-mooc.fr et le chemin est courses/MinesTelecom/04011S02/session02/about
</code>
<code>
Le programme
Le programme Arduino que l'on a fait permet d'ouvrir la connexion vers le serveur api.tom.tools sur le port 80.
Si on le regarde avec plus de détail le programme WiFiClient-compteur.ino, dans la boucle (loop) on retrouve cette instruction :
// le serveur Web attend traditionnellement sur le port 80
const int httpPort = 80;
// Si la connexion a échouée, ça sera pour la prochaine fois
if (!client.connect(host, httpPort)) {
Serial.println("connection failed");
return;
}
host et httpPort sont deux variables déclarées en début de programme qui valent respectivement api.tom.tools, soit le nom du serveur et connect permet d'ouvrir la connexion TCP avec le serveur. Si elle échoue, elle retourne false qui fait afficher un message d'erreur. Si par contre la connexion réussit, on continue à dérouler le programme :
String url = String("/hits/");
On place dans la variable url, le chemin pour accéder à la ressource sur le serveur. On vient de construire l'URI suivante http://api.tom.tools/hits.
client.print(String("GET ") + url + " HTTP/1.1\r\n" +
"Host: " + host + "\r\n" +
"Connection: close\r\n\r\n");
On envoie ensuite sur la connexion TCP une chaîne de caractères comportant 3 lignes (\r\n indique qu'il s'agit d'un changement de ligne). La première ligne contient la requête. Elle commence par l'instruction :
GET permet de récupérer la valeur de la ressource.
url contient le chemin vers cette ressource.
HTTP/1.1 désigne la version du protocole HTTP que l'on souhaite utiliser avec le serveur. Bien entendu, si le serveur ne connaît pas cette version, il répondra avec une autre version. On peut le voir dans la réponse examinée précédemment que le serveur avait répondu avec la version HTTP/1.0.
La deuxième ligne est plus complexe à comprendre. Elle permet de faire de la virtualisation, c'est-à-dire faire tourner plusieurs serveur Web indépendants sur la même machine. Supposons que nous voulions mettre deux serveurs api.tom.tools et www.justinbeiber-fan.fr sur la même machine. Ces deux serveurs vont avoir la même adresse IP. Donc, quand on ouvre une connexion, au niveau IP et TCP, il est impossible de savoir si l'on veut avoir des informations sur le Nelson ou connaître les frasques de notre chanteur favori. En rappelant le nom du serveur après la commande Hosts, le serveur saura quoi répondre.
La dernière ligne indique que l'on peut fermer la connexion quand tout est fini.
Une fois cette requête lancée, on attend une seconde pour avoir la réponse du serveur, puis :
delay(1000);
Tant qu'il y a des données reçues, on les affiche ligne par ligne :
while(client.available()){
String line = client.readStringUntil('\r'); // découpe ligne par ligne
Serial.print(line);
}
et on ferme la connexion TCP. On attend 30 secondes et on recommence en ouvrant une connexion...
Serial.println();
Serial.println("connexion fermée");
Intéressons nous à la température
En reprenant la structure du programme d'interrogation du compteur, il est facile de la transformer pour interroger un autre serveur. Intéressons-nous maintenant au programme WiFiTemperature.ino qui va interroger le serveur openweathermap.org :
// valeurs pour le serveur Web
const char* host = "api.openweathermap.org";
const char* apikey = "votre clé API (apikey)"; // il est possible d'utiliser la clé d'API suivante : 1a702a15a2f46e405e61804cf67c0d30
const char* town = "Rennes,fr";
On ajoute aussi deux variables apikey et town qui serviront à construire l'URL.
String url = String("/data/2.5/weather?q=") + town + "&appid=" + apikey;
Le chemin est un peu plus complexe car il contient une partie fixe et à la fin il y a un point d'interrogation. Formellement, il s'agit de paramètres que l'on fournit à la ressource /data/2.5/weather pour qu'elle puisse fournir un résultat. Ici, on indique la ville et l'API key qui sert à identifier l'utilisateur qui fait la requête.
On attend la réponse:
// On attend 10 millisecondes
delay(10);
puis on ignore toutes les méta-données de l'en-tête en attendant une ligne vide :
inBody = false; // on est dans l'en-tête
// On lit les données reçues, s'il y en a
while(client.available()){
String line = client.readStringUntil('\r');
if (line.length() == 1) inBody = true; /* passer l'en-tête jusqu'à une ligne vide */
if (inBody) { // ligne du corps du message, on cherche le mot clé
La variable booléenne inBody reste à faux tant que l'on ne reçoit pas une ligne vide, c'est-à-dire d'une longueur de 1 (en prenant en compte le retour à la ligne). Si on est dans le corps (c'est-à-dire les données) on peut rechercher le mot clé qui nous intéresse dans la structure. Il est indiqué au début du programme :
String keyword = String("\"temp\":"); //chaîne que l'on recherche dans le JSON
Notez les \ qui permettent de mettre les " dans la chaîne de caractères, donc en fait on recherche "temp" :
if (inBody) { // ligne du corps du message, on cherche le mot clé
int pos = line.indexOf(keyword);
if (pos > 0) { /* mot clé trouvé */
// indexOf donne la position du début du mot clé, en ajoutant sa longueur
// on se place à la fin.
pos += keyword.length();
Si pos est positif, c'est que le mot clé a été trouvé dans la ligne. Comme pos donne l'endroit où cette chaîne de caractères commence dans la ligne, en additionnant sa taille, on obtient la fin de la chaîne de caractères, c'est-à-dire le début du nombre recherché. Comme c'est également une chaîne de caractères, pour le transformer en nombre flottant (c'est-à-dire à virgule) on utilise la commande atof.>
Cette commande prend l'adresse en mémoire du début de la chaîne de caractères, c'est pour cela que l'opérateur & est utilisé :
temperature = atof(&line[pos]);
Voilà on a la valeur, il ne vous reste plus qu'à la combiner avec la commande vers le servo de votre Nelson pour le transformer en thermomètre !
LE JSON
JSON - prononcé jisone en français ou jay-zon avec l'accent anglais - n'est pas un personnage de films d'horreur, mais l'acronyme de Java Script Object Notation. C'est un format qui a été à l'origine conçu pour transporter des données pour les pages Web. Mais, à l'inverse du tueur en série, JSON étant très tolérant, il a été très vite utilisé pour structurer d'autres informations et est très populaire pour l'internet des objets, car, en plus, il est compact et simple à utiliser.
Structurer des données est quelque chose de très simple : sionnestructurepasunephraseenmettantdesespacesilesttrèsdurdelalireetdyretrouverdesmots.
Pour les données c'est la même chose. Si on veut uniquement avoir une température on peut très bien retourner juste 25, mais si dans la réponse on veut mettre d'autres informations, il faut définir une structure. Cela pourrait être par exemple des espaces séparant les valeurs, mais très vite il est difficile de se rappeler à quoi correspond telle colonne.
JSON définit deux types de données de base, les chaînes de caractères qui sont entre " et les nombres qui sont non pas entre " et qui contiennent principalement des chiffres. Par exemple "123" est une chaîne de caractères et -.1e+3 est un nombre (c'est -100). Pour ce dernier, on a un peu exagéré en utilisant la notation eX qui correspond à 10 puissance X (comme sur les calculatrices).
Ensuite on va avoir deux types structures, les listes de paires qui se composent de deux champs, le mot clé qui est un chaîne de caractères, suivi de : et d'une valeur qui peut être n'importe quoi. Les listes sont délimitées par des accolades. Par exemple, nous pourrions donner donne les propriétés d'un écran avec le json suivant :
{ "resolution_verticale": 1200, "resolution_horizontale": 900, "couleurs": true}
Json permet également de faire des tableaux :
[1200, 900, true]
On peut noter que c'est beaucoup plus compact, mais dans ce cas la position est importante, il faut savoir à quoi correspond le premier élément, le second... Un tableau est délimité par des crochets droits et les éléments sont séparés par des virgules. La beauté de JSON est que l'on peut faire des liste de tableaux, des tableaux de listes, des tableaux de tableaux, des listes de listes, de tableaux de listes de tableaux de listes... Par exemple :
{
"Image": {
"Hauteur": 800,
"Largeur": 600,
"Titre": "Vue du 5ieme étage",
"Vignette": {
"Url": "http://www.example.com/image/481989943",
"Hauteur": 125,
"Largeur": 100
},
"Animee" : false,
"IDs": [116, 943, 234, 38793]
}
}
Ce JSON décrit l'image par une liste de paires, donnant la hauteur, la largeur, un titre, une sous-liste qui décrivent une vignette,... Si vous lisez l'anglais, vous pouvez regarder la description officielle de JSON dans un standard.
</code>

15
data/pages/electronique/arduino/xbee.txt Normal file
View File

@@ -0,0 +1,15 @@
====== XBee ======
===== - Modules XBee =====
-- Shield XBee pour Arduino
https://www.ebay.fr/itm/Bluetooth-XBee-Shield-V03-Module-Wireless-Control-For-XBee-ZigBee-Arduino/163586990709
-- XBee S2
https://www.ebay.fr/itm/XBee-S2-2mW-Wire-Antenna-Series-2-ZigBee-Mesh-Wireless-Module-XB24-Z7WIT-004/263382130538
-- XBee USB Adapter
https://www.ebay.fr/itm/XBee-USB-Adapter-Bluetooth-Bee-FT232RL-USB-to-Serial-Port-Module-For-PC-Arduino/173503732416