mjcsystem - Tumblr blog

mjcsystem · 9 years ago

Text

Projet_Repulsif_Nusible_IoT

Projet : Construction d’un Répulsif à Nuisible Ultra-Sonique Connectée

Objectif :

Le montage proposé devrait permettre de traiter un problème récurent de nos appartements et maisons. Nous côtoyons voir hébergeons de nombreuses petites bébêtes plus ou moins sympathiques, que nous trouverons encore plus sympathique si elles avaient idées de s’amuser en-dehors de nos foyers. L’objectif de ce montage est simplement d’aider ces petites amies d’aller vivre ailleurs, en les invitants par un petit signal adapté à chacune d’entre elles de quitter nos foyers. Techniquement, il s’agit d’émettre un signal à Ultrason correspondant au mieux à chaque nuisible, à la détection de ce dernier. Accessoirement rapporter les statistiques de fonctionnements sur nos smartphones, via l’infrastructure MQTT-Mosquitto + Node-Red déjà déployé lors du dernier projet de prises connectées.

Schéma Général

Moyens : Modules / Composants

1. Module détecteur de mouvements infra-rouge HCSR501

Ce petit module, que j’ai déjà utilisé précédemment, est précis et fiable. Il permet le déclenchement de dispositif automatique en liaison avec tous types de µContrôleur.

Valeur moyenne : 1€

Applications type :

Allumage ou extinction automatique d’éclairages,

Piège photographique d’animaux,

Alarmes de locaux,

Détecteur de présence,

Compteur de passages,

Sécurité,

et là on va voir si l’on peu détecter les p’it souris.

Caractéristiques

Capteur de type HC SR501

Tension de fonctionnement : 5V à 20V continu (DC).

Consommation statique de 65 micro Ampères

Niveaux de sortie : High 3.3 V, Low 0 V.

Temps de délai ajustable de 0.3 secondes à 18 secondes.

Temps mort 0.2 secondes.

Déclenchement : L sans répétition , H répétition possible, valeur H par défaut.

Portée de détection : angle de moins de 120°, 7 mètres.

Température de fonctionnement de -15°C à +70 °C.

Dimensions du PCB 32x24 mm

Ecart entre les trous de 28mm, diamètre de vis du capteur de 2 mm

Capteur de 23 mm de diamètre.

Brochage - Raccordement :

2. µContrôleur module de communication ESP-12F

J’ai déjà bien documenté ce module, je vous invite donc à retrouver la description ICI :

3. Module ‘AD9833’ Générateur de Signal, Sinusoïdale, Carrée, Triangulaire.

Valeur moyenne : 7€

Description générale :

L’AD9833 est un générateur de signal programmable capable de produire des signaux sinusoïdales, triangulaires, et carrées, de faible puissance. Un génération de signal est utiliser dans de nombreuses situations, pour des applications de réceptions où d’émissions, mais aussi pour des applications de réfléctrométrie temporel (TDR), et bien d’autres comme pour l’usage très particulier visé dans ce projet . La fréquence de sortie comme le phasage du signal, sont programmable par logiciel, ce qui permet un réglage et une utilisation simplifier. Aucun autre composant externe complémentaire est nécessaires.

Les consignes de fréquence sont codées sur 28 bits, cela permet une précision de réglage remarquable :

avec une fréquence d’horloge de 25 MHz, on obtient une résolution de 0,1 Hz,

avec une fréquence d’horloge de 1 MHz, on obtient une résolution de 0,004 Hz,

L’AD9833 se pilote en mode série SPI, cela qui permet une interface directe la quasi-totalité des microcontrôleurs avec un 3 fils de raccordement. Cette interface série fonctionne à des fréquences d’horloge jusqu’à 40 MHz et est compatible avec les normes de DSP et microcontrôleurs. Le dispositif fonctionne avec une alimentation de 2,3 V à 5,5 V L’AD9833 dispose d’une fonction de mise hors tension (SLEEP). Cela permet un fonctionnement en mode économie.

Caractéristiques:

Consigne de fréquences et de phase par programmation

Consommation d’énergie à 3V : 12,65 mW

Plage de fréquence de sortie de 0 Hz à 12,5 MHz

Résolution de 28 bits ; 0,1 Hz pour une horloge de référence de 25 MHz

Forme des ondes de sorties : Sinusoïdales, triangulaires, et d’ondes carrées

Alimentation : de 2,5 à 5,5V

Aucun composant externe n’est requis

Pilotage : bus SPI à 3 fils

Plage de fonctionnement : de -40 à +105°

Fonction d’économie d’énergie (SLEEP)

Fréquence de rafraîchissement du pilotage : 25 Hz

Tension de sortie Max : 0.65V

Tension de sortie Min : 38 mV

Taille: 17 * 12mm

Pour une description en profondeur Rdv sur le datasheet

Remarque :

L’usage d’un tel composant dans le cadre de ce projet, est ultra largement sur-dimensionné. Je l’ai choisi déjà par le prix très faible, mais surtout, je vise à utiliser ce composant pour d’autres projets. C’est donc aussi une étape d’apprentissage.

4. Module d’amplification - Carte numérique miniature PAM8403

Valeur moyenne : 1 €

Pour ce prix c’est un amplificateur audio de folie, précision et qualité HIFI (Oui! Oui!) Voyons voir un peut ce qu’il peu bien avoir dans le buffet ?

Ce module ampli audio basé sur la puce une PAM8403 est un amplificateur stéréo, de classe D. Il produit une sortie de 2x3 watts et capable de fonctionner sur une mini alimentation de 2,5 V, jusqu’à un maximum de 5 V.

Heu ! C’est quoi la classe D Audio Wifi ?

Avantages de la classe D La distorsion harmonique totale est inférieur à 0.11%, quasi plus aucun bruit !!! Cela permet à ce module une reproduction sonore de très haute qualité. Avec de bons haut-parleurs, vous devriez obtenir un signal audio d’une qualité dans les basse et dans le ton impossible à atteindre (entendre) sur une chaine HIFI classique de classe AB (construit avec des transistors Analogiques).

C’est donc un amplificateur de haut-parleur sur une micro carte très efficace avec une ultra faible consommation d’énergie, et un taux d’efficacité de 90%. Il ne produira aucune dissipation de chaleur des classiques amplificateurs conventionnels de classe AB, c’est l’un des avantages typique des amplis de classe D.

Inconvénients de la classe D Il y a beau chercher on trouve très peu d’inconvénients pour type d’amplification numérique de classe D. On constatait préalablement sur les ampli de cette classe D, un rayonnement externe dû au signal numérique de fréquence carré assez élevée. Dans le passé, cela posait un problème de bruit ‘RFI’ rayonnée à l’extérieur du boîtier de la puce. Cependant, cette puce utilise une technologie de gravure de silicium plus avancés, le bruit de rayonnement constaté n’est quasi plus mesurables.

Description générale :

Tension de fonctionnement: 2.5V-5.5V

Puissance de sortie maximale: 3W * 2 (5V 4Ω)

La taille de PCB est d’environ: longueur 30mm largeur 22mm hauteur après installation est d’environ 16mm

Brochage & Raccordement :

Ce module est capable de commander un haut-parleur conventionnel directement, sans avoir besoin d’un condensateur de sortie ou tout autre filtrage. Un haut-parleur 4 Ω fournira 3 watts maximum, à condition qu’il soit alimenté par une source 5 V.

Pour plus d’ informations, consulter le datasheet PAM8403 .

Whaou, il se prépare une Mega Teuf Ultra-Sonique en Stéréo Haute Fidélité pour mes petites souris.

Remarque : Une qualité pareil pour la p’tit pièce d’1€, a ce prix la prenez en 1 kg M’sieu. D’autant que l’objectif initial, n’était pas d’embêter les p’tite souris, mais plutôt de faire plaisir à nos p’tite oreilles. Alors imaginé ce que vous pouvez faire avec ce p’ti bijou !

Passons maintenant à la restitution de ce beau signal audio stéréo Mega Ultra-Sonique.

5. Tweeter à Ultrason - Émetteur Sonotrode antiparasite

Ces éléments sont les seuls à être totalement dédiés au projet, à savoir la restitution du signal ultra-sonique.

Valeur moyenne : 2€

Haut-parleur à ultrasons étanche, répulsif de rongeurs et autres nuisibles.

Caractéristiques:

Diamètre: 51mm;

Fréquence nominale: 20KHz ± 5 KHz;

Tension nominale: 5.5Vp-p;

Tension de fonctionnement: 1 Vp-p ~ 30Vp-p;

Plage de fréquences de fonctionnement: 2,5 kHz ~ 60KHz (voir diagramme);

Courant nominal nominal Tension: ≤2.0mA;

Capacité à 1KHz: 100000 ± 30% pF;

Nominale de sortie audio: ≥100dB;

Température de fonctionnement: -20 ° c ~ + 70 ° c;

Température de stockage: -30 ° c ~ + 80 ° c;

Encombrement :

Diagramme des fréquences :

Nomenclature

Pos Référence Description Valeur Qt Total cat 1 HCSR501 Détecteur de mouvements infra-rouge 1€ 2 2€ * 2 ESP-12F µContrôleur de communication WiFi 3€ 1 3€ * 3 AD9833 Générateur de Signal, Sinusoïdale, Carrée, Triangulaire 7€ 1 7€ 4 PAM8403 Amplificateur Numérique HIFI Stéreo 2x3W 1€ 1 1€ * 5 US Rep Tweeter Émetteur Sonotrode antiparasite 2€ 2 4€

#Projet #Objet connecté #IoT #ESP-12F #ESP8266 #HC-SR501 #AD9833 #PAM8403

0 notes

mjcsystem · 9 years ago

Text

Pilotage et Étude de l'ESP8266

ESP8266

L’ESP8266 est un micro-contrôleur conçu par Systems Espressif. Espressif est une société chinoise basée à Shanghai. L’ESP8266 se présente comme une solution réseau WiFi autonome, qui se comporte comme un pont (bridge) réseau entre le contrôleur interne et le réseau WIFI extérieur. L’ESP8266 est également un véritable micro-contrôleur capable de faire tourner des applications autonomes.

Spécification général

Voici les particularités essentielles.

Description Valeur Tension 3.3V Consommation de courant 10uA – 170mA La mémoire flash attaché 16 Mo max (512K normal) Processeur Tensilica L106 32 bits Vitesse du processeur 80-160 MHz RAM 32K + 80K GPIO 17 (multiplexées avec d’autres fonctions) Convertisseur Analogique 1 entrée avec une résolution de 1024 bits Protocole WIFI 802.11 supportés b/g/n/d/e/i/k/r Nombre maximal de connexions TCP simultanées 5

Avec cette consommation afficher, est-il possible de faire fonctionner l’ESP8266 sur une pile ? La consommation de courant est loin d’être constante. Lors de la transmission à pleine puissance, il peut consommer 170mA mais quand dans un sommeil profond, il suffit de 10 uA. Cela est une différence notable. Cela signifie que le temps d’exécution d’un ESP8266 sur une source de courant fixe est non seulement en fonction du temps, mais également de ce qu’il fait pendant ce temps … et qui est une fonction du programme déployé sur lui.

L’ESP8266 est conçu pour être utilisé avec un module de mémoire associé, le plus souvent une mémoire flash. La plupart des modules sont livrés avec une mémoire flash complémentaire. Sachez qu’une mémoire flash a un nombre fini de cycle d’écriture. Actuellement évalué à 10.000 cycles. Cela ne constitue pas dans un usage standard un problème … mais si votre processus est sans cesse en train d’écrire de nouvelles données de façons extrêmement rapide, cela peut alors être un problème qu’il faudra évaluer.

Particularité physique de l’ESP8266

En soit le module ESP8266 est un circuit intégré d’une taille de 5 mm de coté. Sauf à être un as du fer à souder ultra fin, livré tel quel on ne peut pas en faire grand chose. Évidemment, de nombreux intégrateurs on construit des cartes supports et autres dispositifs pour faciliter les montages et expérimentations d’essais.

Dans le reste de ce documents je me concentrerais sur le module ESP12 et les différentes variations du modèle.

ESP-12

C’est aujourd’hui le modèle le plus aboutie et vraisemblablement le plus populaire? il est disponible sur de très nombreuse plate-formes d’essai et d’expérimentations, comprenant plus ou moins d’accessoires.

L’ESP-12E met à disposition de l’utilisateur la quasi totalité des GPIO intégré dans la puce de base l’ESP8266. Voici à quoi ressemble un module ESP-12 monté sur une mini carte d’expérimentation.

C’est la carte que j’ai utilisé dans le montage du bloc 4 prises.

Brochage de l’ESP-12

Les dernières évolutions de ESP12 (version E ou F) propose une mise a disposition de la totalité des GPIO et autres broches particulières. La représentation suivante illustre cette mise à dispositions des broches de EPS12.

Toutefois, peut de carte complémentaires permettent l’utilisation de toutes ses broches, usuellement seules les broches latérales sont misent à disposition de l’utilisateur. les plus averties peuvent toutefois réaliser leurs propre montage pour utiliser les connexions situées en opposition à l’antenne sérigraphié sur la carte de l’ESP-12.

La suite du document restera concentré sur la connectique standard, présenter par l’image suivante :

L’on peut déjà remarquer le rectangle situé au bas à droite de l’antenne, il s’agit de la LED “bleu” d’information du trafic sur la liaison série UART de l’ESP-12.

Description du brochage :

Pos Broche Description BOOT FLASH 1 VCC 3.3V. 2 GPIO 13 Également utilisé pour SPI MOSI. 3 GPIO 12 Également utilisé pour SPI MISO. 4 GPIO 14 Également utilisé pour SPI Horloge. 5 GPIO 16 6 CH_PD Validation de la puce. Doit être à un niveau haut pour un fonctionnement normal. 0 - Désactivé : 1 - Activé 7 ADC entrée du convertisseur Analogique/Numérique 8 REST réinitialisation externe. 0 - Reset : 1 - Normal 9 TXD Transmission sur l’UART 0. 10 RXD Reception sur UART 0. 11 GPIO 4 GPIO Regular. 12 GPIO 5 GPIO Regular. 13 GPIO 0 Fixe le mode de démarrage. 1 = boot normal 0 = Mode Flash du firmware 14 GPIO 2 Valide le BOOT 1 = lecture du boot 15 GPIO 15 Contrôle le lancement de la puce 0 0 16 GND Masse de l’ESP-12

Les paramètres relatif au mode de fonctionnement Normal-BOOT ou le mode Flash, que l’on viens de décrire dans ce tableau vont déterminer le montage à mettre en œuvre pour pouvoir utiliser l’ESP-12. Voyons donc comment réaliser un montage de base.

Schéma de raccordement

Se connecter à L’ESP-12 “ESP8266”

L’ESP8266 est nativement un équipement WIFI, toutefois avant de pouvoir entrer en relation dans ce mode sans fil, il convient de fixer au préalable un certains nombres de paramètres. Cela est nécessaire pour précisément, construire voir se connecter à un réseau WIFI existant. Il est donc primordiale d’établir au préalable, une communication filaire commune au microcontrôleur de type série UART TX/RX.

Je reviendrais plus tard pour traiter et nous connecter via une liaison WIFI. Pour une première prise en main nous allons nous contenter de la traditionnelle liaison série. Le moyen le plus commode pour établir cette communication est de se munir un convertisseur USB->UART de type FTDI ou CP2102 voir autres équivalents.

Remarques : Selon les constructeurs votre ESP8266 sera packagé sous la forme d’un ESP-01 … jusqu’à l’ESP-14 pouvant passer par différents autres boîtiers. Chaque constructeur aura ou pas installé un “Fimrware” (Un micro code système, faisant office d’un OS plus ou moins complet). Ce Firmware ‘micro-code’ possède ses caractéristiques, notamment les paramètres de connexion. L’un des point cruciale dans l’établissement d’une communication série ‘UART’ est d’identifier la vitesse de transmission. C’est la vitesse à laquelle les données vont transiter entre ESP8266 et son partenaire (votre application de communication sur votre machine). Par défaut sans Firmware rapporté ou particulier cette vitesse est positionné à 74880 bauds. C’est donc à cette vitesse qu’il convient de configurer votre application de communication.

Une fois votre ESP8266 raccordé et votre application de communication connectée à la vitesse correspondant à l’attente du Firmware, vous devriez voir apparaître un message du type :

ets sep 15 2015,rst cause:2, boot mode:(1,0)

Exemple d’un echo d’un Firwware compilé le 15 septembre 2015.

Remarque : Les plus attentifs on pu remarque la présence sur le brochage de l’ESP8266, existence d’une seconde liaison série UART. Cette seconde ligne fonctionne exclusivement en mode sortie, seul le RX2 est disponible. L’objectif principale de cette deuxième UART est une prise de diagnostics pour des informations de débogage. Cela peut être extrêmement utile au cours du développement. Il est recommander d’utiliser un second convertisseur, afin de bénéficier de cette sortie d’information extrêmement utile en cours de développement. Cette seconde UART est multiplexé avec broche GPIO2.

Avant d’entreprendre la mise en place d’une connexion en mode WIFI, je souhaite en rappeler quelques concepts de base.

Un peut de théorie sur le réseau WIFI

Lorsque vous travaillez avec un dispositif orientée WiFi , il est important que nous ayons au moins une certaine compréhension des concepts liés aux concept de base du WiFi. À un niveau élevé, le WiFi est la possibilité de participer à des connexions TCP/IP sur une liaison de communication sans fil. WiFi est précisément l’ensemble des protocoles décrits dans l’architecture IEEE 802.11 sans fil. Dans le vocabulaire standard WIFI, un dispositif appelé un Point d’Accès sans fil (Point d’Accès ou AP) agit comme la plaque tournante de toutes les communications. En général, il est connecté à (ou agit en tant que) comme routeur TCP/IP pour les autres équipement raccordé à ce même protocole TCP/IP . Par exemple, dans votre maison, vous êtes susceptible d’avoir un point d’accès WiFi connecté à votre Box (c��blé ou DSL). Les connexions WiFi sont ensuite dirigé vers le point d’accès (par le biais d’équipement appelés stations) le trafic TCP/IP est alors acheminé par le point d’Accès vers l’Internet.

Les équipements qui se connecte à un point d’Accès sont appelées “Stations“.

Quels rôles peut jouer un ESP8266

L’ESP8266 peu être configuré en un point d’accès, mais aussi comme une station, voir même les deux en même temps. Très souvent, le point d’accès dispose également d’une connexion réseau à l’Internet et agit comme un pont entre le réseau sans fil et le réseau TCP/IP étendu qui est l’Internet. Une réseau de stations qui souhaitent communiquer entre elles est appelé Basic Service Set (BSS). Cette configuration particulière est communément appelé Infrastructure BSS. Dans ce mode, tout le monde causent à tous le monde sur le même réseau, les communication passent par le point d’Accès.

Le mode de programmation natif de l’ESP8266

Nous voila un peut dans le dur de la programmation du module. Il faut bien comprendre que l’ESP8266 intègre en bas niveau le langage de communication “Hayes”. C’est un langage destiné aux communication, le jeu de commande Hayes AT est directement codé en dur dans la puce du composant. Ces commandes sont tous précédés de “AT” et suivent (à peu près) le style connu comme le “jeu de commandes Hayes”.

Espressif publier l’ensemble complet des commande AT implémenté dans l’ESP8266, qui se trouve dans leur forum à l’adresse:

http://bbs.espressif.com/viewforum.php?f=5

LIENS

Adafruit : Using NodeMCU Lua

#Robots #Robotique #Objet_Connecté #ESP8266 #ESP-12

2 notes · View notes

mjcsystem · 9 years ago

Text

Le Servomoteur ! comment ça marche ?

Principe général du servomoteur

Utilisation pour nos systèmes micro-programmé

Fonctionnement d’un servomoteur standard

Quelles différences entre servomoteurs digital (numérique) et analogique ?

Avantages à embarquer un microcontrôleur

Construction et Fonctionnement d’un servomoteur

Utilisation des servomoteurs en mode programmé

Passons maintenant à un côté pratique :

L’ ordre de pilotage :

Gestion de la durée de la pulsation de commande :

La programmation

Principe général du servomoteur

Un servomoteur est avant tout un dispositif asservi en position.

C’est un système capable d’assurer et de maintenir une position.

Il existe une variété de dispositif nommé “Servomoteur” dans une gamme d’utilisation assez élargie. L’industrie est le précurseur de l’utilisation d’équipements asservies en position, le terme de servomoteur a donc une origine industriel. A l’origine le servomoteur est un préactionneur, a plupart du temps pneumatique (système membrane/ressort), plus rarement hydraulique ou électrique d’une vanne de régulation. Dans ce cas l’asservissement de position est toujours effectué par un organe distinct nommé positionneur.

Un servomoteur est un système motorisé capable d’atteindre des positions prédéterminées, puis de les maintenir. La position est : dans le cas d’un moteur rotatif, une valeur d’angle et, dans le cas d’un moteur linéaire une distance. On utilise des moteurs électriques (continu, asynchrone, brushless) aussi bien que des moteurs hydrauliques. Le démarrage et la conservation de la position prédéterminée sont commandés par un système de réglage.

Le système de réglage souvent électronique compare le signal à une valeur prescrite de la position de consigne. S’il y a une déviation, le moteur est commandé dans la direction qui garantit le plus petit chemin à effectuer pour arriver à la valeur de consigne. Cela a pour conséquence de faire diminuer l’écart. La procédure se répète aussi longtemps et, jusqu’à ce que la valeur courante se trouve incrémentalement ou par l’intermédiaire d’une approximation dans les seuils de tolérance de la valeur consigne. Alternativement, la position du moteur peut être saisie aussi numériquement et comparée via un ordinateur approprié à une valeur prescrite.

Il existe une vaste gamme de servomoteurs : des gros modèles industriels de plusieurs kilogrammes à courant alternatif, avec des boîtiers et carters d’engrenages en métal, jusqu’aux minuscules servomoteurs en plastique de quelques grammes à courant continu que l’on retrouve en modélisme dans les avions, les bateaux, les voitures et les hélicoptères modèles réduits.

Je limiterais cette petite étude à des servomoteurs utilisable dans nos petits montages µsystem. Une utilisation assez comparable en nature à celui du monde du modélisme. Pour un usage sur des systèmes programmés, seul la manière de générer et de contrôler la consigne d’origine se différencie du mode du modélisme qui utilise principalement une consigne radio-commandé.

Utilisation pour nos systèmes micro-programmé

Comme pour le modélisme le servomoteur sera utilisé en µsystem pour réaliser des déplacements en translation ou en rotation sur des montages de taille et de puissances limités. Mais même dans ces limites d’usage assez fermé, il existe une grande variété et qualité de servomoteur, se différenciant par leur vitesse de rotation/seconde , par leur course en degré et par leur couple exprimé en kg.cm . Ils se distinguent également par la matière utilisée et le montage éventuel sur roulements …

C’est un ensemble mécanique et électronique comprenant :

Un moteur à courant continu de très petite taille ;

Un réducteur en sortie de ce moteur diminuant la vitesse mais augmentant le couple ;

Un potentiomètre (faisant fonction de diviseur résistif) qui génère une tension variable, proportionnelle à l’angle de l’axe de sortie ;

Un dispositif électronique d’asservissement ;

Un axe dépassant hors du boîtier avec différents bras ou roues de fixation.

En modélisme les servosmoteur servent à actionner les parties mobiles du modèle : ailerons, volets et trains pour les avions, contrôle de direction dans le cas de modélisme automobile… À cette fin, les moteurs sont asservis et obéissent à une commande externe, généralement transmise par radio

Dans nos utilisations micro-programmé on va principalement retrouver les servomoteurs en robotique. Ils seront utilisés à chaque fois que l’on aura besoin d’effectuer un positionnent, un déplacement, de façons générale dès que nous auront besoin d’effectuer une action dynamique sur l’un de nos objets, contrôler par l’un de nos micro-contrôleur.

Fonctionnement d’un servomoteur standard

Mécaniquement, il s’agit d’un moteur avec réducteur. Le mouvement de sortie est une rotation . Lorsque le moteur tourne, l’axe du servomoteur change de position , ce qui modifie la résistance du potentiomètre. Le rôle de l’électronique est alors de commander le moteur pour que la position de l’axe de sortie soit conforme à la consigne reçue .

La commande se fait via une petite impulsion, une consigne de position codé en largeur d’impulsion plus communément appelé PWM ( P ulse W ide M odulation en français MLI M odulation à L argeur d’ I mpulsion). Cela signifie que c’est la durée des impulsions qui détermine l’angle absolu de l’axe de sortie et donc la position du bras de commande du servomoteur. Le signal est répété périodiquement, en général toutes les 20 millisecondes, ce qui permet à l’électronique de contrôler et de corriger continuellement la position angulaire de l’axe de sortie, cette dernière étant mesurée par le potentiomètre.

La durée de cette impulsion de consigne est comprise entre 1ms et 2ms. La valeur intermédiaire de 1,5ms donne au servomoteur la position centrale, à 90° en général.

Commande en largeur d’impulsion : la largeur des impulsions, comprise en général entre 1 et 2 millisecondes, commande la position du servomoteur.

L’augmentation de l’amplitude des impulsions agit sur le contrôle de la vitesse jusqu’au moment où le bras du servomoteur se trouve dans la position souhaitée . Durant la rotation , le potentiomètre indique au circuit électronique le moment où la position désirée est obtenue . Les impulsions diminuent alors d’amplitude jusqu’à ce que plus aucune tension soit appliquée au moteur du servomoteur tout en conservant le bras dans sa nouvelle position .

Inconvénient : l’impulsion est forte et instantanée , entraînant aucune continuité de la rotation initiée comme pourrait le faire une mise sous tension continue . Les petites impulsions de commande ne produisent que de faibles effets . Ils peuvent se révéler inefficaces et sont les causes de l’importante zone neutre qui caractérise les servomoteurs traditionnels .

Quelles différences entre servomoteurs digital (numérique) et analogique ?

Qu’il soit Analogique ou Digital, un servomoteur contient le même moteur, les mêmes engrenages mais aussi le même potentiomètre. Où est donc la différence ? … il embarque un microcontrôleur en lieu et place de l’étage de commande électronique (analogique).

Avantages à embarquer un microcontrôleur

Le microcontrôleur embarqué dans le servomoteur est capable de transformer la consigne de position, en une chaîne de pilotage au moteur plus dynamique. L’échantillonnage de la commande moteur passe d’un signal à 50Hz à un pilotage en PWM à 300Hz. Cela confère une bien meilleur dynamique :

Une rapidité accrue du temps de réponse du moteur.

Donc un temps d’atteinte à la consigne plus court.

La mémorisation de la consigne de base, apporte un autre avantage :

Celui de maintenir la position dans l’état jusqu’à tant qu’une nouvelle consigne est appliqué.

Le servomoteur Numérique (Digital) gagne ainsi en finesse et en précision, réduisant également sa zone “neutre” tout en garantissant une bien meilleur stabilité statique. Car la position finale est contrôlé et compensé tant qu’une nouvelle consigne n’est pas demandé.

Inconvénient du servomoteur digital

une plus grande consommation d’énergie

Construction et Fonctionnement d’un servomoteur

youtube

Utilisation des servomoteurs en mode programmé

Passons maintenant à un côté pratique :

Dans cette première étape étudions la mise en œuvre d’un servomoteur avec un Arduino.

L’ ordre de pilotage :

Je vous ai indiqué que la consigne à transmettre à un servomoteur était du type PWM. Cela étant dit il faut pour assurer un pilotage correct entrer dans quelques détails de fonctionnements particuliers aux servomoteurs. Le signal PWM destiné aux servomoteurs doit impérativement être cadencé à une fréquence de 50Hz. Soit une pulsation de signal toute les 20ms, comme représenté dans le schéma suivant :

Cela tombe bien, me direz-vous, l’Arduino possède précisément une fonction pour traiter le mode PWM : La fonction analogWrite(). Loupé, car cette fonction distribue un signal PWM de fréquence 500Hz, soit 10x trop important pour être comprise par notre servomoteur. Alors comment faire ? … Nous allons voir cela un peut pus loin. Avant d’émettre notre consigne regardons d’abord comment faire comprendre au servomoteur comment atteindre telle distance, à telle vitesse et dans tel sens.

Gestion de la durée de la pulsation de commande :

Vous vous en doutiez, en effet c’est cette largeur d’impulsion qui indiquera la nature de l’action à effectuer par le servomoteur. Mais comment ça marche ?

Attention !! et retenez bien cela …. Toute la subtilité de la commande d’un servomoteur se joue sur une toute petite milliseconde. Oui! une seule milliseconde , 1ms.

Exemple : Prenons un servomoteur standards, qui fonctionne sur une plage de 180°. Considérons qu’il se trouve en son point central, usuellement indiqué comme point ‘neutre’ à 90°. Bien, alors pour effectuer un positionnement à 0° (soit vers la droite de mon cercle trigonométrique) j’appliquerais une consigne, une pulsation de 1ms, répété toute les 20ms. Vous aurez immédiatement compris que pour positionner le servomoteur à l’angle opposé, cad à 180°, je vais donc appliquer une consigne, une pulsation de 2ms, à une cadence de 50HZ.

Whaouu !!

Et pour revenir au point neutre à 90°, c’est tout à fait proportionnel, il faut donc appliquer une consigne, une largeur d’impulsion de 1,5ms avec toujours la même fréquence de 50Hz. c’est tout … Cela est illustré par le schéma suivant :

Et pour la vitesse ? Rien à dire, car rien à faire … ?? J’explique (oui quand même un peut) ,c’est en fait la boucle de régulation du servomoteur qui s’occupe de tout, selon un seul objectif : aller à la valeur demandé le plus vite possible et de façons stabilisée. Selon la performance mécanique des servomoteurs, cela va légèrement différer, en respectant toujours la même règle. Faire le job le plus vite possible ! Cela implique que plus la consigne est éloigné de la position courante, plus l’on va monter en vitesse, en décélérant à l’approche de la consigne, la valeur courante étant donnée par le potentiomètre monté sur l’axe de sortie du servomoteur. (le feeback de la boucle de régulation)

Oui mais ! Mais quoi ? Mais pour les servomoteurs à rotation continue, on fixe bien la vitesse, NON ? En fait, on utilise exactement la même méthode. Mais, mais on triche sur un seul paramètre. Oui mais lequel ?

Soit vous trouvez tout seul, soit vous allez voir sur mon prochain article.

“Transformation en servomoteur à rotation continue”

La programmation

Vous allez me dire, ça va pas être coton pour piloter le servomoteur avec une finesse aussi pousser, tout se joue en 1ms.

Rassurez-vous et comme d’ab, les développeurs ont déjà fait tout le job pour vous, il suffit comme toujours de choisir la bonne librairie de travail.

C’était bien la peine de nous prendre la tête avec toute cette théorie. Oui vraiment oui, c’est beaucoup mieux de comprendre les concepts des objets que l’on manipule.

Bon alors, on y va à cette programmation ??

Ok ! Réalisons d’abord le montage. La connectique d’un servomoteur est composé de trois fils : Deux pour l’alimentation (Vcc et la masse) et le dernier pour le signal de commande.

1 fil de masse - noir ou marron -

1 fil de tension d’alimentation de 4 à 6V - rouge -

1 fil de tension de commande 0-5V - blanc, jaune voir orange selon les constructeurs -

Un servomoteur accepte généralement une plage d’alimentation comprise entre 4.5V et 6V (à 6V il aura plus de couple et sera un peu plus rapide qu’à 4.5V). On peut, sans être du tout recommander, utiliser la tension de 5V distribuer par l’Arduino, mais attention l’alimentation de l’Arduino n’est pas conçu pour fournir un courant important. On risque de détériorer définitivement l’Aduino. Il est bien préférable d’utiliser une Alimentation complémentaire de 6V. Dans ce cas, n’oubliez pas de relier la masse de l’alimentation externe et celle de l’Arduino afin de garder un référentiel électrique commun.

Le montage sur un Arduino Uno :

Et enfin le programme ! Enfin presque, d’abord quelle librairie utiliser, pour ne par être obligé de gérer en dur cette notion de temps de signal. L’équipe Arduino, a bien fait le travail, en proposant une bibliothèque nommé très a propos “Servo“.

1er action : inclure la fameuse bibliothèque dans notre code.

#include <Servo.h>

Puis on crée une instance, un objet ‘Servo’, je propose de l’appeler ‘testServo’.

Servo testServo;

Bien sur il faudra crée une instance de ce type pour chaque servomoteur à creer dans notre programme. Maintenant nous devons indiquer à quelle broche est attaché physiquement le servomoteur. La méthode (fonction à utiliser) de nommer précisément “attach()”, elle prend 3 arguments :

Le numéro de la broche sur laquelle est relié le fil de signal

La valeur basse (angle à 0°) de la durée de l’état haut du signal de PWM en microsecondes (optionnel, défaut à 544 µs)

La valeur haute (angle à 90°, 180°, 360°, etc.) de la durée de l’état haut du signal de PWM en microsecondes (optionnel, défaut à 2400 µs)

Dans l’exemple du servomoteur standard décrit précédemment, on obtient :

#include <Servo.h> Servo monServo; void setup() { monServo.attach(2, 1000, 2000); }

Voilà notre servomoteur initialisé, nous pouvons maintenant lui passer une consigne. En général pour s’assurer de sa position dite ‘neutre’, dans la phase d’initialisation, il est fréquent de positionner le servomoteur dans cette phase, en demandant une consigne de 1,5ms. Dans le cas présent une valeur d’angle de 90°. Pour cela, nous allons utiliser la méthode (fonction) prévue à cet effet : write()

monServo.write(90);

En intégrant cette commande dans le code précédent, j’obtiens le programme complet suivant :

#include <Servo.h> Servo monServo; void setup() { monServo.attach(2, 1000, 2000); monServo.write(90); } void loop() { }

On aurait pu ajouter une commande de positionnement dans le corps du programme (boucle loop), vous avez maintenant compris comment cela fonctionne, alors à vous maintenant de jouer.

#Robots #Robotique #Servomoteur

0 notes

mjcsystem · 9 years ago

Text

Transformation d'un Servomoteur Continu 360°

Fonctionnement d’un Servomoteur

Règles de transformation

Pour arriver à ce résultat il y a 2 techniques :

Fonctionnement d’un Servomoteur (rappel)

Typiquement le Servomoteur à un asservissement qui varie selon l’écart entre la position courante lue sur le potentiomètre et la consigne envoyer du contrôleur. Plus l’écart est grand, plus la vitesse de rotation est grande. Pour un usage en continu nécessaire pour notre Robot, il n’est pas possible de reprendre ce mécanisme de pilotage pour ordonner un pilotage avant puis arrière. Le potentiomètre étant entraîné par le Servomoteur, il limite le déplacement du Servomoteur jusqu’à sa position de consigne. Cela ne peut donc être réalisé que pour des rotations inférieurs à un tour.

Règles de transformation

Pour faire plus d’1 tour il faut donc faire croire au Servomoteur, qu’il n’atteint jamais sa consigne. Il n’y a qu’une seul principe pour y arriver :

Faire croire au Servomoteur qu’il ne tourne pas, donc que le feeback du potentiomètre n’évolue pas ! Le Servomoteur va donc continuer d’avancer pour atteindre un point de retour de position qu’il n’atteindra jamais.

La vitesse du servo va être dépendante de l’écart entre de la valeur fixe de la résistance qui faut bloquer et la valeur de la consigne à atteindre : Plus l’écart sera grand, Plus le Servomoteur va chercher à combler rapidement cet écart et donc sa vitesse va être importante.

Pour arriver à ce résultat il y a 2 techniques :

) Soit, on dé-solidarise l’axe du potentiomètre des engrenages et on le bloque (colle super glue) dans sa position la plus centrale possible (attention à ne pas coller le reste des engrenages). Cela fixe le potentiomètre à une valeur résistive dite ‘neutre’. (pas d’opération de soudure électronique dans ce cas). Mais attention ce cas est parfois impossible car l’axe du potentiomètre peut faire office d’axe de rotation de la roue dentée sur laquelle il est solidaire et sans axe, plus de rotation des engrenages et du Servomoteur.

) Soit, on crée artificiellement ce point ‘neutre’ en remplacent le potentiomètre par un couple de résistances. Mais là, si l’on veut bien faire, c’est souvent de la soudure de haute précision.

Et dans tout les cas on débloque le mécanisme d’anti-rotation de plus d’un tour. Selon les modèles de Servomoteurs ce mécanisme est variable. Généralement cela se limiter à un ergot de plastique disposé sur la roue dentée finale de l’engrenage du Servomoteur. On peut trouver sur certains modèles un mécanisme de blocage de rotation sur le potentiomètre en plus de celui existant systématiquement dans la chaîne d’engrenage. Ce dispositif peut en général être cassé par simple forçage, en aidant à la rotation complète lors des premiers test après avoir réaliser les autres modifications.

Alors quel choix entreprendre ? La réponse est très Normande, ça dépend… Oui mais quand ça dépend, ça dépasse ! Ça dépasse mes compétences et ça dépend des compétences de celui qui va réaliser les manips, mais aussi de chaque type de Servomoteur. Pour certain, l’opération , 1 sera bien plus simple, dans d’autres elle sera juste impossible …. Alors ça dépend.

!! MAIS dans tous les cas, couper juste l’ergot en plastique, comme tu as pu le lire sur certain site, ne peut en théorie pas fonctionner.

Dans mon expérience de ce matin j’ai opté pour le remplacement du potentiomètre par 2 résistances CMS de 2,2 Ko.

Photos avants :

Vue d’ensemble du servo-Moteur démonté

Carte contrôleur & Câble Alim et Consigne (Brun-GND, Rouge VCC 6V, Jaune Signal de consigne) à droite alimentation du moteur du servo. Le micro-contrôleur Chip KC5188 de production chinoise, destiner à piloter en modulation d’impulsion (PWM) le moteur du Servo, en fonction de l’écart de la valeur de consigne et du retour ohmique du potentiomètre de position.

Câblage du Potentiomètre (droite) et départ moteur (gauche dans cette vue)

Détail de l’ergot à retirer

Photos après :

Vue d’ensemble avec les nouvelles résistances CMS de 2,2 KΩ

Vue latérale de contrôle du soudage

Vérification d’absence de pont de soudure avec les résistances avoisinantes

Résultat : Ça fonctionne parfaitement MAIS !! ……..

Mais sans une réalisation sous un microscope USB avec retour d’affichage sur mon écran 28’’ et un fer avec une pane ultra fine, l’opération aurait été presque impossible. Je pense qu’un de mes prochains robots, va être un robot de sous-mutiplication de mouvements de type robot de chirurgien. La carte sur les photos à en effet une dimension de 8mm x 6mm.

C’était aussi une manip réaliser sur l’un des plus petit servomoteur, un modèle S0009. Ce servomoteur est juste adapté pour le très petits robots en découpe acétate MIT d’une centaine de grammes au max.

Pour des servomoteurs plus gros et plus adapté à des montages de robots plus lourd, la manipulation sera certainement plus facile.

(reste à présenter quelques programmes exemples sous Arduino et en Lua sous ESP8266)

#Robots #Robotique #Servomoteur

0 notes

mjcsystem · 9 years ago

Text

Thermomètre Analogique/Numérique avec un TM35

µSystem

Thermomètre Analogique/Numérique avec un LM35

Objectif :

Réaliser un petit montage permettant de lire, consigner, afficher la température ambiante.

J’ai pris soins de sélectionner des équipements disponibles dans les différents Kits d’initiations ( Arduino 1 & 2 et Raspberry 2).

Au choix le contrôleur pourra être soit un Arduino (Uno ou Nano), soit un Raspberry ou Odroid

Matériel :

Les Contrôleurs

Selon votre préférence, Arduino ou Raspberry

Une sonde de Température analogique LM35

Exemple de Mesure de température avec le capteur LM35

Bloc de 4 Afficheurs 7 segments

Exemple de montage avec un arduino

Un ensemble de 6 Leds (2 bleus, 2 vertes, 2rouges)

Le circuit MAX7219 (dispo dans les kits), qui permet d’attaquer le bloc de 4 afficheurs en mode série SPI.

Séquences à réaliser :

Information de la température en mode graphe LED

Utilisation de la petite rampe de 6 LED’s pour afficher la température ambiante de 15° à 25°, par gradient de 1°.

Afficher la valeur de la température via le bloc de 4 Digit à 8 Segments. le contrôleur (Arduino ou Rpi) de dispose pas suffisamment d’E/S pour piloter 4 x 8 segments (led’s). Il faut donc passer par un circuit d’interface pour étendre le nombre de sorties. On pourrait utiliser le circuit 74HC595 (registre à décalage) que nous avons déjà étudié. Je vous propose ici d’utiliser un circuit dédié aux afficheurs 8 segments et aux matrices de LED’s, Le circuit MAX7219.

Évolutions (seront réalisées plus tard)

Créer une interface graphique sur le PC pour afficher un thermomètre numérique et/ou Analogique. Via l’interface série de l’arduino remonter les données de température au PC pour l’afficher sur l’interface graphique. Dans le cas du Rpi l’affichage se fera directement dans la session graphique du Rpi.

Transformer l’arduino ou le Rpi en objet connecté pour remonter les valeur sur le NET (could), et rattacher (en mode client) l’interface graphique crée précédemment à la base de données température dans le cloud.

#TM35 #Arduino #Raspberry #IoT #MAX7219 #LedControl

0 notes

mjcsystem · 9 years ago

Text

Le Bus One Wire (1-Wire)

D’abord un peut de théorie

Généralité sur le Bus 1-Wire

Le bus 1-Wire (ou OneWire) est un bus conçu par Dallas Semiconductor. Il permet de connecter et de faire dialoguer entre eux des circuits sur un seul fil. Il fonctionne suivant le principe maître / esclave. Il y a donc un seul maître, qui pourra dialoguer avec un ou plusieurs esclaves.

Le niveau de tension normalisé sur ce bus est +5V (Standard TTL). Ce bus supporte une topologie de réseau1 en série, parallèle ou étoile.

Dans le cas des composants Dallas la tension du bus doit être comprise entre 3 et 5V. Cela permet de les utiliser dans aucune adaptation complémentaire, aussi bien sur des Arduino UNO en 5V, qu’avec des Arduino Mini en 3,3V comme pour les Raspberry-Pi qui travaillent aussi en 3,3V pour les GPIO.

Sur le schéma ci-dessus, on voit que le bus 1-wire est relié au +3,3 V par une résistance de tirage de 4,7 kΩ. En fonction de la longueur des fils de liaison, il sera parfois nécessaire d’ajuster sa valeur. Tous les appareils sont branchés en parallèle sur le bus et c’est en mettant (ou pas) leur sortie à la masse qu’ils envoient les données au maître.

La topologie d’un réseau correspond à son architecture physique. En ce sens ou leur structure détermine leur type.

Raccordement au Filaire au Bus OneWire en mode Standard :

L’avantage de ce bus est qu’il peut être utilisé en mode « parasite » (alimentation à partir du fil de données). Cela permet d’utiliser seulement 2 fils (et non un seul comme le nom le laisse supposer), un fil de données et un fil de masse.

Raccordement des abonnés du Bus OneWire en mode Parasite :

Dans le mode parasite, l’esclave est connecté en reliant ses broches d’alimentation ensemble et en les reliant à la masse. Il n’y a plus besoin dans ce cas que de deux fils pour assurer la liaison avec les esclaves connectés au bus 1-wire.

Lorsque le bus est au niveau 1, un condensateur interne au composant esclave est chargé, et c’est lui qui assurera l’alimentation du composant pendant que le niveau du bus sera bas.

Chaque circuit possède une adresse physique unique, gravée dans la puce à la fabrication. C’est une des raisons expliquant la réticence de Dallas à permettre la création d’esclave 1-Wire autres que ceux qu’il produit : avoir la maîtrise de l’identification des esclaves du bus.

Généralement utilisé pour des mesures de températures, il existe une gamme complète de composants compatibles.

Principe du protocole 1-Wire

La communication sur le bus 1-Wire est caractérisée par un ensemble de « pulse » ou changement d’état. L’état par défaut de la ligne data est +5V, ce qui permet d’alimenter les différents composants à partir de la ligne data en mode parasite.

Avant toute communication, le maître met le bus à l’état bas (0V) pendant 480 μs pour faire une initialisation (reset) des composants connectés. Après un délai de 15 à 60 μs, le ou les esclaves connectés, forcent le bus à l’état bas pendant 60 à 240 μs pour signaler leur présence. Le maître est alors informé des esclaves connectés sur le bus.

Chaque circuit possède une adresse physique unique, gravée dans la puce à la fabrication. Cette adresse est constituée de 64 bits soit 8 octets. Le premier octet détermine le type de famille auquel appartient le circuit. Les 6 octets suivants, constituent le code propre du circuit. Le dernier octet est le CRC. C’est un octet de contrôle calculé à partir des 56 bits précédents.

Toute transaction entre un maître et un ou plusieurs esclaves, débute par une initialisation, constituée par l’envoi du pulse de Reset par le maître. Le maître doit ensuite envoyer une commande de type ROM qui est propre au protocole 1-Wire, et que tous les circuits de ce type vont reconnaître. Cela va permettre entre autre de sélectionner un circuit parmi les différents esclaves qui ont répondu présents au pulse de Reset. Le dialogue et l’échange de données pourra ensuite commencer, entre le maître et l’esclave sélectionné.

Pour émettre un bit sur le bus, le maître force le bus à « 0 » pendant 1 à 15 μs. L’esclave va lire le bus entre 15 et 45 μs après le front descendant ( valeur typique 30 μs). Si on veut émettre un « 1 », il faut repasser le bus à « 1 » immédiatement, et ne plus rien faire jusqu’à t = 60 μs. Pour émettre un « 0 » il faut laisser le bus à « 0 » jusqu’à t = 60 μs, puis repasser le bus à « 1 ».

La durée total d’un bit est donc de 60us, ce qui donne une vitesse de communication maximale de 16kbits/s.

Après la réception d’une commande du maître, l’esclave peut renvoyer des données. Pour lire les données de l’esclave, le maître force le bus à « 0 » pendant au moins 1 μs. Si l’esclave veut émettre un « 1 », il laisse le bus libre, donc tiré à « 1 ». Pour émettre un « 0 », l’esclave doit tirer le bus à « 0 » pendant 15 μs au minimum. Le maître devra donc dans tous les cas lire le bus 15 μs maximum après avoir tiré le bus à « 0 » pendant 1 μs. L’état du bus donnera alors le bit transmis par l’esclave.

Ceci est une description assez sommaire du protocole 1-Wire. Il faut ensuite se reporter à la datasheet de chaque composant 1-Wire pour connaître les fonctions qui sont supportées et les zones de données qui peuvent être lues pour obtenir les températures, niveaux de tensions…

Pour allez plus loin : Sur la compréhension détaillé du bus 1-Wire, notamment sur le calcul du CRC j’invite les intéressé à consulter le document pdf de Daniel Menesplier, qui ma servi à faire cette introduction.

Passons à la pratique

Le composant DS18B20

Le DS18B20 a une gamme de mesure qui s’étend de -55 °C à +125 °C. Il transmet sa mesure directement en degrés Celsius, codée sur 16 bits. Sa précision est de ±0,5 °C entre -10 °C et +85 °C.

Montage avec un Arduino

Avec une plage de tension d’alimentation allant de 3v à 5,5v, le DS18B20 est un candidat idéal pour utiliser un Arduino, utilisant soit une tension de fonctionnement de 3,3V comme les Arduino Pro-Mini ou un plus classique 5V utilisé par les Arduino Uno. Pour ma part j’ai plutôt opté pour un Arduino Pro-Mini de 3.3V, dans le but d’une future utilisation « portable » alimentée par une batterie Li-Po de 3,7V. (Forme de thermomètre mobile et autonome)

Le montage avec l’Arduino Pro-Mini

Le Programme Arduino

Pour cette phase de « programmation » dans l’environnement Arduino.

Nous allons avoir besoin de :

L’ environnement de programmation Arduino adapté à votre plate-forme (Mac OS, Windows, Linux…), à télécharger ici, pour ceux qui ne l’aurait pas encore installé.

La librairie OneWire disponible ici. A décompresser dans votre répertoire < Arduino >/Librairies/ .

La librairie Dallas Temperature Control – DTC – disponible ici. Idem à décompresser dans votre répertoire < Arduino >/Librairies/ .

L’autre méthode pour l’installation des librairies, consiste à ouvrir l’IDE Arduino, puis sous le menu ‘Croquis->Inclure une bibliothèque->Ajouter la bibliothèque .ZIP’ sélectionner le fichier Compressé .ZIP . La prise en compte sera effective au prochain démarrage de l’IDE.

Une foi les 2 librairies installées, le programme utilisé est le suivant :

#include <OneWire.h> #include <DallasTemperature.h> // On utilise la Pin #2 pour connecter le DS18B20 #define ONE_WIRE_BUS 2 // Initialisation de la librairie OneWire OneWire oneWire(ONE_WIRE_BUS); // Lien avec la librairie Dallas Temperature Control DallasTemperature sensors(&oneWire); void setup(void) { // On initialise le port série Serial.begin(9600); Serial.println("Démonstration de prise de température avec le DS18B20"); // On initialise la librairie DTC sensors.begin(); } void loop(void) { // On réalise un appel pour tous les "esclaves" connectés Serial.print(" Demande de température en cours..."); sensors.requestTemperatures(); // Envoi de la demande Serial.println("DONE"); // Confirmation de l'envoi de la demande Serial.print("La temperature pour le DS18B20 est de: "); Serial.print(sensors.getTempCByIndex(0)); // Le 0 corresponant au premier esclave trouvé (nous n'en avons qu'un). delay(1000); // On attend une seconde avant la prochaine mesure }

Rien de particulier à signaler dans ce code si ce n’est l’utilisation de nos deux librairies. J’ai inseré un délai d’une seconde entre chaque mesure mais que dans la pratique l’opération de conversion prenant environ 750 ms, il se passe ainsi presque 2 secondes (1,75s pour être précis) entre chaque affichage sur le moniteur série.

Vous pouvez désormais compiler ce code et lancer la programmation de votre Arduino après avoir pris soin de sélectionner le bon type de carte et le port série associé.

En activant le moniteur série, vous devriez désormais voir apparaître les informations suivantes:

Démonstration de prise de température avec le DS18B20 Demande de température en cours...DONE La temperature pour le DS18B20 est de: 19.81 Demande de température en cours...DONE La temperature pour le DS18B20 est de: 19.87 Demande de température en cours...DONE La temperature pour le DS18B20 est de: 19.87 Demande de température en cours...DONE La temperature pour le DS18B20 est de: 19.94 Demande de température en cours...DONE La temperature pour le DS18B20 est de: 19.94 Demande de température en cours...DONE

Cela clos cette première utilisation, de la sonde de température DS18B20, avec un Arduino.

Je vous propose d’entrer un peut plus loin dans le détail de la librairie OneWire :

Étude de la librairie OneWire :

Méthodes et utilisation :

OneWire myWire(pin); Déclare un objet du type OneWire sur la broche « pin », il est possible de déclarer plusieurs objets OneWire sur la même broche étant donnée qu’il s’agit d’un bus.

myWire.search(addrArray) ; Cherche des modules compatible OneWire sur le bus. Si un module est trouvé la fonction renvoi True et l’adresse du module est placé dans « addrArray » (addrArray qui correspond à un tableau de 8 byte), si aucun module n’est trouvé elle retourne False. (Ps: C’est une fonction de recherche « glissante », cela signifie que si plusieurs module Dallas sont présent, il faudra appeler la fonction autant de fois qu’il y a de modules sur le bus)

myWire.reset_search() ; Fait repartir la recherche de zéro, utile pour rescanner tous les modules présent sur le bus.

myWire.reset() ; Relance le bus 1-Wire, obligatoire avant de communiquer avec la plupart des modules Dallas.

myWire.select(addrArray) ; Sélectionne un module d’adresse addrArray afin de pouvoir communiquer avec lui. Toutes les communications réalisées jusqu’au prochain reset se feront avec ce module.

myWire.skip() ; Permet d’outre passer la sélection du module avec qui communiquer. Utile dans le cas ou il n’y a qu’un module Dallas sur le bus et où, par conséquent, faire une recherche serait inutilement lourd. (ne fonctionne QUE s’il n’y a qu’un module Dallas sur le bus)

myWire.write(valeur) ; Écrit un octet « valeur » sur le bus. (Note: bien prendre le temps de lire le datasheet du module utilisé, la plupart possède un « scratchpad » qui sert de mémoire tampon entre la mémoire physique et une mémoire ram virtuelle. Si les données contenu dans le « scratchpad » ne sont pas transférées dans la mémoire physique en suivant la procédure qui va bien elle ne seront tout simplement pas sauvegardées)

myWire.write(valeur, 1) ; Écrit un octet « valeur » sur le bus, mais conserve l’alimentation sur le bus à la fin de la transmission. (utile dans le cas d’un câblage en mode parasite)

myWire.read(); Lit un octet depuis le bus.

myWire.crc8(dataArray, length) ; Calcul la checksum (CRC8) du tableau « dataArray » de taille « length », très utile pour savoir si les données reçu sont corrompu ou non.

Passons maintenant au Raspberry-PI / Odroid pour un usage un peut similaire.

Montage avec un Raspberry-Pi

Linux n’est pas Temps Réel (RT)

Nous avons vu que l’utilisation du Bus OneWire exige une gestion temporelle très précise de l’ordre de quelque µS. Si les µContrôleur comme l’Arduino ou ses semblables sont bien taillé pour de telles performances, c’est qu’il ne fonctionnent pas dans un mode Multitâche préemptif, où voir pire en mode collaboratif. Cette caractéristique de fonctionner dans un mode séquentiel monotâche, garantie une temporalité du programme exécutés. Il n’y en à qu’un et il n’est pas interrompu.

Pour un Système Multitâche préemptif, comme Linux sur le Rasberry-Pi, le contrôle d’un bus séquencé par une horloge externe n’est pas possible sans adaptations particulière. Il est indispensable, lors des phases de dialogues (le contrôle du bus), d’avoir la maîtrise du temps d’exécution du processeur. Pour ce faire il faut pouvoir ‘geler’ temporairement, la capacité de l’OS à préempter, notre tache de dialogue sur le bus OneWire. Rassurez-vous une tel gestion est prévus par le noyau de Linux. Il faut donc pouvoir intervenir au niveau du noyau, c’est le rôles des modules de noyau complémentaire. Les fonctions de gestion du bus OneWire ne seront donc pas, comme c’était le cas pour l’Arduino, de simples librairies (extensions fonctionnelles du langage), mais des modules du noyau de Linux. Qui auront en charge de bloquer le mode préemptif de Linux pendant l’exécution de ces routines particulières.

Pour résumer : Pour que le noyau Linux sache gérer le composant OneWire DS18B20, il faut lui adjoindre un module pour la gestion du OneWire, et un module pour la gestion des composants de la famille 28h, capteurs de température. Cela parait très simple, mais en réalité le travail à exécuter …. Bref d’autres l’on considérablement simplifié pour nous.

Passons maintenant au concret !

Quels modules noyaux et comme les ajouter ?

Les modules en question sont :

w1-gpio et,

w1-therm.

Comment installer ces modules au noyau ?

Ce n’est pas l’objectif, que de faire un cours sur la gestion du noyau Linux et des modules de périphériques (pilotes). Toutefois quelques notions me sembles importantes à préciser. Généralement ignoré, les modules noyaux sont sont au cœur du système, globalement chargés d’interfacer un matériel avec le noyau Linux. Les modules noyaux existent sous 2 formes :

Soit ils ont été compilé au sein même du noyau, on dit parfois compilé “en dur”,

Soit ils ont été compilé sous forme de modules externes.

Vous aurez devinez que dans notre cas, on va utiliser des modules externes. Dans le cas d’une distribution Debian, qui se trouve être la distribution principal utilisé sur le Raspberry-Pi et nommé dans ce cas “Raspbian”. Deux façons de monter un module :

en mode direct Charger les modules du kernel pour prendre en charge le capteur. w1-gpio est le module pour les capteurs avec un seul fil, w1-therm est celui pour les sondes de température.

modprobe w1-gpio modprobe w1-therm

Par configuration: Les modules externes sont définis dans le fichier :

/etc/ modules Il suffit d’éditer, avec votre éditeur de fichier préféré en mode root, puis de compléter ce fichier avec les lignes suivantes :

w1-therm w1-gpio pullup=1

Votre fichier de modules devrait ressembler un peut à ceci :

# /etc/modules: kernel modules to load at boot time. # # This file contains the names of kernel modules that should be loaded # at boot time, one per line. Lines beginning with "#" are ignored. # Parameters can be specified after the module name. i2c-dev i2c-bcm2708 spi-bcm2708 snd-bcm2835 w1-therm w1-gpio pullup=1

La prise en charge par le noyau, de cette nouvelle configuration, se fait au plus simple par un redémarrage.

Schéma de raccordement de la sonde DS18B20 au Raspberry-Pi

Pour une sonde en boîtier industriel.

En mode labo sur un Breadboard

Lecture de la température de notre sonde DS18B20

Reconnaître la sonde :

Dans un premier temps vérifions, après notre petit montage, que le système a bien reconnu la sonde :

>pi@rasphil $ cd /sys/bus/w1/devices >pi@rasphil /sys/bus/w1/devices $ ls 28-0000054c2ec2 w1_bus_master1

Ma sonde a effectivement été détectée. Elle porte le numéro 28-0000054c2ec2 (numéro unique au monde, je vous le rappelle). Le système a créé un répertoire à son nom et c’est dans ce dossier que nous allons trouver les informations qui nous intéressent.

Lire le température :

Dans un premier temps, et pour bien comprendre comment le système (l’OS) gère la sonde, on va effectuer cette lecture directement en ligne de commande.

Remarque : il n’y à pas réellement d’autre manière de communiquer directement avec un périphérique sous Linux. En effet tout périphérique dialogue avec un fichier d’interface disponible dans le répertoire des ‘devices’. Un programme sous python ou autre ne fera rien d’autre que d’invoquer ce même fichier pour communiquer avec la sonde. Il est donc intéressant d’étudier ce mécanisme au travers de notre exemple de lecture la sonde DS18B20.

Allons directement sous le répertoire de notre sonde :

>cd /sys/bus/w1/devices/28-0000054c2ec2

Contenu du répertoire :

>ls -la driver id name power subsystem uevent w1_slave

Lecture du fichier ‘w1_slave’

>cat w1_slave 7c 01 4b 46 7f ff 04 10 09 : crc=09 YES 7c 01 4b 46 7f ff 04 10 09 t=23750

Le fichier w1_slave contient sur la première ligne le code correspondant au numéro de la sonde, avec son CRC qui a été vérifié (YES), et sur la deuxième ligne la température en hexadécimal (peu utilisable) mais aussi en milièmes de degrés Celsius.

Il suffira de diviser par 1000 pour obtenir la température réelle. On peut arrondir à un chiffre après la virgule sans vergogne, puisque la précision n’est que de ±0,5 °C.

Une topologie de réseau est en informatique une définition de l’architecture d’un réseau. Elle donne une certaine disposition des différents postes informatiques du réseau et une hiérarchie de ces postes. ↩

#Bus #µSystem #1-Wire #Arduino #Raspberry-Pi #DS18B20

1 note · View note

mjcsystem · 9 years ago

Text

Projet Bloc 4 Prises

Objet connecté

Projet : Bloc 4 Prises

Objectif

Réaliser la construction d’un objet connecté, en détournant (Hacking) un bloc de 6 prises du commerce, pour reconstruire un bloc de 4 prises piloté indépendamment par un module de communication Wifi de type ESP8266 (Ultra Low Cost , 2 €). Le Bloc de 4 Prises (B4P, dans la suite du document) reconstruit aura une visibilité sur Internet via un accès sécurisé ‘https’.

Schéma de principe

Remarque : La partie central (en jaune) est soit totalement éclaté en 2 voir 3 serveurs connectés sur internet (le Cloud), mais peut dans une phase de développement et d’essai être localisé sur un seul poste sur un réseau local sans aucune connexion internet. (internet n’est rien d’autre qu’une infrastructure de routage). Un Raspberry-Pi ou un Odroid peuvent parfaitement convenir pour porter l’ensemble de ces fonctions, c’est d’ailleurs ce que nous feront dans cette phase d’étude.

Nomenclature pour la réalisation du bloc 4 prises

Pos désignation Commentaire Img+Lien Tarif indicatif 1 Bloc 4 Prises Pour la récupération du module de connexion 4 prises 19€ 2 Bloc 6 Prises Seulement pour le corps Alu (le bloc de 6 prise pouvant être utilisé indépendamment sans aucun problème) 24€ 3 ESP-8266 Le cerveau et la communication de notre montage. J’ai finalement opté pour un ESP12F, que j’ai monté sur une petite platine qui sera complété par un bouton de Reset. Vous pouvez remplacer cela par tout autre module ESP-8266 (ESP-7, ESP-12, Olimex, …) disposant au minimum de 6 GPIO disponibles. 3€ 4 Bloc 4 Relais Ensemble de 4 relais 5V-DC 10A/220V. l’installation dans le rail de la prise se fait sans problème, en y apportant des glissières latérale et un socle d’isolation. 5€ 5 Sonde Température Une simple sonde numérique mono fil DS18B20 de chez DALLAS en boîtier TO92 1€ 6 Alim 5V J’ai opté pour une mini alim à découpage 220V-AC/5V-DC 1A, la puissance et la dimension de ce module s’insère idéalement dans le rail de montage, la puissance de de 5W est largement dimensionné pour un usage même simultané de tous les relais. 2.5€ 7 Adaptateur 5/3.3V Nécessaire pour alimenter ESP-8266 qui supporte uniquement un 3.3V bien stabilisé 1.5€

J’attends le retour de la société Brennenstuhl, pour savoir si il consente à une livraison des blocs en pièces détachées ?

Voila pour cette liste, suivra dans la foulé, le schéma de raccordement … à suivre !

Les Images du Montage :

enter link description here

#Objet #Connecté #NodeMCU #ESP8226 #IoT #ESP-12 #Projet

0 notes

mjcsystem · 9 years ago

Text

Projet Bloc 4 Prises

Objet connecté

Projet : Bloc 4 Prises

Objectif

Schéma de principe

Nomenclature pour la réalisation du bloc 4 prises

J’attends le retour de la société Brennenstuhl, pour savoir si il consente à une livraison des blocs en pièces détachées ?

Voila pour cette liste, suivra dans la foulé, le schéma de raccordement … à suivre !

Les Images du Montage :

enter link description here

#Objet #Connecté #NodeMCU #ESP8226 #IoT #ESP-12 #Projet

0 notes

mjcsystem · 9 years ago

Text

Programmer Arduino

Programmer avec un Arduino sous Linux

Arduino kesako ?

Petite présentation

Particularités de l’Arduino Standard

IDE Arduino

Présentation de l’interface

La Fenêtre principale’

Programmer avec L’Arduino

Le langage de programmation

La structure d’un programme

La Coloration syntaxique

La syntaxe du langage

La Ponctuation

Les variables

Les fonctions

Les structures de contrôle

Exemple Complet de programme

Pour aller plus loin

Coder Proprement Avec Arduino

Conventions de nommage

Déclarer ses variables

Indenter son code

Faire des commentaires

Les sous-routines ou fonctions

Vérifier son code

Bonus

Bibliothèques Complémentaires

Bibliothèques fournies par défaut dans le logiciel Arduino

Arduino kesako ?

Les modules Arduino™ sont des plates-formes de prototypage micro contrôlées “open-source” spécialement conçues pour les artistes, les concepteurs ou les hobistes.

Programmables via un langage proche du “C” (disponible en libre téléchargement), les modules Arduino™ peuvent fonctionner de façon autonome.

Petite présentation

Issue d’un design “Open-Hardware” & “Open-Source” le concept Arduino se décline en une impressionnante armada de cartes à µContrôleur. Originellement piloté par un coeur Amtel de 8 bits, le concept Arduino s’étend du 8 au 32 bits (ARM Cortex M), ainsi qu’une multitude de formats. Seul le nom Arduino™ est déposé, les constructeurs alternatifs proposent des cartes avec des noms dérivés comme Finduino, Oliduino …

Initiation proposé ici, sera réalisée et testé sur un Arduino standard de type Uno R3.

Particularités de l’Arduino Standard

Une taille physique est standardisée, notament pour sont connecteur d’extension,

Un vaste choix de carte filles, traitant tous les aspects possible, ces cartes sont nommées “Shield”,

Un coût de produits très abordable ± 20€

Un environnement de développement IDE Open Source, Multi plateforme, en Java.

Un langage de programmation dérivé du C++, d’apprentissage aisé.

Un écosystème très riche, tant au niveau matériel avec un immense choix de cartes complémentaires, que logiciel, un vaste choix d’outils et et de langages de développements.

Une communauté nombreuse et très active

IDE Arduino

Bien qu’il est aujourd’hui possible de programmer l’Arduino avec différent langages sous differentes Interface de Développement IDE. Nous resterons focaliser pour cet introduction à la programmation, à L’IDE officielle. Développé en Java, elle est disponible pour toutes plateformes Windows, Mac, Linux. L’IDE propose un langage issue du C++ simplifie et adapté à la micro-programmation.

Présentation de l’interface

La Fenêtre principale’

Les programmes sont écrits dans l’éditeur de texte.

la zone de messages donne l’état de l’opération en cours et affiche également les erreurs.

La console texte affiche les messages produit par le logiciel Arduino incluant des messages d’erreur.

la barre de boutons vous permet de vérifier la syntaxe et de transférer les programmes, créer, ouvrir et sauver votre code, et ouvrir le moniteur série.

la barre des menus vous permet d’accéder à toutes les fonctionnalités du logiciel Arduino.

Détail de la barre des boutons

Sélection de la carte cible

Sélection du port Cette sélection s’opère dans le menu “Outils > Port: “

Ouvrir/Choisir un Programme Pour sélectionner un programme, on va dans la barre de menu, on ouvre « fichiers ». On peut ouvrir un nouveau programme ou un exemple. Ici on ouvre le fichier « Fichier > Exemples > 01.Basics > Blink »

Le Programme Blink Le programme avec son code apparaît :

On clique sur pour vérifier que le code est bon, puis on clique sur pour l’envoyer sur la carte arduino.

Programmer avec L’Arduino

Cette section présente le langage Arduino, son vocabulaire ainsi que la structuration d’un programme écrit en C pour l’Arduino.

Le langage de programmation

Un langage de programmation1 est un langage permettant à un être humain d’écrire un ensemble d’instructions (code source) qui seront directement converties en langage machine grâce à un compilateur (c’est la compilation). L’exécution d’un programme Arduino s’effectue de manière séquentielle, c’est-à-dire que les instructions sont exécutées les unes à la suite des autres. Voyons plus en détail la structure d’un programme écrit en Arduino.

La structure d’un programme

Je propose d’utiliser le programme du multiplexeur 74hc595, pour illustrer les différentes zones d’un programme.

Un programme Arduino comporte trois parties :

la partie déclaration des variables (optionnelle)

la partie initialisation et configuration des entrées/sorties : la fonction setup ()

la partie principale qui s’exécute en boucle : la fonction loop ()

Dans chaque partie d’un programme sont utilisées différentes instructions issues de la syntaxe du langage Arduino.

La Coloration syntaxique

Lorsque du code est écrit dans l’interface de programmation, certains mots apparaissent en différentes couleurs qui clarifient le statut des différents éléments :

En orange , apparaissent les mots-clés reconnus par le langage Arduino comme des fonctions existantes. Lorsqu’on sélectionne un mot coloré en orange et qu’on effectue un clic avec le bouton droit de la souris, l’on a la possibilité de choisir « Find in reference » : cette commande ouvre directement la documentation de la fonction sélectionnée.

En bleu , apparaissent les mots-clés reconnus par le langage Arduino comme des constantes.

En gris , apparaissent les commentaires qui ne seront pas exécutés dans le programme. Il est utile de bien commenter son code pour s’y retrouver facilement ou pour le transmettre à d’autres personnes. L’on peut déclarer un commentaire de deux manières différentes :

dans une ligne de code, tout ce qui se trouve après « // » sera un commentaire.

l’on peut encadrer des commentaires sur plusieurs lignes entre « /* » et « */ ».

La syntaxe du langage

La Ponctuation

Le code est structuré par une ponctuation stricte :

toute ligne de code se termine par un point-virgule ” ; “

le contenu d’une fonction est délimité par des accolades ” { “et ” } “

les paramètres d’une fonction sont contenus pas des parenthèses ” ( ” et ” ) “.

Une erreur fréquente consiste à oublier un de ces éléments.

Les variables

Une variable est un espace réservé dans la mémoire de l’ordinateur. C’est comme un compartiment dont la taille n’est adéquate que pour un seul type d’information. Elle est caractérisée par un nom qui permet d’y accéder facilement.

Il existe différents types de variables identifiés par un mot-clé dont les principaux sont :

nombres entiers (int)

nombres à virgule flottante (float)

texte (String)

valeurs vrai/faux (boolean).

Un nombre à décimales, par exemple 3.14159, peut se stocker dans une variable de type float. Notez que l’on utilise un point et non une virgule pour les nombres à décimales. Dans Arduino, il est nécessaire de déclarer les variables pour leurs réserver un espace mémoire adéquat. On déclare une variable en spécifiant son type, son nom puis en lui assignant une valeur initiale (optionnel). Exemple :

int ma_variable = 45; // int est le type, ma_variable le nom et = 45 assigne une valeur.

Les fonctions

Une fonction (également désignée sous le nom de procédure ou de sous-routine) est un bloc d’instructions que l’on peut appeler à tout endroit du programme.

Le langage Arduino est constitué d’un certain nombre de fonctions, par exemple analogRead(), digitalWrite() ou delay().

Il est possible de déclarer ses propres fonctions par exemple :

void clignote(){ digitalWrite (brocheLED, HIGH) ; delay (1000) ; digitalWrite (brocheLED, LOW) ; delay (1000) ; }

Pour exécuter cette fonction, il suffit de taper la commande :

clignote();

On peut faire intervenir un ou des paramètres dans une fonction :

void clignote(int broche,int vitesse){ digitalWrite (broche, HIGH) ; delay (1000/vitesse) ; digitalWrite (broche, LOW) ; delay (1000/vitesse) ; }

Dans ce cas, l’on peut moduler leurs valeurs depuis la commande qui l’appelle :

clignote(5,1000); //la sortie 5 clignotera vite clignote(3,250); //la sortie 3 clignotera lentement

Les structures de contrôle

Les structures de contrôle sont des blocs d’instructions qui s’exécutent en fonction du respect d’un certain nombre de conditions.

Il existe quatre types de structure :

if…else : exécute un code si certaines conditions sont remplies et éventuellement exécutera un autre code avec sinon. exemple :

//si la valeur du capteur depasse le seuil if(valeurCapteur>seuil){ //appel de la fonction clignote clignote(); }

while : exécute un code tant que certaines conditions sont remplies. exemple :

//tant que la valeur du capteur est supérieure à 250 while(valeurCapteur>250){ //allume la sortie 5 digitalWrite(5,HIGH); //envoi le message "0" au port serie Serial.println(1); //en boucle tant que valeurCapteur est supérieue à 250 } Serial.println(0); digitalWrite(5,LOW);

for : exécute un code pour un certain nombre de fois. exemple : //pour i de 0 à 255, par pas de 1 for (int i=0; i <= 255; i++){ analogWrite(PWMpin, i); delay(10); }

switch/case : fait un choix entre plusieurs codes parmi une liste de possibilités exemple : // fait un choix parmi plusieurs messages reçus switch (message) { case 0: //si le message est "0" //allume que la sortie 3 digitalWrite(3,HIGH); digitalWrite(4,LOW); digitalWrite(5,LOW); break; case 1: //si le message est "1" //allume que la sortie 4 digitalWrite(3,HIGH); digitalWrite(4,LOW); digitalWrite(5,LOW); break; case 2: //si le message est "2" //allume que la sortie 5 digitalWrite(3,LOW); digitalWrite(4,LOW); digitalWrite(5,HIGH); break; }

Exemple Complet de programme

L’exemple qui suit montre l’utilisation de quelques éléments de la syntaxe du langage Arduino.

/* Dans ce programme, un signal analogique provenant d'un capteur (potentiomètre) fait varier la vitesse de clignotement d'une LED, à partir d'un certain seuil */ ////declaration des variables // selection de la broche sur laquelle est connectée le capteur int brocheCapteur = 0; // selection de la broche sur laquelle est connectée la LED int brocheLED = 13; // variable stockant la valeur du signal reçu du capteur int valeurCapteur = 0; //seuil de déclenchement int seuil= 200; ///////////initialisation void setup () { // broche du capteur configurée en entrée pinMode (brocheCapteur, INPUT) ; // broche de la LED configurée en sortie pinMode (brocheLED, OUTPUT) ; } ////////////boucle principale void loop () { // lecture du signal du capteur valeurCapteur = analogRead (brocheCapteur) ; //condition de declenchement if(valeurCapteur>seuil){ //appel de la fonction clignote clignote(); } } /////fonction personnalisée de clignotement void clignote(){ // allume la LED digitalWrite (brocheLED, HIGH) ; // délai de «valeurCapteur" millisecondes delay (valeurCapteur) ; // éteint la LED digitalWrite (brocheLED, LOW) ; // delai de «valeurCapteur" millisecondes delay (valeurCapteur) ; }

Le principe de fonctionnement est le suivant :

Le signal est lu avec la fonction « analogRead () ». La valeur du signal varie en 0 et 1023. Si la valeur dépasse le seuil, la LED est allumée et éteinte pendant un délai correspondant à la valeur du signal reçu du capteur.

Pour aller plus loin

La liste exhaustive des éléments de la syntaxe du langage Arduino est consultable sur le site : http://arduino.cc/fr/Main/Reference

Coder Proprement Avec Arduino

L’utilisation d’un langage de programmation passe par l’apprentissage d’un vocabulaire et d’une syntaxe précise. Dans ce chapitre, nous aborderons quelques unes de ces règles ainsi que d’autres éléments à prendre en considération dans l’écriture d’un programme Arduino. Si quelqu’un doit lire ou modifier votre code, vous pouvez lui faciliter la tâche en attachant une attention particulière à sa structure et en y apposant des commentaires qui expliquent votre logique. Bref, un code clair offre une meilleure lecture, qu’il s’agisse de modifier ses configurations pour l’adapter à votre besoin ou de localiser une source d’une erreur.

Conventions de nommage

La syntaxe d’un langage de programmation se base généralement sur une ‘convention de nommage’2. Il est important de respecter cette nomenclature pour rester dans l’esthétique du code.

Dans la déclaration des variables, il faut écrire les constantes en majuscule :

const int CAPTEUR = A0; // CAPTEUR est une constante.

Pour les autres variables (int, char, etc.), les fonctions et les sous-routines seront en minuscule. Dans le cas où ces variables ont des noms composés, le premier mot est en minuscule et les autres commencent par une majuscule. Par exemple :

int bookSprint = 2011;

Pour les sous-routines (voir explication plus bas), la règle est identique à celle des variables composées. Par exemple :

afficherValeurCapteur ();

Attention à ne pas omettre le point-virgule à la fin des instructions.

Déclarer ses variables

Le nom des éléments (capteurs, actionneurs, etc. ) utilisés dans un projet sont généralement repris par les variables du programme qui fait fonctionner le dispositif. Cette pratique permet de clarifier la fonction des différentes variables. Par exemple pour choisir une variable qui a pour fonction de définir port sur lequel est connectée une LED, nous choisirons la variable suivante :

int brocheLed = 13;

Indenter son code

Il est conseillé d’effectuer un retrait par rapport à la ligne précédente à chaque nouveau bloc d’instructions. Les blocs d’instructions inscrits dans les fonctions et boucles sont délimités par des accolades, l’une est ouvrante et l’autre fermante.

if (etatCaptation == 1) { if (valeurCapteur >= seuil) { analogWrite (pinLed, HIGH);} }

Le code ci-dessus n’est pas indenté. Après indentation, nous obtenons ceci :

if (etatCaptation == 1) { if (valeurCapteur >= seuil) { analogWrite (pinLed, HIGH); } }

Il est à noter qu’un code indenté est plus attrayant et lisible. C’est un aspect qui facilite la recherche d’erreurs éventuelles qui pourraient se glisser dans le code.

Faire des commentaires

Il n’y a rien de plus embêtant qu’une instruction écrite dans un code et dont on a oublie l’utilité quelques jours après. Les commentaires permettent de se retrouver dans son code. Ils facilitent en outre la compréhension du code pour ceux qui en auront éventuellement besoin.

Ci-dessous, un commentaire sur plusieurs lignes explique le fonctionnement du programme.

/*TEXTE BRILLANT Ce programme permet de piloter les LEDs à partir de certaines touches du clavier. Principe: Saisir les caractères dans le moniteur sériel de l'interface de programmation Arduino pour allumer et éteindre les LEDs. Saisir 'R' pour allumer la LED rouge, Saisir 'J' pour allumer la LED jaune, Saisir 'V' pour allumer la LED verte, Saisir 'B' pour allumer la LED bleue, Saisir 'E' pour éteindre les LEDs. */

Ci-dessous, une instruction suivie d’un commentaire explique l’instruction.

digitalWrite(pinLed0, HIGH); // Allumer la LED connectée à pinLed0

Les sous-routines ou fonctions

Quand votre code commence à tenir une place importante et que vous utilisez à plusieurs reprises les mêmes blocs d’instructions, vous pouvez utiliser une sous-routine qui vous permet de mieux organiser et d’alléger votre programme Les sous-routines doivent être écrites après la boucle principale.

Vérifier son code

Les erreurs dans un code sont parfois subtiles à retrouver. Il est donc conseillé de compiler régulièrement son code avec le bouton « Verify » ; les erreurs éventuelles apparaissent dans la console.

Bonus

Pour indenter votre code vous pouvez utiliser la fonction « auto-format ». Cette fonction se base sur les conventions de programmation pour formater le code. Elle indente votre code automatiquement. Pour cela il faut aller dans le menu Tools > Auto Format ou utiliser le raccourci correspondant.

Bibliothèques Complémentaires

Une bibliothèque est un ensemble de fonctions utilitaires, regroupées et mises à disposition des utilisateurs de l’environnement Arduino afin de ne pas avoir à réécrire des programmes parfois complexes. Les fonctions sont regroupées en fonction de leur appartenance à un même domaine conceptuel (mathématique, graphique, tris, etc). Arduino comporte par défaut plusieurs bibliothèques externes. Pour les importer dans votre programme, vous devez les sélectionner dans Sketch > Import Library.

L’instruction suivante sera alors ajouté au début de votre programme.

#include <la_bibliothèque.h>

Cette commande inclut au code source tout le contenu de la bibliothèque. Les fonctions qu’elle contient peuvent alors être appelées au même titre que les fonctions de base.

Pour info : les bibliothèques logicielles se distinguent des exécutables par le fait qu’elles ne s’exécutent pas “seules” mais sont conçues pour être appelées par d’autres programmes.

Bibliothèques fournies par défaut dans le logiciel Arduino

EEPROM : lecture et écriture de données dans la mémoire permanente.

Ethernet : pour se connecter à Internet en utilisant le Shield Ethernet.

Arduino Firmata : pour rendre l’Arduino directement accessible à des applications en utilisant un protocole sériel.

LiquidCrystal : pour contrôler les afficheurs à cristaux liquides (LCD).

SD : pour la lecture et l’écriture de données sur des cartes SD.

Servo : pour contrôler les servomoteurs.

SPI : pour communiquer avec les appareils qui utilisent le protocole de communication SPI (Serial Peripheral Interface).

SoftwareSerial : pour établir une communication sérielle supplémentaire sur des entrées et sorties numériques (la carte Arduino dispose d’un seul port sériel hardware).

Stepper : pour commander des moteurs « pas à pas ».

Wire : pour interfacer plusieurs modules électroniques sur un bus de données utilisant le protocole de communication TWI/I2C.

D’autres librairies sont disponibles en téléchargement à l’adresse suivante.

http://www.arduino.cc/en/Reference/Libraries

Pour installer ces librairies provenant de tiers, il faut décompresser le fichier téléversé et le stocker dans un répertoire appelé libraries situé dans le répertoire sketchbook. Sur Linux et Windows, le dossier sketchbook est créé au premier lancement de l’application Arduino dans votre dossier personnel. Sur Mac OS X, un dossier Arduino est créé dans le répertoire « Documents ».

Par exemple, pour installer la librairie DateTime, le fichier devra être déposé dans le dossier : /libraries/DateTime de votre sketch.

Langage de programmation ↩

Convention_de_nommage ↩

0 notes

mjcsystem · 9 years ago

Text

Le Monde des Objets Connectés

Robots et Objets Inter-Connectés

Le Monde des Objets Connectés

Techcryptage : De quoi s’agit-il ?

1. Le Module ESP8266

Techcryptage

Pour aller plus loin

Pourquoi L’ESP8266 :

Étude du NodeMCU Developpement Kit

Particularités :

Installation et Configuration -

Chargement “Flashage” du dernier micro-code “Firmware” NodeMCU

Pourquoi LUA ?

Techcryptage LUA

Nos premiers pas avec LUA

1) Débutons par le classique “Bonjour à Tous”

2) Plus sérieux : Le Bonjour des geek, la LED qui clignote ‘le blink’

3) Création d’un fichier programme dans notre NodeMCU

4) Séquence d’initialisation sous LUA

5) Utilisation du script de transfert luatool

Un IDE pour l’ESP8266 & NodeMCU

Installation de ESPlorer

(Fin provisoire de l’article)

A) upgrade firmware :

A.1) Outils pour flacher le firmware :

Récupération firmware en mode Windows

ESPlorer

ESP8226 avec l’IDE Arduino

Exemples de codes & montages

Mise en place d’un container docker ESP

Liens

Photon

Projets

Autres Liens Annexes

Techcryptage : De quoi s’agit-il ?

De créer une infrastructure d’Objets en Connectés sans fil, qui interagiront de façon autonome comme un assistant global. Une espèce de Robot éthérisé à notre service.

Un exemple, un peut futuriste (mais si peut) de ce concept dans notre vie quotidienne : Votre réveil connecté à votre smartphone s’est programmé tout seul grâce à votre agenda électronique, ce même réveil a programmé le grille-pain pour que votre tartine saute en même temps que le café est servi. Votre voiture a programmé l’ouverture des portes de votre garage etc .. Ainsi Internet et les objets connectés ne forme plus qu’un ensemble à la fois physique et virtuel.

Techniquement, l’internet des objets est un réseau de réseaux qui permet par des systèmes d’identifications complexes de transmettre des données entre objets physiques et virtuels. Ainsi Internet n’est plus qu’un réseau invisible mais il prend forme dans ces objets. On peut imaginer, ce réseau d’objets connectés, un peut comme un robot autonome à notre service. Dans une vision optimiste, avec l’assistance de l’intelligence artificielle, cette nouvelle urbanisation d’objets connectés sera doté de comportement d’assistant, proche de celle que nous pouvons nous même apporté à notre entourage.

Le développement de cette nouvelle sphère d’objets inter-agissant dans notre quotidien, constituera en soi un écosystème de “cyber-objets”, qui sera bien plus efficace, qu’une simple agrégation d’objets, mais un ensemble d’agents économiquement utile à la Société.

Globalement, C’est une bataille technologique aux enjeux considérables. Opérateurs et industriels sont en train de créer de nouveaux réseaux de communication pour les milliards d’objets connectés qui nous attendent dans l’avenir.

Votre curiosité à été titillé, vous voulez en savoir d’avantage tout en restant généraliste :

Objet connecté : histoire et définition

Les différents usages des objets connectés

Remarque globale de lecture : L’article se situ à deux niveaux,

l’un généraliste dans l’esprit Techcryptage, rend compte du sujet, sans plonger dans les rouages des techniques nécessaires au fonctionnement de la technologie évoquée.

Un second pour comprendre comment mettre en œuvre cette technologie, avec détails et exemples de réalisations. Cette partie s’adresse bien sur aux membres du groupe µSystem, et ceux qui à cette occasion oseront plonger dans ce grand bain du nouvel internet, celui des Objets.

Pour chaque chapitre, je proposerais une intro de type TechCryptage. Pour une connaissance fonctionnelle des objets connectés vous pouvez picorer, en sautant de ‘Techcryptage’ en ‘Techcrypage’ le long de l’article.

L’objectif de l’article est d’apporter une description détaillé avec le support d’exemples de réalisation, permettant à ceux qui le souhaitent de construire ou d’adapter un réseau d’objets connectés, en utilisant les briques techniques de bas niveau. Par l’étude des composants matériels et logiciels constituant ce cette vaste technologie des Objets Connectés.

L’on va débuter cette étude avec l’un des composants clé de ce bouillonnement (buzz), des objets connectes, le Module ESP8266.

1. Le Module ESP8266

Techcryptage

L’ESP8266 est un module de communication Wifi-Série (je reviendrais sur cette définition) apparu ces derniers temps (fin 2013 - début 2014 pour les premières versions fiabilisées).

L’ESP8266 est un design Open-Hardware d’ESPressif Systems une entreprise chinoise. Proposé à un tarif très agressif (à partir de 2€ sur les sites chinois) avec un positionnement en Open-Hardware, cela à contribuer d’emblée à une explosion de l’offre. Une gamme1 en forte croissances de modules sont disponible chez de nombreux fournisseurs 2.

La version initiale l’ESP-01 d’une taille réduite (env une piéce de 2€) contient :

Le µContrôleur EPS8266 à 80Mhz ,

une puce WI-FI avec son antenne,

un port série et deux Entrées/Sorties (GPIO).

D’autres versions, contiennent d’avantages de GPIO, ou d’autres particularités, forcement positionné sur une grille de tarif adapté. Certains modules comme le NodeMCU3 incorpore un modèle EPS-12 ou EPS-12E sur une mini carte mère comprenant un connecteur micro USB et un brochage normalisé pour les platines d’expérimentations (breadboard), simplifiant l’élaboration du prototypage. Le ModeMCU est conçus comme un kit d’initiation au module ESP8266.

le NodeMCU dû à ses caractéristiques d’outils d’expérimentation, sera le premier module évalué dans cette étude.

Un Forum (ESP8266 Community Forum) ainsi qu’un Wiki fédère une communauté assez active.

Pour aller plus loin

Pourquoi L’ESP8266 :

Le module ESP8266 est avant tout un équipement de communication série :

soit en mode direct câblé,

soit en mode sans fil Wifi, qui reste une encapsulation dans le protocole Wifi, d’une communication série standard. C’est en effet une Communication de type UART, comme celle que l’on retrouve dans les modules de communication série sans fil traditionnel 433MHz .

L’ESP8266, comme pour les modules de comm serie 433MHz, sont à la fois bon marché mais également de basse consommation électrique. Et comme pour les modules 433MHz, les modules ESP8266 peuvent s’interconnecter entre eux pour faire de L’UART à travers un pont Wifi.

Mais alors pourquoi l’ESP8266 ? les modules standard de communication sans fil à 433Mhz ne sont-il pas suffisant ?

Les différences ne sont pas nombreuses mais elles sont majeurs :

L’ESP8266 possède une unité de traitement, le µContrôleur cadencé à 80Mhz, assez remarquable pour le prix du composant. Cela confère une autonomie de fonctionnement, il peut donc se passer d’un arduino ou autre µSystem pour effectuer des taches de traitements localisés,

Le protocole WIFI est supporté, d’une façon un peut particulière certes ( on verra cela lors de l’implémentation des exemples). Grâce à quoi il peut tout de même interférer avec nos réseaux locaux voir communiquer avec des sites distants,

il bénéficie de la sécurité de chiffrement WPA/WPA2, inhérent au Wifi,

Une porté de communication très convenable, qui permet d’être en interconnexion partout dans un champs wifi conventionnel, donc partout dans la maison,

Grand plus, en fonction des modèles, il dispose de point de raccordement plus ou moins nombreux avec son environnement, les fameuse Entrées/Sorties GPIO, conférant par la même d’une capacité d’interaction direct avec l’environnement. Ouvrit une porte de garage, enclenché la cafetière ….,

Dernier point et non des moindres, la capacité à reflacher le firmware. Le fait que le module soit openHarware et OpenSource, ouvre des perspectives intéressantes. De nombreux Microcodes (Firmware) sont disponible permettant permettant d’attaquer le module avec différents environnement et différents langages.

Pour une connaissance détaillé sur le module le datasheet est la référence.

Voyons comment se servir de ce module EPS8266, avec le NodeMCU

Étude du NodeMCU Developpement Kit

NodeMCU Developpement Kit que je vais simplement nommer NodeMCU dans la suite de cet article

Particularités :

Pour cette première étude approfondie j’utilise une version 1.0 (Black, la version précédente 0.9 était nommé blue), embarquant le module ESP8266 - ESP-12E -. Pour les reconnaître rien de plus facile la 1.0 est noir la précédente était bleu. Le NodeMCU , n’est rien d’autre qu’un module ESP-12E . Monté sur une platine avec :

une connexion micro USB, avec un chip UART CP2102,

Un régulateur de tension,

Un bouton de Reset ‘RST’, raccordé sur la broche REST de l’ESP-12E

Un bouton de ‘FASH’, raccordé en entrée sur le GPIO_00

Une LED Bleu de contrôle, raccordé en sortie sur le GPIO_01

Un ensemble de 30 broches(2x15) au pas standard pour plaque d’expérimentation (breadboard).

- Le Brochage du module embarqué ESP-12E

- Le brochage de la carte NodeMCU

Installation et Configuration -

Remarque : Bien que je vais utiliser le NodeMCU, pour la suite de ce chapitre. Le cœur de notre platine est composé d’un ESP8266, la version ESP-12E pour être précis. Tout autres équipements possédant une puce ESP8266, par exemple ceux d’autres constructeurs comme Olimex, sont tout aussi indiqués pour réaliser les mêmes manipulations. Les différences entre les modules vont se situer sur la forme, la facilité de réaliser les montages sur une plaque d’expérimentation, le raccordement direct en mode USB, mais également sur le nombres d’entrée/sorties GPIO disponibles. Le jeu de commande ou langage sera lié au firmware utilisé. Ces firmwares pourront être installé sur tous les modules incorporant la puce ESP8266.

Chargement “Flashage” du dernier micro-code “Firmware” NodeMCU

Une mise à niveau du firmware est toujours une bonne option lorsque l’on démarre sur une nouvelle plate forme. Ne serait-ce que pour récupérer les dernières évolutions et patchs correctifs, d’autant plus que le produit est très jeune et donc soumis à correctifs et mise à jour régulières.

Organisation de mes répertoires pour cet exemple :

Répertoire firmware : $HOME/Developpement/µSystem/EPS/NodeMCU Répertoire esptool : $HOME/Developpement/µSystem/EPS/esptool

Commençons par récupérer le dernier firmware sur le site nodemcu-firmware Ou directement ici :

Pour procéder à l’installation nous auront besoin d’un outil de transfert. Sous Linux une mini application en ligne de commande, écrite en python, par un contributeur, fera amplement l’affaire.

esptool : disponible sur Github. Entrez dans votre répertoire de travail. Pour ma part et pour la suite du document se sera $HOME/Developpement/µSystem/EPS :

Si vous n’avez par encore installé le programme Git, faite le maintenant : - avec Ubuntu - Avec OpenSuse Pour d’autres distrib voir votre gestionnaire de paquet.

On passe à l’installation esptool

$ git clone https://github.com/themadinventor/esptool.git

Dernier point avant de lancer le flashage du firmware. Sur le brochage du NodeMCU vous avez peut être remarqué une broche noté “FLASH“, cette broche doit être raccordé au GND pour effectué cette opération. Le bouton “FLASH” devrait effectuer cette action, cela n’a pas eu d’effet lors de mes tests, j’ai donc opté pour le pont filaire direct.

Le pont étant en place on lance la commande depuis le répertoire esptool :

sudo python esptool.py --port /dev/ttyUSB0 \ write_flash -fm=dio -fs=32m \ 0x00000 ../NodeMCU/nodemcu_float_0.9.6-dev_20150704.bin

Pour flasher uniquement les données et les fichiers utilisateurs + init (nous auront besoin de cette séquence un peut plus loin)

sudo python esptool.py --port /dev/ttyUSB0 \ write_flash \ 0x7C000 nodemcu-firmware/bin/esp_init_data_default.bin \ 0x7E000 nodemcu-firmware/bin/blank.bin

Après le temps de transfert on obtient :

Parfait, nous allons pouvoir jouer avec le module NodeMCU. Un peut de patience, je vous propose avant cela de faire un peut connaissance avec le langage LUA

Pourquoi LUA ?

C’est un parti pris des concepteurs du NodeMCU que de proposer une interface de programmation en mode script, dans un esprit très similaire au Python. Cela permet une interaction plus immédiate avec l’utilisateur, les commandes tapées dans la console sont directement exécutées ligne à ligne par l’interpréteur LUA. Pas de compilation, mais une interprétation du code, un retour immédiat pour l’utilisateur, qui peut ainsi directement visualiser le résultat des commandes.

Techcryptage LUA

LUA est un langage de script souple et puissant, destiné à être utilise sur des équipements lèges comme les systèmes embarqués. La force de LUA, une taille très compacte et une portabilité aisé, pouvant par ce fait être intégré dans des plate-formes très réduite comme l’ESP8266. LUA est un langage que l’on trouve de plus en plus souvent en Robotique. Autre atout, être abordable par des débutants en programmation.

Les curieux pourront aller voir sur le net, de très nombreuses pages traitant de ce langage, comme :

Nous allons donc nous faire quelques armes avec LUA sur NodeMCU.

Nos premiers pas avec LUA

Physiquement on raccorde le module NodeMCU via le port micro USB à notre ordinateur. Par défaut on sera raccordé sur le périphérique interne ttyUSB0. L’identification du périphérique (device) est indispensable pour paramétrer la console série. Sous Linux, j’utilise la console minicom avec les paramètres suivant :

Périphérique de connexion : ttyUSB0 ‘a adapté selon votre config’

Vitesse du protocole : 9600 bauds

Autres paramètres : 8 bits de données, sans parité, 1 stop bit; qui est résumé par : 8N1

Ma console :

La première commande LUA que je vais utiliser, permet d’étendre le système de fichier sur la totalité de la mémoire disponible. Opération nécessaire après le flashage du firmware :

> file.format()

Pas d’inquiétude l’opération dure plusieurs minutes sans affichage particulier.

Nous voila avec un module NodeMCU parfaitement vivant et sain.

1) Débutons par le classique “Bonjour à Tous”

> print("Bonjour à Tous")

Le résultat :

Facile ! C’est comme du python, on tape sa commande, et Hop! La ligne est interprété.

2) Plus sérieux : Le Bonjour des geek, la LED qui clignote ‘le blink’

Le petit montage idoine :

La séquence des commande pour le clignotement :

> gpio.mode(3, gpio.OUTPUT) > gpio.write(3, gpio.LOW) > gpio.write(3, gpio.HIGH)

J’allume, j’éteins, OK! . Ce serait mieux si j’automatisais un peut la chose

Le programme Blink !

> while 1 do >> gpio.write(3, gpio.LOW) >> tmr.delay(1000000) -- délais 1.000.000 µs = 1 seconde >> gpio.write(3, gpio.HIGH) >> tmr.delay(1000000) -- délais 1.000.000 µs = 1 seconde > end

! Génial ! Dès ma dernière commande validée, le programme est en action et ma LED clignote.

C’est pas mal, mais se serait plus pratique de pouvoir créer un fichier, plutôt que de saisir ligne à ligne chacune des commandes de notre petit programme.

3) Création d’un fichier programme dans notre NodeMCU

Avant de nous lancer dans la réalisation de ce programme, un petit retour sur le site officiel NodeMCU . On y trouve la liste des commandes et instructions LUA, disponible pour notre module. On va particulièrement intéresser au groupe de commande file module, pour la construction du fichier programme. Commandes utilisées pour la création de notre fichier de programme.

file.open()

Description : Création et Ouverture du fichier nommé. Syntaxe : file.open(NomFichier, Mode) Parametres :

NomFichier: type ‘string’, le nom du fichier à ouvrir, directories are not supported

Mode: type ‘string’

”r”: fichier en Lecture (Le mode par défaut) “read”

“w”: Fichier en écriture “write”

“a”: Mode ajout “append”

“r+”: Mode de mise à jour, écriture en début de fichier avec préservation des données,

“w+”: Mode de mise à jour avec effacement des données,

“a+”: Mode de mise à jour, écriture en fin de fichier avec préservation des données,

file.writeline()

Description : Écrit une chaîne de caractères dans le fichier et ajoute une mise à la ligne \n Syntaxe : file.writeline(string) Parametres :

string: Contient la chaîne de caractère à écrire

file.close()

je n’en precise pas d’avantage, tout est dans le nom.

L’écriture du programme sous la forme d’un fichier pour l’ESP8266 devient :

> file.open("blink.lua","w+") > file.writeline([[while 1 do]]) > file.writeline([[gpio.write(3, gpio.LOW)]]) > file.writeline([[tmr.delay(1000000)]]) > file.writeline([[gpio.write(3, gpio.HIGH)]]) > file.writeline([[tmr.delay(1000000)]]) > file.writeline([[end]]) > file.close()

Et pour lancer ce petit bout de programme,

> dofile("blink.lua")

Bingo ! Ma LED Clignote.

Vu la difficulté à saisir ce petit bout de code, est-il au moins persistant suite à une coupure de courant ? Faisons le test ! Je débranche . -> le terminal m’informe de la perte de la connexion et rebranche après une petite attente de 30s. -> Je retrouve automatiquement le prompt de LUA, après une action sur ma touche ‘Enter’ Faisons un petit contrôle sur l’état des fichiers en mémoire dans le module. Saisir le petit code suivant dans la console :

l = file.list(); for f,t in pairs(l) do print("Fichier:"..f..", Taille:"..t) end

(mettre image du résultat)

2 fichiers sont bien présent, dont : Fichier:blink.lua, Taille:102 Je relance l’exécution du fichier “blink”

> dofile("blink.lua")

Et à nouveau ma LED Clignote !

Qu’avons nous appris ? Le firmware NodeMCU est doté d’un gestionnaire de fichier. On peut ainsi invoqué l’exécution d’un fichier via la console ou par programmation.

Il serait pertinent de pouvoir faire exécuter notre programme immédiatement au démarrage du module. Est-ce possible ? Bien sur NodeMCU, possède d’un fichier auto-exécutable au démarrage, un fichier d’initialisation.

4) Séquence d’initialisation sous LUA

Le fichier d’initialisation, est simplement défini par son nom, et comme on peut s’en douter il se nomme : “init.lua” Si ce fichier existe, son contenu est exécuté au démarrage d’un module ESP8266.

Reste à faire la vérification sur le NodeMCU , c’est parti :

> file.open("init.lua","w+") > file.writeline([[print("Demarrage du programme Blink")]]) > file.writeline([[dofile("blink.lua")]]) > file.close()

On voit ce qui ce passe après une action sur le bouton de reset ‘RST‘.

Super ! Ça démarre avec le petit jingle d’accueil ’ Demarrage du programme Blink ’ puis on enclenche sur le programme ‘blink.lua‘.

Satisfait ? Ça fonctionne comme je le souhaitais.

Mais ATTENTION .. ce code soufre d’un Gros BUG… Le programme une fois lancé ne laisse plus la main, plus de console et donc plus aucun moyen de passer la moindre commande. Impossible de supprimer éventuellement le programme d’init ou le Blink.

Le programme Blink tourne dans une boucle sans fin. La seule issue, consiste à re-fasher le ModeMCU pour effacer les data et repartir dans une configuration propre (on est tout de même pas obliger de re-flacher le ‘firmware’). je vous avais bien dit que nous allons avoir à nouveau besoin de cette séquence réinitialisation

On re-Flash la zone data et les zones utilisateurs

sudo python esptool.py --port /dev/ttyUSB0 \ write_flash \ 0x7C000 nodemcu-firmware/bin/esp_init_data_default.bin \ 0x7E000 nodemcu-firmware/bin/blank.bin

Correction de notre code Le module ‘timer’ du langage LUA, propose une fonction interruptive qui sera traité à intervalle paramétré. A chaque appel, le timer alarme ‘tmr.alarm()’ transfert le pointeur d’exécution, à la fonction passé en paramètre au timer. Si cette fonction est nommé ‘function()’ elle sera directement codé dans le module ‘tmr.alarm‘, à la suite de la déclaration. C’est ce mode compact, que j’utilise dans la ré-écriture du code ‘blink‘.

Une utilisation plus conventionnel du module ‘tmr.alarm’ sera traité ultérieurement.

Saisir ou recopier le script suivant dans votre éditeur, nommé ce fichier blink.lua

allume=0 pin=3 gpio.mode(pin,gpio.OUTPUT) -- la broche 3 est fixé en sortie tmr.alarm(1,2000,1,function() -- tmr.alarm traité toute les 2 secondes - function() est codé ci-suivant if allume==0 then -- si le suis éteint allume=1 -- j'alume gpio.write(pin,gpio.HIGH) else -- sinon allume=0 -- j’éteins gpio.write(pin,gpio.LOW) end end)

Précédemment nous avions écrit notre code directement dans le module NodeMCU via les instructions file.writeline([[..]])

Le moins que l’on puisse dire, c’est que le mode d’écriture, consistant à saisir ligne à ligne, chacune des commandes en utilisant la commande file.writeline([[..]]) est assez contraignant. Ce même constat à été fait par d’autres expérimentateurs, et des réponses ont été apportées pour soulager la création de programme sous LUA. La solution la plus simple : la création, l’utilisation d’un script de transfert. Le script python ‘luatool’ établie une connexion série avec le module ESP8266, puis automatise la phase de création du fichier cible, complète chaque ligne avec la séquence : (élément en gras)

file.writeline([[ la ligne de code ]])

et termine le fichier avec l’instruction de clôture du fichier.

5) Utilisation du script de transfert luatool

Sur la racine du répertoire de travail, je charge le gitub du script luatool.

$ git clone https://github.com/4refr0nt/luatool.git

Je vous laisse découvrir la doc, sur le gitub du projet.

Transfert du script ‘blink.lua’ sur l’ESP8266

python luatool.py --port /dev/ttyUSB0 --src blink.lua --dest init.lua --verbose

Puis un reset sur le module pour lancer la phase d’init, la LED est a nouveau en clignotement. Contrairement au programme précédent qui bouclait sans fin, on peut se connecter avec la console série, pour stopper/ supprimer le programme d’init.

file.remove("init.lua")

Au restart, plus de programme init().

Cela clos, cette première initiation à ESP8266, de LUA et du module ModeMCU. Dans le chapitre suivant je vous propose de traiter un projet complet. Pour ce faire, nous allons au préalable étudier un environnement de développement (IDE), plus adapté à la réalisation d’un projet plus conséquent.

Un IDE pour l’ESP8266 & NodeMCU

Cette première prise en main de L’ESP8266 sous un mode console série, nous a fait découvrir les bases de fonctionnements en mode console série.

Cette approche console série, si elle peut être intéressante dans cette phase de découverte, elle reste peut adapté à la création de projet plus ambitieux. Nous somme habitué à des environnements plus complet intégrant la communication avec les plates-formes cibles, un éditeur pleine page, des correcteurs de syntaxe voir des débogueurs pour la correction de nos programme.

Si un outil aussi complet n’est pas encore disponible, il existe une bonne approche en Open Source pour l’ESP8266 :

l’IDE ESPlorer, est un projet Java, multiplate-forme, disponible sous Windows, Mac et aussi Linux.

La pré-existence de Java est donc nécessaire à l’installation d’ESPlorer. Si vous n’avez pas encore installé Java sur votre machine, voir le lien, pour l’installation de la version la plus récente adapté à votre configuration.

Installation de ESPlorer

Java est en place, nous pouvons à présent télécharger ESPlorer. Enregistrer le fichier compressé dans votre répertoire de téléchargement. Décompresser et installer ESPlorer dans votre répertoire d’applications. Pour ma part j’ai opté pour :

/opt/EXPlorer/

Dans votre lanceur d’applications ajouter une nouvelle entrée sous votre Menu ‘Développement’, comme pour l’image suivante :

Pour la commande de lancement :

java -jar /opt/ESPlorer/ESPlorer.jar

Un clic sur cette nouvelle entrée du menu ‘ESPlorer’ pour obtenir :

Une interface bien plus riche que ce que nous avions précédemment avec la console série, très épure.

Pas de crainte nous allons explorer l’utilisation de cette interface, dans la cadre de notre premier projet.

Connexion du NodeMCU Quitter ESPlorer, connecté NodeMCU, puis relancer ESPlorer. (il existe un BP de ré-synchronisation, nous verrons plus tard) On remarque qu’ESPlorer reconnaît automatiquement le périphérique connecté. Dans mon cas : ‘/dev/ttyUSB0’

Chargement, Sauvegarde du programme ‘blink’ Pour débuté nous allons faire un copier/coller du programme ‘blink’ dans la fenêtre gauche d’ESPlorer (fenêtre de l’onglet ‘NEW’) On sauvegarde “icone save” au-dessus de la fenêtre d’édition, sous le nom et répertoire de votre choix. Pour ma part : $HOME/Developpement/µSystem/ESP/My-Prog/blink.lua

Versement et Exécution de ‘blink’ dans l’ESP8266 Avant de pouvoir verser un programme dans le module ESP8266, il est nécessaire d’ouvrir la connexion. Par défaut la vitesse de connexion est paramétré à 9600 bauds. Il suffit de cliquer sur le gros bouton ‘Open’ au-dessus de la fenêtre de droite, qui passe instantanément à Close avec le résultat de la connexion dans la fenêtre de contrôle. Sous la fenêtre d’édition cliqué sur ‘Save&Run’

(Fin provisoire de l’article)

Notes et liens utilisé pour mes essais

On peut mais c’est pas très pratique. Je vous conseil d’utiliser ESPlorer un environnement dédié développement LUA et MicroPython qui cible les plate-forme EPS8266.

A) upgrade firmware :

A.1) Outils pour flacher le firmware :

esptool : Dialogue en comm serie, flashage, … (Linux)

modmcu-flasher : (Windows)

ESP Flasher Tool : (Windows)

Building and Running MicroPython on the ESP8266 (Adafruit)

<– ### Commande de connexion au réseau Wifi –> <- Sur le réseau freebox < < wifi.sta.config(“freebox_photon”,”AF007BC123”) < <- Sur le réseau interne Fonera <

Récupération firmware en mode Windows

https://github.com/nodemcu/nodemcu-flasher

ESPlorer

ESP8226 avec l’IDE Arduino

esp8266/Arduino

Exemples de codes & montages

ESP8266 and Arduino IDE - blink :

Voir simplement dans la liste des exemples dans IDE

Mini Client with the Arduino TRINKET and the ESP8266 :

Installing and Building an Arduino Sketch for the $5 ESP8266 Microcontroller :

Mise en place d’un container docker ESP

https://github.com/speakinghedge/docker-esp-open-sdk utilise : https://github.com/pfalcon/esp-open-sdk

Liens

Site Officiel :

Site Github :

Wiki :

devkit :

firmware :

modules :

esp_tool :

esptool : Dialogue en comm serie, flashage, … (Linux)

Loading new firmware onto an ESP8266 :

firmware à charger :

Construire son propre firmware :

Flashing the NodeMCU firmware on the ESP8266 (Linux) - Guide

What is NodeMCU How to Code LUA Script with a Simple Lines of Code :

explication de connexion +++ :

voir les Chapitre :

Wifi with ESP8266 - Part 2

Wifi with ESP8266 - Part 3

Liste de commandes LUA

App Inventor 2 - ESP8266 GPIO Control with Nodemcu LUA

NodeMCU ESP8266 simple httpd (web server) example

How to push code to an ESP8266 module : esp

Tool for loading Lua-based scripts from file to ESP8266 with nodemcu firmware : luatool

ESP8266 NodeMCU/LUA: Saving, Executing, and Compiling Script Files : ESPlorer

flash and erase data

0x7c000 .bin/esp_init_data_default.bin 0x7e000 ./bin/blank.bin

Wifi detector using ESP8266 and NodeMCU

ESP8266 + ds18b20 + thingspeak+ nodemcu

ESP8266 / NodeMCU: Methods of Interrupting init.lua During Boot

Photon

internet-of-things-photon

Code for the Internet of Things with the Photon book

Projets

ESP8266 servo roboservo

User customizable Bluetooth / Internet / WiFi remote control for Arduino, PIC, etc.

Adafruit - Using NodeMCU Lua

Autres Liens Annexes

micropython :

wipy :

4 raisons pour lesquelles j’ai abandonnés NodeMCU/Lua pour ESP8266 :

Olimex connect

Liste modèle ESP8266 : ↩

Une liste non exhaustive (à compléter) - ESPressif - Olimex - Adafruit - Spark - Wireless-tag - Qilianer - … ↩

Site officiel NodeMCU : ↩

#Robots #Objets #Connectés #NodeMCU #ESP8226 #IoT

0 notes