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

10
data/pages/404.txt Executable file
View File

@@ -0,0 +1,10 @@
====== Le site a été modifié ======
{{ :ooops.jpg?noLink|Ooops, le site a été modifié}}
**Rechercher la page**\\
Il faut utiliser le moteur de recherche pour effectuer une recherche. C'est en haut, à droite. Il peut être caché derrière le menu {{:pasted:20200427-122409.png?20&noLink|Menu Burger pour écran étroit}}.
\\
\\
--- //Page modifiée le 12/11/2021 10:30:36 par [[user:cedricabonnel]]//

12
data/pages/__template.txt Normal file
View File

@@ -0,0 +1,12 @@
====== @PAGE@ ======
{{tag>"script linux"}}
{{ :dummy.png?75x75|Nom de la section}}
Lorem ipsum dolor sit amet, ...
--- //[[user:@USER@]]//
<php>
setlocale(LC_TIME, 'fr_FR');
echo strftime(' - Article paru en premier le %A %d %B %Y');
</php>

8
data/pages/admin/index.txt Normal file
View File

@@ -0,0 +1,8 @@
====== Admin ======
{{ :dummy.png?75x75|Nom de la section}}
===== Editions par user =====
==== Jean Serien ====
{{editor>:?jeanserien}}

1
data/pages/cookie/banner.txt Normal file
View File

@@ -0,0 +1 @@
Des cookies sont utilisés dans le **site** afin d'améliorer l'expérience utilisateur lors de la navigation et de la connexion au site. Ils ne sont pas soumis à approbation par le visiteur. Il n'existe aucune autre utilisation de ces cookies. En visitant ce site, l'**adresse IP de connexion**, les **ressources demandées**, les **éléments techniques** associés aux ressources, l'**identifiant** dans le site pour un utilisateur inscrit, sont stockées dans les fichiers **logs** pour réaliser des **statistiques de visites**. **En poursuivant** votre navigation sur ce site, **vous acceptez** l’utilisation de Cookies ou autres traceurs. Plus d'infos dans les [[:cookie:start|Mentions légales]]

13
data/pages/electronique/adaptateur-usb-ethernet-asix-887x.txt Normal file
View File

@@ -0,0 +1,13 @@
====== adaptateur usb ethernet AXSI 887x ======
{{ :electronique:pasted:20220113-013119.png?75x75|Adaptateur Ethernet USB Amazon Basics}}
Une série d'adaptateur USB Ethernet Amazon Basics est basée sur les puces réseaux ASIX.
En utilisant le commande ''lsusb'', les identifiants Vendor ID et Product ID permettent de connaitre le puce ASIX présente dans votre produit.
Vous pouvez consulter le site http://www.asix.com.tw/products.php?op=ProductList&PLine=71 pour obtenir plus d'informations.
| **ASIX Product** | **ASIX Vendor ID** | **Product ID** |
| AX88772C | 0B95h | 772Bh |
| AX88772B | 0B95h | 772Bh/7E2Bh |
| AX88760 | 0B95h | 772Ah |
| AX88772A | 0B95h | 772Ah |
| AX88772 | 0B95h | 7720h |

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

37
data/pages/electronique/audio/les-microphones-unidirectionnels.txt Normal file
View File

@@ -0,0 +1,37 @@
====== Les microphones unidirectionnels (cardioïde) ======
Les microphones unidirectionnels peuvent être placés de façon à ce que la source sonore indésirables, tel que les retours de scène et des haut-parleurs, soit directement derrière lui. Pour minimiser le larsen acoustique et optimiser le rejet des sons indésirables, toujours essayer le placement du microphone avant une prestation.
{{ :electronique:audio:pasted:20230808-152506.png }}
<WRAP clear/>
---
Diriger le microphone vers la soupe sonore désirée, tel qu'un orateur un chanteur ou un instrument et à l'opposé des sources sonores indésirables.
Placer le microphone le plus près possible de la source sonore.
Utiliser un seul microphone pour chaque source sonore.
Utiliser un minimum de microphone dans la mesure du possible.
Placer les microphones le plus loin possible des surfaces réfléchissantes.
Si le microphone est utilisé à l'extérieur, le munir d'une bonnette anti-vent.
---
Les cas suivant répertorie les applications et techniques de placement les plus communes. Ne pas oublier que la façon d'utiliser un microphone est souvent une question de goût personnel et qui n'existe aucune position de microphone correcte à proprement parler.
{{ :electronique:audio:pasted:20230808-152540.png}}
* Si les lèvres sont à moins de 15 cm de la bonnette anti-vent où en la touchant dans l'axe du microphone, le son est puissant grave accentué, avec une isolation maximum par rapport aux autres sources
* Si le micro est à 15 à 60 cm de la bouche, juste au dessus de la hauteur du nez, alors le son est naturel, et les graves sont atténuées.
* Si le micro est de 20 à 60 cm de la bouche, avec un léger d'exassage d'un côté, alors le son est naturel, les graves sont atténuées et il y a des sifflements minimaux.
* Si le micro est de 90 cm à 1 m 80 de l'instrument, le son est plus ténu, distant, avec un niveau notable de bruit ambiant.
<WRAP clear/>

29
data/pages/electronique/cc2531-chipset.txt Normal file
View File

@@ -0,0 +1,29 @@
====== CC2531 chipset ======
{{ :electronique:pasted:20220828-101739.png?75x75|CC2351 sur CI USB et CC2540 en bas}}
Microcontrôleur pour réseau sans-fil Zigbee et IEEE 802.15.4 avec 256ko de mémoire Flash et 8ko de RAM.
Associée à la pile de protocoles ZigBee (Z-Stack) de Texas Instruments, la puce CC2531 constitue un dongle USB ZigBee robuste et complet ou un nœud de réseau pouvant être mis à niveau par un micrologiciel.
===== Propriétés principales =====
1. Radio Fréquence
* Émetteur-récepteur RF conforme à la norme IEEE 802.15.4 de 2,4 GHz
* Excellente sensibilité du récepteur et robustesse aux interférences
* Puissance de sortie programmable jusqu'à 4,5 dBm
* Un seul cristal nécessaire pour les réseaux asynchrones
* Convient aux systèmes visant à se conformer aux réglementations mondiales en matière de radiofréquences
* Radiofréquence : ETSI EN 300 328 et EN 300 440 (Europe), FCC CFR47 Partie 15 (USA), et ARIB STD-T-66 (Japon).
2. USB
* Dispositif certifié USB 2.0 à pleine vitesse (12 Mbps)
* 5 points d'extrémité très flexibles
* FIFO dédiée de 1 Ko
* Accès DMA à la FIFO
* Pas de cristal 48 MHz requis
3. Faible consommation
* Mode actif RX (CPU inactif) : 24 mA

23
data/pages/electronique/cc2531-dongle.txt Normal file
View File

@@ -0,0 +1,23 @@
====== Dongle USB Zigbee CC2531 ======
{{ :dummy.png?75x75|Nom de la section}}
Dongle USB Zigbee avec la [[electronique:cc2531-chipset|puce CC2531]].
Ce dongle USB est utilisé avec le programme Zigbee2MQTT (Zigbee to MQTT).
===== Comment utiliser le dongle USB CC2531 ? =====
1. Brancher le clé USB Zigbee
2. Vérifier la présence de la clé USB avec la commande ''lsusb''
> lsusb
Bus 001 Device 015: ID 0451:16ae Texas Instruments, Inc. CC2531 Dongle
3.
===== Bibliographie =====
* https://www.zigbee2mqtt.io/ - Zigbee to MQTT bridge, get rid of your proprietary Zigbee bridges

44
data/pages/electronique/ces-technos-qui-n-ont-jamais-encore-percees.txt Normal file
View File

@@ -0,0 +1,44 @@
====== Ces technologies qui n'ont jamais encore percées ======
{{ :electronique:pasted:20220219-101705.png?300}}
Ces technologies qui n'ont jamais encore percées, sois parce qu’elles n'intéressent personne, soit parce qu'elles sont trop en avance sur leur temps. À moins que ce soit un problème de prix...
* Second Life - 1999-..., 2003-2007 Buzz médiatique
* Télévision 3D ou stéréoscopique - 2009-2017, expériences menées depuis 1838
* Cinéma odorama - 1975-2010 avec une dizaine d'experiences.
* CD-R autogravable - 2005
Et ces technologies dont on rêve tous mais qui n'ont pas encore existées
* voiture volante
* chaussure à lassage automatique
* conduite autonome
Des technologies qui ont fait leur temps
* Phares escamotables sur les voitures - 1960-1990
* Monéo, Solutions monétiques - 1999-2015
* Minitel - 1980-2012
* Téléphone RTC - 1876-2018
* Ethernet Coaxial type 10BASE5 puis 10BASE2 - 1973-199?,
* prise en T / F-010, conjoncteur PTT - 1910(?)-2003
* CD Audio
* DVD
* Disquette 3 1/2
* VHS
* ZIP IOMEGA - 1994-2003
Technologies qui vont faire scratch ?
* Metaverse par meta (Facebook) - 2019-...
* Bitcoin, la monnaie - 2009-...
* NFT, propriété numérique - 2016-....
* DRM, droit accès, identification, authentification, chiffrement - 1983-... - Exemples de protection : zonage DVD, l'algorithme CSS, Macrovision, CGMS, HDCP, AACS, VCMS/AV, Cinavia, BD+, SCMS, Copy Control, FairPlay, TPM, BitLocker, Lightweight Content Protection, DRM Adobe, DRM Apple, DRM Amazon, DRM Microsoft...
Technologies en fin de vie :
* CD-R - 1988-..., buzz en 1998
* Télécopieur - 1947-..., essaies depuis 1851

9
data/pages/electronique/depannage/index.txt Normal file
View File

@@ -0,0 +1,9 @@
====== Montages, Dépannages et produits ======
{{ :electronique:ecran-televiseur.jpg?nolink&75x75|Dépannage}}
<WRAP clear/>
<nspages . -h1 -hideNoSubns -subns -textNS=" " -textPages=" " -usePictures -exclude:cookie: -exclude:user: -exclude:playground: -exclude:[sidebar index start rightsidebar navbar topheader header help pageheader pagefooter legal-notices footer 404]>
~~NOTOC~~
~~NOCACHE~~

46
data/pages/electronique/depannage/radiateur-carlotec-1000w.txt Normal file
View File

@@ -0,0 +1,46 @@
====== Radiateur Caroltec 1000 W ======
<WRAP center round alert 60%>
Article en cours de rédaction. Avant de continuer, je dois élaborer le protocole de communication entre Arduino/ESP8266.
</WRAP>
===== - Défaillance : témoin clignote rouge et ne le radiateur ne chauffe pas =====
J'ai rencontré à deux reprises, sur deux radiateurs différents, le **dysfonctionnement** suivant. Le **témoin lumineux**, en dessous du thermostat **clignote rouge**. De plus, le **radiateur ne chauffe plus**. J'ai essayé de disjoncter un long moment et j'ai même essayé de supprimer le fil pilote. Rien n'y fait.
En démontant le radiateur, j'ai constaté plusieurs choses.
- Malgré le thermostat à fond, le sortie vers la résistance est toujours à **0 Volt**. J'ai testé sur un radiateur qui fonctionne, et je devrais avoir 230 V.
- La référence de la **carte électronique** est ERD10001 220/240~11A
- En branchant le 230 Volts sur la résistance, le radiateur fonctionne : il chauffe.
- En consultant le forum de [[https://forums.futura-sciences.com/depannage/566558-dysfonctionnement-radiateur-calortec-ceramique-resolu.html|Futura Sciences]], une des personnes indique qu'il s'agit d'un **défaut de sonde de température**.
Prix de la carte électronique : trop chère ! Sur le site age86.fr, il est affiché à 159€ ce 8 avril 2020.
{{ electronique:arduino:age86_ctherm_erd10001.jpg |Prix d'une carte ERD10001 sur age86}}
Je n'ai pas cherché à remplacer la sonde de température seule. J'imagine qu'il s'agit d'un capteur de température que l'on peut trouver à pas cher.
{{ electronique:arduino:ebay_sonde_temperature_exemple.jpg |Exemple de sonde à température sur eBay}}
>> Que faire ?
Je peux court-circuiter la carte électronique en alimentant directement la résistance chauffante. A moi de trouver le moyen de piloter l'alimentation électrique de la résistance.
La puissance de radiateur est de **1000 W**, alimenté à **230 V**. Par calcul, l'__intensité__ demandé est de 1000 / 230 = __4,35 A__.
Un relais électrique permettrait de piloter la résistance, comme un interrupteur. Il a l'avantage d'être un isolant entre la partie commande (circuit basse tension), et la résistance électrique (partie haute tension).
{{ electronique:arduino:ebay_relais_250v_5a.jpg |}}
Par contre, un relais comporte une partie mécanique qui provoque un peu de bruit lors du changement d'état (ouvert/fermé). Cela peut être gênant dans une pièce à dormir.
===== - Reste à faire dans cet article =====
09/04/2020
* Nous voyons que le transistor peut remplacer facilement un relai. nous voyons bien que nous allons mettre derrière un Arduino qui permettra de piloter ce transistor. La question de s'avoir où positionner cet arduino pour se pose entièrement. Il peut être positionné juste à côté du radiateur, où se trouve dans l'armoire électrique ce qui permettrait de mutualiser un Arduino pour piloter plusieurs transistor, donc plusieurs radiateurs. J'y reviendrai un peu plus bas.
* La partie capteur se pose également. doit-on mettre un capteur de température tel qu'il avait été conçu initialement c'est-à-dire juste derrière le radiateur avec une sonde, dans quel cas on aurait un système autonome et non connecté. ou plutôt un capteur de température dans la pièce qui permettrait de piloter plusieurs radiateur elle disait la valeur de cette température pour d'autres usages.
* Mettre la partie intelligente dans une armoire électrique donc mutualiser l'arduino et mettre un capteur de température par piece, permet de faire des économies. toutefois cela enlève une partie intelligente au radiateur en lui-même étant donné qu'il doit être dépendant de la partie centrale. L'objectif global reste quand même d'avoir une domotique centralisée à la maison, donc cette réflexion n'est pas dénué de bon sens, malgré que la centralisation n'est pas forcément toujours une bonne chose. Toutefois je vais faire un mix entre les deux. je vais installer un capteur de température par piece, et ajouter une partie commande pas radiateur. La relation entre la commande et le température s'effectuera par un serveur intelligent. cela se traduit donc par le montage d'un Arduino connecté. Arduino qui permettra de servir d'interrupteur à la réception d'un ordre.
* ESP 32 permet de faire un réseau mesh bluetooth

6
data/pages/electronique/depannage/smart-touch-switch/branchement.txt Normal file
View File

@@ -0,0 +1,6 @@
====== Branchement et montage ======
{{ :dummy.png?75x75|Interrupteur tactile phase 240V 300W}}
{{:electronique:depannage:smart-touch-switch:pasted:20210321-213239.png}}
Si vous utilisez cet interrupteur pour des LED ou des ampoules à économie d'énergie, la puissance de charge doit être de 150W maximum par ligne.

6
data/pages/electronique/depannage/smart-touch-switch/dimensions.txt Normal file
View File

@@ -0,0 +1,6 @@
====== Dimensions ======
{{ :dummy.png?75x75|Interrupteur tactile de 10mm d'épaisseur}}
{{:electronique:depannage:smart-touch-switch:pasted:20210321-213132.png}}
{{:electronique:depannage:smart-touch-switch:pasted:20210321-213502.png}}

13
data/pages/electronique/depannage/smart-touch-switch/index.txt Normal file
View File

@@ -0,0 +1,13 @@
====== Smart Touch Switch ======
{{ :electronique:depannage:smart-touch-switch:pasted:20210321-193404.png?75x75|L'interrupteur sensitif}}
<WRAP clear/>
{{page>.:prix:}}
{{page>.:dimensions:}}
{{page>.:branchement:}}
{{page>.:manuel:}}

4
data/pages/electronique/depannage/smart-touch-switch/manuel/index.txt Normal file
View File

@@ -0,0 +1,4 @@
====== Manuel d'utilisation ======
{{ :electronique:depannage:smart-touch-switch:manuel:pasted:20210321-193203.png?75x75|Smart Touch Swtich}}
{{gallery>.}}

8
data/pages/electronique/depannage/smart-touch-switch/prix.txt Normal file
View File

@@ -0,0 +1,8 @@
====== Prix ======
{{ :dummy.png?75x75|Interrupteur tactile 230V}}
Prix constaté (20/03/2021) : 4.31€
Prix promo (21/03/2021) : 3.46€
https://fr.aliexpress.com/item/1005001403728029.html

25
data/pages/electronique/dongle-usb-sans-fil.txt Normal file
View File

@@ -0,0 +1,25 @@
====== Dongle USB sans fil ======
Il existe plusieurs catégories de sans fil.
===== Wifi =====
| {{:electronique:pasted:20211207-001433.png?300}} | ID 7392:7811\\ Edimax Technology Co., Ltd\\ EW-7811Un 802.11n Wireless Adapter [Realtek RTL8188CUS] | Clé USB Wifi 2,4 GHz\\ Plug-and-play Linux, Windows, Mac OS\\ 150 Mbps max\\ {{:electronique:pasted:20211207-001645.png}} |
===== Sans fil propriétaire =====
| {{:electronique:pasted:20211221-091653.png?300&nolink|Dongle Logitech MK260}} | ID 046d:c52e\\ Logitech, Inc.\\ MK260 Wireless Combo Receiver | Pack Clavier et souris Logitech MK260\\ {{:electronique:pasted:20211206-234846.png?300}} |
| {{:electronique:pasted:20211206-235214.png?300}}\\ {{:electronique:pasted:20211206-235911.png?300}} | ID 046d:c52b\\ Logitech, Inc.\\ Unifying Receiver | Récepteur USB à utiliser avec une souris ou un clavier Unifying. |
| {{:electronique:pasted:20211221-234849.png?300|Dongle Rii 2015}} | ID 1997:2433\\ Shenzhen Riitek Technology Co., Ltd\\ wireless mini keyboard with touchpad | Récepteur à utiliser avec un mini clavier et son touchpad\\ {{:electronique:pasted:20211207-000619.png?300}}\\ voir la [[http://www.riitek.com/product/index.html|liste des produits Rii]] |
| {{:electronique:pasted:20211221-215153.png?300|Dongle ET}} | ID 062a:5918\\ MosArt Semiconductor Corp.\\ 2.4G Keyboard Mouse | Clé USB sans fil pour clavier et souris de marque ET \\ {{:electronique:pasted:20211207-002921.png?300}}\\ **Ne fonctionne pas sur port USB 3.0** |
| | ID 1a86:5453\\ QinHeng Electronics HIDKB | Clé USB sans fil pour douchette code barre 2D et QR code |
| | ID 062a:5918\\ MosArt Semiconductor Corp.\\ 2.4G Keyboard Mouse | Clé USB sans fil pour clavier et souris de marque ET \\ {{:electronique:pasted:20211207-002921.png?300}}\\ **Ne fonctionne pas sur port USB 3.0** |
| | ID 1ea7:0064\\ SHARKOON Technologies GmbH 2.4GHz Wireless rechargeable vertical mouse [More&Better] | |
===== Bluetooth =====
| {{:electronique:pasted:20211207-000325.png?300}} | ID 050d:016a\\ Belkin\\ Components Bluetooth Mini Dongle\\ \\ ID 0a5c:4503\\ Broadcom Corp.\\ Mouse (Boot Interface Subclass)\\ \\ ID 0a5c:4502\\ Broadcom Corp.\\ Keyboard (Boot Interface Subclass)\\ \\ ID 0a5c:4500\\ Broadcom Corp.\\ BCM2046B1 USB 2.0 Hub (part of BCM2046 Bluetooth) | Clé USB Bluetooth 1.1, 1.2, 2.0, and 2.1 standards\\ AD2P compatible |
| {{:electronique:pasted:20211207-002336.png?300}} | ID 0b05:17cb\\ ASUSTek Computer, Inc.\\ Broadcom BCM20702A0 Bluetooth | Clé USB Bluetooth 4+LE\\ Bluetooth Low Energy\\ 24 Mbp/s\\ Portée entre 10 et 60 mètres\\ Liaison radio 802.11\\ Appelée égalment Asus BT400 |
| {{ :electronique:pasted:20211221-090927.png?nolink&300|Adaptateur Bluetooth KY-BT100}} | ID 1131:1001\\ Integrated System Solution Corp.\\ KY-BT100 Bluetooth Adapter | Clé USB Bluetooth 1.1\\ **Ne fonctionne pas sur port USB 3.0** |

65
data/pages/electronique/esp/adapteur-usb-esp01.txt Normal file
View File

@@ -0,0 +1,65 @@
====== Adaptateur USB vers ESP-01 ======
{{ :electronique:esp:pasted:20201207-233302.png?75x75|Adapteur USB vers ESP-01}}
===== Généralités =====
Cet [[https://amzn.to/3oHZ1Eo|adaptateur USB vers ESP-01 avec puce CH340]] permet d'accéder facilement au circuit ESP-01 via le port USB d'un ordinateur. L'adaptateur dispose également d'un régulateur 3,3 V.
Cela permet de recevoir des informations de l'ESP-01 ou d'[[electronique:esp:esp8266-commandes-at|envoyer des commandes AT]].
> Acheter un [[https://amzn.to/3oHZ1Eo|adaptateur USB vers ESP-01 avec puce CH340]]
===== Activer le mode PROGRAMMATION =====
Il faut basculer l'**ESP-01** du **mode UART** en **mode FLASH** ou mode PROGRAMMATION , ce qui permet de programmer l'ESP8266. Cette bascule n'est pas réalisée logiciellement. Il faut réaliser la bascule en **mode PROGRAMMATION** électriquement.
{{ :electronique:esp:pasted:20201212-191417.png |Erreur lors du téléversement vers ESP-01}}
Sans cette bascule, l'IDE Arduino affiche des erreurs graves.
<code>
Executable segment sizes:
IROM : 234612 - code in flash (default or ICACHE_FLASH_ATTR)
IRAM : 26888 / 32768 - code in IRAM (ICACHE_RAM_ATTR, ISRs...)
DATA : 1252 ) - initialized variables (global, static) in RAM/HEAP
RODATA : 1376 ) / 81920 - constants (global, static) in RAM/HEAP
BSS : 25112 ) - zeroed variables (global, static) in RAM/HEAP
Le croquis utilise 264128 octets (25%) de l'espace de stockage de programmes. Le maximum est de 1044464 octets.
Les variables globales utilisent 27740 octets (33%) de mémoire dynamique, ce qui laisse 54180 octets pour les variables locales. Le maximum est de 81920 octets.
esptool.py v2.8
Serial port /dev/ttyUSB0
Connecting........_____....._____....._____....._____....._____....._____.....____Traceback (most recent call last):
File "/home/cedric24c/.arduino15/packages/esp8266/hardware/esp8266/2.7.4/tools/upload.py", line 65, in <module>
esptool.main(cmdline)
File "/home/cedric24c/.arduino15/packages/esp8266/hardware/esp8266/2.7.4/tools/esptool/esptool.py", line 2890, in main
esp.connect(args.before)
File "/home/cedric24c/.arduino15/packages/esp8266/hardware/esp8266/2.7.4/tools/esptool/esptool.py", line 483, in connect
raise FatalError('Failed to connect to %s: %s' % (self.CHIP_NAME, last_error))
esptool.FatalError: Failed to connect to ESP8266: Timed out waiting for packet header
esptool.FatalError: Failed to connect to ESP8266: Timed out waiting for packet header
</code>
Certains [[https://amzn.to/3oHZ1Eo|adaptateurs USB vers ESP-01]] ne sont pas équipés de cette bascule. Voici quelques modifications matérielles a effectuer pour rendre programmable l'ESP8266. Cette modification est à effectuer sur l'adaptateur. Il est nécessaire d'avoir de l'**étain** et un **fer à souder**. J'ai utiliser **deux fils** et **une broche de connexion** avec un **jumper**.
{{ :electronique:esp:pasted:20201212-134043.png?150 |Broches de l'ESP-01 }}
Il faut relier les broches **GPIO0** et **GND**.
{{ :electronique:esp:pasted:20201212-173952.png |Adaptateur USB vers ESP-01 hacké}}
J'ajoute un peu de colle blanche, avec un pistolet à colle afin de rigidifier l'ensemble et de ne pas tirer sur les soudures.
{{ :electronique:esp:pasted:20201213-084414.png |Finition du hack sur l'adaptateur USB vers ESP-01}}
A partir de maintenant, vous pouvez téléverser votre programme.
{{ :electronique:esp:pasted:20201213-083952.png }}
Le programme téléversé écrasera le code déjà chargé et notamment celui avec les commandes AT ([[electronique:esp:esp8266-commandes-at|commandes Hayes]]).
<WRAP clear/>

16
data/pages/electronique/esp/communiquer-avec-un-esp-32.txt Normal file
View File

@@ -0,0 +1,16 @@
====== Communiquer avec un module ESP-32 ======
{{tag>"script linux"}}
{{ :dummy.png?75x75|Nom de la section}}
Pour communiquer avec un module ESP-32, vous pouvez utiliser plusieurs méthodes, notamment:
1. Communication série (UART): L'ESP-32 dispose de broches UART qui permettent la communication série. Vous pouvez utiliser un câble USB-TTL pour connecter l'ESP-32 à votre ordinateur et utiliser un terminal série pour envoyer et recevoir des données.
2. Wi-Fi: L'ESP-32 prend en charge la communication Wi-Fi. Vous pouvez [[electronique:esp:creer-un-point-d-acces|configurer l'ESP-32 en tant que point d'accès]] ou le [[electronique:esp:se-connecter-a-un-reseau-wifi|connecter à votre réseau Wi-Fi existant]]. Une fois connecté, vous pouvez communiquer avec l'ESP-32 via des sockets TCP/IP ou en utilisant des protocoles réseau tels que HTTP.
3. Bluetooth: Certains modules ESP-32 prennent également en charge la communication Bluetooth. Vous pouvez utiliser des protocoles Bluetooth tels que Bluetooth Low Energy (BLE) pour établir une communication avec d'autres appareils compatibles Bluetooth.
4. Protocoles de communication spécifiques: L'ESP-32 prend en charge divers protocoles de communication tels que MQTT, CoAP, WebSocket, etc. Vous pouvez choisir le protocole qui convient le mieux à votre cas d'utilisation et configurer l'ESP-32 en conséquence.
Il est important de noter que la communication avec l'ESP-32 nécessite un développement logiciel approprié. Vous pouvez utiliser l'IDE Arduino, PlatformIO ou d'autres outils de développement pour écrire le code nécessaire pour établir la communication et traiter les données sur l'ESP-32. Assurez-vous de consulter la documentation et les exemples fournis par le fabricant de l'ESP-32 pour obtenir des informations déta

31
data/pages/electronique/esp/creer-un-point-d-acces.txt Normal file
View File

@@ -0,0 +1,31 @@
====== Créer un Point d'Accès Wifi (AP) ======
Un **point d'accès Wifi** (AP) consiste à créer un réseau Wifi avec nom (appelé SSID). Ci-dessous, un code pour créer rapidement un point d'accès Wifi avec l'**ESP 8266**. Le nom de réseau s’appellera **ESP1 - AP**, stockée dans la variable **ssid**.
<code C esp8266-wifi-ap.ino>
#include <ESP8266WiFi.h>
#include <WiFiClient.h>
/* Définition du réseau Wifi à diffuser */
const char *ssid = "ESP1 - AP";
void setup() {
delay(1000);
Serial.begin(115200);
Serial.println();
Serial.println("Configuration du point d'accès...");
WiFi.softAP(ssid);
IPAddress apIP = WiFi.softAPIP();
Serial.print("AP adresse IP: ");
Serial.println(apIP);
}
void loop() {
}
</code>

21
data/pages/electronique/esp/doiting-esp-12f/index.txt Normal file
View File

@@ -0,0 +1,21 @@
====== DOITING ESP 12F ======
{{ :dummy.png?75x75|Nom de la section}}
====== Galerie photos ======
{{gallery>.:}}
====== Caractéristiques ======
^ Tension de fonctionnement | 3.3 V (3.0 à 3.6 ~ V) |
^ Température de l'environnement de travail | de -40°C à 85°C |
^ Processeur | Tensilica L106 32 bits |
^ RAM | 50KB (disponible) |
^ Flash | 32 Mbits |
^ Wifi | 802.11 b/g/n 2.4 GHz, prend en charge le mode de sécurité WPA/WPA2 |
^ Gamme de fréquences | 2.4 GHz ~ à à à 2.5 à 2400 GHz (2483.5 MHz à MHz) |
^ Fréquences | de 80 MHz et 160 MHz |
^ Bus | UART, I2C, GPIO, PWM, SDIO, SPI, ADC, PWM, IR |
^ Protocoles réseau | Prendre en charge TCP, uu, UDP, HTTP, FTP |
^ Consommation | Consommation moyenne : 80mA\\ Consommation en sommeil profond : 20µA\\ Consommation en arrêt : < 5µA |

112
data/pages/electronique/esp/esp32-commander-led-wifi.txt Normal file
View File

@@ -0,0 +1,112 @@
====== Commander une LED Wifi ======
{{ :dummy.png?75x75|Commander la LED intégrer aux boards basées sur ESP866 par une page HTML via une connexion Wifi.}}
Nous avons vu dans le chapitre [..] comment la carte ESP 8266 peut se connecter à un **point d'accès** Wifi. Nous nous fixons comme objectif de connecter l'ESP 8266 au même réseau qu’un smartphone ou un ordinateur pour commander une LED. Pour ce faire, nous allons configurer l'ESP 8266 afin d'**offrir un service**. Dans un premier temps nous **offrirons** une page Web à l'utilisateur. Elle permettra de commander la LED incorporée sur votre plaque de développement ESP 8266.
{{ :electronique:esp:pasted:20220325-185318.png | Carte ESP-12F avec la LED BUILT IN allumée }}
Sur la carte de développement, comme l'ESP-12F, est soudée une LED. Cette LED est celle qui clignote faiblement quand vous téléversez une programme. C'est également celle qui clignote avec le programme **blink led**. Techniquement parlant, cette LED est branchée sur le port GPIO 16. Mais il n'est pas forcément nécessaire de connaître cette valeur par cœur car nous utiliserons dans le code la **constante** (mot clé défini dans l'IDE ARDUINO) ''LED_BUILTIN''.
..
Jusqu'à présent nous avons utiliser l'ESP pour **présenter une page Web**, fournir un moyen de **commander la LED** et **informer de l'état de la LED**. Dans les objets connectés il n'est pas nécessaire de **présenter une page Web** car celle-ci est fournie par un service centralisé comme **Domoticz** ou **OpenHAB**.
<code C>
#include <ESP8266WiFi.h>
const char* ssid = "MON-REZO-WIFI";
const char* password = "leMotDePasseDuRezoWifi";
int ledPin = 16;
// Déclaration du Server sur le port 80
WiFiServer server(80);
void setup()
{
// initialisation de la communication série
Serial.begin(115200);
delay(100);
// initialisation de la sortie pour la LED
int valeurLED = HIGH;
pinMode(ledPin, OUTPUT);
digitalWrite(ledPin, valeurLED);
// Connexion wifi
Serial.println();
Serial.print("Connexion au réseau Wifi ");
Serial.println(ssid);
WiFi.begin(ssid, password);
// connexion en cours ...
while (WiFi.status() != WL_CONNECTED)
{
delay(500);
Serial.print(".");
}
// Wifi connecter
Serial.println("Réseau WIFI connecté");
// Démmarrage du serveur.
server.begin();
Serial.println("Serveur démarré !");
// Affichage de l'adresse IP
Serial.print("Utiliser cette adresse URL pour la connexion : ");
Serial.print("http://");
Serial.print(WiFi.localIP());
Serial.println("/");
}
void loop() {
// Attente de connexion d'un client
client = server.available();
if (!client)
{
return;
}
// Attendre si le client envoie des données ...
Serial.println("nouveau client");
while(!client.available()){
delay(1);
}
String request = client.readStringUntil('\r');
Serial.println(request);
client.flush();
if (request.indexOf("/LED=ON") != -1) {
valeurLED = LOW;
digitalWrite(ledPin, valeurLED); // allumer la led
}
if (request.indexOf("/LED=OFF") != -1) {
valeurLED = HIGH;
digitalWrite(ledPin, valeurLED); // éteindre la led
}
// Réponse
client.println("HTTP/1.1 200 OK");
client.println("Content-Type: application/json");
client.println("");
if(valeurLED == LOW) {
client.println("{\"LED\": \"on\"}");
} else {
client.println("{\"LED\": \"off\"}");
}
Serial.println("Client déconnecté");
Serial.println("");
}
</code>

28
data/pages/electronique/esp/esp32-ep8266-mesh.txt Normal file
View File

@@ -0,0 +1,28 @@
====== ESP32 ESP8266 MESH ======
{{ :dummy.png?75x75|Nom de la section}}
**ESP Mesh** permet à plusieurs appareils (//node// en anglais) de communiquer avec chacun des autres sur un seul réseau sans fil.
**ESP Mesh** est un protocole de réseau qui s'appuie sur le protocole Wifi. **ESP Mesh** permet à des appareils identifiés, répartis sur une grande étendu a être interconnectés sous le même WLAN unique. **ESP Mesh** agrandi, organise et maintient son réseau MESH de manière autonome.
Dans un réseau Wifi traditionnel chaque appareil doit établir une connexion avec le point d'accès pour pouvoir établir une connexion. Il y a deux limites à se mode de connexion. La première est le nombre d'appareils connectés au point d'accès. La seconde est la porté maximale du point d'accès.
{{:electronique:esp:pasted:20220815-180756.png}}
Le réseau MESH permet de repousser ces limites. Chaque appareil peut communiquer avec un autre appareil voisin sans pour autant avoir un point d'accès à portée. La configuration des appareils constituant le réseau MESH est effectué dans l'appareil, mais la détection des voisins est automatique. Son maintient est gérée de manière automatique.
{{:electronique:esp:pasted:20220815-180946.png}}
===== Pré requis =====
* Arduino IDE
* Librairie **painlessMesh**
===== Documentation =====
Documentation officielle Espessif ESP WIFI MESH [[https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-reference/network/esp-wifi-mesh.html|Go to Espressif]]
ESP-MESH avec des ESP32 et des ESP8266 en utilisant la librairie **painlessMesh**.
[[https://randomnerdtutorials.com/esp-mesh-esp32-esp8266-painlessmesh/|Go to Random Nerd Tutorial]]

188
data/pages/electronique/esp/esp8266-commandes-at.txt Normal file
View File

@@ -0,0 +1,188 @@
====== Commandes AT ======
Sans modification du programme le **circuit intégré ESP8266** répondra à des commandes AT (ou commandes Hayes) s'il est chargé avec le [[electronique:esp:esp8266ex-restore-commandes-at|firmware adéquat]]. C'est le cas de la plupart des [[electronique:esp:specifications-esp-01|ESP-01]]
Je propose le T.P. suivant afin de prendre en main un **ESP8266** avec les commandes AT.
<WRAP clear/>
----
Vérifier le fonctionnement du mode Wifi
AT+CWMODE?
----
Passer en mode dual (AP + client)
AT+CWMODE=3
-> ok
----
Se connecter à un réseau
AT+CWJAP="ACEGRP_NET","249cb30b415788bdd20c5d3c20"
-> WIFI CONNECTED
-> WIFI GOT IP
->
-> OK
----
Mémoriser les paramètres de connexion
AT+CWQAP
->
-> OK
----
Lister les adresses réseaux
AT+CIFSR
-> +CIFSR:APIP,"192.168.4.1"
-> +CIFSR:APMAC,"1a:fe:34:9a:36:13"
-> +CIFSR:STAIP,"192.168.101.20"
-> +CIFSR:STAMAC,"18:fe:34:9a:36:13"
->
-> OK
----
Activer les connexions multiples
<code>
00:21:55.429 -> OK
01:09:33.601 -> AT+CIPMUX=1
</code>
----
Activer le serveur Web (port 80)
<code>
01:09:33.601 -> OK
01:09:40.391 -> AT+CIPSERVER=1,80
</code>
Lorsqu'un client se connecte, les informations suivantes dans la console s'affichent :
<code>
01:09:56.319 -> 0,CONNECT
01:09:56.319 ->
01:09:56.319 -> +IPD,0,341:GET / HTTP/1.1
01:09:56.319 -> Host: 192.168.101.20
01:09:56.319 -> User-Agent: Mozilla/5.0 (X11; Fedora; Linux x86_64; rv:83.0) Gecko/20100101 Firefox/83.0
01:09:56.319 -> Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
01:09:56.319 -> Accept-Language: fr,fr-FR;q=0.5
01:09:56.319 -> Accept-Encoding: gzip, deflate
01:09:56.352 -> DNT: 1
01:09:56.352 -> Connection: keep-alive
01:09:56.352 -> Upgrade-Insecure-Requests: 1
01:09:56.352 ->
01:12:56.522 -> 0,CLOSED
</code>
====== Glossaire des commandes AT - Wifi ======
===== CWMODE : Mode de fonctionnement du Wifi =====
**Retourner** la valeur numérique du mode de fonctionnement du Wifi du module ESP.
AT+CWMODE?
**Désigner** la valeur numérique du mode de fonctionnement du Wifi du module ESP. Par exemple
AT+CWMODE=3
**Valeurs numériques** pour désigner du mode de fonctionnement du Wifi pour **CWMODE** :
* 1 = mode client
* 2 = mode point d'accès (AP)
* 3 = AP + mode client (dual mode)
__Exemple de réponse avec AT+CWMODE?__
23:16:33.243 -> AT+CWMODE?
23:16:33.243 -> +CWMODE:1
===== CWLAP - Lister les points d'accès =====
Lister les points d'accès vus par l'ESP.
AT+CWLAP
Chaque ligne retournée correspond à un point d'accès avec les paramètres **ecn**, **ssid**, **rssi**, **mac**, **channel**.
* ecn: 0 OPEN , 1 WEP , 2 WPA_PSK , 3 WPA2_PSK , 4 WPA_WPA2_PSK
* ssid: chaîne représentant le nom du point d'accès
* rssi: force du signal en dB
* mac: chaîne représentant l'adresse MAC
* channel : valeur numérique
__Exemple de réponse avec AT+CWLAP__
<code>
23:16:55.796 -> AT+CWLAP
23:16:57.915 -> +CWLAP:(3,"ACEGRP_NET-F2",-22,"f8:9a:78:9b:67:05",4)
23:16:57.915 -> +CWLAP:(3,"ACEGRP_NET",-68,"50:c7:bf:8c:4f:e9",6)
23:16:57.915 -> +CWLAP:(3,"ACEGRP_NET",-82,"e0:24:81:49:14:eb",7)
23:16:57.915 ->
23:16:57.915 -> OK
</code>
===== CWJAP - Se connecter à un point d'accès =====
Connecter à un point d'accès l'ESP de nom de réseau **ssid** et de mot de passe **passwd**.
AT+CWJAP="ssid","passwd"
__Exemple de réponse avec AT+CWJAP en echec__
<code>
00:13:39.096 -> AT+CWJAP="ACEGRP_NET","249cb30b415788bdd20c5d3c20"
00:13:46.182 -> WIFI DISCONNECT
00:13:54.427 -> +CWJAP:1
00:13:54.427 ->
00:13:54.427 -> FAIL
</code>
__Exemple de réponse avec AT+CWJAP en réussite__
<code>
00:14:02.538 -> AT+CWJAP="ACEGRP_NET","249cb30b415788bdd20c5d3c20"
00:14:08.763 -> WIFI CONNECTED
00:14:12.671 -> WIFI GOT IP
00:14:13.632 ->
00:14:13.632 -> OK
</code>
===== CIFSR - Renvoi l'adresse IP local =====
AT+CIFSR
Renvoi l'adresse IP local. Il y a une adresse en mode client et une adresse en mode AP.
===== CIPMUX - Permettre des connexions multiples =====
Permet des connexions multiples ou non. L'option **mode** permet d'autoriser (valeur 1) ou non (valeur 0) les connexions multiples.
AT+CIPMUX=mode
===== CIPSERVER - Configurer comme un serveur =====
Configurer l'ESP8266 comme un serveur (**mode** à 1) ou non (**mode** à 0) sur le **port** indiqué. **Port** n'est pas une valeur obligatoire.
AT+CIPSERVER=mode,port
Si **mode** est passé à 0, il faut redémarrer l'ESP8266.
Le **port** par défaut est le 333.
La création d'un serveur n'est possible qu'a condition d'executer en pré requis la commande ''AT+CIPMUX=1''.

55
data/pages/electronique/esp/esp8266ex-restore-commandes-at.txt Normal file
View File

@@ -0,0 +1,55 @@
====== Réinitialiser ESP8266EX avec le Firmware AT Espressif ======
{{ :dummy.png?75x75|ESP8266EX AT Firmware}}
Je vous propose de réinitialiser votre ESP-01, basé sur l'ESP8266EX, afin de retrouver les fonctionnalités de base tel que les commandes AT.
--
Se rendre sur le site https://www.espressif.com/en/products/socs/esp8266ex/resources
{{ :electronique:esp:pasted:20201213-085909.png }}
Dans la section ''AT'', choisir ''ESP8266 NonOS AT Bin V1.7.4'' ou plus récent.
L'archive ZIP téléchargée contient des binaires pour ESP8266EX. Les binaires sont des fichiers compilés depuis un langage avancé tel que le langage C. Nous ne pouvons pas comprendre les fichiers binaires si nous les éditons. Les fichiers binaires peuvent être téléverser dans le microcontrôleur sans autres étapes.
L'archive propose 4 binaires :
* boot - **boot_v1.7.bin**
* programme AT - **user1.1024.new.2.bin**
* data - **esp_init_data_default_v08.bin**
* du vide - **blank.bin**
Une copie des ces binaires pour **ESP8266EX 512k+512k** est disponible à l'adresse https://gitlab.com/cedricAbonnel/esp/-/tree/master/esp01/esp8266ex_at_bin
--
Nous utilisons le programme Pyhton **esptool.py** pour téléverser dans l'ESP8266EX. Il faut au préalable connaitre le port USB sur lequel est branché le circuit. Il faut consulter les fichiers présents dans ''/dev/tty*'' depuis un terminal :
ls /dev/tty*
Parmi la liste retournée, la valeur **/dev/ttyUSB0** nous semble la plus appropriée.
--
Pour téléverser les binaires en ligne de commande, utilisons **esptool.py** :
<code>
esptool.py --port /dev/ttyUSB0 write_flash --flash_mode qio 0x0 boot_v1.7.bin 0x01000 user1.1024.new.2.bin 0xfc000 esp_init_data_default_v08.bin 0x7e000 blank.bin 0xfe000 blank.bin
</code>
Les valeurs précédents le nom des binaires à charger représentent l'emplacement mémoire (adresse mémoire) ou l'écriture doit commencer :
<code>
### Flash size 8Mbit: 512KB+512KB
boot_v1.2+.bin 0x00000
user1.1024.new.2.bin 0x01000
esp_init_data_default.bin 0xfc000
blank.bin 0x7e000 & 0xfe000
</code>
Je verse une larme à l'affichage du résultat :
{{ :electronique:esp:pasted:20201213-094634.png }}
Une vérification s'impose dans une console série.
{{ :electronique:esp:pasted:20201213-094758.png }}

117
data/pages/electronique/esp/familles-et-evolutions.txt Normal file
View File

@@ -0,0 +1,117 @@
====== Familles et évolutions ======
{{tag>"script linux"}}
{{ :dummy.png?75x75|Nom de la section}}
Il existe plusieurs familles d'ESP (System on a Chip - ESP8266, ESP32, etc.), chacune ayant ses propres caractéristiques et fonctionnalités.
{{ :electronique:esp:pasted:20220127-233808.png?240|ESP8266 }}
**ESP8266** : L'ESP8266 st considéré comme l'un des premiers et le plus populaire microcontrôleurs IoT à faible coût avec une connectivité Wi-Fi intégrée, en raison de sa simplicité d'utilisation et de son coût abordable.
La famille d'ESP8266 a évolué au fil du temps pour inclure de nouvelles fonctionnalités et une connectivité Wi-Fi améliorée. Les modèles les plus anciens tels que l'ESP-01 étaient principalement utilisés pour les projets IoT de base, mais les modèles plus récents, tels que l'ESP-12E et l'ESP-32, offrent une connectivité Wi-Fi plus stable et une plus grande capacité de traitement, ainsi que des broches supplémentaires pour des interfaces de communication telles que les ports UART, SPI et I2C. De plus, certains modèles récents d'ESP8266 proposent également un support pour la connectivité Bluetooth, ce qui les rend encore plus polyvalents pour les projets IoT.
* ESP-01
* ESP-01S
* ESP-01M
* ESP-02
* ESP-03
* ESP-04
* ESP-05
* ESP-06
* ESP-07
* ESP-07S
* ESP-08
* ESP-09
* ESP-10
* ESP-11
* ESP-12
* ESP-12E
* ESP-12F
* ESP-12S
* ESP-13
* ESP-14
* ESP-WROOM-02
* ESP-WROOM-02D
* ESP-WROOM-02U
* ESP-WROOM-S2
Voir https://en.wikipedia.org/wiki/ESP8266
---
<WRAP clear/>
{{ ::electronique:esp32.png?256|ESP32}}
L'**ESP32** est une évolution de l'ESP8266, offrant des fonctionnalités supplémentaires telles que le Bluetooth, une plus grande mémoire, des cœurs supplémentaires pour une meilleure gestion des tâches multiples et une meilleure consommation d'énergie.
Certains modèles d'ESP-32 proposent également des fonctionnalités supplémentaires telles que des capteurs intégrés, une connectivité sans fil sécurisée et un support pour des protocoles de communication supplémentaires.
* ESP-WROOM-03
* ESP32-WROOM-32
* ESP32-WROOM-32D
* ESP32-SOLO-1
* ESP32-WROOM-32U
* ESP32-WROVER
* ESP32-WROVER-I
* ESP32-WROVER-B
* ESP32-WROVER-IB
* ESP32-PICO-V3-ZERO
* ESP32-S
* ESP32-A1S
* ESP-32S-ALB
* ALB-WROOM
* ALB32-WROVER
* ESP-WROOM-32
* ESP32-Bit
* ESP-32F
* W32
* W33
* PSH-C32
* W01
* L01
* L04
* S01
* G01
* NINA-W131
* NINA-W132
Voir https://en.wikipedia.org/wiki/ESP32
La famille des '**ESP32-S**, qui se concentre sur les applications à faible coût et à faible consommation d'énergie.
* ESP32-S2
* ESP32-S2-MINI-1
* ESP32-S2-MINI-1U
* ESP32-S2-SOLO
* ESP32-S2-SOLO-U
* ESP32-S2-WROVER
* ESP32-S2-WROVER-I
* ESP32-S2-WROOM
* ESP32-S2-WROOM-I
* ESP32-S3
* ESP32-S3-WROOM-1
* ESP32-S3-WROOM-1U
* ESP32-S3-WROOM-2
* ESP32-S3-MINI-1
* ESP32-S3-MINI-1U
Famille des **ESP32-C**
* ESP32-C3-MINI-1
* ESP32-C3-MINI-1U
* ESP32-C3-WROOM-02
* ESP32-C3-WROOM-02U
* ESP32-C6
Famille des **ESP32-H**
* ESP32-H2
---
--- //[[user:cedricabonnel]]//

114
data/pages/electronique/esp/index.txt Normal file
View File

@@ -0,0 +1,114 @@
====== ESP ======
{{ ::electronique:esp32.png?75x75|ESP}}
Les **ESP** (Espressif Systems Processor) sont des microcontrôleurs avec un module **Wi-Fi intégré**, conçus pour le développement **IoT** (Internet of Things). Ils sont souvent utilisés pour la conception de produits intelligents pour la maison, la vie personnelle et l'industrie. Les **ESP** peuvent être programmés à l'aide d'un environnement de développement intégré (IDE) similaire à celui d'**Arduino**, ce qui en fait un choix populaire pour les développeurs débutants et expérimentés. Il existe plusieurs familles d'**ESP**, chacune avec ses propres caractéristiques et fonctionnalités uniques, telles que la mémoire flash, la RAM, les ports GPIO, etc. Les produits les plus populaires de la famille **ESP** incluent l'**ESP8266** et l'**ESP32**.
===== Comparaison des differéntes familles =====
^ ^ ESP8266 ^ ESP32 ^ ESP32-C3 ^
^ Date de sortie | 2014 | 2016 | 2020 |
^ MCU | Xtensa Single-Core 32-bit | Xtensa Dual-Core 32-bit | RISC-V 32-bit Single-Core |
^ Fréquence | 80 MHz | 160 à 240 MHz | 160 MHz |
^ RAM / SRAM | 160 Ko | 520 Ko | 400 Ko |
^ Wifi | 802.11b/g/n (max 65Mbps) | 802.11b/g/n | 802.11b/g/n |
^ Bluetooth | non | 4.2 et BLE | 5.0 et BLE |
^ ESP Mesh | oui | oui | oui |
^ Capteur T° integré | non | oui | oui |
^ Capteur Effet Hall | non | oui | non |
^ GPIO | 17 | 36 | 22 |
^ Crypto Support | non | AES, SHA-2, RSA, ECC, RNG | AES-128/256, RSA Accelerator, SHA Accelerator, Random Number Generator (RNG), HMAC |
^ Consommation en veille | 20 µA | 5 µA | 5 µA\\ 1 µA en mode arrêt |
===== Table des matières =====
* [[.:|Introduction]]
--
** ESP8266 ** : un microcontrôleur Wi-Fi à faible coût utilisé pour construire des projets IoT (Internet des objets) et domotiques.
* [[.:programmer-esp-avec-arduino-ide]]
* [[.:specifications-ESP-8266]]
* [[https://arduino-esp8266.readthedocs.io/en/latest/|ESP8266 Arduino Core’s documentation]]
* [[https://github.com/esp8266/Arduino|Arduino core for the ESP8266]]
* **ESP-01**
* [[.:specifications-ESP-01]]
* [[.:premier-programme-esp01]]
* ** ESP-12F **
* [[.:doiting-esp-12f:]]
**ESP32** : un autre microcontrôleur Wi-Fi et Bluetooth doté de plus de mémoire et de puissance de traitement que l'ESP8266.
* ** Infos concernant la Famille des ESP32 **
* [[.:programmer-esp32-avec-arduino-ide]]
* [[https://github.com/espressif/arduino-esp32|Arduino core for the ESP32]]
* [[https://docs.espressif.com/projects/esp-idf/en/latest/esp32/index.html|ESP32 Programming Guide]]
* ** Infos concernant la Famille des ESP32-S **
* [[.:programmer-esp32-avec-arduino-ide]]
* [[https://docs.espressif.com/projects/esp-idf/en/latest/esp32s2/index.html|ESP32-S2 Programming Guide]]
* [[https://docs.espressif.com/projects/esp-idf/en/latest/esp32s3/index.html|ESP32-S3 Programming Guide]]
* ** Infos concernant la Famille des ESP32-C **
* [[.:programmer-esp32-avec-arduino-ide]]
* [[.:specifications-ESP32-C3]]
* [[https://docs.espressif.com/projects/esp-idf/en/latest/esp32c3/index.html|ESP32-C3 Programming Guide]]
* **ESP32-H2**
* [[.:specifications-ESP32-H2]]
**Adaptateurs USB vers ESP** : des dispositifs permettant de connecter des ESP à un ordinateur via USB pour la programmation et le débogage.
* [[.:adapteur-usb-esp01]]
**Programmation de l'ESP** : comment écrire et charger du code sur l'ESP pour contrôler les périphériques connectés.
* [[.:installer-logiciel-arduino-ide]]
**Communiquer avec l'ESP**
* [[.:communiquer-avec-un-ESP-32]]
* [[.:se-connecter-a-un-reseau-wifi]]
* [[.:creer-un-point-d-acces]]
* [[.:wifi-manager]]
Les commandes AT
* [[.:esp8266-commandes-at]]
* [[.:esp8266ex-restore-commandes-at]]
SPIFFS
* [[electronique:esp:telechargement-de-donnees-esp32-spiffs]]
Mise à jour OTA
* [[electronique:esp:mises-a-jour-ota-over-the-air-de-l-esp32]]
IRemote
* [[electronique:esp:iremote]]
Serveur NTP
* [[electronique:esp:serveur-ntp]]
**Interaction de l'ESP avec d'autres périphériques** : comment utiliser l'ESP pour contrôler des appareils tels que des moteurs, des capteurs et des écrans.
**Sécurité de l'ESP** : comment protéger les projets IoT contre les attaques en ligne en utilisant des techniques telles que le cryptage et l'authentification.
--
** [[Références et bibliographies Arduino et ESP]] **
--

1
data/pages/electronique/esp/installer-logiciel-arduino-ide.txt Normal file
View File

@@ -0,0 +1 @@
{{page>:electronique:arduino:105-installation-du-logiciel-arduino-ide}}

4
data/pages/electronique/esp/iremote.txt Normal file
View File

@@ -0,0 +1,4 @@
====== Bibliothèque IRemote ======
https://github.com/Arduino-IRremote/Arduino-IRremote

5
data/pages/electronique/esp/mises-a-jour-ota-over-the-air-de-l-esp32.txt Normal file
View File

@@ -0,0 +1,5 @@
====== Mises à jour OTA (Over-the-Air) de l’ESP32 ======
https://randomnerdtutorials.com/esp32-ota-over-the-air-arduino/

75
data/pages/electronique/esp/module-relais-wifi-esp.txt Normal file
View File

@@ -0,0 +1,75 @@
====== Module relais wifi ESP ======
{{ :electronique:esp:pasted:20210327-090456.png?75x75|Module de contrôleur de relais WIFI sans fil basé sur un ESP.}}
Cet article est en cours de rédaction. Il manque des informations essentielles à la compréhension et à la réalisation de l'exemple. Vous pouvez participer à la rédaction de cet article en vous inscrivant ou en laissant un message dans les commentaires.
===== Composants principaux de la carte =====
{{:electronique:esp:pasted:20210327-090529.png}}
===== Détail des connecteurs =====
{{:electronique:esp:pasted:20210327-090543.png}}
^ N° ^ Désignation ^
| 1 | VCC, GND: alimentation cc 8-80V |
| 2 | Micro USB: alimentation USB cc 5V\\ Remarque: DC8-80V/DC5V USB/broche d'en-tête 5V peut choisir l'une des trois méthodes d'alimentation. Bouton 3,6x6mm: bouton de réinitialisation ESP8266 |
| 3 | Bouton reset |
| 4 | Port UART: GND, RX, TX, 5V\\ Sont respectivement connectés au GND, TX, RX, 5V de l'ESP8266. Module de port série TTL externe.\\ IO0 doit être connecté à GND pour télécharger. Une fois le téléchargement terminé, déconnectez la connexion IO0 et GND. |
| 5 | Report GPIO de l'ESP8266 |
| 6 | Sortie de relais\\ NC: relais normalement fermé. Le relais est relié avec le COM\\ COM: commun du relais;\\ NON: relais normalement ouvert. Il est relié au COM après avoir reçu la commande. |
| 7 | Indicateur de puissance LED |
| 8 | LED Programmable: utilisez le contrôle GPO16 |
| 9 | Indicateur de relais LED: s'allume lorsqu'il est fermé. |
===== Vue du dessous =====
{{:electronique:esp:pasted:20210327-091509.png}}
===== ESP-12F =====
{{:electronique:esp:pasted:20210327-091523.png}}
{{:electronique:esp:pasted:20210327-091544.png}}
^ PIN ^ Désingation ^
| GND | Terre |
| GPIO15 | MTDO; HSPICS; UARTO-RTS |
| GPIO2 | GPIO4 |
| GPIO0 | |
| GPIO5 | port d'entraînement de relais, l'entraînement de IO5 est utilisé par défaut. Si vous voulez utiliser d'autres e/s pour conduire le relais, vous pouvez supprimer e14, puis connecter les e/s du relais d'entraînement à cette broche de relais |
| GPIO4 | |
| RXD0 | RX: UARTO-RXD: GPIO3 |
| TXD0 | UARTO-TXD; GPIO1 |
| RST | |
| ADC | résultat de conversion A/n. Plage de tension d'entrée: 0 ~ 1V, plage de valeur: 0 ~ 1024 |
| EN | |
| GPIO16 | |
| GPIO14 | |
| GPIO12 | HSPI-MISO |
| GPIO13 | |
| VCC | Alimentaiton 3v3 |
| CS0 | sélection de puce |
| MISO | sortie esclave et entrée hôte |
| GPIO9 | |
| GPIO10 | |
| MOSI | sortie hôte et entrée esclave |
| SCLK | horloge |
===== Caractéristiques du relais =====
* Switching capacity available by 10A in spite of small size design for highdensity P.C. board mounting technique.
* UL,CUL,TUV recognized.
* Selection of plastic material for high temperature and better chemical solution performance.
* Sealed types available.
* Simple relay magnetic circuit to meet low cost of mass production.
{{:electronique:esp:pasted:20210327-095627.png}}
{{ :electronique:esp:srd-12vdc-xx-x_etc.pdf |}}

59
data/pages/electronique/esp/premier-programme-esp01.txt Normal file
View File

@@ -0,0 +1,59 @@
====== Premier programme ESP-01 ======
{{ :dummy.png?75x75|Premier programme ESP-01}}
Je vous propose un programme qui affichera dans la console série, des informations utiles concernant votre ESP-01.
<code C>
ADC_MODE(ADC_VCC);
void setup()
{
Serial.begin(115200);
}
void loop()
{
/* ESP8266EX */
Serial.println("INFO ESP8266EX");
Serial.printf("Numéro de série de l'ESP8266EX .....: %u\n", ESP.getChipId());
float frequenceCpu = float(ESP.getCpuFreqMHz());
Serial.printf("Fréquence du CPU ...................: %4.1f MHz\n", frequenceCpu);
float vcc = float(ESP.getVcc()) / 1000;
Serial.printf("Alimentation .......................: %4.2f V\n", vcc);
String chaine = ESP.getCoreVersion();
chaine.replace('_', '.');
Serial.print("Version du gestionnaire de carte...: ");
Serial.println(chaine);
Serial.printf("Version du SDK .....................: %s\n\n", ESP.getSdkVersion());
/* Mémoire flash */
Serial.println("INFO FLASH");
Serial.printf("Numéro de série du chip ............: %u\n", ESP.getFlashChipId());
float frequenceFlash = float(ESP.getFlashChipSpeed()) /1000000;
Serial.printf("Fréquence ..........................: %4.1f MHz\n", frequenceFlash);
Serial.printf("capacité effective .................: %u octets\n", ESP.getFlashChipRealSize());
Serial.printf("capacité paramétrée dans l'EDI .....: %u octets\n", ESP.getFlashChipSize());
Serial.printf("Taille du sketch ...................: %u octets\n", ESP.getSketchSize());
Serial.printf("Mémoire disponible .................: %u octets\n\n\n", ESP.getFreeSketchSpace());
delay(10000);
}
</code>
Consultez la dernière version de ce programme à l'adresse {{https://gitlab.com/cedricAbonnel/esp/-/blob/master/esp01/infoesp8266exp.ino}}
Le résultat est le suivant
<code>
23:22:50.073 -> INFO ESP8266EX
23:22:50.073 -> Numéro de série de l'ESP8266EX .....: 10106374
23:22:50.073 -> Fréquence du CPU ...................: 80.0 MHz
23:22:50.106 -> Alimentation .......................: 3.47 V
23:22:50.106 -> Version du gestionnaire de carte...: 2.7.4
23:22:50.106 -> Version du SDK .....................: 2.2.2-dev(38a443e)
23:22:50.106 ->
23:22:50.106 -> INFO FLASH
23:22:50.106 -> Numéro de série du chip ............: 1327304
23:22:50.106 -> Fréquence ..........................: 40.0 MHz
23:22:50.106 -> capacité effective .................: 1048576 octets
23:22:50.106 -> capacité paramétrée dans l'EDI .....: 1048576 octets
23:22:50.106 -> Taille du sketch ...................: 268288 octets
23:22:50.139 -> Mémoire disponible .................: 778240 octets
</code>

72
data/pages/electronique/esp/programmer-esp-avec-arduino-ide.txt Normal file
View File

@@ -0,0 +1,72 @@
====== Programmer un ESP8266 avec Arduino IDE ======
Nous utiliserons la carte de développement (DevKit) NodeMCU v3 avec un **circuit intégré ESP8266MOD** soudé.
Cette carte peut être programmée avec **Arduino IDE**.
{{ :electronique:esp:pasted:20201206-195401.png }}
Il va donc falloir mettre à jour l'IDE Arduino pour pouvoir l'adapter à ce nouveau module.
L'IDE Arduino est très flexible. Comme pour la partie matériel, l'idée est de mettre à disposition de l'utilisateur un produit puissant, flexible et très simple à utiliser. Il va donc falloir passer par une étape de configuration qui va nous permettre de programmer sur notre module ESP comme sur un Arduino.
Dans un premier temps, on va indiquer au programme que l'on a besoin d'installer une nouvelle carte (board) et préciser où l'on va pouvoir récupérer ces informations.
Dans l'IDE, aller dans //Fichiers//=>//Préférences//.
{{ electronique:arduino:idearduino_fichier_preferences.png?nolink |}}
Une fenêtre intitulé //Préférences//.
{{ electronique:arduino:idearduino_preferences.png?nolink |}}
Dans le champs intitulé //URL de gestionnaire de cartes supplémentaires// , coller l'URL suivante :
http://arduino.esp8266.com/stable/package_esp8266com_index.json
Si le site précédent (arduino.esp8266.com) ne répond pas, je vous donne une variante :
https://github.com/esp8266/Arduino/blob/master/package/package_esp8266com_index.template.json
{{ electronique:arduino:idearduino_preferences_url_de_gestionnaire_de_cartes_supplementaires.png?nolink |}}
Puis cliquer sur le bouton {{electronique:arduino:bouton_ok.png?nolink|Ok}}
On va installer la carte correspondant au NodeMCU.
Aller dans //Outils// => //Type de carte// => //Gestionnaire de carte//
{{ electronique:arduino:idearduino_outils_typedecarte_gestionnairedecarte.png?nolink |}}
Le fenêtre de //Gestionnaire de carte// s'ouvre. Saisir dans le champ de recherche le nom ''ESP8266''.
{{ electronique:arduino:idearduino_gestionnairedecarte_esp8266.png?nolink |}}
Cliquer à l'intérieur du cadre //esp8266//. Un bouton //Installer// apparaît à côté de la version disponible. Cliquer dessus pour installer...
{{ electronique:arduino:idearduino_gestionnairedecarte_esp8266_installer.png?nolink |}}
L'installation des fichiers commence. L'IDE va aller récupérer le compilateur, des sources de librairies et tout ce qu'il faut pour pouvoir utiliser l'ESP8266 comme un Arduino.
{{ electronique:arduino:idearduino_gestionnairedecarte_esp8266_installer_progression.png?nolink |}}
L'indicateur ''INSTALLED'' apparait. L'IDE est maintenant capable de compiler un logiciel pour l'ESP8266 et le téléverser sur votre carte.
{{ electronique:arduino:idearduino_gestionnairedecarte_esp8266_installed.png?nolink |}}
Maintenant, on indique à l'IDE d'utiliser les éléments pour la carte ESP8266.
Aller dans //Outils// => //Type de carte//.
{{ electronique:arduino:idearduino_outils_typedecarte.png?nolink |}}
Sélectionner dans la longue liste, //NodeMCU 1.0 (ESP-12E Module)//.
{{ electronique:arduino:idearduino_outils_typedecarte_nodemcu.png?nolink |}}
Enfin, il faudra sélectionner le port de communication.
{{ electronique:arduino:idearduino_outils_port_devttyusb3.png?nolink |}}
On pourra vérifier que la communication soit bien initialisée en utilisant //Outils// => //Get Board Info//
{{ electronique:arduino:idearduino_outils_getboardinfo.png?nolink |}}

68
data/pages/electronique/esp/programmer-esp32-avec-arduino-ide.txt Normal file
View File

@@ -0,0 +1,68 @@
====== Programmer un ESP32 avec Arduino IDE ======
Nous utiliserons la carte de développement (DevKit) NodeMCU ESP C3 avec un **circuit intégré ESP-C3-32S** soudé.
Cette carte peut être programmée avec **Arduino IDE**.
{{ :electronique:esp:pasted:20220127-162544.png?noLink | ESP32 C3 32S}}
Il va donc falloir mettre à jour l'IDE Arduino pour pouvoir l'adapter à ce nouveau module.
L'IDE Arduino est très flexible. Comme pour la partie matériel, l'idée est de mettre à disposition de l'utilisateur un produit puissant, flexible et très simple à utiliser. Il va donc falloir passer par une étape de configuration qui va nous permettre de programmer sur notre module ESP comme sur un Arduino.
Dans un premier temps, on va indiquer au programme que l'on a besoin d'installer une nouvelle carte (board) et préciser où l'on va pouvoir récupérer ces informations.
Dans l'IDE, aller dans //Fichiers//=>//Préférences//.
{{ electronique:arduino:idearduino_fichier_preferences.png?nolink |}}
Une fenêtre intitulé //Préférences//.
{{ electronique:arduino:idearduino_preferences.png?nolink |}}
Dans le champs intitulé //URL de gestionnaire de cartes supplémentaires// , coller l'URL suivante :
https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_dev_index.json
{{ electronique:arduino:idearduino_preferences_url_de_gestionnaire_de_cartes_supplementaires.png?nolink |}}
Puis cliquer sur le bouton {{electronique:arduino:bouton_ok.png?nolink|Ok}}
On va installer la carte correspondant au NodeMCU.
Aller dans //Outils// => //Type de carte// => //Gestionnaire de carte//
{{ electronique:arduino:idearduino_outils_typedecarte_gestionnairedecarte.png?nolink |}}
Le fenêtre de //Gestionnaire de carte// s'ouvre. Saisir dans le champ de recherche le nom ''ESP32''.
{{ :electronique:esp:pasted:20220127-155732.png?noLink |Recherche d'ESP32 dans le Gestionnaire de carte}}
Cliquer à l'intérieur du cadre //esp32//. Un bouton //Installer// apparaît à côté de la version disponible. Cliquer dessus pour installer...
{{ :electronique:esp:pasted:20220127-155807.png?noLink | Clique sur le bouton Installer}}
L'installation des fichiers commence. L'IDE va aller récupérer le compilateur, des sources de librairies et tout ce qu'il faut pour pouvoir utiliser l'ESP8266 comme un Arduino.
{{ :electronique:esp:pasted:20220127-155425.png?noLink |Progression de l'installation dans le Gestionnaire de carte}}
L'indicateur ''INSTALLED'' apparait. L'IDE est maintenant capable de compiler un logiciel pour l'ESP8266 et le téléverser sur votre carte.
{{ :electronique:esp:pasted:20220127-155644.png?noLink |esp32 installé}}
Maintenant, on indique à l'IDE d'utiliser les éléments pour la carte **ESP32 Arduino** .
Aller dans //Outils// => //Type de carte//.
{{:electronique:esp:pasted:20220127-162228.png?noLink | menu Outils, type de carte}}
Sélectionner dans la longue liste, //ESP32C3 Dev Module//.
{{ :electronique:esp:pasted:20220127-162151.png?noLink | Selection type de carte ESP32C3}}
Enfin, il faudra sélectionner le port de communication.
{{ electronique:arduino:idearduino_outils_port_devttyusb3.png?nolink |}}
On pourra vérifier que la communication soit bien initialisée en utilisant //Outils// => //Get Board Info//
{{ electronique:arduino:idearduino_outils_getboardinfo.png?nolink |}}

147
data/pages/electronique/esp/references-et-bibliographies-arduino-et-esp.txt Normal file
View File

@@ -0,0 +1,147 @@
====== Références et bibliographies Arduino et ESP ======
__Livre **Arduino, Maîtrisez sa programmation et ses cartes d'interface (shields)**__
[[https://amzn.to/3G7yIQu|{{:electronique:esp:pasted:20220128-082624.png?248 }}]]
de **Christian Tavernier**
* [[https://amzn.to/3G7yIQu|Commander le livre]]
* [[https://amzn.to/3G7yIQu|Commander le Kindle]]
**Notes de l'éditeur :**
Après un bref rappel de ce qu’est un microcontrôleur et une présentation des différentes versions d’Arduino, cet ouvrage fournit tous les éléments nécessaires à la conception et à la mise en oeuvre de nombreuses applications performantes avec notamment :
* la présentation complète de la syntaxe du langage de programmation ;
* plusieurs dizaines de schémas d’interfaces avec les dispositifs les plus divers (afficheurs, moteurs, relais, capteurs, bus I2C, SPI, Ethernet, etc.) ;
* plusieurs dizaines d’exemples de programmes types permettant la mise en oeuvre de ces interfaces.
Accessible sans connaissances préalables en électronique ou en programmation, cette nouvelle édition mise à jour s’adresse aussi bien à l’amateur passionné, qu’au professionnel désireux d’intégrer des Arduino dans ses applications. Chacun pouvant y trouver selon son niveau le degré d’information requis.
**Commentaires :**
Surement le meilleur ouvrage. Démarche très étudiée et les informations sont pertinentes. Il aborde de façon très claire et bien structurée la programmation de l'Arduino puis la réalisation de circuits.
<WRAP clear/>
---
__Livre **Mouvement, lumière et son avec Arduino et Raspberry Pi**__
[[https://amzn.to/3ucTZpD|{{:electronique:esp:pasted:20220128-084748.png?248 }}]]
Avec 30 projets ludiques (Serial makers) de **Simon Monk**
* [[https://amzn.to/3ucTZpD|Commander le livre]]
* [[https://amzn.to/3r7zIzL|Commander le Kindle]]
**Notes de l'éditeur :**
Cet ouvrage à vocation pratique explique comme créer et contrôler des mouvements, de la lumière et du son à l'aide d'un Arduino et d'un Raspberry Pi. Avec à l'appui 30 projets ludiques à réaliser, il détaille comment utiliser ces deux plates-formes pour contrôler des LED, des moteurs de divers types, des bobines, des dispositifs à courant alternatif, des pompes, ou encore des systèmes d'affichage ou de production de sons. Il se clôt par des projets permettant de contrôler des mécanismes et des systèmes avec Internet, faisant ainsi pénétrer le lecteur dans le monde des objets connectés. Le maker, qui aura déjà eu l'occasion d'utiliser un Arduino ou un Raspberry Pi pour mesurer le monde réel à l'aide de capteurs, passera ici à l'action en découvrant les bases de l'automatisation.
Dans ce livre, vous apprendrez notamment à :
* créer un système d'arrosage automatique de vos plantes avec Arduino
* mettre au point un rafraîchisseur de boissons
* fabriquer une marionnette qui danse en fonction de vos tweets
* concevoir un éclateur aléatoire de ballon
Téléchargez le code source des programmes Arduino et Raspberry Pi présentés dans cet ouvrage sur www.serialmakers.com
**Commentaires :**
Toutes les explications sont claires et précises. Idéal pour débuter mais aussi pour l'utilisateur confirmé.
Les comparaisons Arduino - Raspberry PI sont très utiles.
<WRAP clear/>
---
__Livre **Arduino pour la domotique**__
[[https://amzn.to/3G8tl3e|{{:electronique:esp:pasted:20220128-083115.png?248 }}]]
de **Marc-Olivier Schwartz**
* [[https://amzn.to/3G8tl3e|Commander le livre]]
* [[https://amzn.to/3G8tl3e|Commander le Kindle]]
**Notes de l'éditeur :**
Cet ouvrage est un guide pas-à-pas de projets concrets avec des exemples de code, des schémas et des photos pédagogiques.
Il se termine par une introduction à l'impression 3D pour réaliser soi-même les boîtiers dans lesquels encastrer circuits et capteurs.
<WRAP clear/>
---
__Livre **Arduino le guide complet**__
[[https://amzn.to/3o7F0Jv|{{:electronique:esp:pasted:20220128-083453.png?248 }}]]
Une référence pour ingénieurs, techniciens et bricoleurs de **John Malcolm Hughes**
* [[https://amzn.to/3o7F0Jv|Commander le livre]]
* [[https://amzn.to/3o7F0Jv|Commander le Kindle]]
**Notes de l'éditeur :**
Le livre le plus complet sur Arduino et son environnement de programmation.
JM Hughes est ingénieur système et possède 30 ans d'expérience dans le domaine de l'électronique. Il est spécialisé dans le domaine de l'aérospatiale. Il a piloté le projet informatique associé au Phoenix Mars Lander, la sonde spatiale qui s'est posée sur la planète Mars en 2008.
Au programme :
* La famille Arduino
* Le micro-contrôleur AVR
* Programmer Arduino
* Utiliser le langage C et C++
* Les bibliothèques Arduino
* Les modules d'entrées/sorties
* Élaborer 4 projets grandeur nature
**Commentaires :**
Ce guide ressemble plus à un inventaire des produits (shields) disponibles avec les différentes cartes ARDUINO qu'à un ouvrage sur les possibilités de ces cartes de développement.
<WRAP clear/>
---
__Magazine français **Hackable**__
{{:electronique:esp:pasted:20220128-075944.png?248 }}
Né en 2014, Hackable est un magazine destiné aux professionnels et particuliers souhaitant découvrir et progresser dans les domaines de l’électronique numérique et de l’embarqué. Il fournit un contenu riche. Le contenu du magazine est conçu de manière à permettre une mise en pratique directe des connaissances acquises et apprendre tout en faisant.
<WRAP clear/>
---
__Livre **Arduino, Applications avancées**__
[[https://amzn.to/3g2sXZt|{{:electronique:esp:pasted:20220128-081229.png?noLink&248 }}]]
Claviers tactiles, télécommande par Internet, géolocalisation, applications sans fil... (Technologie électronique) de **Christian Tavernier**
* [[https://amzn.to/3g2sXZt|Commander le livre]]
* [[https://amzn.to/3g2sXZt|Commander le Kindle]]
**Notes de l'éditeur :**
Ce livre présente des montages électroniques programmables complexes et ambitieux.
Il aborde ainsi des concepts et des interfaces dits "évolués" tels que :
* la connexion aux réseaux (notamment à Internet) que ce soit en mode filaire ou sans fil,
* l'utilisation de modules GSM pour exploiter Arduino via un téléphone mobile,
* l'utilisation de cartes mémoire SD
* le couplage à des modules GPS pour réaliser des applications géolocalisées,
* l'utilisation de la synthèse et de la reconnaissance vocale.
Les programmes nécessaires à leur mise en oeuvre sont fournis dans les suppléments en ligne de l'ouvrage.
Un premier chapitre de "remise à niveau" permet à ceux qui n'auraient pas lu le premier ouvrage d'aborder néanmoins celui-ci sans difficulté.
<WRAP clear/>

46
data/pages/electronique/esp/se-connecter-a-un-reseau-wifi.txt Normal file
View File

@@ -0,0 +1,46 @@
====== Se connecter à un réseau Wifi ======
Les extraits de codes suivants ont été testés avec un **Espressif ESP8266** / **ESP 12F** soudé sur une carte **NodeMcu V3**.
Un connexion **Wifi Client** permet d'indiquer à l'**ESP** de se connecter à un réseau Wifi, désigné dans notre code par la variable **wifi_ssid**, utilisée par la méthode **WiFiMulti.addAP**. Il est également possible d'indiquer un mot de passe en tant que second paramètre (''WiFiMulti.addAP(wifi_ssid, "mot de passe");'').
<code C esp8266-wifi-client.ino>
#include <ESP8266WiFi.h>
#include <ESP8266WiFiMulti.h>
const char* wifi_ssid = "AP_for_Alpinux_FABLAB";
ESP8266WiFiMulti WiFiMulti;
void setup() {
Serial.begin(115200);
delay(1000);
Serial.println("\n");
// Tentative de connexion Wifi
WiFi.mode(WIFI_STA);
WiFiMulti.addAP(wifi_ssid);
Serial.print("Tentative de connexion au Wifi .");
while (WiFiMulti.run() != WL_CONNECTED) {
Serial.print(".");
delay(500);
}
Serial.println("\n");
Serial.println("Connexion Wifi réussie");
Serial.print("Adresse IP : ");
Serial.println(WiFi.localIP());
}
void loop() {
}
</code>
Voilà le résultat dans le **moniteur série** de l'application **Arduino IDE**.
{{:electronique:esp:pasted:20201111-233656.png}}

3
data/pages/electronique/esp/serveur-ntp.txt Normal file
View File

@@ -0,0 +1,3 @@
====== Serveur NTP ======
https://www.elektormagazine.fr/labs/ntp-server

5
data/pages/electronique/esp/sidebar.txt Normal file
View File

@@ -0,0 +1,5 @@
{{ ::electronique:esp32.png?75x75 |ESP ESP-01 ESP8266}}
<WRAP clear/>
{{page>index#table-des-matieres}}
~~NOCACHE~~

57
data/pages/electronique/esp/specifications-esp-01.txt Normal file
View File

@@ -0,0 +1,57 @@
====== Spécifications de l'ESP-01 ======
{{ :electronique:esp:pasted:20220128-103802.png?128|Image d'un ESP-01}}
L'[[https://amzn.to/3oAwIaR|ESP-01]] est un circuit imprimé avec pour caractéristique un **microcontrôleur ESP8266EX**, une **mémoire SPI Flash** de 1 MB à 16 MB, une **antenne sur PCB de 3 dBi** et un **connecteur 8 broches**.
> Acheter un [[https://amzn.to/3oAwIaR|ESP-01 basé sur ESP8266]]
L'**ESP-01** ne possède pas d'interface USB. Cela va nécessiter un montage complémentaire pour le programmer. Un **adaptateur USB vers série pour ESP8266EX** permettra dans un premier temps d'interagir avec l'**ESP-01**, depuis un ordinateur avec port USB.
Avant tout, nous allons comprendre la différence entre **ESP8266EX** et **ESP-01**. L'**ESP8266EX** représente le circuit intégré, le composant principal, alors que l'**ESP-01** est le circuit imprimé intégrant les composants, connecteurs et circuit PCB.
<WRAP clear/>
__DataSheet ESP-01__
__Schéma des connecteurs ESP-01__
{{ :electronique:esp:pasted:20220128-110155.png |Schéma des connecteurs de la carte PINOUT ESP-01 }}
<WRAP clear/>
Sur le ESP-01, il y a 8 connecteurs reliés directement à l' ESP8266EX.
* 2 pour l'alimentation (VCC) et la masse (GND).
* 2 pour la réception (RX) et l’émission de données (TX) avec l'UART.
* 2 connectées à la GPIO (GPIO0 et GPIO2)
* et 2 autres (RST) et (CH_PD)
<WRAP clear/>
{{ :electronique:esp:pasted:20201207-233302.png?300|ESP-01 avec connecteur USB CH360}}
Lorsque l'on connecte un **circuit imprimé ESP-01** avec un **adaptateur USB** basé sur une puce **CH360**, le circuit effectue un pont entre l'ESP-01 et l'ordinateur. Il se connecte sur la port série UART de l'ESP8266.
<WRAP clear/>
===== Fiche technique / datasheet =====
Vous pouvez télécharger le datasheet : {{ :electronique:esp:esp01.pdf |ESP 01 Wifi Module}}
{{ :electronique:esp:pasted:20201209-085932.png |DataSheet l'ESP-01}}
===== Configurer l'IDE Arduino =====
{{ :electronique:esp:pasted:20201212-183454.png|Paramétrage Arduino Uno}}
Je vous invite à consulter la page dédiée à [[electronique:esp:installer-logiciel-arduino-ide|l'installation de logiciel IDE Arduino]] et au paramétrage de celui-ci pour intégrer les [[electronique:esp:programmer-esp-avec-arduino-ide|paramètres pour les circuits ESP]].
Ensuite, il faut modifier quelques paramètres.
Pour l’**ESP-01** il faut sélectionner le **Generic ESP8266 module** et modifier les paramètres selon votre carte ! Dans la plupart des cas dont le mien, pas besoin de toucher à quoique se soit mise à part le port série sur lequel votre carte est branchée.
<WRAP clear/>

120
data/pages/electronique/esp/specifications-esp-8266.txt Normal file
View File

@@ -0,0 +1,120 @@
====== Spécifications de l'ESP8266 ======
L'**ESP826** est un **micro controleur** bas coût avec une capacité de communication **Wifi** en protocole TCP/IP. Le développement est assuré **Espressif Systems**, société publique de Chine de portée multi nationale (Repulbique Tchèque, Inde, Brésil, Singapour).
===== - Spécifications techniques =====
* Processeur : Microprocesseur RISC L106 32-bit basé sur le processeur **Tensilica Xtensa Diamond Standard 106Micro** cadencé à 80 MHz
* Memory:
* 32 KiB instruction RAM
* 32 KiB instruction cache RAM
* 80 KiB user-data RAM
* 16 KiB ETS system-data RAM
* External QSPI flash: up to 16 MiB is supported (512 KiB to 4 MiB typically included)
* IEEE 802.11 b/g/n Wi-Fi
* Integrated TR switch, balun, LNA, power amplifier and matching network
* WEP or WPA/WPA2 authentication, or open networks
* 17 GPIO pins
* Serial Peripheral Interface Bus (SPI)
* I²C (software implementation)[7]
* I²S interfaces with DMA (sharing pins with GPIO)
* UART on dedicated pins, plus a transmit-only UART can be enabled on GPIO2
* 10-bit ADC (successive approximation ADC)
===== - Circuits intégrés (modules) =====
Il existe deux principaux constructeurs de circuits intégrés (modules) **ESP8266** :
__Circuits intégrés **Ai-Thinker**__
{{ :electronique:ai-thinker.png?100|Logo Ai-Thinker}}
* ESP-01
* ESP-01S
* ESP-01M
* ESP-02
* ESP-03
* ESP-04
* ESP-05
* ESP-06
* ESP-07
* ESP-07S
* ESP-08
* ESP-09
* ESP-10
* ESP-11
* ESP-12
* ESP-12E
* ESP-12F
* ESP-12S
* ESP-13
* ESP-14
<WRAP clear/>
__Circuits intégrés **Espressif**__
{{ :electronique:espressif-logo-pratik-panda-clients-2.png?100|Logo Espressif}}
* ESP-WROOM-02
* ESP-WROOM-02D
* ESP-WROOM-02U
* ESP-WROOM-S2
<WRAP clear/>
+ d'infos : https://en.wikipedia.org/wiki/ESP8266
===== - Cartes de développement (SDK) =====
La carte de développement intègre le **circuit intégré** avec le nécessaire pour réaliser des montages rapidement.
La première version de l'**ESP866** est sortie en 2014 avec différentes cartes de développement : NodeMCU DEVKIT, Ai-Thinker ESP01, WeMos, Adafruit, SparkFun ...
==== - ESP-01 ====
Voir la page [[electronique:esp:specifications-esp-01|]]
==== - AI Thinker ESP8266MOD ====
{{ :electronique:esp:nodemcuv3.0-pinout.jpg |AI Thinker ESP8266MOD}}
<WRAP clear/>
==== - Espressif ESP-12E ====
__Schéma des connecteurs ESP-12E__
{{ :electronique:esp:pasted:20220128-104522.png |Schéma des connecteurs de la carte PINOUT ESP-01}}
==== DOITING ESP 12F ====
Ver 0.1
[[.:doiting-esp-12f:|plus d'infos]]
<WRAP clear/>
--- //[[user:CédricABONNEL]] 2022/01/28 09:05//

38
data/pages/electronique/esp/specifications-esp32-c3.txt Normal file
View File

@@ -0,0 +1,38 @@
====== Spécifications de l'ESP32-C3 ======
<WRAP center round important 60%>
En cours de rédaction
Le contenu peut être faux
</WRAP>
L'[[https://amzn.to/3KPSx2b|ESP32-C3]] est un circuit imprimé avec pour caractéristique un **microcontrôleur ESP32 série C**.
> Acheter un [[https://amzn.to/3KPSx2b|ESP32-C3, le successeur de l'ESP32]]
<WRAP clear/>
===== Fiche technique / datasheet =====
Vous pouvez télécharger les datasheets :
* {{ :electronique:esp:esp32-c3_datasheet_en.pdf |ESP32-C3}}
* {{ :electronique:esp:esp-c3-32s-kit-v1.0_specification.pdf |Ai ESP-c3-32s}}
{{ :electronique:esp:pasted:20220128-004933.png |esp32-c3-devkitm-1-v1-pinout}}
===== Configurer l'IDE Arduino =====
{{ :electronique:esp:pasted:20201212-183454.png|Paramétrage Arduino Uno}}
Je vous invite à consulter la page dédiée à [[electronique:esp:installer-logiciel-arduino-ide|l'installation de logiciel IDE Arduino]] et au paramétrage de celui-ci pour intégrer les [[:electronique:esp:programmer-esp32-avec-arduino-ide|paramètres pour les circuits ESP32]].
Ensuite, il faut modifier quelques paramètres.
Pour l’**ESP32** il faut sélectionner le **???????** et modifier les paramètres selon votre carte ! Dans la plupart des cas dont le mien, pas besoin de toucher à quoique se soit mise à part le port série sur lequel votre carte est branchée.
<WRAP clear/>

19
data/pages/electronique/esp/specifications-esp32-h2.txt Normal file
View File

@@ -0,0 +1,19 @@
====== Specifications ESP32 H2 ======
{{ :dummy.png?75x75|Nom de la section}}
**Espressif** annonce en novembre 2021 la sortie de l'ESP32-H2 qui vient compléter l'offre des ESP32 en ajoutant un connexion **IEEE 802.15.4** et **Bluetooth 5 (LE)**.
Le IEEE 802.15.4 est un protocole de communication de la famille des LR WPAN :
* faible consommation
* faible portée
* faible débit
* formation d'un réseau mèche ou maillé
* détection d'énergie
* ...
Il y aura deux type de dispositifs :
* le dispositif ayant toutes les fonctions possibles (FFD : Full Function Device)
* dispositif ayant des fonctions limitées (RFD : Reduced Function Device)
L'implémentaiton de ce protocole est utilisée dans les protocoles **ZigBee** ou **6LoWPAN**.

6
data/pages/electronique/esp/telechargement-de-donnees-esp32-spiffs.txt Normal file
View File

@@ -0,0 +1,6 @@
====== Téléchargement de données ESP32 SPIFFS ======
https://randomnerdtutorials.com/install-esp32-filesystem-uploader-arduino-ide/

88
data/pages/electronique/esp/wifi-manager.txt Normal file
View File

@@ -0,0 +1,88 @@
===== Wifi Manager avec l'ESP =====
Vous pouvez programmer l'ESP pour se connecter à un point d'accès Wi-Fi existant ou de créer un point d'accès s'il ne peut pas se connecter. Vous pouvez configurer et gérer la connexion Wi-Fi d'un ESP à l'aide de la bibliothèque **WiFiManager**.
La bibliothèque **WiFiManager** simplifie la gestion des informations d'identification du réseau (SSID et mot de passe) en éliminant la nécessité de les coder en dur. En utilisant cette bibliothèque, l'ESP est capable de se connecter automatiquement à un réseau Wi-Fi préalablement configuré, ou de créer un point d'accès auquel vous pouvez vous connecter pour configurer les informations d'identification du réseau. Ainsi, vous n'avez plus à modifier le code source pour changer les paramètres de connexion Wi-Fi, ce qui facilite grandement la mise en place et la configuration de vos projets.
<code C esp8266-wifi-manager.ino>
#include <WiFiManager.h>
WiFiManager wm;
void setup() {
// Configuration du mode Wi-Fi en mode client station
WiFi.mode(WIFI_STA);
Serial.begin(115200);
delay(1000);
Serial.println();
Serial.println("Tentative de connexion au réseau Wi-Fi...");
// Connexion automatique au réseau Wi-Fi connu
if (!wm.autoConnect()) {
Serial.println("Erreur de connexion au réseau Wi-Fi.");
// Vous pouvez ajouter ici une logique pour gérer l'erreur de connexion
} else {
// Connexion réussie
Serial.println("Connexion au réseau Wi-Fi réussie !");
Serial.print("Adresse IP : ");
Serial.println(WiFi.localIP());
// Vous pouvez ajouter ici une logique pour exécuter des actions supplémentaires après la connexion réussie
}
}
void loop() {
// Vous pouvez ajouter ici du code supplémentaire à exécuter en boucle
}
</code>
===== Exemples de fonctionnement =====
__1. Réseau Wifi enregistré non disponbile__
Après un redémarrage de l'ESP, le réseau WiFi ''ACEGRP_SATNET1'' devient inaccessible. Le gestionnaire **WiFi Manager** propose son interface Web pour effectuer d'autres réglages si écessaires.
| {{:electronique:esp:pasted:20230706-190947.png}} |
Il est possible de sélectionner un autre réseau Wifi dans le menu **Configure Wifi** (http://192.168.4.1/wifi) :
| {{:electronique:esp:pasted:20230706-191715.png}} |
Il est possible de supprimer la configuration Wifi déjà enregistré dans la section **Info** (http://192.168.4.1/info) :
| {{:electronique:esp:pasted:20230706-192055.png}} |
__2. Aucun réseau Wifi connu__
| {{:electronique:esp:pasted:20230706-193716.png}} |
On peut ajouter un nouveau réseau :
| {{:electronique:esp:pasted:20230706-194049.png}} |
__3. ESP connecté sur le même réseau Wifi qu'un ordinateur__
Utilisation du programme ''nmap'' pour découvrir les périphériques réseau.
{{:electronique:esp:pasted:20230706-194454.png}}
<code>
sudo nmap 192.168.197.0/24
</code>
<code>
Starting Nmap 7.80 ( https://nmap.org ) at 2023-07-06 19:43 CEST
...
Nmap scan report for 192.168.197.228
Host is up (0.012s latency).
All 1000 scanned ports on 192.168.197.228 are closed
MAC Address: C4:4F:33:75:8C:9D (Espressif)
</code>

31
data/pages/electronique/esp8266.txt Normal file
View File

@@ -0,0 +1,31 @@
====== esp8266 ======
{{ :dummy.png?75x75|Nom de la section}}
Quelques notes rapides.
===== Projets =====
==== Accès à un système de fichiers sur ESP8266 ====
https://projetsdiy.fr/esp8266-littlefs-data-upload-plugin-ide-arduino-televerser-fichier/
{{:electronique:pasted:20200817-185740.png?400}}
==== Paramétrage Wifi à la demande ====
https://projetsdiy.fr/librairie-wifimanager-connexion-wifi-projets-esp8266/
{{:electronique:pasted:20200817-185536.png?400}}
==== ESP8266 vers serveur Web Raspberry Pi ====
https://randomnerdtutorials.com/esp32-esp8266-raspberry-pi-lamp-server/
{{:electronique:pasted:20200817-185418.png?400}}
==== Commander une lampe depuis une page Web ====
https://maker.pro/esp8266/tutorial/esp8266-tutorial-how-to-control-anything-from-the-internet
{{:electronique:pasted:20200817-185821.png?400}}

5
data/pages/electronique/fournisseur-electricite-barry.txt Normal file
View File

@@ -0,0 +1,5 @@
====== Barry, le fournisseur d'électricité orienté Tech et pas cher ======
{{ :electronique:fournisseur-electricite-barry:pasted:20210321-191657.png?75x75}}
~~GOTO>electronique:fournisseur-electricite-barry:~~

122
data/pages/electronique/fournisseur-electricite-barry/barry-api.php.txt Normal file
View File

@@ -0,0 +1,122 @@
<code PHP>
<?PHP
$priceArea = array(
'dk' => 'DK_NORDPOOL_SPOT_DK1',
'fr' => 'FR_EPEX_SPOT_FR'
);
function getMethod($postData) {
// Le token suivant n'est pas valide. Il faut le modifier avec le votre, obtenu dans l'application Barry Eenrgy
$authToken = 'Bx6Da6v0h34MM7OhAjCaN9zak+IZLNe9tUlCebw7+LiP8+5SH6BcdNrOY85s9q7Sdfrmc/yyjWrJROlJ9vhlRCYY310TsHcGNodMzr3cGfZOwVYNPYWxGxcZHO94p6W98SJC/TdIYhsE+tRnvMMKHktTdkRjmMolHAtWpYyFzDw=';
$url = "https://jsonrpc.barry.energy/json-rpc";
echo "<pre>";
echo '<p>La méthode appelée : </p>';
print_r(json_encode($postData));
echo "</pre></br>";
// Create the context for the request
$context = stream_context_create(array(
'http' => array(
'method' => 'POST',
'header' => "Authorization: Bearer {$authToken}\r\n".
"Content-Type: application/json\r\n",
'content' => json_encode($postData)
)
));
// Send the request
$response = file_get_contents($url, FALSE, $context);
// Check for errors
if($response === FALSE){
die('Error');
}
return $response;
}
function translateDate($strDate) {
$nomJourSemaineEN = array("Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday");
$nomJourSemaineFR = array("Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi", "Dimanche");
$nomMoisEN = array("January","February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December");
$nomMoisFR = array("Janvier","Février", "Mars", "Avril", "Mai", "Juin", "Juillet", "Août", "Septembre", "Octobre", "Novembre", "Décembre");
$strDate = str_ireplace($nomMoisEN, $nomMoisFR, $strDate);
$strDate = str_ireplace($nomJourSemaineEN, $nomJourSemaineFR, $strDate);
return $strDate;
}
setlocale(LC_ALL,'fr');
//$dateJour=date('d F Y', strtotime('31-12-2018'));
$dateJour=date('d F Y');
$dateJourDemain=date('d F Y', strtotime('+1 day', strtotime($dateJour)));
echo "<h1>Métriques de Barry Energy</h1>";
echo "<p>Rapport établi le ".translateDate(date('l d F Y'))." à ".date('H:i:s')."</p>";
echo "<h2>Etat de l'abonnement</h2>";
// The data to send to the API getMeteringPoints
$postData = array('method' => 'co.getbarry.api.v1.OpenApiController.getMeteringPoints'
, 'id' => 0
, 'jsonrpc' => '2.0'
, 'params' => array()
);
$response = getMethod($postData);
// Decode the response
$responseData = json_decode($response, TRUE);
echo "<pre>";
echo '<p>La réponse : </p>';
print_r($responseData);
echo "</pre>";
echo "<h2>Consommation du $dateJour </h2>";
// The data to send to the API getAggregatedConsumption
$postData = array('method' => 'co.getbarry.api.v1.OpenApiController.getAggregatedConsumption'
, 'id' => 0
, 'jsonrpc' => '2.0'
, 'params' => array(date(DATE_ATOM, strtotime($dateJour)), date(DATE_ATOM, strtotime($dateJourDemain)))
);
$response = getMethod($postData);
// Decode the response
$responseData = json_decode($response, TRUE);
echo "<pre>";
echo '<p>La réponse : </p>';
print_r($responseData);
echo "</pre>";
echo "<h2>Prix du $dateJour </h2>";
// The data to send to the API getPrice
$postData = array('method' => 'co.getbarry.api.v1.OpenApiController.getPrice'
, 'id' => 0
, 'jsonrpc' => '2.0'
, 'params' => array($priceArea['fr'], date(DATE_ATOM, strtotime($dateJour)), date(DATE_ATOM, strtotime($dateJourDemain)) )
);
$response = getMethod($postData);
// Decode the response
$responseData = json_decode($response, TRUE);
echo "<pre>";
echo '<p>La réponse : </p>';
print_r($responseData);
echo "</pre>";
</code>

13
data/pages/electronique/fournisseur-electricite-barry/barry-connaitre-le-cout-horaire-du-kwh.txt Normal file
View File

@@ -0,0 +1,13 @@
====== Barry, connaître le coût horaire du kWh ======
Parlons programmation et domotique !
Afin d'adapter les appareils qui consomment beaucoup d'énergie (chauffe-eau, chauffage par accumulation, charge de voiture...) au meilleur tarif horaire, je me lance dans la conception et la réalisation d'un commutateur intelligent.
Tout d'abord, je dois pouvoir anticiper le prix du **kWh** journalier. **Barry** propose une API dont la documentation se trouve à l'adresse https://developer.barry.energy/. Cette API va me permettre de me connecter sur les serveurs de Barry afin d'obtenir des informations. La méthode **getMeteringPoints** permet de connaître le coût du prix du **kWh** à chaque heure.
Je vais retenir 8 tranches horaires qui me permettent de savoir quand c'est le meilleur moment pour consommer.
Voici un extrait de code en PHP pour interroger les API fournis par Barry Energy.
//Aujourd'hui, il y a 3 méthodes disponibles : **getMeteringPoints**, **getAggregatedConsumption** et **getAggregatedConsumption**.//
{{page>electronique:fournisseur-electricite-barry:barry-api.php}}

36
data/pages/electronique/fournisseur-electricite-barry/index.txt Normal file
View File

@@ -0,0 +1,36 @@
====== Barry, payer moins cher son électricité et consommer autrement ======
{{ :electronique:fournisseur-electricite-barry:pasted:20210321-191657.png?75x75|Barry bouscule les codes de la distribution d'électricité avec un prix marché.}}
<note important>[[https://barry.energy/fr/signup|Inscrivez-vous à Barry Energy]] avec le code **#CÉDRIC361** et gagnez 25 €</note>
Cet article est en cours de rédaction, depuis le 1er mars 2021. Il s'agit d'un article regroupant des informations techniques suite à mon abonnement chez **Barry**.
> Pourquoi Barry est innovant ?
Les factures électriques sont basées sur un prix d'abonnement et un prix fixe au **kWh**. Certains abonnement permettent des tranches horaires ou le prix du **kWh** peut être différent. Il s'agit des tarifs heures creuses / heures pleines, heures Week End, heure JP, heure TEMPO, heure bleue, heure rouge ....
Les **concurrents** au distributeur historique EDF, proposent également des **tarifs plus ou moins avantageux**. En 2017, j'avais fait le choix de souscrire à l'offre **CDiscount Energie**. Il est vraie que j'ai pu économiser entre 100 et 200€ par an sur ma consommation électrique.
En **janvier 2021** est arrivé un nouveau fournisseur d’électricité, **Barry Energy**. En plus de vous permettre d'économiser sur le prix moyen de **kWh**, il offre la possibilité de payer sa consommation sur le prix du marché, sans marge.
{{:electronique:pasted:20210302-085200.png}}
> Parlons chiffre ?
Avec **Barry**, je paye au plus juste la vraie consommation d'énergie. C'est ainsi que je paye un prix au **kWh** différent chaque heure. Le prix à payer va dépendre du prix du **kWh** et de ma consommation heure par heure.
{{:electronique:pasted:20210302-132826.png}}
Pour aujourd'hui, le 02/03/2021 :
^ date heure ^ kW consommés ^
|
Fini les heures creuses et heures pleines ! Bonjour le vrai prix !
====== Table des matières ======
* [[electronique:fournisseur-electricite-barry:|Présentation]]
* [[electronique:fournisseur-electricite-barry:barry-connaitre-le-cout-horaire-du-kwh]]
* [[electronique:fournisseur-electricite-barry:quelques-liens]]

19
data/pages/electronique/fournisseur-electricite-barry/quelques-liens.txt Normal file
View File

@@ -0,0 +1,19 @@
====== Quelques liens ======
{{ :dummy.png?75x75|concernant le projet Barry}}
API pour accéder aux données\\
https://developer.barry.energy/
Inscription à Barry\\
https://barry.energy/fr/signup avec le code parrain **#CÉDRIC361** pour économiser 25€
État des services\\
https://barry.energy/fr/faq/360005006394
Consommation électrique mondiale\\
https://www.electricitymap.org/zone/FR
Développement\\
https://barry.energy/fr/roadmap

2
data/pages/electronique/fournisseur-electricite-barry/sidebar.txt Normal file
View File

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

26
data/pages/electronique/index.txt Normal file
View File

@@ -0,0 +1,26 @@
~~NOCACHE~~
====== Technologies ======
{{ :logo-electronique.png?nolink&150x150|Electronique, Arduino & Raspberry Pi}}
La passion des sciences et de la technologie. On en parle ? **Électronique**, **Arduino**, **Raspberry Pi** et composants sont les thèmes de cette section.
===== Table des matières =====
* [[.:|introduction]]
==== Les pages ====
<nav stacked="true" fade="true">
<nspages . -h1 -nbCol=1 -textNS=" " -textPages=" " -simpleList -exclude:cookie: -exclude:user: -exclude:playground: -exclude:[sidebar index start rightsidebar navbar topheader header help pageheader pagefooter legal-notices footer 404]>
</nav>
==== Les sous-catégories ====
<nav stacked="true" fade="true">
<nspages . -h1 -nbCol=1 -noPages -subns -textNS=" " -textPages=" " -simpleList -exclude:cookie: -exclude:user: -exclude:playground: -exclude:[sidebar index start rightsidebar navbar topheader header help pageheader pagefooter legal-notices footer 404]>
</nav>
~~NOTOC~~
~~NOCACHE~~

45
data/pages/electronique/liitokala-lii-s8-battery-charger.txt Normal file
View File

@@ -0,0 +1,45 @@
====== Chargeur de batterie Liitokala Lii-S8 ======
{{ :dummy.png?75x75|Nom de la section}}
===== Caractéristiques techniques =====
==== Tension d'alimentation ====
12 V DC et 4.0 A
==== Types et modèles de batteries compatibles ====
Li-ion / IMR / LiFePO4 : 26650, 21700, 20700, 18650, 18490, 18350, 17670, 17500, 16340(RCR123), 14500, 10440
NiMH / Cd : AA, AAA, SC/C
==== Tension de charge ====
4.20 V DC for Li-ion
 
4.35 V DC for IMR
 
3.65 V DC for LiFePO4
 
1.48 V DC for the NiMH/Ni - CD
 
9.0 V DC for the NiMH
==== Courant de charge ====
Li-ion / IMR / LiFePO4 : 2.00 A sur les canaux 1, 3, 6 et 8
Li-ion / IMR / LiFePO4 : 0.30 A, 0.50 A, 0.70 A et 1.00 A sur les 8 canaux
NiMH / Nicd : 0.50 A sur les 8 canaux
NiMH-9V: 85m A sur 2 canaux

44
data/pages/electronique/lithium-battery-charger-2s-a1.txt Normal file
View File

@@ -0,0 +1,44 @@
====== Module de chargeur de batterie Li-ion ======
{{ :electronique:pasted:20220823-011010.png?75x75|Carte de charge de batterie au Lithium DDTCCRUB 2S 1A}}
===== Description =====
Chargeur de 2 batteries Lithium-Ion (Li-Ion) de 7.4V (2 x 3.7V) au format 18650. Interface d'entrée prise USB-C
===== Caractéristiques =====
Courant d'entrée : 1A
Tension d'entrée : DC de 3.7V à 5V (tolérance de 3V à 6V)
Courant de charge : 0.55A (0.40A si tension d'entrée à 3.7V)
Tension de charge : 8.4V
LED **CR* pour indiquer le statut de charge
LED **OK** pou rindiquer que la charge est complète
Température de fonctionnement : de -40°C à +85°C
Fréquence de commutation jusqu'à 1MHz, compense la perte de tension en mode quadruple CV.
La résistance interne et la résistance de suivi de la batterie sont chargées automatiquement.
La tension de la batterie de Protection est inférieure à la tension d'entrée et au court-circuit de la batterie.
Forte adaptabilité à l'alimentation d'entrée, la capacité de conduite est limitée batterie de protection contre les surtensions.
===== Photos du produit =====
{{:electronique:pasted:20220823-011010.png}}
{{:electronique:pasted:20220823-012130.png}}
===== Montage =====
{{:electronique:pasted:20220823-012555.png}}

54
data/pages/electronique/lois-et-composants/100-lois-simples-d-electricite.txt Normal file
View File

@@ -0,0 +1,54 @@
====== Lois simples de l'électricité ======
{{ :electronique:lois-et-composants:logo-lumiere.png?nolink&75x75|Loi simples de l'électricité}}
===== - Les circuits électriques =====
Un circuit électrique est constitué de récepteurs et de générateurs réliés par des conducteurs. Il y a au moins un récépteur et un générateur dans un circuit électrique.
===== - Le courant électrique =====
Le courant électrique est un ensemble de ions et d'électrons, appelés porteurs des charges électriques, qui se déplacent dans un circuit électrique fermé.
Par conventions, le courant électrique sort de la borne '+' (positive) pour se diriger vers la borne '-' (négative) du générateur.
===== - L'intensité =====
L'**intensité (i)** du courant électrique est une grandeur physique qui caractérise une quantité d'électricité traversant la section d'un conducteur en une seconde.
Si le débit est invariable dans le temps, le **courant** est dit **continu**.
L'**intensité** du courant électrique est une grandeur algébrique et s'exprime en **Ampère (A)**. Elle se mesure à l'aide d'un ampèremètre branchée en série.
===== - Loi des nœuds =====
Tous les appareils montés en série sont traversés par la même intensité I.
La somme algébrique des intensités des courants dans les conducteurs arrivant vers un noeud est égale à la somme algébrique des intensités des courants dans les conducteurs partant du nœud.
===== - La tension électrique =====
La **tension électrique (U)** est une différence de potentiel entre deux points d'une portion d'un circuit.
La tension est une grandeur algébrique, on la mesure à l'aide d'un voltmètre branchée en parallèle (ou en dérivation). Elle s’exprime en **Volt (V)**.
===== - Loi des mailles =====
Une maille est un chemin fermé passant par différents points d'un circuit.
- La somme algébrique des tensions rencontrées dans une maille est nulle.
- La tension totale entre deux points d'un circuit est égale à la somme des tensions partielles.
===== - Loi d'Ohm d'un dipôle linéaire passif =====
Un dipôle linéaire passif est également appelé **conducteur ohmique**.
La relation entre U et I est linéaire. La caractéristique du conducteur ohmique. Elle s'appelle **résistance (R)** et s'exprime en **Ohm (Ω)**. Elle se mesure avec un ohmètre hors charge.
De ce fait, R = U / I
On notera la conductense, G = 1 / R

53
data/pages/electronique/lois-et-composants/500-capteur-de-distance-ultrasons.txt Normal file
View File

@@ -0,0 +1,53 @@
====== Capteur de distance ultrasons ======
{{ :dummy.png?75x75|Nom de la section}}
Le premier capteur de distance que j'ai utilisé est le **HC-SR04**. Il existe une bibliothèque populaire pour les télémètres à ultrasons sur Arduino [[https://www.arduinolibraries.info/libraries/ultrasonic|Ultrasonic.h]].
===== Spécificités =====
| Nombre de connecteur | 4 |
| Alimentation | 5 V |
| Fréquence des ultrasons | 40 Khz |
| Consommation | 2 mA en veille\\ 15 mA au travail |
| Angle effectif | 15° |
| Distance mesurée | de 2 cm à 400 cm |
| Marge d'erreur | Variation de 0.3 cm\\ à partir de 250 cm la résolution ne sera pas très bonne |
| Prix | https://amzn.to/3MgE8fS |
===== Principe =====
Un capteur à ultrasons détermine la distance d’un objet du capteur sur la base du temps de propagation du son (340 m/s) vers et depuis l’objet, la distance en centimètre de l’obstacle peut être déterminée assez précisément.
{{:electronique:lois-et-composants:pasted:20220515-202803.png}}
Le capteur à ultrasons HC-SR04 doit recevoir un signal ''LOW'' de 4 µs puis un signal ''HIGH'' de 10 µs et enfin une pause, signal ''LOW'' de 60 ms minimum sur la pin ''TRIG''.
Après de l'envoi du signal ''HIGH'', on va lire l'informations sur la broche ''ECHO''.
{{:electronique:lois-et-composants:pasted:20220515-233303.png}}
Le calcul de la distance s'appuie sur la vitesse du son dans l'atmosphère proportionnel au temps de réception du signal. On n'oublie pas de divisez par **2**.
{{:electronique:lois-et-composants:pasted:20220515-233506.png}}
===== Schéma =====
Il faut identifier les broches ''D8'' et ''D9'' sur l'Arduino. Repérer les 4 broches ''VCC'' , ''GND'', ''TRGI'' et ''ECHO'' sur le module **HC-SR04**. Aucun autre composant est nécessaire.
| +5 V | VCC |
| GND | GND |
| D2 | ECHO |
| D3 | TRIG |
{{:electronique:lois-et-composants:pasted:20220516-000835.png}}
===== Code =====
Code de base [[https://gitlab.com/cedricAbonnel/esp/-/blob/master/arduino/sketchDistanceSerial.ino|calculer une distance avec un HC-SR04 sur Arduino]]
Code [[https://gitlab.com/cedricAbonnel/esp/-/blob/master/arduino/sketchDistanceSerial-Ultrasonic.ino| calculer une distance avec un HC-SR04 sur Arduino et la bibliothèque ultrasonic]]

19
data/pages/electronique/lois-et-composants/500-capteur-infrarouge-de-mouvements.txt Normal file
View File

@@ -0,0 +1,19 @@
====== Capteur de mouvements infrarouge ======
{{ electronique:arduino:pir_rcw0506_vuegenerale.jpg?noLink |}}
Voyons voir comment mettre en œuvre un ** PIR MOTION DETECTOR**, **capteur infrarouge de mouvements** en français dans le texte.
La référence que j'utilise est le **DSN-FIR800**, gravée **RCW 0506** et **D-SUN**. Le circuit est composé de :
* 4 condensateurs
* 2 résistances variables ''Sx'' et ''Tx''
* un circuit intégré BISS0001 - {{ electronique:arduino:biss0001.pdf |Micro Power PIR Motion Detector IC}}
* un {{ electronique:arduino:bm71xx.pdf |régulateur de tension}} 3.3V 30mA
{{ electronique:arduino:pir_rcw0506_zoombiss0001.jpg?noLink |}}
Le principe de fonctionnement du BISS0001 est basé :
* sur un détecteur de mouvements infrarouge externe qui déclenche un trigger
* un timer ''Tx'' qui maintient un niveau logique après déclenchement du trigger
* un timer ''Ti'' qui inhibe le détecteur

10
data/pages/electronique/lois-et-composants/index.txt Normal file
View File

@@ -0,0 +1,10 @@
====== Lois simples, composants et principes ======
{{ :electronique:logo-lumiere.png?nolink&75x75|Lois et composants}}
<WRAP clear/>
<nspages . -h1 -hideNoSubns -subns -nbCol=1 -textNS=" " -textPages=" " -simpleList -exclude:cookie: -exclude:user: -exclude:playground: -exclude:[sidebar index start rightsidebar navbar topheader header help pageheader pagefooter legal-notices footer 404] -sortId >
----
Retour à [[..:]]

49
data/pages/electronique/lois-et-composants/interface-5v-230v-avec-optocoupleur-et-triac.txt Normal file
View File

@@ -0,0 +1,49 @@
====== Interface 5V 230V avec optocoupleur et Triac ======
{{ :dummy.png?75x75|Commander du 230 V avec du 5 V}}
Lorsqu'on veut piloter un circuit en 230 volts, depuis un Arduino où depuis un composant électronique basse tension, on utilise un relais de commande. La partie commande est en 5 volts et la partie commandée se trouve en 230 volts. L'isolante entre les deux parties, c'est le relais.
L'inconvénient d'un relais c'est le bruit qu'il fait quand il commute. Ça claque !
Lorsqu'on veut piloter un appareil en 230 volts, dans un environnement où le bruit est à proscrire, par exemple dans une chambre, il faut effectuer un choix technologique plus silencieux.
Quelles solutions avons-nous en électronique pour pouvoir piloter du 230 volts. Le pilote, c'est l'Arduino ou un composant électronique à basse tension. La basse tension c'est du 5 volts. Le piloté, c'est un radiateur, une ampoule ou un autre composant à 230 Volts. D'ailleurs, l'appareil piloté s'appelle une charge.
La solution serait le triac est un dispositif semi-conducteur avec 3 bornes. Pour faire simple, c'est un composant électronique à trois pattes. Il a 2 anodes et une porte appelée gate en anglais. Rapidement, la gate permet de faire circuler le courant entre les anodes. L'avantage de celui-ci c'est qu'il est compatible avec une tension alternative. Suivant le modèle choisi nous pourrons piloter de 4 à 25 ampères, pour une tension de 600 volts maximale. Ce qui représente une puissance de 5500 W maximale pour 230 V.
Toutefois, le Triac ne permet pas d'isoler galvaniquement le 230 volts du 5 volts, car le schéma représente une masse commune. Il faut ajouter un optocoupleur pour isoler le 5 et 230 V. Le courant présenté en entrée de l'optocoupleur et transmis par une LED émettrice au bornier de la sortie. Sur le bornier de sortie est positionné un capteur de lumière qui laissera passer le courant si de la lumière est émise. Entre le bornier d'entrée et le borne de sortie de l'optocoupleur, il n'y a aucune masse commune, aucun conducteur commun. Il y a une isolation dite galvanique.
Un triac, un optocoupleur et vogue la galère. Il y aura un bornier pour amener le 230 volts et un autre pour brancher la charge. Il y a également un module de transformation 230 volts alternatif vers 5 volts continu, ceci afin d'alimenter l'Arduino. L'Arduino sera programmé avec un programme spécifique qu'on injectera en USB. Une des sorties pilotera un optocoupleur.
Il reste à modéliser un boîtier afin d'intégrer tous ses composants et modules. Et les quelques composants à souder le seront sur une plaque pré-percée.
{{:electronique:depannage:pasted:20200806-003439.png}}
====== Composants ======
Voici une liste de composants nécessaires à la réalisation du circuit, avec un prix indicatif sur les prix. Évidemment cela n'inclus ni le prix de l'étain, ni celui de la plaque pré-percée et ni des fils de jonctions.
^ module 230 V AC - 5 V DC | 0,66 € |
^ triac BTA16-600 | 0,136 €|
^ résistance 220 ohms | < 0,004 € |
^ fusible 1A | 0,008 € |
^ porte fusible | 0,09 € |
^ 1 borniers 2 connecteurs | 0,043 € |
^ optocoupleur MOC3031 | 0,15 € |
Voici quelques informations complémentaires sur certains composants ou modules.
Le ''module 230 V AC - 5 V DC'' est un circuit avec transformateur, condensateurs, résistances, diodes et régulateur **TL431**.
{{ :electronique:depannage:pasted:20200806-090408.png}}
Caractéristiques
* Tension d'entrée: 85 ~ 265 V AC 50/60 Hz ou 100 ~ 370 V DC
* Tension de sortie: 5 V (+/-0.2 V) DC
* Courant de sortie : 700 mA
* Puissance : 3.5 W (5 V x .7 A)
* Température de fonctionnement : 20 ~ 60 degrés

1
data/pages/electronique/lois-et-composants/sidebar.txt Normal file
View File

@@ -0,0 +1 @@
{{page>index}}

7
data/pages/electronique/modules/scd30-capteur-co2.txt Normal file
View File

@@ -0,0 +1,7 @@
====== SCD30 - Capteur CO2 ======
{{ :electronique:modules:scd30.jpg?nolink&400|Module SCD30 Capteur CO2 à cabler}}
===== Liens =====
* Grove - CO2 & Temperature & Humidity Sensor (SCD30) : https://wiki.seeedstudio.com/Grove-CO2_Temperature_Humidity_Sensor-SCD30/
* Seeed SCD30 Library : https://github.com/Seeed-Studio/Seeed_SCD30

15
data/pages/electronique/mqtt/broker.txt Normal file
View File

@@ -0,0 +1,15 @@
====== 120 · broker ======
{{ :dummy.png?75x75|Nom de la section}}
Un broker MQTT est un serveur qui implémente le protocole MQTT et qui gère la communication entre les différents clients MQTT. Le broker MQTT sert d'intermédiaire pour transmettre les messages publiés par les clients aux autres clients qui se sont abonnés aux sujets pertinents.
Le broker MQTT peut être considéré comme un centre de messages pour les clients MQTT. Il reçoit des messages publiés par les clients, les stocke temporairement et les transmet aux clients abonnés aux sujets pertinents. Le broker peut également effectuer d'autres tâches telles que la sécurité, la gestion des sessions, la gestion des abonnements, la gestion de la qualité de service (QoS) et la gestion des thèmes (topics).
Le broker MQTT peut être exécuté sur différents types de plateformes, telles que des ordinateurs personnels, des serveurs cloud ou des appareils IoT. Il existe plusieurs implémentations de broker MQTT open source et commerciales disponibles, qui peuvent être utilisées pour créer des systèmes MQTT personnalisés en fonction des besoins spécifiques de votre application.
Il en existe quelques un :
* **ActiveMQ** développé par Apache et permet d'intégrer le protocole dans un serveur Apache httpd.
* **JoramMQ** pour une intégration Java de MQTT
* [[informatique:linux:applications:mosquitto|Mosquitto]], le broker le plus utilisé actuellement dans les projets DIY
* **RabbitMQ** propose un support commercial
* **EMQTT**, conçu pour recevoir de très nombreuses connexions

40
data/pages/electronique/mqtt/index.txt Normal file
View File

@@ -0,0 +1,40 @@
====== MQTT ======
{{ :electronique:mqtt:mqtt_dash.png?75x75|MQ Telemetry Transport}}
MQTT est un **protocole simple de communication entre machines**. Le **protocole est un standard international**, adopté pas de grandes entreprises et nombreux industriels. **MQTT** signifie **MQ Telemetry Transport**.
MQTT (//Message Queuing Telemetry Transport//) est un protocole de communication léger et ouvert pour l'Internet des objets (IoT) qui a été développé en 1999 par **Andy Stanford-Clark** de **IBM** et **Arlen Nipper** de **Eurotech**.
MQTT est conçu pour être simple, efficace et adaptable aux besoins de nombreux types de systèmes IoT. Le protocole MQTT permet une communication bidirectionnelle entre les périphériques connectés à un réseau, en utilisant un modèle de publication/abonnement (**pub/sub**) où les périphériques publient des messages sur des sujets (**topics**) spécifiques, et les autres périphériques peuvent s'abonner à ces sujets pour recevoir les messages pertinents.
MQTT a des caractéristiques qui le rendent particulièrement adapté aux systèmes **IoT**, tels que sa faible consommation d'énergie, sa bande passante réduite, sa tolérance aux pannes et son évolutivité. Le protocole MQTT est également compatible avec une grande variété de plateformes et de langages de programmation, ce qui le rend facile à intégrer avec d'autres technologies.
Aujourd'hui, MQTT est devenu un standard ouvert et largement adopté pour la communication dans l'Internet des objets, et il est utilisé dans une grande variété de domaines, tels que la domotique, l'agriculture intelligente, l'industrie, les villes intelligentes et les services connectés.
===== Table des matières =====
[[.:]]
<WRAP clear/>
<WRAP group>
<WRAP half column>
==== Les pages ====
<nav stacked="true" fade="true">
<nspages . -h1 -nbCol=1 -textNS=" " -textPages=" " -simpleList -exclude:cookie: -exclude:user: -exclude:playground: -exclude:[sidebar index start rightsidebar navbar topheader header help pageheader pagefooter legal-notices footer 404]>
</nav>
</WRAP>
<WRAP half column>
==== Les sous-catégories ====
<nav stacked="true" fade="true">
<nspages . -h1 -nbCol=1 -noPages -subns -textNS=" " -textPages=" " -simpleList -exclude:cookie: -exclude:user: -exclude:playground: -exclude:[sidebar index start rightsidebar navbar topheader header help pageheader pagefooter legal-notices footer 404]>
</nav>
</WRAP>
</WRAP>
~~NOTOC~~
~~NOCACHE~~

48
data/pages/electronique/mqtt/les-sujets.txt Normal file
View File

@@ -0,0 +1,48 @@
====== 150 · Les sujets ======
{{ :dummy.png?75x75|Nom de la section}}
En MQTT, un sujet (ou //topic// en anglais) est une chaîne de caractères qui identifie une catégorie ou un canal de communication. Les clients MQTT peuvent s'abonner à un ou plusieurs sujets pour recevoir les messages publiés sur ces sujets.
Lorsqu'un client publie un message sur un sujet particulier, tous les clients qui se sont abonnés à ce sujet recevront ce message. Les sujets sont organisés sous forme de hiérarchie à l'aide de barres obliques (/) pour séparer les différents niveaux de la hiérarchie.
Par exemple, le sujet ''maison/chambre1/temperature'' pourrait être utilisé pour publier la température de la chambre 1 d'une maison. Les clients peuvent alors s'abonner à ''maison/chambre1/temperature'' pour recevoir des mises à jour sur la température de cette pièce spécifique.
Les sujets sont un élément clé de la flexibilité et de l'extensibilité de MQTT, permettant une communication efficace et ciblée entre les différents clients de l'écosystème MQTT.
===== Sujets réservés =====
MQTT définit plusieurs sujets réservés (ou //reserved topics// en anglais) qui ont une signification particulière et qui ne doivent pas être utilisés pour la publication de messages personnalisés. Voici quelques exemples de sujets réservés dans MQTT :
* ''$SYS/#'' : ce sujet réservé est utilisé pour publier des informations système sur le broker MQTT lui-même, telles que des statistiques de performance ou des informations de connexion des clients.
* ''$SYS/broker/version'' : ce sujet réservé est utilisé pour publier la version du broker MQTT.
* ''$SYS/broker/uptime'' : ce sujet réservé est utilisé pour publier le temps d'activité du broker MQTT.
* ''$SYS/+'' : ce sujet réservé permet d'accéder aux différents sous-sujets sous le répertoire ''$SYS'', qui contiennent des informations système spécifiques.
Il ne faut pas utiliser ces sujets réservés pour publier des messages personnalisés, car cela peut perturber le fonctionnement normal du broker ou des clients MQTT qui s'attendent à recevoir des informations système spécifiques sur ces sujets.
===== Caractère générique # =====
En MQTT, le symbole ''#'' est un caractère générique utilisé comme joker dans les noms de sujets pour s'abonner à tous les sous-sujets d'un certain niveau. Lorsqu'un client s'abonne à un sujet qui contient le joker ''#'', il reçoit des messages publiés sur tous les sous-sujets de ce niveau et de niveaux inférieurs.
Par exemple, si un client s'abonne au sujet ''maison/chambre1/#'', il recevra des messages publiés sur tous les sous-sujets de ''maison/chambre1'', tels que ''maison/chambre1/temperature'', ''maison/chambre1/humidite'', ''maison/chambre1/lumiere'', etc.
L'utilisation du joker ''#'' peut avoir des conséquences importantes sur le trafic réseau et la charge de travail du broker MQTT, en particulier pour les hiérarchies de sujets importantes avec de nombreux sous-sujets. Par conséquent, il est recommandé d'utiliser le joker ''#'' avec parcimonie et de manière judicieuse, en fonction des besoins spécifiques de votre application MQTT.
Lorsque le symbole ''#'' est utilisé seul comme sujet, il est considéré comme un sujet non valide dans MQTT. En effet, MQTT spécifie que tous les sujets valides doivent commencer par un caractère non-joker.
Ainsi, si un client s'abonne à ''#'' comme sujet, cela n'aura aucun effet, car ''#'' n'est pas un sujet valide en soi. De même, si un client publie un message avec ''#'' comme sujet, le broker MQTT refusera le message car ''#'' n'est pas un sujet valide.
Il est important de se rappeler que le broker MQTT peut appliquer des règles spécifiques pour valider les sujets des messages, qui peuvent varier en fonction de l'implémentation spécifique du broker. Il est donc recommandé de vérifier la documentation du broker MQTT pour connaître les règles de validation des sujets.
===== Caractère générique + =====
MQTT définit un autre caractère générique, le symbole ''+'', qui est utilisé pour s'abonner à un sous-sujet spécifique dans une hiérarchie de sujets. Contrairement au symbole ''#'', le symbole ''+'' ne correspond qu'à un seul niveau de sous-sujet.
Par exemple, si un client s'abonne au sujet ''maison/+/temperature'', il recevra des messages publiés sur tous les sous-sujets qui correspondent au modèle ''maison/*/temperature''. Les sous-sujets qui correspondent incluent ''maison/cuisine/temperature'', ''maison/chambre1/temperature'', etc.
Le symbole ''+'' est donc utile pour filtrer les messages à un niveau spécifique de la hiérarchie de sujets, en s'abonnant à un seul sous-sujet plutôt qu'à l'ensemble du niveau comme avec le symbole ''#''.
Il est important de noter que le symbole ''+'' ne peut être utilisé que pour remplacer un seul niveau de sous-sujet, tandis que le symbole ''#'' peut remplacer plusieurs niveaux de sous-sujets.

48
data/pages/electronique/mt3608-convertisseur-elevateur-de-tension.txt Normal file
View File

@@ -0,0 +1,48 @@
====== MT3608 Convertisseur Élévateur de tension ======
{{ :electronique:pasted:20220824-075144.png?75x75|MT3608 Convertisseur Élévateur de Tension DC-DC Réglable Step Up Boost Converter Module}}
===== Champs d'applications =====
* Circuits de relais solaire
* Batteries d'alimentation
* Chargeurs de batteries
Alimentation réglable de 2V à 28V avec un courant de sortie de 2A maximum.
===== Spécifications =====
Tension d'entrée : 2V - 24V
Tension de sortie : 2V - 28V
Courant de sortie : max. 2A
Efficacité:> 93%
Taille: 36 mm x 17 mm x 6,5 mm
==== Réalisation ====
Régler le tension de sortie à l'aide de la vis du potentiomètre ajustable.
Protéger le circuit avec un fusible de 2A.
{{ :electronique:pasted:20220824-074435.png }}
Le module à 4 connecteurs :
IN+ Brancher le pole positif (+) de la source d’alimentation (batterie) avec une tension de 24V maximale.
IN- Brancher le pole négatif (- ou GND) de la source d’alimentation (batterie).
OUT+ Brancher le pole positif (+) du circuit à alimenter. Ne pas dépasser les 2A de consommation.
OUT- Brancher le pole négatif (-) du circuit à alimenter.
{{:electronique:pasted:20220824-074549.png}}
===== Photos =====
{{:electronique:pasted:20220824-073029.png}}
{{:electronique:pasted:20220824-075144.png}}

47
data/pages/electronique/raspberry-pi/configurer_alimentation_disque_dur.txt Normal file
View File

@@ -0,0 +1,47 @@
====== Configurer l'alimentation du disque dur ======
Avec Raspbian il est possible de paramétrer l'alimentation du disque dur afin de rentrer en mode **standby** et **hibernate** après un temps défini. Cela afin d'éviter une usure prématurée et une économie d'énergie.
Je suppose que les disques durs USB sont montés.
1. Dans un premier temps, il est nécessaire de mettre à jour de la liste des package et install le programme **hdparm** :
<code>
$ sudo apt-get update && sudo apt-get install hdparm
Les paquets supplémentaires suivants seront installés :
powermgmt-base
Paquets suggérés :
apmd
Les NOUVEAUX paquets suivants seront installés :
hdparm powermgmt-base
</code>
2. On va interroger l'ensemble des disques durs afin de connaître l'état du mode d'alimentation. Les réponses possibles sont **unkonown**, **active** / **idle** et **standby**.
<code>
$ sudo hdparm -C /dev/sd?
/dev/sda:
drive state is: standby
/dev/sdb:
drive state is: standby
/dev/sdc:
drive state is: standby
/dev/sdd:
drive state is: standby
/dev/sde:
drive state is: standby
/dev/sdf:
drive state is: standby
/dev/sdg:
drive state is: standby
/dev/sdh:
drive state is: standby
</code>

5
data/pages/electronique/raspberry-pi/creer-un-point-d-acces-wifi-et-routage-evolue-avec-raspap.txt Normal file
View File

@@ -0,0 +1,5 @@
====== Créer un point d'accès Wifi et routage évolué avec RaspAp ======
{{ :dummy.png?75x75|Nom de la section}}
https://raspap.com/

4
data/pages/electronique/raspberry-pi/creer-un-point-d-acces-wifi-et-routage.txt Normal file
View File

@@ -0,0 +1,4 @@
====== Créer un point d'accès Wifi et routage ======
{{ :dummy.png?75x75|Nom de la section}}
https://thepi.io/how-to-use-your-raspberry-pi-as-a-wireless-access-point/

38
data/pages/electronique/raspberry-pi/fondamentaux/accessoires_pour_raspberry_pi_3_bplus.txt Normal file
View File

@@ -0,0 +1,38 @@
====== Accessoires pour Raspberry Pi 3 B+ ======
Je vais détailler les accessoires indispensables pour fonctionner avec le Raspberry Pi 3 B+.
===== Alimentation =====
Pour fonctionner, le Raspberry Pi à besoin d'une alimentation électrique. Elle n'est pas fournie par défaut.
Certains périphériques USB demandent beaucoup de courant pour fonctionner. Si l'alimentation n'est pas suffisamment dimensionnée, cela peut provoquer de graves défaillances. Je vous recommande cette [[https://amzn.to/2X9FQph|alimentation pour Raspberry Pi]] qui tiendra la charge même si plusieurs périphériques sont branchés.
Cette alimentation secteur est dotée d'un câble de 1,5 m et d'une fiche mâle micro USB. Certification CE et ROSH pour plus de sécurité, elle est garantie contre les courts-circuits, les surintensités et les surtensions. Son courant de consommation en veille est très faible.
[[https://amzn.to/2X9FQph|{{https://www.abonnel.fr/_media/informatique/accessoires_pour_raspberry_pi/5ea6da060f069e9e024c154d2dad4d70.png?nolink&}}]]
===== Carte mémoire =====
Le Raspberry Pi est dépourvu de disque dur. Il fonctionne avec une carte mémoire micro SD. Je vous conseille une [[https://amzn.to/2KDgMWb|Carte micro SD 64 Go pour Rapberry Pi]] pour stocker un maximum d'informations. La robustesse de cette carte permettra un grand nombre de lecture/écriture.
[[https://amzn.to/2KDgMWb|{{https://www.abonnel.fr/_media/informatique/accessoires_pour_raspberry_pi/58d14163eb5a1774f00095af5625e6f8.png?nolink&295x218}}]]
===== Clavier et souris =====
Pour naviguer dans les programmes ou taper les lignes de commandes, il faudra un clavier et une souris qui ne sont pas fournies par défaut.
Il y a deux types de clavier qui peuvent être utiliser.
Le clavier a largeur standard permettra de taper du texte facilement. Il sera utile si vous utilisez le Rabperry Pi comme un ordinateur. Un clavier standard d'ordinateur peut faire l'affaire. Si vous souhaiter avoir un clavier à usage excluif pour le Raspberry Pi, je vous conseille [[https://amzn.to/2KBNszu|un clavier et une souris sans-fil Logitech]].
Pour une utilisation de salon, un [[https://amzn.to/2KBYdBV|petit clavier avec trackpad intégré et rétro éclairage]] peut parfaitement convenir. Il sera utile lorsque vous utiliserez Kodi pour naviguer dans l'interface ou renseigner des champs de recherche.
[[https://amzn.to/2KAGdrr|{{:informatique:accessoires_pour_raspberry_pi:7715131786e6dd782ca9efe942fa29cd.png?nolink&}}]] [[https://amzn.to/2KBYdBV|{{:informatique:accessoires_pour_raspberry_pi:rii_clavier_azertry.png?nolink&400|}}]]
===== Câble HDMI =====
===== Boitier de protection =====

13
data/pages/electronique/raspberry-pi/fondamentaux/comparaison_performances_raspberrypi4.txt Normal file
View File

@@ -0,0 +1,13 @@
====== Comparaison des performances ======
Comparaison des performances des Raspberry Pi.
^ ^ Raspberry Pi 1 Model A ^ Raspberry Pi 1 Model A+ ^ Raspberry Pi 1 Model B ^ Raspberry Pi 1 Model B+ ^ Raspberry Pi 2 Model B ^ Raspberry Pi 3 Model B ^ Raspberry Pi Zero ^ Raspberry Pi 4 model B ^
^ Date de sortie | 2013 | 2014 | 2012 | 2014 | 2015 | 2016 | 2015 | 2019 |
^ SoC | Broadcom BCM2835 | Broadcom BCM2835 | Broadcom BCM2835 | Broadcom BCM2835 | Broadcom BCM2836 | Broadcom BCM2837 | Broadcom BCM2835 | Broadcom BCM2711 |
^ Cores | 1 | 1 | 1 | 1 | 4 | 4 | 1 | 4\\ Cortex-A72 (ARM v8) 64-bits à 1.5GHz |
^ SDRAM | 256 MB | 256 MB | 512 MB | 512 MB | 1 GB | 1 GB | 512 MB | 1 GB\\ 2 GB\\ 4 GB |
^ Circuit Graphique | | | | | | VideoCore IV | | VideoCore VI |

18
data/pages/electronique/raspberry-pi/fondamentaux/comparer_ports_raspberrypi.txt Normal file
View File

@@ -0,0 +1,18 @@
====== Comparaison des ports ======
Comparaison des ports des Raspberry Pi.
^ ^ Raspberry Pi 1 Model A ^ Raspberry Pi 1 Model A+ ^ Raspberry Pi 1 Model B ^ Raspberry Pi 1 Model B+ ^ Raspberry Pi 2 Model B ^ Raspberry Pi 3 Model B ^ Raspberry Pi Zero ^ Raspberry Pi 4 model B ^
^ USB Ports | 1 USB 2.0 | 1 USB 2.0 | 2 USB 2.0 | 4 USB 2.0 | 4 USB 2.0 | 4 USB 2.0 | 1 micro USB 2.0 | 2 USB 2.0\\ 2 USB 3.0 |
^ Ethernet | | | 10/100 Mbits/s | 10/100 Mbits/s | 10/100 Mbits/s | 10/100 Mbits/s | | 1 Gbits/s |
^ Bluetooth | | | | | | 4.1 | | 5.0 |
^ WiFi | | | | | | 802.11n | | bi-bande 802.11b/g/n/ac |
^ Audio In | I²S | I²S | I²S | I²S | I²S | I²S | I²S | I²S |
^ Audio Out | I²S\\ Analog 3.5 mm jack\\ Digital HDMI | I²S\\ Analog 3.5 mm jack\\ Digital HDMI | I²S\\ Analog 3.5 mm jack\\ Digital HDMI | I²S\\ Analog 3.5 mm jack\\ Digital HDMI | I²S\\ Analog 3.5 mm jack\\ Digital HDMI | I²S\\ Analog 3.5 mm jack\\ Digital HDMI | Digital HDMI\\ Analog GOPI PWM | I²S\\ Analog 3.5 mm jack\\ Digital HDMI |
^ Video In | CSI Camera Connector | CSI Camera Connector | CSI Camera Connector | CSI Camera Connector | CSI Camera Connector | CSI Camera Connector | | CSI Camera Connector |
^ Video Out | HDMI\\ Composite RCA | HDMI\\ Composite TRRS | HDMI\\ Composite RCA | HDMI\\ Composite TRRS | HDMI\\ Composite TRSS | HDMI\\ Composite TRSS | Mini HDMI\\ GPIO Composite | 2 Micro HDMI 4K\\ Composite TRSS |
^ External Storage | SD | Micro SD | SD | Micro SD | Micro SD | Micro SD | Micro SD | Micro SD |

32
data/pages/electronique/raspberry-pi/fondamentaux/index.txt Normal file
View File

@@ -0,0 +1,32 @@
====== Les fondamentaux pour Raspberry Pi ======
Les fondamentaux pour Raspberry Pi incluent:
* Connaissances de base en informatique et en programmation
* Comprendre les bases du système d'exploitation Linux
* Connaissance de la structure du Raspberry Pi et de ses composants
* Comprendre comment connecter des périphériques externes au Raspberry Pi
* Connaître les options de stockage et d'alimentation pour le Raspberry Pi
* Comprendre les protocoles de communication tels que SSH, FTP et les réseaux locaux.
Ces fondamentaux vous permettront de comprendre comment utiliser au mieux votre Raspberry Pi et de réaliser des projets intéressants avec celui-ci.
===== Table des matières =====
* [[.:|introduction]]
==== Les pages ====
<nav stacked="true" fade="true">
<nspages . -h1 -nbCol=1 -textNS=" " -textPages=" " -simpleList -exclude:cookie: -exclude:user: -exclude:playground: -exclude:[sidebar index start rightsidebar navbar topheader header help pageheader pagefooter legal-notices footer 404]>
</nav>
==== Les sous-catégories ====
<nav stacked="true" fade="true">
<nspages . -h1 -nbCol=1 -noPages -subns -textNS=" " -textPages=" " -simpleList -exclude:cookie: -exclude:user: -exclude:playground: -exclude:[sidebar index start rightsidebar navbar topheader header help pageheader pagefooter legal-notices footer 404]>
</nav>
~~NOTOC~~
~~NOCACHE~~

72
data/pages/electronique/raspberry-pi/fondamentaux/ou_acheter_son_raspberrypi4.txt Normal file
View File

@@ -0,0 +1,72 @@
====== Où acheter son Raspberry Pi 4 ? ======
{{ electronique:raspberry-pi:pi4-labelled-ou_acheter.png?direct&600 |}}
Je vous propose une sélection de sites Internet vendant le Raspberry Pi 4, 4 Go en France Métropolitaine. Mais avant tout, je reviens sur les caractéristiques du produit.
Caractéristiques principales :
* **Carte mère** Raspberry Pi 4
* **Pocesseur** : Broadcom BCM2711, quad-core Cortex-A72 (ARM v8) 64-bit SoC @ 1.5GHz
* **RAM** : 4 Go LPDDR4
* **GPU** : VideoCore VI prenant en charge OpenGL ES 3.0
* **Connexion sans fil** : Bluetooth 5.0, BLE\\ Wi-Fi 802.11b/g/n/ac de 2,4 GHz et 5,0 GHz
* **Connexion filaire** : Gigabit Ethernet (RJ45)
* **Lecteur de carte** micro-SD (stockage non fourni)
* **Port caméra** CSI pour connecter la caméra Raspberry Pi
* **Port d'affichage** DSI pour connecter l'écran tactile Raspberry Pi
* **Audio :** AV 3.5 mm
* **Multimédia** : H.265 (décodage 4Kp60)\\ H.264 (décodage 1080p60, encodage 1080p30)\\ OpenGL ES, 3.0 graphiques
* **Ports** : 2 x USB 3.0 \\ 2 x USB 2.0 \\ 1 x USB-C (alimentation seulement) \\ 1 x GPIO 40 pin (compatibilité ascendante avec les cartes précédentes) \\ 1 x port quadripôle Audio/Vidéo composite \\ 2 x micro-HDMI
* **Alimentation** 5V / 3.1A (non fournie) par USB-C ou GPIO\\ Power over Ethernet (PoE) possible – (nécessite l'acquisition d'une carte PoE HAT)
* **Environnement** : Température de fonctionnement 0–50 ° C
<WRAP clear/>
----
{{ electronique:raspberry-pi:capture_raspberrypi4_ldlc.png?direct&600|}}
**LDLC** propose cette //carte mère ultra-compacte// au prix de 79,95€. Le site met en avant //le processeur Broadcom BCM2711 gagne en performance par rapport à son prédécesseur pour une exécution des calculs encore plus fluide.// Aucune date de disponibilité.
https://www.ldlc.com/fiche/PB00273916.html
<WRAP clear/>
----
{{ electronique:raspberry-pi:capture_raspberrypi4_mchobby.png?direct&600|}}
**McHobby** propose ce //Nano-Ordinateur mono-carte// au prix de 59,90€. Le site met en avant le Raspberry Pi 4 qui //est, aujourd'hui, vraiment en mesure de remplacer un ordinateur de bureau//. Il est disponible sans être disponible ....
https://shop.mchobby.be/fr/raspberry-pi-4/1610-raspberry-pi-4-4-go-de-ram-dispo-en-stock--3232100016101.html
<WRAP clear/>
----
{{ :undefined:capture_raspberrypi4_kubbi.png?direct&600|}}
**Kubbi** propose cet //ordinateur// au prix de 58,95€. Le site met en avant //le Raspberry Pi 4 modèle B qui offre des performances de bureau comparables à celles des systèmes PC d'entrée de gamme x86//. Il est en pré-commande pour une livraison en septembre.
https://www.kubii.fr/les-cartes-raspberry-pi/2677-nouveau-raspberry-pi-4-modele-b-3272496298750.html
<WRAP clear/>
----
{{ electronique:raspberry-pi:capture_raspberrypi4_elektor.png?direct&600|}}
**Elektor** propose ce //mutant// au prix de 59,95€. Le site met en avant ce Raspberry Pi 4 B qui //n’a plus rien à envier à un système PC x86 d'entrée de gamme//. Il est en pré-commande pour une livraison le 19 août.
https://www.elektor.fr/raspberry-pi-4-b-4-gb-ram
<WRAP clear/>
<WRAP clear/>
--- //[[user:cedricabonnel]] 2019/08/02 23:38//\\
Aucun lien sponsorisé

48
data/pages/electronique/raspberry-pi/fondamentaux/stockage_pour_raspberry_pi.txt Normal file
View File

@@ -0,0 +1,48 @@
====== Le stockage principal du Raspberry Pi ======
En standard, les Raspberry Pi requièrent au minimum pour fonctionner un support de stockage mémoire carte SD ou micro SD selon le modèle.
===== - Cartes SD pour Raspberry Pi =====
La taille minimale pour une installation de **Raspbian Lite** est de 4 Go. Pour les Raspberry Pi 3A+ et 3B+, la taille maximale de la carte SD de boot doit être de **256 Go**. En règle générale, une carte de 32 Go suffit.
L’usure des cartes SD est due uniquement à l'écriture des informations dans les cellules mémoire flash. Il faut entre 10 000 et 100 000 cycles d'écriture sur une cellule avant la mort de celle-ci, selon les technologies.
> Carte SD de 32 Go pour Raspbian Desktop Full
La partition de la carte SD doit être **FAT16** ou **FAT32**. Attention, car les cartes SD de taille supérieure à 32 Go sont formatée en exFAT. Il sera impératif de reformater en **FAT32**.
===== - Boot sur disque dur avec un Raspberry Pi =====
>> Modifier le fichier ''/boot/config.txt''
Jusqu'au **Raspberry Pi 3**, pour indiquer au Raspberry Pi de booter sur le disque dur branche sur un port USB, il faut à la fin du fichier ''/boot/config.txt'' écrire un paramètre. Celui-ci modifie le registre 17, bit 21 de l'OTP.
<code>program_usb_boot_mode=1</code>
> Plus d'informations sur l'OTP : [[https://www.raspberrypi.org/documentation/hardware/raspberrypi/otpbits.md|OTP register and bit definitions]]
>> Vérifier
Après avoir redémarré de nouveau, dans un terminal, il faut exécuter le programme **vcgencmd** avec le paramètre **opt_dump**. Cela affiche toutes les valeurs OTP (One-time Programmable).
<code>vcgencmd otp_dump | grep 17</code>
La valeur retournée doit être :
<code>17:3020000a</code>
Soit en binaire (32 bits) :
<code>0011 0000 0010 0000 0000 0000 0000 1010</code>
J'éteins le Raspberry Pi et enlève la carte micro SD.
Le Raspberry Pi peut maintenant démarrer sur un périphérique USB (clé ou disque). Si un carte micro SD est présente, elle reste prioritaire lors de la séquence de boot.
===== - Réduire le temps de démarrage =====
On peut raccourcir le délai de //boot// sur disque USB ou clé USB, en insérant une carte micro SD vierge.
===== - A voir aussi =====
* Vidéo : [[https://youtu.be/b83r13rtR8A?t=426|Raspberry Pi 3B/3B+ USB SATA/SSD (2019)]]
* [[https://www.framboise314.fr/boot-simplifie-sur-usb-avec-les-raspberry-pi-1-2-et-3/|Boot simplifié sur USB avec les Raspberry Pi 1, 2 et 3]]
* https://jamesachambers.com/raspberry-pi-storage-benchmarks-2019-benchmarking-script/

60
data/pages/electronique/raspberry-pi/index.txt Normal file
View File

@@ -0,0 +1,60 @@
~~NOTOC~~
{{ electronique:raspberry-pi:raspberry_pi-64x64.png|}} ====== Raspberry Pi ======
Je rédige ces pages pour me souvenir de comment utiliser Raspberry Pi. En effet, ce n'est pas tous les jours que l'on fait ces manipulations, donc il est plus prudent de prendre des notes.
Je note du déploiement à la réalisation de projets. J'espère être le plus clair possible.
Je vous laisse découvrir les chapitres de mes notes sur Rasberry Pi ci-dessous.
<WRAP center round box>
Je vous propose une sélection d'articles.
{{page>lectronique:raspberry-pi:raspbian:start}}
* Kodi
* [[informatique:linux:linux:logiciels:recallbox]]
**Quelques projets** :
* [[electronique:teleinformation-compteur-electricite:index]]
Des **trucs et astuces** :
* [[electronique:raspberry-pi:relever_temperature_cpu_gpu]]
* [[electronique:raspberry-pi:fondamentaux:stockage_pour_raspberry_pi]]
* [[informatique:linux:cfp:changer-le-nom-de-machine]]
* [[electronique:raspberry-pi:configurer_alimentation_disque_dur]]
**Ressources complémentaires** :
* [[electronique:raspberry-pi:quelques_liens]]
* [[electronique:raspberry-pi:the-magpi]]
</WRAP>
===== Table des matières =====
* [[.:|introduction]]
==== Les pages ====
<nav stacked="true" fade="true">
<nspages . -h1 -nbCol=1 -textNS=" " -textPages=" " -simpleList -exclude:cookie: -exclude:user: -exclude:playground: -exclude:[sidebar index start rightsidebar navbar topheader header help pageheader pagefooter legal-notices footer 404]>
</nav>
==== Les sous-catégories ====
<nav stacked="true" fade="true">
<nspages . -h1 -nbCol=1 -noPages -subns -textNS=" " -textPages=" " -simpleList -exclude:cookie: -exclude:user: -exclude:playground: -exclude:[sidebar index start rightsidebar navbar topheader header help pageheader pagefooter legal-notices footer 404]>
</nav>
~~NOTOC~~
~~NOCACHE~~

8
data/pages/electronique/raspberry-pi/lire-le-numero-de-serie.txt Normal file
View File

@@ -0,0 +1,8 @@
====== Lire le numéro de série du Raspberry Pi ======
{{ :electronique:raspberry-pi:pasted:20220220-193728.png?300}}
Le fichier ''/sys/firmware/devicetree/base/serial-number'' contient le numéro de série du Raspberry Pi. On peut utiliser la commande suivante pour le lire :
cat /sys/firmware/devicetree/base/serial-number
Le fichier ''/proc/cpuinfo'' contient des informations sur les processeurs et il contient également le numéro de série du Raspberry Pi. La commande suivante permet d'extraire le numéro de série :
cat /proc/cpuinfo | grep Serial | cut -d ' ' -f 2

25
data/pages/electronique/raspberry-pi/quelques_liens.txt Normal file
View File

@@ -0,0 +1,25 @@
===== Quelques liens =====
{{ electronique:raspberry-pi:http-63525_960_720.jpg?nolink&200|}}
Informations concernant le Raspberry Pi
* [[https://fedoraproject.org/wiki/Raspberry_Pi]]
* [[https://korben.info/univers/raspberry-pi]]
* [[https://fr.wikipedia.org/wiki/Raspberry_Pi]]
* [[http://raspbian-france.fr/]]
* [[http://raspbian-france.fr/accessoires-raspberry-pi-2/]]
Evolution des prix sur Amazon
* [[http://fr.camelcamelcamel.com/Raspberry-Pi-Processeur-900MHz-lecteur/product/B00T2U7R7I]]
Liste des OS avec liens et infos
* [[https://www.raspberrypi.org/downloads/]]
NAS, Media Center and Co
* [[http://blog.idleman.fr/billet-invite-creer-un-nas-avec-le-raspberry-pi/]]
* [[http://pihair.fr/creer-un-mediacenternasseedbox-avec-un-raspberry-pi/]]
* [[http://chezmat.fr/nas-low-cost-raspberry-pi-part1/]]
* [[http://linuxfr.org/users/totof2000/journaux/un-clone-de-la-raspberry-pi-avec-reseau-1-gb-et-port-sata]]
Mindcraft sur Raspberry
* [[informatique:applications:minecraft]]

71
data/pages/electronique/raspberry-pi/relever_temperature_cpu_gpu.txt Normal file
View File

@@ -0,0 +1,71 @@
====== Relever la température dans la GPU et le CPU d'un Raspberry Pi ======
Il est judicieux de connaître la température du processeur et de la puce graphique afin de ne pas endommager votre Raspberry Pi. **La température maximale est de 80 °C**, au delà de 93 °C les composants peuvent subir des dommages irréversibles. Le pire ? Griller votre carte !
Voici mes tests réalisés avec un Raspberry Pi 4.
===== Fondamentaux =====
La température de la GPU est accessible depuis la commande ''vcgencmd'' et le paramètre ''measure_temp'' :
<code>
$ vcgencmd measure_temp
temp=43.0'C
</code>
La température du processeur est stocké dans le fichier ''/sys/class/thermal/thermal_zone0/temp'', exprimée en millième de **°C** :
<code>
$ cat /sys/class/thermal/thermal_zone0/temp
44790
</code>
Pour afficher la valeur en **°C**, il faut effectuer une division par 1000 de la valeur contenue dans ''/sys/class/thermal/thermal_zone0/temp'' :
<code>
$ awk '{printf("\ntemp=%.1f°C\n\n",$1/1e3)}' /sys/class/thermal/thermal_zone0/temp
temp=44.7'C
</code>
===== Script évolué =====
Le script ci-dessous affiche la température de la GPU et du CPU.
<code BASH piSensorsTemp>
#!/bin/bash
# Script: piSensorsTemp
# Purpose: Display the ARM CPU and GPU temperature of Raspberry Pi 2/3/4
# Author: Cédric Abonnel <https://www.abonnel.fr/start?q=piSensorsTemp&do=search> under CC BY
# -------------------------------------------------------
echo "$(date) @ $(hostname)"
echo "-------------------------------------------"
echo "GPU => $(/opt/vc/bin/vcgencmd measure_temp)"
echo "CPU => $(awk '{printf("temp=%.1f°C\n\n",$1/1e3)}' /sys/class/thermal/thermal_zone0/temp)"
</code>
Pour rendre exécutable le code :
<code>
$ sudo chmod +x piSensorsTemp
$ ./piSensorsTemp
</code>
Pour afficher toutes les secondes, les informations rafraîchies :
<code>
$ watch -n 1 -d ./piSensorsTemp
</code>
Exemple d'execution :
<code>
$ ./piSensorsTemp
vendredi 17 janvier 2020, 11:25:31 (UTC+0100) @ rpitst
-------------------------------------------
GPU => temp=43.0'C
CPU => temp=43.3°C
</code>
===== Biblio =====
[[https://www.cyberciti.biz/faq/linux-find-out-raspberry-pi-gpu-and-arm-cpu-temperature-command/|How to find out Raspberry Pi GPU and ARM CPU temperature on Linux]]
[[https://github.com/lm-sensors/lm-sensors/issues/30|lm-sensors does not detect integrated temperature sensor on Raspberry Pi]]

2
data/pages/electronique/raspberry-pi/sidebar.txt Normal file
View File

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

19
data/pages/electronique/raspberry-pi/test_carte_relais_8_voies/index.txt Normal file
View File

@@ -0,0 +1,19 @@
====== Test d'une carte relais 8 voies ======
<WRAP group>
<WRAP half column>
{{youtube>dvS1mSxiYAk?medium}}
</WRAP>
<WRAP half column>
**Caractéristiques principales :**\\
Relais haut courant, AC 250 V / 10 A, DC 30 V / 10 A\\
Chaque canal requiert un courant conducteur de 15-20 mA
[[http://www.amazon.fr/gp/product/B00AEIDWXK|Vendu sur Amazon à 5,20 EUR]]
</WRAP>
</WRAP>

46
data/pages/electronique/raspberry-pi/the-magpi.txt Normal file
View File

@@ -0,0 +1,46 @@
===== Rasbperry Pi : The MagPi =====
<WRAP group>
<WRAP half column>
**The MagPi** est le magazine officiel du Raspberry Pi. Il livre les dernières infos, tests, caractéristiques et tutoriaux de votre PC format carte de crédit.
Plus! All this inside The MagPi 80
* Amazing ham radio projects
* Use ham radio with Raspberry Pi
* Hack a Lego Boost
* Use a Raspberry Pi device to control your Lego projects
* Set up a Samba file server
* Quickly build a Raspberry Pi network file-storage device
* Build a karaoke machine
* Sing your heart out with this great Raspberry Pi project
* Make comic books from TV recordings
* Automatically turn video recordings into mock hand-drawn comic books
* The top 10 HATs
* The best Hardware Attached on Top accessories for Raspberry Pi
* Learn the command line
* A great selection of resources for anybody looking to boost their command-line skills
* Underwater drone
* How one reader has built a remote-control underwater robot
* The Clapper
* Recreate this classic clap on/off light switch with a Raspberry Pi
* Win! Keybow keyboards
* Your chance to win one of five mechanical keyboards
Need more details. View the contents page for a complete list of what’s in the mag.
Et bien plus encore et encore !
[[https://www.raspberrypi.org/magpi-issues/MagPi80.pdf|Télécharger The MagPi #80]]\\
[[https://www.raspberrypi.org/magpi/issues/80/|The MagPi #80 HomePage]]
</WRAP>
<WRAP half column>
{{ electronique:raspberry-pi:001_magpi80_cover_web.jpg?nolink&400 |}}
</WRAP>
</WRAP>

43
data/pages/electronique/ressort-de-compression.txt Normal file
View File

@@ -0,0 +1,43 @@
====== Ressorts de compression ======
{{ :electronique:pasted:20211124-174856.png?100|Ressort de compression}}
Les ressorts de compression sont utilisés dans une large gamme de produits où une force de compression est requise. Cela peut inclure n’importe quoi, des aides auditives aux stylos-billes ou aux tondeuses, en passant par les machines industrielles et bien plus encore.
Un ressort de compression est à la base un composant qui peut accumuler une force et fonctionner très longtemps à des niveaux optimaux, pourvu qu’il soit utilisé correctement et de la bonne dimension. Le ressort comprimé accumule une force qui se détend dès qu’il revient à sa longueur d’origine.
===== Materiaux =====
==== En corde à piano ====
L’utilisation de ressorts en corde à piano est recommandée dans les environnements secs. En effet, le matériau ne dispose d’aucune protection contre la rouille. Les ressorts en corde à piano sont environ 10 % plus robustes que les ressorts en acier inoxydable.
Les ressorts de compression électrozingués sont fabriqués à partir de corde à piano puis électrozingués. Cela leur confère une surface brillante et attrayante. L’électrozingage n’offre qu’une résistance moyenne à la corrosion, mais si le ressort est utilisé en environnement humide, sa durée de vie sera plus longue par rapport à celle d’un même ressort qui serait fabriqué en corde à piano sans traitement de surface.
==== En fil d’acier inoxydable ====
Pour les environnements humides, il est recommandé les ressorts en fil d’acier inoxydable. Les ressorts en acier inoxydable sont approximativement 10 % moins puissants que les ressorts en **corde à piano**.
Si vous utilisez des ressorts dans des environnements où ils seront exposés à des produits chimiques agressifs ou à l’eau de mer, il est recommandé les ressorts fabriqués à partir d’un type spécial d’acier inoxydable (AISI 316).
===== Cotes =====
{{:electronique:pasted:20211124-180147.png}}
| d | Diamètre du fil (mm) |
| De | Diamètre extérieur (mm) |
| Di | Diamètre intérieur (mm) |
| L0 | Longueur libre (mm) |
| Ln | Longueur sous charge max. (mm) |
| Sn | Course maximale (mm) |
| Fn | Charge maximale sous Ln (N) |
| R | Constante de ressort (N/mm) |
---
{{:electronique:pasted:20211124-174009.png}}*
Diamètre du fil * diamètre extérieur * longueur
Wire diameter * outer diameter * length
Par exemple **1.0*10*100** signifie que le diamètre du fil est de **1.0mm**, le diamètre extérieur est de **10mm** et la longueur est de **100mm**.

5
data/pages/electronique/sidebar.txt Normal file
View File

@@ -0,0 +1,5 @@
{{ :logo-electronique.png?nolink&150x150|Electronique, Arduino & Raspberry Pi}}
<WRAP clear/>
{{page>index#table-des-matieres}}
~~NOCACHE~~

42
data/pages/electronique/teleinformation-compteur-electricite/circuit-de-demodulation-ask.txt Normal file
View File

@@ -0,0 +1,42 @@
====== Démodulation ASK ======
Les compteurs électriques de type électronique, fournis par Enedis (anciennement ErDF et EDF), permettent d'effectuer une relevé d'information par liaison informatique. Cette liaison informatique est assimilée à une liaison série, appelée également TTL ou RS232, après un traitement correctif.
Cette liaison série permet de communiquer avec le compteur et ainsi obtenir des informations tel que la consommation instantanée, la consommation électrique, la puissance maximale autorisée...
Les infos sont transmises cycliquement sur la ligne, modulées en **ASK à 50kHz**, ce qui correspond en gros à : soit aucune tension présente, soit un signal à 50kHz de 10V CC environ. Le 0V équivaut à un 1 logique, le 50kHz à un 0 logique. Pour être exploitées, ces infos doivent être démodulées pour être aux formats **TTL** ou **RS232**.
L’accès au circuit de communication se fait via les bornes **I1** et **A**. Ce circuit est mis à disposition des clients pour alimenter un récepteur de télé-information rattaché au compteur.
Lorsque aucune charge n’est raccordée à la sortie de l’alimentation au circuit de communication, la tension aux bornes de l’alimentation vaut 13 Vrms max.
En charge, la tension est 6 Vrms ±10% à 50 kHz (12 V pic au maximum tenant compte d’éventuelles déformations du signal). La puissance minimale délivrée est de 130 mW.
{{ electronique:teleinformation-compteur-electricite:teleinformation-modulee-ask-50-khz.jpg?400 |}}
Il convient de protéger la sortie contre les court-circuits. La tenue à la tension secteur (230 V 50Hz) est exigée (en cas de branchement intempestif de l’installation client).
Les spécifications imposées par ERDF pour les compteurs électroniques et intelligents Linky indiquent que la **composante** parallèle **résistive** doit être au **maximum de 2 KΩ** **sur le bornier de sortie** **Téléinfo**.
Le signal émis par le compteur est de la modulation ASK, c'est une modulation du signal binaire dans une onde de 50Hz.
Je me suis basé sur un schéma proposé par le site [[http://hallard.me]] pour réaliser le circuit interface entre le bornier Téléinfo et le Rabperry Pi.
Pour réaliser l'interface entre le bornier TIC et le Raspberry Pi, j'ai acheté :
* une plaque pré-percée
* 2 résistances
* un opto-coupleur
* bornier
* câbles pour connecter au Raspberry Pi
* câble pour relier au bornier TIC - câble réseau
{{ electronique:teleinformation-compteur-electricite:opto_teleinfo_1.png?direct&600 |}}
Si vous avez des difficultés, je vous conseille vivement le circuit proposé sur la page [[http://hallard.me/pitinfov12/]]
On va relier le deux conducteurs provenant du **démodulateur** sur les borniers 9 et 10 de la GPIO du RaspberryPi.
La **bornier 9** étant le **GND** et la **bornier 10** le **RxD**.
{{ electronique:teleinformation-compteur-electricite:raspberrypi_2_pinout_zoom.png?direct&600 |}}

267
data/pages/electronique/teleinformation-compteur-electricite/cote_informatique.txt Normal file
View File

@@ -0,0 +1,267 @@
===== Coté informatique =====
Voici le principe de fonctionnement que je voulais faire initialement :
- lecteur des informations sur le port série (coté local)
- envoie sur serveur de base de données SGBD (coté serveur)
On y reviendra plus tard.
Pour l'instant j'installe tout sur le raspberyPi.
==== Installer PHP ====
La lecture sur des informations va s'effectuer en PHP. C'est le plus simple pour moi parce que c'est très proche du langage C.
Dans un premier temps il faut installer l’interpréteur PHP :
sudo apt-get install php
<WRAP group round box>
<WRAP half column>
On s’aperçoit que l'installation du package PHP intègre d'autres composants.
On retrouve Apache2 et des fonctions associées à SQLite3, LDAP et JSON.
Plusieurs fichiers de configuration sont créés :
* ''/etc/php/7.0/apache2/php.ini''
* ''/etc/php/7.0/cli/php.ini''
* fichiers présents dans ''/etc/php/7.0/mods-available/''
Deux binaires sont accessibles :
* ''php''
* ''phar''
</WRAP>
<WRAP half column>
<code>
Lecture des listes de paquets... Fait
Construction de l'arbre des dépendances
Lecture des informations d'état... Fait
The following additional packages will be installed:
apache2 apache2-bin apache2-data apache2-utils libapache2-mod-php7.0 libapr1 libaprutil1
libaprutil1-dbd-sqlite3 libaprutil1-ldap php-common php7.0 php7.0-cli php7.0-common php7.0-json
php7.0-opcache php7.0-readline ssl-cert
Paquets suggérés :
apache2-doc apache2-suexec-pristine | apache2-suexec-custom php-pear openssl-blacklist
Les NOUVEAUX paquets suivants seront installés :
apache2 apache2-bin apache2-data apache2-utils libapache2-mod-php7.0 libapr1 libaprutil1
libaprutil1-dbd-sqlite3 libaprutil1-ldap php php-common php7.0 php7.0-cli php7.0-common php7.0-json
php7.0-opcache php7.0-readline ssl-cert
0 mis à jour, 18 nouvellement installés, 0 à enlever et 0 non mis à jour.
Il est nécessaire de prendre 4 582 ko dans les archives.
Après cette opération, 17,0 Mo d'espace disque supplémentaires seront utilisés.
Souhaitez-vous continuer ? [O/n]
</code>
</WRAP>
</WRAP>
==== Installer le SGBD PostgreSQL ====
<WRAP group round box>
<WRAP half column>
J'ai installé le SGBD PostgreSQL ainsi que le bibliothèque de connexion PHP.
Une fois installé, les programmes n'occuperont que 30 Mo. Je n'ai pas l'habitude d'avoir une installation prenant aussi peu de place.
</WRAP>
<WRAP half column>
sudo apt-get install php-pgsql postgresql
Résultat :
<code>
Lecture des listes de paquets... Fait
Construction de l'arbre des dépendances
Lecture des informations d'état... Fait
The following additional packages will be installed:
libpq5 php7.0-pgsql postgresql-9.6 postgresql-client-9.6 postgresql-client-common postgresql-common
postgresql-contrib-9.6 sysstat
Paquets suggérés :
postgresql-doc locales-all postgresql-doc-9.6 libdbd-pg-perl isag
Les NOUVEAUX paquets suivants seront installés :
libpq5 php-pgsql php7.0-pgsql postgresql postgresql-9.6 postgresql-client-9.6
postgresql-client-common postgresql-common postgresql-contrib-9.6 sysstat
0 mis à jour, 10 nouvellement installés, 0 à enlever et 0 non mis à jour.
Il est nécessaire de prendre 6 281 ko dans les archives.
Après cette opération, 30,2 Mo d'espace disque supplémentaires seront utilisés.
Souhaitez-vous continuer ? [O/n]
</code>
</WRAP>
</WRAP>
==== Paramétrer le SGBD PostgreSQL ====
<WRAP center round box>
Voilà comment je fais pour me connecter au moteur de SGBD PostgreSQL. J'effectue ces manipulations depuis le compte ''pi''.
1. Je me connecte avec le compte du SGBD qui se nomme ''postgres'' :
sudo su postgres
2. Je me connecte au SGBD :
psql
Oh joie ! L'invite ''postgres=#'' apparaît.
</WRAP>
==== Créer la base de données ====
Je vais utiliser les informations suivantes :
* base de données : ''ampere''
* utilisateur de la base de données (rôle) : ''r_ampere''
<WRAP group round box>
<WRAP half column>
Il faut créer l'utilisateur de la base de données. De manière schématique, l'utilisateur de connexion à la base de données s'appelle un ''rôle''.
</WRAP>
<WRAP half column>
Création du rôle ''r_ampere''
CREATE ROLE r_ampere PASSWORD 'This1sN0tAnPwd' LOGIN VALID UNTIL 'infinity';
</WRAP>
</WRAP>
<WRAP group box round>
<WRAP half column>
Il faut créer la base de données qui va accueillir les données.
J'ai choisi d'utiliser l'encodage ''UTF-8'' dans la base de données, et l'utilisation des règles de la langue Française (''fr_FR'').
</WRAP>
<WRAP half column>
CREATE DATABASE "ampere"
WITH OWNER "r_ampere"
ENCODING 'UTF8'
LC_COLLATE = 'fr_FR.UTF-8'
LC_CTYPE = 'fr_FR.UTF-8';
</WRAP>
</WRAP>
<WRAP group box round>
<WRAP half column>
Il faut autoriser les connexions. Pour cela, le fichier de configuration des clients authentifié doit être adapté. Lors de l'installation du SGBD, il a été créé dans ''/etc/postgresql/9.6/main/pg_hba.conf''
Il faut l'adapter suivant le schéma suivant :
host database user address auth-method
</WRAP>
<WRAP half column>
On s'identifie avec l'utilisateur ''postgres'' :
pi: $ sudo su - postgres
On ajoute dans le fichier ''/etc/postgresql/9.6/main/pg_hba.conf'' :
local ampere r_ampere trust
On sort de l'environnement ''postgres'' :
postgres: $ exit
Une fois le paramétrage terminé, il faut redémarrer le SGBD :
pi: $ sudo service postgresql reload
On teste la connexion :
pi: $ psql -U r_ampere -W -d ampere
</WRAP>
</WRAP>
==== Principe de fonctionnement ====
Un programme doit sans cesse boucler pour effectuer cette action :
1. lire une trame sur /dev/ttyAMA0 readTrame
2. ajouter un timestamp dans la trame
3. mémoriser la trame brute avec timestamp dans une mémoire tampon - saveTrameTampon
saveTrameBdd
saveTrameCsv
==== Insérer une fichier CSV dans une table MySQL ====
<code PHP>
<?php
$databasehost = "localhost";
$databasename = "telereleve_elec";
$databasetable = "tr_journalier";
$databaseusername="Utilisateur";
$databasepassword = "motDePasse";
$fieldseparator = ",";
$lineseparator = "\n";
$csvfile = "releves/teleinfo_20181219.csv";
if(!file_exists($csvfile)) {
die("File not found. Make sure you specified the correct path.\n");
}
try {
$pdo = new PDO("mysql:host=$databasehost;dbname=$databasename",
$databaseusername, $databasepassword,
array(
PDO::MYSQL_ATTR_LOCAL_INFILE => true,
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION
)
);
} catch (PDOException $e) {
die("database connection failed: ".$e->getMessage());
}
$affectedRows = $pdo->exec("
LOAD DATA LOCAL INFILE ".$pdo->quote($csvfile)." INTO TABLE `$databasetable`
FIELDS TERMINATED BY ".$pdo->quote($fieldseparator)."
LINES TERMINATED BY ".$pdo->quote($lineseparator));
echo "Loaded a total of $affectedRows records from this csv file.\n";
?>
</code>
==== Transformer une donnée timestamp unix en format date et heure ====
SELECT FROM_UNIXTIME(`TIMESTAMP`) FROM `tr_journalier`
==== Bibliothèque PHP ====
Le programme sera écrit en PHP. On va au maximum utiliser des méthodes afin d'obtenir des informations sur la consommation :
* quelle est la consommation Intensité instantannée ? - getIINST
* quelle est la valeur du compteur HC ? - getHCHC
* quelle est la valeur du compteur HP ? - getHCHP
* quelle est la période tarifaire en cours ? - getPTEC
* quelle est la puissance apparente ? - getPAPP
et obtenir des informations sur l'abonnement :
* quelle est le N° d’identification du compteur ? - getADCO
* quelle est l'Option tarifaire ? - getOPTARIF
* quelle est l'Intensité souscrite ? - getISOUSC
Je pense également à des méthodes d'analyse :
* quelle est la consommation HC/HP de la période tarifaire actuelle ? - getConsoPeriodeNow(tarif)
* quelle est la consommation HC/HP de la période précédente ? - getConsoPeriodePrev(tarif)
* quelle est la consommation HC/HP des 24 dernières heures ? - getConsoPeriode24(tarif)
* quelle est la consommation HC/HP d'une période de 7 jours X ? - getConsoPeriode7jours(tarif, dateHeureDebut)
* quelle est la consommation HC/HP de la minute X ? - getConsoMinute(tarif, dateHeure)
* quelle est la consommation HC/HP de l'heure X ? - getConsoHeure(tarif, dateHeure)
* quelle est la consommation HC/HP du jour X ? - getConsoJour(tarif, dateHeure)
* quelle est la consommation HC/HP de la semaine X ? - getConsoSemaine(tarif, date)
* quelle est la consommation HC/HP du mois X ? - getConsoMois(tarif, date)
* quelle est la consommation HC/HP de l'année X ? - getConsoAnnee(tarif, date)
Et ensuite on pourra partir sur des statistiques :
* moyenne
* tendance
* ...
=== Projets ===
http://vesta.homelinux.free.fr/wiki/demodulateur_teleinformation_edf.html
http://lhuet.github.io/blog/2014/01/montage-teleinfo.html
Projet de http://www.magdiblog.fr/gpio/teleinfo-edf-suivi-conso-de-votre-compteur-electrique/
Le relevé d'info compatible http://hallard.me/teleinfo-emoncms/

35
data/pages/electronique/teleinformation-compteur-electricite/index.txt Normal file
View File

@@ -0,0 +1,35 @@
====== Télé-information client des compteurs d'électricité ======
{{ journal_geek:teleinformation_compteur_edf:sagem-s10c4-complet.jpg?75|Compteur électronique SAGEM S10-C4}}
Dans ce projet, je m'appuie sur un Rasbperry Pi pour réaliser un auto relevé.
Il s'agit de retrouver un projet autour d'un Raspberry Pi pour **récupérer de manière régulière** et **automatique** les informations d'un compteur électronique d'électricité de votre distributeur d'électricité (alterna, direct energie, happ'e, proxelia, lampiris, engie, planete oui, edf, énergem, enercoop ...). On pourra relever l'**intensité** et la **puissance instantanées**, les **index** et quelques autres informations.
Les compteurs électroniques, comme les SAGEM S10C1 S10C2 S10C3 et S10C4, possèdent une interface de communication. La réduction en volume et l'augmentation de la puissance de la micro informatique permettent de s'amuser avec ce port de communication, et faire un projet de domotique bien sympathique.
Je vous invite avec une série d'articles à découvrir mes découvertes et tests.
====== Table des matières ======
* [[index|Introduction]]
* Le compteur électrique
* [[electronique:teleinformation-compteur-electricite:le-bornier-teleinformation-d-un-compteur|]]
* [[electronique:teleinformation-compteur-electricite:linky|]]
* [[electronique:teleinformation-compteur-electricite:protocole-de-communication-du-compteur-electrique|]]
* Le démodulateur
* [[electronique:teleinformation-compteur-electricite:circuit-de-demodulation-ask|]]
* Le Raspberry Pi
* [[electronique:teleinformation-compteur-electricite:preparation-du-raspberry-pi|]]
* [[electronique:teleinformation-compteur-electricite:installation-programme-raspjson]]
* [[electronique:teleinformation-compteur-electricite:traitement-json-tic-edf]]
* Le protocole MQTT
* [[informatique:linux:applications:mosquitto]]
* Envoie des fichiers CSV à un service Web
* [[.:script_bash_upload]]
* [[.:page_upload]]
* [[electronique:teleinformation-compteur-electricite:quelques_liens|]]

49
data/pages/electronique/teleinformation-compteur-electricite/installation-programme-raspjson.txt Normal file
View File

@@ -0,0 +1,49 @@
====== Installer le programme RASPJSON ======
{{ :dummy.png?75x75|Nom de la section}}
Lorem ipsum dolor sit amet, ...
sudo apt install build-essential git-core
--
Récupérer le projet
git clone https://github.com/hallard/LibTeleinfo
--
Accéder au dossier
cd LibTeleinfo/examples/Raspberry_JSON/src
--
Modification des infos dans
nano raspjson.cpp
nano LibTeleinfo.h
pour inclure le chemin
#include "../../src/LibTeleinfo.h"
--
Compilation
sudo make
--
Exécution du programme
./raspjson -d /dev/serial0&
--
Exemple de trames reçues
{"_UPTIME":310146, "ADCO":2147483647, "ISOUSC":60, "PTEC":"HC..", "IINST":24, "IMAX":90, "PAPP":5260, "MOTDETAT":0, "ISOUHHPHC":"A", "HO":2147483647, "HCHC":15205491, "HCHP":4851788, "OPTARIF":"HC..", "HHPHC":"A"}

1
data/pages/electronique/teleinformation-compteur-electricite/installer-mqtt-broker-mosquitto-linux.txt Normal file
View File

@@ -0,0 +1 @@
~~REDIRECT>informatique:applications:mosquitto~~

38
data/pages/electronique/teleinformation-compteur-electricite/le-bornier-teleinformation-d-un-compteur.txt Normal file
View File

@@ -0,0 +1,38 @@
====== Le bornier téléinfo ======
En France, c'est à la suite à l’arrêté du 6 janvier 1987 relatif à la construction et à l’approbation de types de compteurs d’énergie électrique, fondés sur un principe électronique, qu'est apparu les **compteurs électroniques**. Il permettait la réception et l'interprétation des ordres de télécommande centralisée 175 Hz de réseau de distribution, mais cela ne nous intéresse pas dans ce dossier. La partie intéressante de ces nouveaux compteurs est l'aide à la gestion de la consommation d'énergie, au moyen d'une liaison série de **télé-information client** sur laquelle le compteur **envoie en permanence ses données internes**.
La télé-information du client est réalisée par une liaison série (modulée en ASK à 50 kHz) qui diffuse en permanence les informations contenues dans les mémoires du compteur.
{{ electronique:teleinformation-compteur-electricite:teleinformation-modulee-ask-50-khz.jpg?400 |télé-information modulée en ASK à 50 kHz}}
Les informations qui sont transmises sur une ligne bifilaire avec écran peuvent être utilisées par un dispositif de gestion de l’énergie. Les bornes de cette liaison sont isolées galvaniquement des circuits internes du compteur.
Cette liaison doit être configurée (en programmation locale) :
* mode **TELEIN** : trames de télé-information transmises
* mode **METROL** : émission d’impulsions métrologiques
* mode **VEILLE** : trames réduites à l’émission de numéro de série.
Après démodulation, on retrouve une liaison asynchrone classique :
* vitesse de transmission : 1200 bits/s
* parité paire
* 7 bits par caractère
* 1 stop bit.
{{ electronique:teleinformation-compteur-electricite:teleinfo_compteur_erdf_sagem.jpg?400|}}
Le Raspberry Pi va se connecter à la sortie **Téléinfo** du compteur. Ce **bornier** est **identifié** **I1** et **I2**. Ce bornier est disponible sur les compteurs suivants :
* compteur électronique de marques SAGEM, Landis+Gyr.
* compteur intelligent Linky de marques Sagemcom, Landis+Gyr et Itron.
Les caractéristiques physiques du câble à utiliser entre le RasbperryPi et la sortie télé-information du compteur sont celles d’un câble téléphonique intérieur de type suivant:
* paire torsadée simple avec écran (aluminium) et conducteur de drain,
* conducteurs monobrins en cuivre étamé de diamètre compris entre 0,5 mm et 0,6 mm,
* isolant PVC.
En utilisation, la longueur du bus mis en œuvre doit est inférieure ou égale à 500m (en topologie quelconque).
Ce qui n'oblige pas à disposer le RasbperryPi à proximité du compteur.
biblio : http://www.erdf.fr/sites/default/files/ERDF-NOI-CPT_02E.pdf

Some files were not shown because too many files have changed in this diff Show More