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. Conclusion

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


Cordialement
Henri

mercredi 22 juillet 2020

DOMOTICZ : installation



DOMOTICZ : installation


DOMOTICZ est un serveur domotique permettant de gérer divers dispositifs (capteurs, relais, prises connectées, etc.) d'une habitation.
Ce blog contient d'ailleurs pas mal de réalisations liées à DOMOTICZ, que j'utilise depuis quelques années.

J'ai récemment voulu mettre à jour mon installation DOMOTICZ. Malheureusement, la nouvelle version ne fonctionne pas avec ma veille RASPBIAN 8 JESSIE. J'ai donc essayé de faire une mise à jour vers la version BUSTER. Le système n'a pas redémarré, pas la moindre ligne n'apparaissait à l'écran.

Il faut donc tout reprendre à ZÉRO, et cela va être une bonne occasion d'écrire un petit tutoriel sur le sujet.

1. Prérequis

La carte sur laquelle va être installé DOMOTICZ est une RASPBERRY PI 3B sous RASPBERRY PI OS. Dans mon installation précédente cette carte donnait toute satisfaction. Il y a fort à parier que même un modèle 1 ou 2 soit suffisant.

Pour l'installation il faut disposer d'une carte µSD d'au minimum 4Go pour un système Lite et 16Go pour un système complet avec interface graphique et logiciels recommandés :

Personnellement j'utilise la version Lite, car la RASPBERRY PI n'est raccordée à aucun écran, donc je n'ai besoin d'aucune interface graphique, tout passe par le réseau.

Pour la mise en route de la RASPBERRY PI, par contre, l'installation requiert le matériel suivant :
  • clavier de PC
  • écran de PC + câble adaptateur HDMI / DVI
  • câble Ethernet
Le câble adaptateur HDMI est raccordé à la prise DVI de l'écran. Ce matériel n'est utilisé que pour le début de l'installation.

Je recommande l'utilisation d'une carte µSD de marque, si possible classe 3 ou 4.
Personnellement j'utilise depuis plusieurs années une Sandisk Extreme 16Go classe 3.

Il est également recommandé d'utiliser une carte d'alimentation UPS, afin d'éviter les problèmes liés aux coupure secteur. Personnellement j'ai installé une DFROBOT DFR0494.

2. Installation de RASPBERRY PI OS

Les distributions sont à télécharger ici :

Cette page donne les instructions d'installation en fonction de l'OS de votre PC :

2.1. Démarage

Après avoir connecté le clavier et l'écran, et inséré la carte µSD, il suffit de brancher l'alimentation 5V à la RASPBERRY PI et le système démarre.

A l'invite "raspberry login:" entrer l'identifiant et le mot de passe :
identifiant: pi
mot de passe: raspberry

2.2. Clavier et langue

Avant toute chose, configurer le clavier en français. Voici la marche à suivre :

On peut éventuellement aussi configurer le système en langue française :
Ce n'est pas vraiment utile car DOMOTICZ possède ses propres jeux de messages dans la majeure partie des langues.

2.3. Réseau

On peut, si ce n'est pas déjà fait, raccorder maintenant le câble réseau à un switch ou directement à la box Internet.
La commande ifconfig permet de visualiser les paramètres réseau :

pi@raspberrypi:~ $ ifconfig
eth0: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1500
        inet 192.168.1.14  netmask 255.255.255.0  broadcast 192.168.1.255
        inet6 fe80::7363:f85e:8ee8:4dc6  prefixlen 64  scopeid 0x20<link>
        ether b8:27:eb:9b:78:e9  txqueuelen 1000  (Ethernet)
        RX packets 205  bytes 14966 (14.6 KiB)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 109  bytes 13567 (13.2 KiB)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0

lo: flags=73<UP,LOOPBACK,RUNNING>  mtu 65536
        inet 127.0.0.1  netmask 255.0.0.0
        inet6 ::1  prefixlen 128  scopeid 0x10<host>
        loop  txqueuelen 1000  (Local Loopback)
        RX packets 0  bytes 0 (0.0 B)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 0  bytes 0 (0.0 B)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0


La RASPBERRY PI a obtenu une adresse IP par DHCP. Cette adresse IP est susceptible de changer sans préavis. Il vaut mieux donc attribuer une adresse fixe à notre RASPBERRY PI.
Plutôt que de configurer une adresse fixe en modifiant l'interface Ethernet du système, je recommande plutôt de modifier les paramètres DHCP de la box Internet afin d'ajouter une adresse IP fixe pour notre RAPBERRY PI.
Il est assez facile de trouver le mode opératoire pour chaque box sur internet.
Pour une LiveBox voir ICI.

2.4. Heure locale

Il faut également configurer le fuseau horaire (TimeZone), afin d'avoir l'heure locale ainsi qu'un changement d'heure automatique été / hiver.
Le serveur DOMOTICZ fonctionnera ainsi en heure française, c'est important si un ou plusieurs dispositifs désirent récupérer l'heure.

2.5. SSH

Après l'installation de DOMOTICZ l'essentiel des opérations se fera depuis un navigateur, mais il se peut que l'on ait besoin d'accéder au système lui-même.
Afin de pouvoir accéder à notre système depuis un ordinateur distant il va falloir activer le login distant : SSH

Voici deux tutoriels :

Pendant que nous y sommes, changer le mot de passe n'est pas une mauvaise chose :

pi@raspberrypi:~ $ passwd
Changing password for pi.
Current password:
New password:
Retype new password:
passwd: password updated successfully

Ce nouveau mot de passe pourra être utilisé aussi bien en local qu'en accès par SSH.

3. DOMOTICZ

3.1. Installation

L'installation de DOMOTICZ est très simple :

pi@raspberrypi:~ $ curl -L https://install.domoticz.com | bash

Cette commande réalise l'ensemble des opérations :
  • téléchargement
  • configuration
  • installation
L'utilitaire de configuration pose quelques questions (choix du port, des interfaces HTTP, HTTPS, du répertoire d'installation, etc.) auxquelles on répondra par défaut OK.

Tous les détails ici :

Pour info on peut trouver le manuel complet de DOMOTICZ ici :

3.2. Lancement et configuration

Avant toutes choses, si l'on utilisait une ancienne version de DOMOTICZ, ce qui est mon cas, il est impératif de VIDER LE CACHE DU NAVIGATEUR.

Pour avoir accès à l'interface de DOMOTICZ il suffit d'entrer l'adresse suivante dans un navigateur :

http://192.168.1.134:8080

On remplacera 192.168.1.134 par l'adresse IP choisie pour la RASPBERRY PI.

L'écran d'accueil de DOMOTICZ apparaît, assez pauvre pour l'instant, mis à part la barre de menus :


On peut dès à présent modifier la configuration de base à l'aide du menu Setup / Settings :
  • langue française
  • thème
  • latitude
  • longitude
  • etc.
Pour la suite il faudra au minimum une passerelle :
  • passerelle MYSENSORS USB ou Ethernet
    • NRF24L01
    • RFM69 ou RFM95
  • passerelle RFLINK
  • etc.
Cette passerelle va permettre la communication par radio avec les dispositifs (capteurs, relais, etc.).

La passerelle USB est une simple carte (NANO par exemple) équipée d'un module radio. Voir ici : https://www.mysensors.org/build/serial_gateway

La passerelle RFLINK permet de communiquer avec des objets connectés 433MHz du commerce (Chacon, Blyss, etc.).

Pour mon cas il s'agit d'une passerelle MYSENSORS USB avec module radio NRF24L01.
La passerelle doit être ajoutée à l'aide du menu Configuration / Matériel :


Les dispositifs viendront s'identifier d'eux-même au serveur DOMOTICZ lorsqu'ils enverront des données ou qu'on les redémarrera.

Bien sûr si l'on ne possède aucun dispositif, il faudra en développer quelques-uns, ou acheter des dispositifs du commerce compatibles avec la passerelle RFLINK si l'on a choisi cette solution.

Pour les DIYers, le développement de dispositifs MYSENSORS et leur intégration à DOMOTICZ ont déjà été présentés ici :

4. Conclusion

Comme on le constate l'installation d'un serveur DOMOTICZ sur RASPBERRY PI est très rapide. On peut le rendre opérationnel en quelques dizaines de minutes.
Pour moi le travail n'est pas fini, il va falloir réintégrer tous les dispositifs en ma possession. Courage ...


Cordialement
Henri

mardi 14 juillet 2020

Un Module à 16 Mosfets




Un Module à 16 Mosfets



Cet article fait suite à celui-ci :

Lorsque l'on veut alimenter une charge (un moteur, une pompe, une vanne, des rubans de LEDs, etc.) à l'aide d'une tension continue le premier réflexe du débutant est de penser à des relais.

Une carte à relais ressemble à un canon pour tuer une mouche quand on veut commuter une charge 5V 12V ou 24V, sans parler de l'encombrement, du bruit et de la fiabilité :
Cette carte a des dimensions imposantes : 180mm * 90mm * 20mm.

N'y a t'il pas d'autre alternative ? Heureusement, si.

Pour commuter une charge en basse tension continue un MOSFET est tout à fait à son aise.

1. Le relais

Le relais a de multiples inconvénients :
  • le bruit
  • la consommation
  • la résistance de contact

1.1. La puissance de commande

La bobine d'un relais courant 5V du type SRD-05VDC-SL-C, qui équipe la majeure partie des cartes du commerce, consomme 70mA, soit 350mW sous 5V.
Lorsque l'on a besoin de 8 ou 16 relais cela devient vite prohibitif.

1.2. La résistance de contact

La résistance de contact de ces relais est de 100mΩ, ce qui implique que pour une dizaine d'ampères qui le traversent, la dissipation thermique sera importante :

P = R * I² = 0.1 * 10² = 10W

10W est une puissance énorme au vu de la taille du relais et de sa capacité à dissiper cette puissance, difficile à dissiper d'ailleurs à travers un boîtier plastique.

La chaleur peut occasionner des blocages du relais.
On a souvent des retours négatifs sur la fiabilité de ces relais lorsqu'ils sont utilisés à leurs limites.

La première alternative qui vient à l'esprit est le relais statique (solid state) :

Module relais SSR 2A
Module 8 relais SSR 2A

Relais SSR 10A

Relais SSR 25A avec dissipateur

Si l'on a besoin de à 8 ou 16 relais pour un courant de 10A, cette solution occupe une place énorme et le prix sera conséquent.

2. Le MOSFET

2.1. La puissance de commande

La puissance nécessaire pour commander un MOSFET est tout simplement nulle. Cela élimine d'office toute consommation du côté commande.

2.2. La résistance à l'état passant

On trouve couramment des MOSFETs ayant une résistance interne en mode passant (RDSon) de quelques milliohms.
Le très courant IRLZ44N a une résistance de 25mΩ. Quant à l'excellent IRLB3034 sa résistance est de seulement 2mΩ.
Il va sans dire que la dissipation d'un tel transistor sera ridicule à 10A :

P = R * I² = 0.001 * 10² = 0.2W

Il ne nécessitera pas le moindre dissipateur.

2.3. La tension de commande

Il est impératif, lorsque l'on désire commander un MOSFET à l'aide d'une tension de 5V, de choisir un MOSFET "Logic Level", c'est à dire commutable à l'aide d'une tension de grille faible.
Ce critère est encore plus important si la tension de commande est de 3.3V.

Cet article présente une liste de MOSFETs utilisables dans le monde ARDUINO ou ESP8266, ESP32, etc. :
Les MOSFETs "Logic Level" sont indiqués en vert.

2.4. Le contrôle PWM

Avec un MOSFET il est facile de contrôler la vitesse d'un moteur ou la luminosité d'un ruban de LEDs avec une sortie PWM d'un microcontrôleur.

3. La disponibilité

S'il est facile de trouver des modules relais de toutes tailles, il n'en va pas de même quand il s'agit de modules à MOSFETs.

Tout d'abord un petit mot à propos des module équipés d'IRF520, IRF530 ou IRF540 : ils sont tout bonnement inutilisables avec une tension de commande de 5V si le courant à commuter est important. A éviter absolument.

Seulement quelques modèles "Logic Level" existent sur le marché :
IRLR7843

AOD4184

Ci-dessous quelques modules personnels :

IRLZ44N

AOI403

A ma connaissance aucun module à MOSFETs multiples n'existe.

Alors que faire ? Do It Yourself !

La carte que je vais présenter est équipée de 16 MOSFETs de puissance moyenne AO3400 (5A maximum).
On pourra facilement la personnaliser :
  • utiliser des MOSFETs plus puissants
  • utiliser des MOSFETs en boîtier traversants
  • etc.

4. Le schéma


Le schéma est réalisé avec KICAD.

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

L'AO3400 est un MOSFET canal N supportant 30V maxi et 5.6A. Sa faible tension VGSth de 1.45V maxi permet de le commander même avec un processeur 3.3V, un ESP8266 par exemple.

La carte est équipée d'un connecteur DUPONT 17 broches GND + 16 entrées.

Un connecteur DUPONT 32 broches est utilisé pour les 16 sorties.
Un connecteur 2 broches permet d'alimenter en 5V, 12V, ou 24V.

Cette carte est prévue pour de la puissance moyenne : 1A par sortie et 3A au total. Elle peut être utilisée par exemple pour piloter 16 rubans de LEDs 5630 12V de petite taille, jusqu'à une soixantaine de LEDs, soit 1m.

Sur chaque canal on trouve un MOSFET canal N et deux résistances :

Le transistor est piloté par une sortie du microcontrôleur à travers une résistance de 220Ω dont le but est de limiter le courant d'appel lors de la montée du signal sur la grille, ceci afin de protéger la sortie du microcontrôleur. Une résistance de pull-down de 100KΩ est câblée entre grille et source afin de ne pas laisser la grille en l'air dans le cas où la sortie du microcontrôleur est en haute impédance, au démarrage par exemple.

5. Photos



Tous les composants sont des modèles CMS.

La carte a des dimensions réduites : 100mm x 37mm, le quart de la surface d'un module à 16 relais.

Les connecteurs sont coudés, ce qui permet de les souder sur ce PCB maison simple face. Dans le cas d'un PCB double face à trous métallisés on pourra utiliser des connecteurs droits.

Cet autre modèle développé précédemment utilisait 8 MOSFETs IRLZ44NS et des résistances traversantes :


Mis à part le nombre et le type de MOSFETs utilisés le schéma électronique est strictement identique au précédent.

Elle est équipée d'un connecteur DUPONT 9 broches GND + 8 entrées.

Elle est également équipée de borniers :
  • bornier 16A d'alimentation de puissance à gauche (maxi 55V pour l'IRLZ44N)
  • 8 borniers 7A pour 8 charges
Le câblage de puissance de cette carte est réalisé avec du fil rigide :
  • liaisons entre borne d'entrée - et sources des MOSFETs (1.5mm²)
  • liaisons entre borne d'entrée + et bornes de sortie + (1.5mm²)
  • liaisons entre bornes de sortie - et drains des MOSFETs (0.5mm²)
Le câblage entre entrées et résistances de grille est fait en fil à wrapper.


Elle peut fournir environ 5A par sortie et 16A au total. On pourrait admettre plus d'ampérage en câblant à l'aide de fil de 2.5mm² et en utilisant d'autres borniers supportant un ampérage plus élevé.

Comme on le voit, même avec une plaquette à pastilles il est parfaitement possible de construire un module à MOSFETs digne de ce nom.

6. Téléchargement

Le projet est disponible ici :
https://bitbucket.org/henri_bachetti/arduino-prototyping/src/master/mosfet-module/sot23-16/

7. Conclusion

Un module 8 ou 16 MOSFETs est simple à concevoir et son prix de revient est ridicule.
Pour information les prix sont les suivants :
AO3400 : 2€ les 50 pièces
IRLZ44N : 2.50€ les 10 pièces
IRLB3034 : 4€ les 10 pièces


Cordialement
Henri

mercredi 8 juillet 2020

ARDUINO : Stockage en Flash SPI



ARDUINO : Stockage en Flash SPI


Lorsque l'on travaille sur un projet ARDUINO et que l'on désire disposer d'un support de stockage de données, le réflexe est souvent le même :
  • EEPROM
  • carte SD
Sur un ESP8266 ou un ESP32 on dispose de beaucoup plus de moyens. Il existe des possibilités de stockage en FLASH :
  • librairie EEPROM
  • système de fichiers SPIFFS
  • système de fichiers FATFS (ESP32 uniquement)

1. Les supports natifs

1.1. ARDUINO

Sur un ARDUINO la taille de la mémoire EEPROM est de :
  • 1Kb sur un ATMEGA328P
  • 4Kb sur un ATMEGA2560
C'est une mémoire I2C assez lente.

1.2. ESP8266

Sur un ESP8266 la librairie EEPROM autorise la création d'un espace de 4096 octets maximum.

Le système de fichiers SPIFFS peut être configuré à l'aide des options de partitionnement (voir menu Outils/Flash Size).
Sur un classique D1 mini possédant 4Mo de FLASH on pourra réserver jusqu'à 3Mo pour le stockage des données.

Cette partition SPIFFS sera plutôt réservée au stockage de fichiers non modifiables, chargés une fois pour toutes à l'aide du menu Outils/Sketch Data Upload :
  • fichiers de paramètres
  • fichiers HTML, CSS, JS, etc.
Il n'est pas interdit à l'application d'y stocker des données mais il faut savoir que le système de fichiers sera écrasé à chaque rechargement des ressources HTML.
Il faut faire un choix. Il sera difficile de combiner les deux.

1.3. ESP32

Sur un ESP32 l'espace EEPROM est réduit à 512 octets maximum.

Le système de fichier SPIFFS ou FATFS peut être configuré à l'aide des options de partitionnement (voir menu Outils/Flash Size).

Comme pour l'ESP8266 la partition SPIFFS sera plutôt réservée au stockage de fichiers non modifiables, chargés une fois pour toutes à l'aide du menu Outils/Sketch Data Upload :
  • fichiers de paramètres
  • fichiers HTML, CSS, JS, etc.
Une partition FATFS sera plutôt réservée au stockage de fichiers générés par l'application :
  • fichiers logs
  • fichiers de données divers (base de données clients par exemple)
Gros avantage par rapport à l'ESP8266, il est possible d'adopter un schéma de partition combinant les deux systèmes de fichiers SPIFFS et FATFS.
Il sera ainsi possible de séparer les ressources HTML et les fichiers de données.

2. Les supports additionnels

2.1. La carte SD

Dans tous les cas, un support de carte SD sera capable de stocker beaucoup plus de données que l'EEPROM d'un ARDUINO ou la FLASH d'un ESP8266 ou ESP32.

Par contre il faut bien reconnaître que la fiabilité n'est pas toujours au rendez-vous. Outre le fait que certaines SD refusent de fonctionner, il arrive que certains modèles soient source de problèmes.
Voir le paragraphe 9.3. Générer le JAVASCRIPT  à l'aide d'une template sur SD

Après de multiples déboires avec d'autres modèles, j'ai retenu les Sandisk Extreme SDHC (le prix tourne aux alentours de 10€ pour une 16Go).

2.2. L'EEPROM I2C

Les EEPROM I2C ont des capacités faibles et sont lentes. On trouvera des composants allant jusqu'à 256Kbits (32Ko). C'est peu.

2.3. La FRAM

La mémoire FRAM offre des capacité allant jusuqu'à 4Mbits (512Ko). Son prix est très élevé : une trentaine d'euros.

2.4. La flash SPI

Il s'agit du même type de FLASH que sur un ESP8266 ou un ESP32. Ces composants à 8 pattes ont des capacités allant de 512Kbits (64Ko) à 2Gbits (256 Mo).

Comme on peut le voir le choix est large et peut sérieusement augmenter l'espace de stockage d'un ARDUINO ou même d'un ESP32.
Les capacités sont bien moindres que celles des cartes SD mais cela reste tout de même très intéressant.

Il existe des modèles CMS, DIP et même des modules :
Un module comme celui-ci équipé d'une W25Q128 coûte 2€, loin du prix d'une SD de qualité.
Quand à la version CMS, on peut trouver des lots de 10 pièces pour un peu plus de 6€ :
Une W25Q16 en bôtier DIP coûte 4€ les 10 pièces, de quoi stocker 2Mo de fichiers pour 40 centimes.
Ce composant est directement utilisable sur breadboard :
Autre avantage, leur faible consommation : 4mA en activité et 1μA au repos.

J'ai choisi de tester le modèle WINBOND W25Q128 (16Mo).

3. Le câblage


Ces mémoires sont des modèles 3.3V. elles nécessitent une adaptation de niveau :

Sur un ESP8266 ou un ESP32 les résistances ne seront pas nécessaires.

4. Les librairies

Il existe différentes librairies :

SPIMemory de Marzogh :

SPIFlash de LowPowerLab :

Ces deux librairies ont une interface analogue à celle de la librairie EEPROM, rien de bien intéressant sauf si l'on envisage de stocker des données sans notion de fichiers, à des adresses connues.

4.1. La librairie AdaFruit

https://github.com/adafruit/Adafruit_SPIFlash

La librairie AdaFruit repose sur la librairie SDFat. Elle hérite donc de l'inerface de cette dernière. Il faut une quantité de mémoire RAM d'au moins 5Ko pour pouvoir l'utiliser. Elle n'est donc pas adaptée aux petits ARDUINOs.

Le programme exemple SdFat_Format requiert 10.5Ko de mémoire RAM, donc une carte MEGA sera incapable de formater la FLASH.

Il faut adopter une ARDUINO DUE pour formater la FLASH, ensuite elle pourra être utilisée sur une MEGA. Cela suppose une organisation lourde, et la MEGA est une carte sans grand intérêt que je n'utilise quasiment jamais.

Quelques remarques pour ceux qui voudraient néanmoins tenter l'expérience :

Dans le fichier Adafruit_SPIFlashBase.cpp la liste des devices supportés ne contient pas la W25Q128. Je l'ai ajouté :

static const SPIFlash_Device_t possible_devices[] = {
    // Main devices used in current Adafruit products
    GD25Q16C,
    GD25Q64C,
    S25FL116K,
    S25FL216K,

    // Only a handful of production run
    W25Q16FW,
    W25Q64JV_IQ,
    W25Q128JV_SQ,

    // Nordic PCA10056
    MX25R6435F,

    // Other common flash devices
    W25Q16JV_IQ,
};

Pour info la liste complète des FLASH se trouve dans le fichier flash_devices.h.
Il est parfaitement possible d'ajouter des descripteurs. La W25Q128 est définie comme suit :

#define W25Q128JV_SQ                                                           \
  {                                                                            \
    .total_size = (1 << 24), /* 16 MiB */                                      \
        .start_up_time_us = 5000, .manufacturer_id = 0xef,                     \
    .memory_type = 0x40, .capacity = 0x18, .max_clock_speed_mhz = 133,         \
    .quad_enable_bit_mask = 0x02, .has_sector_protection = false,              \
    .supports_fast_read = true, .supports_qspi = true,                         \
    .supports_qspi_writes = true, .write_status_register_split = false,        \
    .single_status_byte = false,                                               \
  }

Ajouter la W25Q256 ou W25Q512 ne devrait pas être bien complexe. Il suffit de lire la datasheet.

Pour une W25Q256 :

    .memory_type = 0x40, .capacity = 0x19, .max_clock_speed_mhz = 133,         \

Pour une W25Q512 :

    .memory_type = 0x71, .capacity = 0x19, .max_clock_speed_mhz = 133,         \

J'ai tout de même essayé de formater la FLASH avec un ARDUINO DUE :

Adafruit SPI Flash FatFs Format Example
Flash chip JEDEC ID: 0xEF4015
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
This sketch will ERASE ALL DATA on the flash chip and format it with a new filesystem!
Type OK (all caps) and press enter to continue.
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
Creating and formatting FAT filesystem (this takes ~60 seconds)...
Setting disk label to: EXT FLASH
Formatted flash!
Error, failed to mount newly formatted filesystem!

Comme on le voit l'identifiant 0xEF4015 (W25Q16) est bien lu, donc la communication SPI se fait bien, mais la suite échoue. Une W25Q128 donne le même résultat.

Abandon de la librairie AdaFruit.


4.2. La librairie de Paul Stoffregen

https://github.com/PaulStoffregen/SerialFlash.git

La librairie de Paul Stoffregen offre une interface du type système de fichiers :
  • création ou ouverture d'un fichier
  • écriture / lecture / effacement
  • positionnement
  • parcours de la liste des fichiers
Parmi les inconvénients on peut citer :
  • il n'y a pas de répertoires
  • les fichiers sont créés avec une taille fixe
J'ai décidé d'adopter cette librairie car elle est légère et adaptée aux petits ARDUINOs.

4.2.1. Les fichiers de données

Si l'application crée un fichier pour y stocker des données, la taille fixe est un handicap.
En effet le fichier est créé au départ avec un contenu effacé (une suite de bytes ayant la valeur 0xFF).
Il sera assez difficile d'en faire un fichier de données, à moins d'effectuer pas mal d'opérations manuellement :
  • ouvrir le fichier
  • se positionner à la fin des données écrites précédemment (il faut mémoriser cet index)
  • écrire les données
  • sauvegarder le nouvel index
  • fermer le fichier
Où stocker l'index ? en EEPROM ?
Ce n'est pas d'une élégance démesurée.

Bien entendu il est impossible de réécrire par dessus des données déjà écrites. La mémoire FLASH s'efface par bloc. Si l'on souhaitait réécrire une partie du fichier il faudrait :
  • mémoriser le bloc
  • l'effacer
  • le réécrire en incorporant les nouvelles données
Or sur ce type de FLASH on ne effacer que par blocs de mémoire d'au minum 4Ko (16 pages de 256 octets). Il est donc impossible de sauvegarder un bloc dans la mémoire RAM d'un ARDUINO, à moins qu'il ne s'agisse d'un MEGA2560.

4.2.2. Les fichiers ressources

Nous allons aborder ici la gestion des fichiers ressources :
  • fichiers de paramètres
  • fichiers HTML, CSS, JS
  • fichiers images, logos
  • etc.
Ce cas est plus facile à traiter :
  • création du fichier à la bonne taille
  • ouverture du fichier
  • écriture les données
  • fermeture du fichier
Pour faire cela, que nous manque t'il ?
Il nous faut un logiciel de transfert de fichiers. Il en existe un certain nombre :
  • FTP
  • XMODEM, ZMODEM
  • etc.
Malheureusement ils sont assez peu compatibles avec la taille mémoire d'un ARDUINO.

4.2.3. Le logiciel de transfert

J'ai développé une librairie permettant le transfert de fichiers par le câble USB entre le PC et l'ARDUINO. Elle utilise la librairie de Paul Stoffregen.

Côté PC, un script PYTHON se charge de l'envoi des commandes.

Il est possible de transférer des fichiers texte ou binaires.
A la fin du transfert le contenu du fichier est vérifié.

4.2.3.1. Les commandes

Pour être à même de transférer un fichier il faut charger l'exemple upload dans l'ARDUINO.

Il faut également installer PYTHON 2.7 et PYSERIAL sur le PC.

L'utilitaire serflash.py est un logiciel en ligne de commande.

usage: serflash.py [-h] [-s] [-e] [-l] [-d] [-g] device file [file...]

Les commandes du logiciel PYTHON sont les suivantes :

Option Rôle
device    Port de communication
file
Fichier à transférer
-h
Aide
-s
Affiche la taille de la FLASH en Mo
-b
Affiche la taille d'un bloc en octets
-e
Efface la FLASH
L'effacement d'une W25Q128 prend 40 secondes
-l
Affiche la liste les fichiers dans la FLASH
-d
Affiche un dump du contenu du ou des fichiers
-g récupère de fichier sur le disque (avec l'extension .dump)

Voici des exemples. 3 fichiers (text, bin, big) sont présents dans le répertoire python :

Les 2 premières commandes affichent la taille totale et la taille d'un bloc.
La 3ème commande efface la FLASH.
Les 3 commandes suivantes transfèrent les fichiers.
La 7ème commande liste les fichiers.
La 8ème commande fait un dump des fichiers text et bin.
La 9ème commande récupère les fichiers text et bin.

$ ./serflash.py -s /dev/ttyUSB1
16 Mbytes (16777216 bytes)
$ ./serflash.py -b /dev/ttyUSB1
65536 bytes
$ ./serflash.py -e /dev/ttyUSB1

$ ./serflash.py /dev/ttyUSB1 text
Uploading 1 file(s) ...
text (26 bytes)
26 bytes sent
End of transfer
verified: OK
Files:
text : 26 bytes
$ ./serflash.py /dev/ttyUSB1 bin
Uploading 1 file(s) ...
bin (17 bytes)
19 bytes sent
End of transfer
verified: OK
Files:
text : 26 bytes
bin : 17 bytes
$ ./serflash.py /dev/ttyUSB1 big
Uploading 1 file(s) ...
big (3026 bytes)
128 bytes sent
128 bytes sent
128 bytes sent
128 bytes sent
128 bytes sent
128 bytes sent
128 bytes sent
128 bytes sent
128 bytes sent
128 bytes sent
128 bytes sent
128 bytes sent
128 bytes sent
128 bytes sent
128 bytes sent
128 bytes sent
128 bytes sent
128 bytes sent
128 bytes sent
128 bytes sent
128 bytes sent
128 bytes sent
128 bytes sent
82 bytes sent
End of transfer
verified: OK
Files:
text : 26 bytes
bin : 17 bytes
big : 3026 bytes
$ ./serflash.py -l /dev/ttyUSB1
Files:
text : 26 bytes
bin : 17 bytes
big : 3026 bytes
$ ./serflash.py -d /dev/ttyUSB1 text bin
text:
0000 61 7a 65 72 74 79 75 69 6f 70 71 73 64 66 67 68    azertyuiopqsdfgh
0010 6a 6b 6c 6d 77 78 63 76 62 6e                                  jklmwxcvbn
bin:
0000 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10     ................
0010 11                                                 .
$ ./serflash.py -g /dev/ttyUSB1 text bin
text.dump: Done
bin.dump: Done


Sur un PC Windows il faudra remplacer /dev/ttyUSB1 par COMX.

4.2.3.2. Le sketch

La librairie de transfert de fichiers peut être intégrée facilement dans un sketch :

#include <SerialFlash.h>
#include <serial-flash-upload.h>

#define CSPIN 10
#define LED 2 // Optional (can be set to ZERO)

Uploader uploader(CSPIN);

void setup()
{
Serial.begin(115200);
if (uploader.begin(LED) == false) {
Serial.println("ERR_FLASH");
}
}

void loop()
{
if (Serial.available()) {
uploader.shell();
}
}

Le sketch d'exemple upload est peu volumineux.

12216 octets (39%) de l'espace de stockage de programmes.
281 octets (13%) de mémoire dynamique.

Il suffit d'ajouter le code pour ses propres besoins dans les fonctions setup() et loop(), avec les précautions habituelles (pas d'attentes bloquantes, de delay() dans la fonction loop()).

On peut également utiliser le sketch exemple upload uniquement pour le transfert des fichiers, et écrire un sketch sans cette librairie, pour l'application.
Il faudra simplement recharger le sketch upload avant chaque transfert.

On peut enfin disposer de deux cartes ARDUINO, dont une dédiée au transfert, chargée avec le sketch upload. Dans ce cas la FLASH SPI peut être soudée sur une carte amovible.
Pour cet usage les modules du commerce sont particulièrement adaptés :


La librairie SerialFlash n'est pas très gourmande. Un sketch simple d'écriture de données occupe peu de place :

7726 octets (25%) de l'espace de stockage de programmes.
204 octets (9%) de mémoire dynamique.

Comparativement un sketch exemple ReadWrite de la librairie SDFat occupe :

9374 octets (30%) de l'espace de stockage de programmes.
1057 octets (51%) de mémoire dynamique

La librairie SerialFlash de SerialFlash est donc nettement plus économique en RAM que la librairie SDFat.


5. Téléchargements

Ce projet est téléchargeable ici :


6. Conclusion

Les FLASH SPI me permettront à l'avenir de remplacer avantageusement les cartes SD, et ceci pour un coût très avantageux.


Cordialement
Henri

dimanche 5 juillet 2020

Porte Motorisée de Poulailler (le bilan)




Porte Motorisée de Poulailler (4ème Partie)


Il est temps de faire le bilan de ce projet et de donner quelques chiffres.

1. Configuration retenue

1.1. Moteur continu

Voici le moteur utilisé :
Moteur JGA25-370 60 tours / minute

La configuration est la suivante :
  • alimentation : 2 batteries 18650 (2000mAH au total)
  • panneau solaire 18V 4W
  • moteur à courant continu 12V 60 tours / minute
  • pas de contact de fin de course
  • module radio NRF24L01 + liaison serveur DOMOTICZ
  • module RTC DS3231
  • ouverture et fermeture par calcul de l'heure de lever et de coucher du soleil
  • module SHT31D
  • temps de sommeil : 5 minutes
  • demande de l'heure au serveur DOMOTICZ : une fois par mois
Comme je le disais en 1ère partie, un petit motoréducteur de ce type conviendrait parfaitement :
J'ai réussi à trouver deux vis de fixation de Ø1.6mm. Il me reste à trouver un petit manchon pour l'axe moteur Ø3mm pour l'adaptation de la poulie à alésage Ø4mm.

1.2. ServoMoteur

Le fait que j'aie adopté une solution à moteur continu ne veut pas dire qu'une configuration à base de servomoteur n'est pas viable, bien au contraire.
Entre le 24 avril et le 20 juin celle-ci a donné entière satisfaction.

On utilisera de préférence un contact de fin de course haut, un contact REED + aimant par exemple :


En cas de besoin on trouve des servomoteurs ayant un couple plus élevé que le MG996R, le TD-8120MG (20kg.cm) :
TD-8120MG


2. Problème

La valeur du PWM appliqué au moteur a été réduite car la puissance moteur est encore trop importante. La courroie est soumise à une tension trop importante et a tendance à sauter.

Il est possible que la courroie se soit légèrement détendue du fait que la température est plus élevée qu'en avril. J'ai donc ajouté un tendeur réalisé dans un morceau de fil d'acier galvanisé d'un diamètre de 3mm et un petit morceau de tube aluminium :


La courroie passe à 1mm de la poulie de renvoi située plus bas. Il est préférable qu'elle ne la touche pas, afin d'éviter toute usure.

Avec ce dispositif, outre le fait que la courroie est tendue, le nombre de dents en prise sur le pignon est légèrement supérieur. Le comportement est excellent.
Reste à voir ce que cette solution donnera en fonction de la saison.

3. Comportement

Avec un rapport PWM de 150 les temps d'ouverture et de fermeture sont de 18 et 16 secondes.
L'arrêt moteur est réglé sur 300mA, car en pilotant le moteur en PWM le courant est irrégulier et il y a des pics allant  jusqu'à 220mA.
Le fonctionnement est optimal.

Remarque :
On pourrait filtrer ces pics en ajoutant un condensateur en parallèle sur la résistance shunt du L293D (R8).
Pour filtrer un PWM à 500Hz sur une résistance de 1Ω ou 1.5Ω il faudrait une capacité de 1000µF à 2000µF.

4. Mesure du courant du panneau solaire

Le module de mesure du courant du panneau a été ajouté. Il s'agit d'un module équipé d'un INA138 décrit ici :


Il est enfiché sur un connecteur DUPONT femelle 7 points soudé sur la carte afin de pouvoir être retiré après la phase de tests.


L'information est remontée au serveur DOMOTICZ, c'est à dire que celui-ci sera capable d'afficher un graphique de la puissance fournie par le panneau solaire.

Ce qui m'intéresse est de connaître le courant et le temps de charge en fonction de la météo.

Voici les premières données affichées :


Pour réaliser ces premiers essais j'ai déchargé la batterie à plusieurs reprises avec une résistance de 10Ω. La puissance maximale débitée par le panneau est de 1.7W.

Le module de mesure ne sera utile que pendant la phase de test du système. Il sera retiré au printemps, quand la puissance journalière sera connue sur une période suffisamment longue, hiver compris, et éventuellement neige comprise.
Il sera remplacé par un cavalier entre les broches 5 et 6 afin que le courant du panneau puisse passer directement.

4. Consommation

Avec cette configuration la consommation totale est de 1mA, essentiellement due au DS3231.
La consommation est donc d'une dizaine de mAH pendant la nuit en été. Cette perte est compensée le matin aussitôt que le soleil se lève par le chargeur.

La capacité des batteries étant d'environ 2000mAH l'autonomie sans recharge sera de 2000 heures, donc 2.7 mois.
Cette capacité peut paraître disproportionnée, mais pendant l'hiver l'efficacité des batteries sera amoindrie, par conséquent je préfère surdimensionner.

Enfin, durant l'hiver il se peut que de la neige recouvre le panneau solaire. La batterie ne sera donc pas rechargée pendant des périodes plus ou moins longues.

5. DOMOTICZ

Le serveur DOMOTICZ permet de récupérer des informations sous forme de graphiques :


Ce matin la porte s'est ouverte à 05:49:26.


La tension du panneau solaire commence à augmenter à 5H25.


A 5H30 le chargeur TP4056 absorbe 0.4W fournis par le panneau solaire pendant une courte période. La consommation de la nuit est donc compensée en très peu de temps.

La porte s'ouvre à 05:49. Le chargeur TP4056 ne juge pas nécessaire de recharger la batterie, car la tension de celle-ci n'est probablement pas descendue suffisamment bas.

Entre 5H30 et 7H25 le système continue à consommer : 1mA.

Ensuite à 7H25 une phase de recharge démarre. La tension de la batterie est donc descendue en dessous du seuil déclenchant la recharge. La puissance absorbée varie entre 0.1W et 0.2W. La charge se termine à 8H45.

A 8H45 la tension du panneau est de 5.65V. Elle monte ensuite brutalement à 16.5V, ce qui est normal car le TP4056 n'absorbe plus de courant et le panneau ne débite donc plus rien.

Les conditions météo ce matin : temps couvert.
Le panneau est à l'ombre jusqu'à environ 10H30.

Comme on le voit le panneau solaire n'a aucun mal à recharger la batterie, même par temps couvert et à l'ombre. La consommation est faible et par conséquent la quantité d'énergie nécessaire est faible également.

Le panneau solaire est utilisé au maximum à 10% de ses capacités. Tout ceci est extrêmement satisfaisant. Un panneau de 1W suffirait probablement.

6. Téléchargements

Cette version finale est disponible ici :

https://bitbucket.org/henri_bachetti/mysensors-gate/src/v1.0/

7. Conclusion

Ce projet est certes complexe du fait de ses nombreuses possibilités :
  • moteur
    • courant continu
    • servomoteur
  • alimentation
    • secteur
    • batterie + panneau
  • méthode d'ouverture / fermeture
    • grâce à la luminosité
      • LDR : idéal en cas d'alimentation secteur
      • panneau solaire
    • à l'aide d'un calcul de l'heure de lever et de coucher du soleil
      • RTC DS3231 avec saisie manuelle de l'heure
      • RTC DS3231 avec demande d'heure au serveur DOMOTICZ
A partir du moment où l'on a fait les choix principaux le paramétrage est relativement simple. Le fichier options.h regroupe toutes les options et les commentaires sont nombreux.
Les paramètre liés au moteur continu sont expliqués en 4ème partie :
Voir 3. Le logiciel

J'espère que cette suite d'articles apportera des réponses suffisantes à qui souhaite mener à bien un projet analogue, qu'il s'agisse de piloter une porte de poulailler ou simplement d'automatiser le pilotage d'un moteur en fonction de l'heure, avec une alimentation autonome ou non.


Cordialement
Henri