dimanche 23 août 2020

ARDUINO + ESP8266 : est-ce bien raisonnable ?

 

ARDUINO + ESP8266 :

est-ce bien raisonnable ?

 

En 2014 le premier ESP8266 dit ESP01 sortait. Ce microcontrôleur disposait de seulement 2 GPIOs. Il était utilisé principalement couplé à une carte ARDUINO, afin de bénéficier des nombreuses entrées / sorties de celle-ci.

Pour ce faire la majorité des cartes ESP01 étaient équipées d'un logiciel dit "FIRMWARE AT", permettant le dialogue avec l'ARDUINO.

Le FIRMWARE AT reçoit des commandes de la part de l'ARDUINO par la ligne série et lui renvoie un résultat :

  • AT+GMR : demande de la version
  • AT+CWMODE : fixe le mode (station, point d'accès)
  • AT+CWJAP : connexion à un point d'accès
  • etc.

Cette technologie est-elle encore viable à l'heure où de nombreuses cartes ESP8266 et ESP32, beaucoup plus riches qu'un ESP01, existent sur le marché ?

Que choisir ? un ARDUINO + ESP01, ou un ESP8266 / ESP32 tout seul ?

Nous allons essayer de mettre en œuvre les deux solutions, et nous aider de deux petits exemples de serveur WEB sur ESP32 afin de montrer les différences.

1. L'ESP01

1.1. ESP01 + convertisseur USB

Nous allons dans un premier temps utiliser l'ESP01 seul, en le reliant au PC  à l'aide d'un convertisseur USB / série.

Rappelons le brochage d'un ESP01 :

Il faut impérativement utiliser un convertisseur USB / série 3.3V ou possédant un switch ou un cavalier 5V / 3.3V. Je conseille plutôt un FT232R :


Seulement 4 fils sont nécessaires :

FT232R ESP01
VCC VCC
GND GND
TX RX
RX TX

Le premier point à vérifier est la présence du FIRMWARE AT.

On peut pour cela utiliser le moniteur série de l'IDE ARDUINO, avec les réglages suivants :

  • 115200 baud
  • fin de ligne NL + CR

Entrer la commande suivante :

AT

L'ESP01 doit répondre :

OK

Entrer la commande suivante :

AT+GMR

L'ESP01 doit répondre :

AT version:1.2.0.0(Jul  1 2016 20:04:45)
SDK version:1.5.4.1(39cb9a32)
v1.0.0
Mar 11 2018 18:27:31
OK

La version peut bien entendu être différente, en fonction de l'origine de la carte.

Si l'ESP01 ne répond pas, il est peut-être configuré avec un autre baudrate. Il faut essayer 9600 ou d'autres vitesses.

1.1.1. Recharger le FIRMWARE AT avec ESPTOOL

Si l'ESP01 ne répond toujours pas, il se peut que le FIRMWARE AT soit absent, soit il a été effacé par son propriétaire, soit remplacé par un autre sketch, soit il a été livré tel quel (ce qui est extrêmement rare).
Dans ce cas il faut le recharger. Il existe différents tutoriels sur le WEB dont la documentation "AT Instruction Set" d'ESPRESSIF :

https://www.espressif.com/sites/default/files/documentation/4a-esp8266_at_instruction_set_en.pdf

Voir : 1.2. Downloading AT Firmware into the Flash

Avant de commencer il est impératif de connaître le type de mémoire FLASH implanté sur la carte, le petit circuit à 8 pattes. Il vaut mieux disposer d'une bonne loupe :

Par exemple : t25s80 ou pn25F08 = 8Mbits

Ici un tutoriel utilisant ESPTOOL, fonctionnant sur toutes plateformes :

https://robertoostenveld.nl/esp8266-at-firmware/ 

ATTENTION : l'auteur utilise un ESP01 équipé de 512K de mémoire FLASH (FLASH 4Mbits).

Pour un ESP01 équipé d'une FLASH 8Mbits les commandes sont légèrement différentes, en particulier l'emplacement des données "esp_init_data_default" : voir la doc ESPRESSIF : 1.2.4. 8 Mbit Flash

Voici les commandes à entrer pour recharger  le FIRMWARE AT sur une carte 8Mbits (les cartes les plus courantes actuellement) :

esptool.py --port /dev/ttyUSB1 erase_flash
esptool.py --port /dev/ttyUSB1 --baud 115200 write_flash --flash_mode dio 0x00000 boot_v1.2.bin
esptool.py --port /dev/ttyUSB1 --baud 115200 write_flash --flash_mode dio 0x01000 at/512+512/user1.1024.new.2.bin
esptool.py --port /dev/ttyUSB1 --baud 115200 write_flash --flash_mode dio 0xFE000 blank.bin
esptool.py --port /dev/ttyUSB1 --baud 115200 write_flash --flash_mode dio 0x7E000 blank.bin
esptool.py --port /dev/ttyUSB1 --baud 115200 write_flash --flash_mode dio 0xFC000 esp_init_data_default_v05.bin

J'ai essayé pour vous : cela fonctionne parfaitement.

Où se trouve ESPTOOL ?

ESPTOOL est installé par défaut dans le répertoire suivant :

arduino15/packages/esp8266/hardware/esp8266/2.5.2/tools/esptool/esptool.py

Le répertoire arduino15 se trouve ici :

Sous Linux : /home/username/.arduino15

Sous Windows : C:\Users\username\AppData\Local\Arduino15

Sur Mac : /Users/username/Library/Arduino15

Il y a deux solutions : modifier la variable d'environnement PATH pour lui ajouter le chemin où est installé ESPTOOL, ou utiliser le chemin complet.

1.1.2. Recharger le FIRMWARE AT avec FLASH DOWNLOAD TOOL

D'autre tutoriels utilisent FLASH DOWNLOAD TOOL, une application graphique (Windows uniquement) :

https://www.instructables.com/id/Flash-or-Upgrade-Firmware-on-ESP8266-ESP-01-Module/

Travaillant sous Linux, je n'ai pas essayé ce logiciel.

1.2. ESP01 + ARDUINO

Les ressources WEB (tutoriels, forums) sont en général plutôt simplistes et se contentent de présenter la manière de connecter un ARDUINO et un ESP01, et d'envoyer une page HTML "Hello World", rarement plus, d'où une certaine frustration des débutants, parfaitement compréhensible.

Ce tutoriel par contre, beaucoup plus complet, vous enseignera l'art et la manière de développer un serveur WEB à l'aide de commandes AT :

Tutoriel de J-M-L du forum ARDUINO

On constatera assez facilement que le code est assez conséquent (400 lignes) :

https://forum.arduino.cc/index.php?action=dlattach;topic=501923.0;attach=227323

La page WEB développée est simple, mais elle comporte néanmoins des boutons, ce qui n'est pas le cas de la majorité des tutoriels rencontrés sur le WEB :

Sincèrement je ne pense pas que ce genre de développement soit accessible à un débutant. A chacun donc de se faire sa propre idée en fonction de ses compétences et de sa compréhension de ce tutoriel.

1.3.1. Le matériel

L'ESP01 doit être alimenté en 3.3V / 500mA minimum. Il convient donc de se procurer un régulateur adéquat.

D'autre par l'entrée RX de l'ESP01 n'est pas censée supporter les 5V de la sortie TX d'un ARDUINO. Un pont diviseur sera nécessaire :

L'auteur du tutoriel ci-dessus utilise un adaptateur permettant d'assurer les fonctions alimentation et adaptation de niveau :

Certains tutoriels présentent l'ESP01 alimenté par la broche 3.3V d'une carte UNO.

Or le 3.3V d'une carte UNO est délivré par un régulateur LP2985 capable de fournir 150mA au maximum, ce qui sera insuffisant pour établir une connexion WIFI qui réclame plus de 400mA.

Avec une carte NANO, dont le 3.3V est fourni par le chip CH340, le courant sera également insuffisant.

Il faudra également alimenter l'ARDUINO en 5V par sa broche VCC ou en 7.5V ou plus par sa broche VIN ou JACK, à moins d'opter pour une carte ARDUINO 3.3V, une PRO MINI 8MHz par exemple.

On voit bien que cette solution est déjà complexe rien que pour la partie hardware.

1.3.2. La ligne série

La ligne série utilisée pour le dialogue entre l'ESP01 et l'ARDUINO est généralement la ligne série hardware de l'ARDUINO (broches RX TX) .

Cela supprime donc toute possibilité d'utiliser la sortie standard de l'ARDUINO pour afficher des informations sur le terminal, et complique te chargement du sketch (il faut libérer RX TX).

Il est possible d'utiliser deux GPIOs et un objet du type SoftwareSerial afin de libérer la ligne série matérielle.

Avec une ligne SoftwareSerial on utilisera de préférence un baudrate plus faible (9600 ou 19200 baud, peut-être plus ?). Le baudrate de l'ESP01 peut être configuré à l'aide du moniteur série ARDUINO et de la commande AT+UART_DEF :

AT+UART_DEF=9600,8,1,0,3

Enfin, les utilisateurs de cartes MEGA2560 pourront utiliser une autre liaison série hardware Serial1, Serial2 ou Serial3, afin de réserver la ligne Serial au chargement et au terminal.

1.3.3. Les ressources HTML

Il faut bien comprendre que le code HTML est envoyé à l'ESP01 par l'ARDUINO, en plusieurs morceaux si nécessaire, et que la mémoire RAM de l'ARDUINO est limitée : 2Ko (8Ko pour une MEGA). C'est peu.

Si l'on envisage de stocker des fichier ressources (HTML, JS, images), l'ARDUINO n'aura d'autre choix que d'embarquer une mémoire externe (µSD, FLASH SPI, etc.).

Le code devra assurer l'intégralité de la gestion de ces ressources et la taille mémoire de l'ARDUINO sera vite un handicap.

On comprend vite qu'un serveur WEB développé avec cette technique sera très limité.

1.3. ESP01 seul

L'ESP01 seul a des ressources limitées :

  • 2 GPIOs
  • I2C possible sur ces 2 GPIOs

Il sera difficile de raccorder plus d'un ou deux modules :

  • relais
  • LEDs
  • boutons
  • afficheur I2C, expander

Les possibilités matérielles sont assez limitées mais par contre l'ESP01 dispose de toutes les ressources d'un ESP8266 classique : capacité de calcul, mémoire RAM, FLASH, qu'un ARDUINO aura du mal à concurrencer.

Pour résumer si les deux GPIOs suffisent autant utiliser l'ESP01 seul, sans ARDUINO.

1.4. Carte UNO WIFI

Depuis quelques années des cartes toutes intégrées sont disponibles sur le marché :

Ces cartes UNO sont équipées d'un ESP01 et le connecteur USB permet de communiquer soit avec l'ATMEGA328 soit avec l'ESP01, en fonction de la position de DIP-SWITCHES. Les broches de l'ESP01 sont disponibles : voir en haut à droite.

Il est fortement conseillé de lire la documentation :

https://robotdyn.com/uno-wifi-r3-atmega328p-esp8266-32mb-flash-usb-ttl-ch340g-micro-usb.html

Cette carte a toutefois un inconvénient : il faut sans arrêt changer de configuration :

  • CH340 sur l'ATMEGA328 : chargement du sketch
  • ESP01 sur l'ATMEGA328 : exécution

Il faut donc basculer 4 switches à chaque fois. Galère ... 

On peut opter également pour une liaison SoftwareSerial en ajoutant deux fils, ce qui aura aussi un inconvénient : la vitesse réduite.

1.5. Firmware maison

Qu'il s'agisse d'un couple ARDUINO + ESP01 ou d'une carte ARDUINO WIFI rien n'empêche quiconque de développer pour ses propres besoins un firmware spécialisé afin de communiquer avec d'autres moyens qu'HTTP : MQTT par exemple, ou UDP.

Il est parfaitement possible également d'imaginer un FIRMWARE intelligent qui stockerait les pages HTML dans la mémoire FLASH de l'ESP01, et proposerait une interface permettant de les afficher en passant le nom de la page, avec une liste d'arguments variables, un peu comme on le ferait avec un écran NEXTION.

Mais dans ce cas on se demande quelle est la valeur ajoutée de l'ARDUINO ?
Un ESP8266 ou ESP32 ferait tout cela certainement mieux.

2. L'ESP8266 et l'ESP32

2.1. ESP8266

 
Une carte ESP8266 (D1 MINI par exemple) possède un certain nombre d'entrées sorties :
  • GPIOs (leur nombre dépend de la carte)
  • I2C
  • SPI
  • 1 entrée analogique

On peut examiner cette page afin de déterminer quelle carte sera capable de couvrir les besoins :

https://randomnerdtutorials.com/esp8266-pinout-reference-gpios/ 

2.2. ESP32

 

Une carte ESP32 possède un plus grand nombre d'entrées sorties (16 sorties PWM), ainsi que 18 entrées analogiques, et deux sorties DAC !

De plus, 10 GPIOS peuvent être utilisées avec des touches capacitives.

Voir ici :

https://randomnerdtutorials.com/esp32-pinout-reference-gpios/ 

2.3. Des avantages incontestables

On voit rapidement que le manque d'entrées / sorties d'un ESP8266 ou d'un ESP32 par rapport à une carte ARDUINO est un argument qui ne tient pas.

Dans le pire des cas on pourra ajouter un module expander MCP23008 ou MCP23017 :

https://riton-duino.blogspot.com/2019/02/les-extensions-de-gpios-de-larduino.html

On constatera également que d'un point de vue prix de revient le coût d'une carte ESP32 est sensiblement équivalent à celui d'un couple ARDUINO UNO + ESP01.

L'encombrement du couple ARDUINO UNO + ESP01 est également en défaveur de cette solution, ainsi que les liaisons par fils DUPONT, sources de problèmes (faux contacts).

Une dernière chose : un serveur WEB développé à l'aide d'un ESP8266 ou ESP32 disposera de ressources largement supérieures à celles d'un ARDUINO :
  • puissance de calcul
  • espace mémoire FLASH, RAM
  • espace de stockage des pages WEB

Il faut aussi noter que pour les personnes qui désireraient une intégration maximale, un module seul, soudé sur PCB, peut apporter une solution ultra-compacte :

Module ESP32


2.1. Implémenter un serveur WEB

Il existe différentes possibilités de développer un serveur WEB avec un ESP8266 ou un ESP32.

Les ressources WEB (tutoriels, cours, forums) sont également très nombreuses, beaucoup plus nombreuses que celles liées aux solutions ARDUINO + ESP01, et d'un tout autre niveau.

Sur ce blog certains projets WEB utilisent un ESP8266 ou un ESP32 :

https://riton-duino.blogspot.com/2020/03/serveur-esp32-implementation-et-test.html

https://riton-duino.blogspot.com/2020/04/un-afficheur-tft-pour-domoticz-ou.html 

https://riton-duino.blogspot.com/2020/03/arduino-ethernet-esp32-comparons.html 

https://riton-duino.blogspot.com/2020/01/un-logger-analogique-et-digital-version.html

D'autres articles plus généralistes en parlent également :

https://riton-duino.blogspot.com/2019/02/esp8266-sur-batterie.html

Dans les paragraphes suivants j'évoque les différentes possibilités d'implémentation, sans entrer dans les détails, mis à part que je fournis deux petits exemples. Il est aussi du ressort de chacun d'apprendre à se documenter sans que le travail soit prémâché. Pourquoi réécrire ce qui l'est déjà ?

Je pense que l'effort de documentation et de formation aux techniques de développement ESP8266 ou ESP32 sera moins important que celui qui sera nécessaire pour mener à bien un développement complexe à base d'ARDUINO + ESP01, et que le résultat sera autrement moins tributaire des limitations, aussi bien en matière de performances qu'en matière de vitesse de développement.

2.1.1. SPIFFS ou LittleFS

Lorsque l'on développe un serveur WEB on en vient rapidement à ne plus générer de contenu HTML avec des lignes de code, mais à l'aide de fichiers HTML stockés dans un espace dit "système de fichiers", organisé comme un disque dur.

Un ESP8266 ou un ESP32 offrira un système de fichiers en FLASH permettant le stockage de ces fichiers, ainsi que des images ou des fichiers JavaScript, tout cela sans avoir à ajouter d'espace de stockage supplémentaire (carte µSD ou FLASH SPI).

L'IDE ARDUINO permet le chargement de ces ressources à l'aide de deux plugins :

https://github.com/me-no-dev/arduino-esp32fs-plugin
https://github.com/esp8266/arduino-esp8266fs-plugin

Ces deux plugins créeront deux choix disponibles dans le menu outils :
  • ESP32 Sketch Data Upload
  • ESP8266 Sketch Data Upload

Il sera donc facile de charger les ressources à partir de l'IDE. Les fichiers à charger seront simplement placés dans un sous-répertoire data du projet.

Ensuite dans le code il suffira de lire ces fichiers et de les envoyer sur la sortie standard du serveur.

Les exemples sont nombreux sur le WEB :

https://byfeel.info/utilisation-de-la-memoire-spiffs-sur-esp8266/

Il est à noter que la librairie EspAsyncWebServer propose une méthode qui permet d'éviter de faire cela manuellement :

class AsyncWebServerRequest {
    void send(FS &fs, const String& path, const String& contentType=String(), bool download=false, AwsTemplateProcessor callback=nullptr);

Exemple :

  request->send(SPIFFS, "/index.html", "text/html", false);

Le fichier index.html sera chargé à partir de la FLASH de l'ESP8266 / ESP32, sans que l'on aie à s'en préoccuper. Je parle plus loin de cette librairie.

2.1.2. WifiServer

Les librairies ESP8266WifiServer et WifiServer (ESP32) sont assez bas niveau :

https://randomnerdtutorials.com/esp32-web-server-arduino-ide/

Je déconseille leur usage sauf si c'est dans un but de formation, si l'on désire traiter une requête HTTP soi-même "from scratch" par exemple. C'est assez barbare et peu de gens l'utilisent.

2.1.3. WebServer

Les librairies ESP8266WebServer ou WebServer (ESP32) disposent d'APIs de plus haut niveau permettant de réaliser un développement en peu de temps. Elles permettent d'associer des fonctions à chaque URL à traiter :

https://tttapa.github.io/ESP8266/Chap10%20-%20Simple%20Web%20Server.html

Exemple :

Dans la fonction Setup :

  server.on("/", handleRoot);

Le handler :

void handleRoot(void)
{
  server.send(200, "text/html", message);     // message = texte HTML à afficher
}

Simplissime, n'est ce pas ?

2.1.4. AsyncWebServer

Enfin la librairie EspAsyncWebServer est capable de gérer des pages HTML à l'aide de templates. Les templates sont des fichiers HTML contenant des tags nommés permettant la substitution de variables (PLACEHOLDER).

Cette librairie est très largement documentée sur le WEB.

Ce projet l'utilise :

https://riton-duino.blogspot.com/2020/03/serveur-esp32-implementation-et-test.html

2.1.5. Petits exemples

ESP32 Web server

Ici se trouve un petit exemple ESP32 reproduisant la même page HTML que le tutoriel vu au paragraphe 1.3. ESP01 + ARDUINO :

esp32-simple-webserver

La librairie WebServer est utilisée. Sur un ESP8266 on utiliserait la librairie ESP8266WebServer, le code serait assez peu différent.

On peut remarquer :

  • 105 lignes de code seulement au lieu de 400
  • simplicité : je l'ai écrit en une vingtaine de minutes (la fonction Setup est en grande partie reprise d'un autre projet)
  • le fichier root.h contient la page HTML avec deux tags %TEMP% et %PRESSURE%, qui sont remplacées dans le code par leurs valeurs à l'aide de simples appels à String::replace()

Cet exemple montre que le code est beaucoup plus simple que la version ARDUINO+ESP01, et montre également que l'on peut bénéficier de ressources logicielles inutilisables sur un ARDUINO, en particulier la classe String, qui provoquerait une fragmentation de la mémoire de celui-ci :

https://riton-duino.blogspot.com/2020/02/arduino-la-fragmentation-memoire.html

Bien entendu, cette solution à base d'ESP8266 ou d'ESP32 sera incomparablement plus évolutive qu'une solution à base d'ARDUINO+ESP01, et permettra de développer un serveur beaucoup plus riche, tout en réduisant fortement la charge de travail.

ESP32 Access point

Ici on peut trouver également un petit exemple de serveur WEB fonctionnant en point d'accès WIFI :

esp32-simple-accesspoint

L'adresse IP de ce point d'accès est affiché sur le terminal au démarrage (normalement 192.168.4.1).

3. Conclusion

Est-il raisonnable à l'heure actuelle de s'orienter vers une solution à base d'ARDUINO + ESP01 ?

A moins d'avoir envie de se convaincre que c'est une piètre solution, j'ai bien peur que non.

En tous cas, cette technique ne permettra pas d'aller bien loin de par la pauvreté des ressources matérielles (CPU, mémoire) d'un ARDUINO.

Qu'en est-il du HTML, du JAVASCRIPT ?
Que ce soit avec une carte ARDUINO, un ESP8266 ou un ESP32, dans tous les cas la connaissance de ces deux langages est indispensable. Envisager un développement WEB sans connaissances dans ces domaines est tout bonnement impossible.

On trouve de nombreux tutoriels sur le WEB et on peut facilement tester une page HTML avec un simple navigateur, en chargeant simplement le fichier.


Cordialement
Henri

4. Mises à jour

24/08/2020 : 2.1.5. Petit exemple
                     1.1.2. Recharger le FIRMWARE AT avec FLASH DOWNLOAD TOOL


jeudi 13 août 2020

JLCPCB : mode d'emploi

 

JLCPCB : mode d'emploi

 

Lorsque je conçois une carte électronique (PCB) j'utilise principalement  deux méthodes :

  • plaquettes à pastilles
  • PCB maison gravé à l'acide

On peut également, pour ceux qui sont équipés, effectuer une gravure à l'aide d'une machine CNC.

Le résultat peut être tout à fait correct lorsque le circuit est réalisé en simple face, mais si l'on conçoit un PCB double face, l'opération est plus délicate.

Il arrive qu'il y ait de petits défauts :

  • court-circuit entre piste ou pads
  • piste coupée à cause d'une rayure de la surface photosensible

De plus ces méthodes artisanales ne permettent pas d'obtenir un produit fini, avec une grande finesse de gravure, verni et sérigraphié :

 

Dans mon dernier projet j'ai fait appel aux services de JLCPCB, un fabriquant de circuits imprimés.

On peut voir que ce PCB est composé de deux cartes que l'on peut séparer avec une scie ou une cisaille.

Les deux cartes ont une dimension totale de 92mm x 99mm afin de pouvoir bénéficier du tarif réduit réservé aux cartes 100mm * 100mm.

On peut remarquer que les cartes ont un aspect très professionnel :

  • elles sont vernies
  • elles sont percées
  • les trous sont métallisés
  • les pads sont étamés
  • elles sont sérigraphiées

Voilà de quoi obtenir un résultat final très soigné.

1. Tarif et livraison

La commande minimale est de 5 cartes, le tarif est de 8.04€ pour 5 circuits double couche 100mm x 100mm, port compris. Le délai de livraison est de 2 semaines.

Les frais de ports les moins élevés sont : FR Special Air Mail, à sélectionner lors de la commande.

Le tarif peut sembler extrêmement bas pour une carte électronique. Le secret réside dans le fait que les fabricants utilisent des chutes de PCB provenant de la fabrication de cartes beaucoup plus grandes. Cette offre à bas prix leur évite donc de jeter de grandes quantités de matière première.

2. Le routage

Ici je présenterai la manière de procéder uniquement pour KICAD.

Il faut savoir que soumettre un routage pour une commande entraîne un examen automatique des fichiers GERBER par JLCPCB. Un mail sera envoyé suivant que le routage soit accepté ou refusé.

2.1. Lignes de coupe

Le PCB doit comporter des lignes de coupe (edge cuts) sur les quatre côtés, sans cela le routage sera refusé.

2.2. Plan de masse

Il ne faut pas hésiter à ajouter un plan de masse à la carte. Voir menu KICAD Place / Zone. Ce plan de masse permettra de réduire grandement les résistances de pistes GND et également de réduire les effets des interférences électromagnétiques, et de la diaphonie.

2.3. Perçage

Lorsque l'on utilise les empreintes livrées avec le logiciel KICAD, ou celles disponibles sur github il y de très fortes chances pour que les pads soient correctement dimensionnés, en particulier le diamètre de perçage.

Par contre lorsqu'il s'agit d'empreintes personnelles, il faut être très vigilant et adopter un diamètre de perçage adéquat. Il faut donc consulter la datasheet du composant.

Une erreur de diamètre peut entraîner un reperçage de certains trous, avec pour première conséquence la disparition de la métallisation de ceux-ci. Dommage ...

3. Préparer les fichiers GERBER

Avant toutes choses il est impératif de créer un compte JLCPCB.

Le format de fichier GERBER est le standard utilisé pour transmettre des informations concernant la fabrication des circuits imprimés.

Chaque fabricant de PCB a ses propres exigences.

Cette page explique quelles options doivent être choisies pour la génération des fichiers GERBER dans KICAD :

https://support.jlcpcb.com/article/44-how-to-export-kicad-pcb-to-gerber-files

D'autres supports pour les principaux logiciels de routage sont proposés :

https://support.jlcpcb.com/category/23-technical-support

Ensuite il suffira de remplir le formulaire de commande et de joindre les fichiers GERBER, après les avoir compactés dans un fichier ZIP.

La commande passera dans un premier temps dans un état "Examen en cours".

Si un défaut est constaté un mail sera envoyé avec la liste des défauts. Dans le cas contraire la commande pourra être finalisée.

4. Liens utiles

Je vous renvoie à mon tutoriel KICAD :

https://riton-duino.blogspot.com/2018/11/concevoir-un-pcb.html

5. Conclusion

J'ai été pleinement satisfait par cette première commande. Le résultat est très professionnel.

Cela n'élimine pas pour autant les solutions à base de gravure maison ou de plaquette à pastilles lorsque je suis pressé.

Je seul bémol est la quantité minimale de commande (5 cartes). On peut éventuellement passer une commande groupée à plusieurs personnes.


Cordialement

Henri


mardi 4 août 2020

Juillet 2020 : Actualité des Blogs du Mois


Actualité des Blogs du Mois


Sur le blog d'Yves Pelletier :
Sur  Framboise 314 :
Sur  MCHobby :
Sur Les carnets de Byfeel :

Cordialement
Henri

lundi 3 août 2020

Un éclairage d'escalier à LEDs (nouvelle version)




 Un éclairage d'escalier à LEDs

(nouvelle version)


Dans cet article j'avais présenté un éclairage d'escalier progressif :

Ce projet avait plusieurs défauts :
  • utilisation d'une carte ARDUINO MEGA
  • limitation à 15 marches
Ce sujet était arrivé à un stade parfaitement fonctionnel, mais restait à l'état de prototype, en particulier à cause d'un PCB complexe, la carte MEGA CORE étant assez compacte.

J'ai donc décidé de faire plus simple en utilisant une carte ARDUINO PRO MINI couplé à un module spécialisé, que j'ai récemment découvert : le SX1509 :
Le SX1509 est un composant I2C capable de gérer 16 sorties en PWM, ce qui permettra d'utiliser une simple carte ATMEGA328P, ici une PRO MINI. Grâce à une carte d'extension équipée de 16 MOSFETs il sera capable de piloter 16 rubans de LEDs.

Cette nouvelle version apporte les améliorations suivantes :
  • un encodeur rotatif permet de régler la luminosité
  • une LDR optionnelle est utilisée pour n'éclairer l'escalier que si la luminosité est insuffisante
  • une connexion optionnelle à un serveur domotique est prévue
Beaucoup de paragraphes de l'ancien article restent valables dans le cadre de ce nouveau projet. Je ne vais pas les répéter. Il est donc nécessaire de le lire afin de bien comprendre les principes utilisés, en particulier les calculs liés aux rubans de LEDs et à l'alimentation.

1. Le schéma


Le schéma est réalisé à l'aide de KICAD.

Pour récupérer le projet voir plus bas :  3. Téléchargements

Par rapport à l'ancien schéma seule la partie puissance n'est pas représentée. Le SX1509 commande une carte à 16 MOSFETs présentée ici :

La carte PRO MINI 8MHz a été choisie car le SX1509 doit être alimenté en 3.3V. Cela permet d'alimenter le tout à l'aide d'un seul régulateur LM78L33.

Le module NRF24L01 n'est utilisé que dans le cas où l'on désire connecter ce montage à un serveur DOMOTICZ afin de le commander à distance.

Comme dans la version précédentes deux PIRs sont utilisés pour la détection de personnes en haut et en bas de l'escalier.

La carte PRO MINI doit avoir les broches I2C A4 et A5 disposées comme ceci, à côté de A2 et A3 :
Celle-ci ne conviendra pas, à moins de modifier le routage de la carte de commande :
L'encodeur rotatif EC11 est un modèle chinois courant que l'on peut approvisionner chez n'importe quel revendeur :

Le module SX1509 est de ce type :

La LDR est une classique GL5528 :

Les capteurs PIR sont des MH-SR602, que l'on peut alimenter directement en 3.3V :
On peut également utiliser des HC-SR501, moyennant une petite modification :

2. Photos

Voici les photos des cartes utilisées. Il s'agit de cartes commandées chez JLCPCB. Le routage est fourni dans le projet, ainsi que les fichiers GERBER :



 
On voit à gauche la partie commande et à droite la partie puissance, que l'on peut séparer avec une scie ou une cisaille.
Les deux cartes ont une dimension totale de 92mm x 99mm afin de pouvoir bénéficier du tarif réservé aux cartes 100mm * 100mm.
La commande minimale est de 5 cartes, le tarif est de 9.14€ port compris. Le délai de livraison est de 2 semaines.

Ce projet est parfaitement réalisable sur une plaquette à pastilles, pour peu que l'on choisisse des MOSFETs en version traversante, des IRLZ44N (boîtier TO220) par exemple, ou des AOD409 (boîtier IPAK).

Voici la carte de commande toute équipée :


La carte de puissance est vissée en dessous de la carte de commande. Il s'agit d'un prototype réalisé par mes soins en PCB simple couche :


Les deux cartes sont reliées par un connecteur de commande à 17 points et un connecteur de puissance à 2 points.
Elles sont superposables, c'est à dire que l'on peut équiper une des deux cartes d'un connecteur 17 points mâle et l'autre carte d'un connecteur 17 points femelle et les embrocher l'une sur l'autre.
Sur ce prototype j'ai simplement relié les deux cartes à l'aide d'une nappe femelle-femelle DUPONT 17 points :


Les connecteurs d'alimentation 12V de la carte de commande sont des JST B2P-VH au pas de 3.96mm. Celui de la carte de puissance est un NS25 au pas de 2.54mm.

Le JST B2P-VH est capable de supporter 10A, le NS25 seulement 3A.
J'estime que 3A sont amplement suffisants. Cela fait tout de même 36W !

Dans le cas où la puissance nécessaire serait plus importante, on peut envisager de concevoir une autre carte de puissance, la carte de commande restant identique.
Cette carte à 8 MOSFETs IRLZ44N est capable de fournir 16A au total :


On peut bien entendu alimenter la carte de puissance directement à partir de l'alimentation 12V.

Voici une vidéo du montage :

Au démarrage les rubans de LEDs sont allumés progressivement, puis éteints. Cela permet un test rapide.

3. Téléchargements

Le projet est disponible ici : https://bitbucket.org/henri_bachetti/mysensors-led-stair-dimmer.git

Cette page vous donne toutes les informations nécessaires :
https://riton-duino.blogspot.com/p/migration-sous-bitbucket.html

Dans le projet KICAD il y a un répertoire jlcpcb contenant les fichiers GERBER requis pour une commande chez JLCPCB.
Il faut les zipper.

4. L'IDE ARDUINO

Deux librairies sont à prévoir :

https://github.com/thomasfredericks/Bounce2.git

Cette dernière librairie n'est utile que dans le cas où l'on connecte des boutons-poussoirs sur les entrées prévues pour les capteurs PIR, pour tester le montage.

La configuration est simple :

#define LDR                                                      // à commenter si la LDR n'est pas utilisée
// light level in LUX
#define LIGHT_MAX_LEVEL       5.0                // niveau de luminosité
// dimmer clock in microseconds
#define DIMMER_CLOCK          2000               // horloge du dimmer en millisecondes
// dimmer ON time in milliseconds
#define DIMMER_ON_TIME        15000           // durée d'allumage
en millisecondes
// MYSENSORS option (NRF24L01)
#define MYSENSORS                                       // option DOMOTICZ (à commenter si l'option n'est
                                                                            pas utile)

5. Configuration

Ma configuration est la suivante :

  • 16 rubans de LEDs 5730 12V de 10cm
  • une alimentation 12V 20W
Bien entendu on peut facilement adapter n'importe quel type de ruban 12V. La carte de puissance peut supporter jusqu'à 16 rubans consommant au total 3A.
Il est facile de concevoir une carte de puissance permettant de fournir plus de puissance si nécessaire, avec 16 MOSFETs IRLZ44N par exemple :

L'utilisation d'un ruban 5V est possible. Ils sont plutôt peu courants.
La carte de commande pourra être alimentée en 5V également; on devra cependant remplacer le régulateur LM78L33 par un modèle ayant une tension de drop-out moins élevée. Un LM2936-3.3V ou un LP2950-3.3V conviendra, ils ont le même brochage, par contre les condensateurs C2 et C3 devront être remplacés :
  • LM2936 : C2 = 100nF polyester, C3 = 10µF 10V
  • LP2950 : C2 = 1µF 10V, C3 = 2.2µF 10V
Les condensateurs tantale ou MLCC conviennent.

Il conviendra de lire l'article précédent si l'on désire adapter d'autres rubans de LEDs, et dimensionner l'alimentation :

6. Intégration

Le projet précédent devait être intégré dans le tableau électrique en utilisant un boîtier 9U (160mm) sur rail DIN :

Cette nouvelle version permettra de réduire la taille de ce boîtier. Un 6U suffira (106mm).

Si le tableau électrique est éloigné on peut utiliser une boîte à encastrer permettant d'accueillir également l'alimentation :
Seule la ligne 230V sera donc à raccorder au tableau. Cette boîte peut être encastrée au plafond sous le palier par exemple.

7. Consommation

La consommation du montage au repos est de 1.5mA.
La consommation totale est de 1.2A lorsque la luminosité est maximale, c'est à dire une quinzaine de Watts.

8. Utilisation

L'encodeur permet de régler la luminosité maximale. Pendant le réglage toutes les LEDs sont allumées. Il faut appuyer sur le bouton pour valider.
Lorsqu'une personne passe à proximité de l'un des détecteurs l'escalier s'allume 15 secondes (réglable en modifiant la constante DIMMER_ON_TIME).
A part cela, il n'y a pas grande chose à dire, à part que lorsqu'une personne passe devant un détecteur alors que l'escalier est déjà allumé, le temps d'allumage de 15 secondes est réarmé.

9. liens utiles

La superbe réalisation de Nicolas en vidéo (mai 2021) :

10. Conclusion

Cette réalisation est nettement plus simple et plus compacte que la précédente, et donne un résultat équivalent.



Cordialement
Henri

11. Mises à jour

30/12/2020 : correction de bug.
                     Quand la luminosité est < 7 il y a un débordement de calcul