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 à 8 ou 16 Mosfets




Un Module à 8 ou 16 Mosfets



Cet article fait suite à celui-ci :

https://riton-duino.blogspot.com/2019/01/mosfets-de-puissance.html

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.

L'élévation de température peut occasionner un blocage 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. :

https://riton-duino.blogspot.com/2019/01/mosfets-de-puissance.html

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, ce qui serait impossible avec un relais.

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 traversant (TO220 ou IPAK)
  • etc.

4. Le schéma

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

Pour récupérer le projet voir plus bas :  7. 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 ou un ESP32 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 de ruban.

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

Piloter une carte carte à 8 canaux à l'aide de 8 sorties d'un ARDUINO, un ESP8266 ou un ESP32 est envisageable, bien que cela soit dommage de monopoliser autant de sorties pour si peu de choses.

A moins de disposer d'une carte ARDUINO MEGA une carte à 16 canaux pourra difficilement se passer d'un module expander :

Module MCP23017

Ce module I2C dispose de 16 sorties. On le reliera au bus I2C de l'ARDUINO et on pourra donc piloter 16 canaux avec simplement 2 sorties :

  • ARDUINO : A4 et A5
  • ESP8266 : GPIO4 et GPIO5
  • ESP32 : GPIO21 et GPIO22

Il existe d'autres versions :

  • MCP23008 : 8 sorties
  • PCF8577 : 8 sorties
  • PCF8575 : 16 sorties
  • SX1509 : 16 sorties PWM

D'autres choix sont proposés ici :

Les extensions de GPIOs de l'ARDUINO

Bien entendu il existe des librairies pour piloter ces modules :

  • MCP23008 : https://github.com/adafruit/Adafruit-MCP23008-library.git
  • MCP23SXX : https://github.com/sumotoy/gpio_MCP23SXX
  • MCP23017 : https://github.com/adafruit/Adafruit-MCP23017-Arduino-Library.git
  • MCP23S17 : https://github.com/n0mjs710/MCP23S17.git 
  • PCF857X : https://github.com/skywodd/pcf8574_arduino_library
  • PCF8574 : https://github.com/RobTillaart/PCF8574
La plupart sont installables depuis le gestionnaire de bibliothèques de l'IDE ARDUINO.

6. 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. Chez JLCPCB on pourra commander 5 PCB de 100mm x 100mm pour 9€. Chaque PCB peut contenir 2 modules. Chaque module revient donc à 0.90€.

Le prix de revient de cette carte est ridicule :

  • un lot de 50 AO3400 à 1.30€ : 0.42€ les 16 pièces
  • 2 jeux de 100 résistances CMS à 0.50€ pièce : 0.32€ les 32 pièces
  • 2 connecteurs DUPONT 40 broches (à recouper) : 0.25€
  • le PCB : 0.90€

Au total chaque carte revient à 1.90€. En comparaison un module 16 relais coûte 9€.

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

Son prix de revient :

  • un lot de 10 IRLZ44N à 1.80€ : 1.44€ les 8 pièces
  • 2 jeux de 100 résistances 1/4W à 1.50€ pièce : 0.24€ les 16 pièces
  • 1 connecteurs DUPONT 40 broches (à recouper) : 0.12€
  • un lot de 30 borniers à 5€ : 1.50€ les 9 pièces
  • plaquette à pastilles 8x12 : 1€

Au total chaque carte revient à 4,30€. En comparaison un module 8 relais coûte 6€.

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.

7. Téléchargement

Le projet est disponible ici :

https://bitbucket.org/henri_bachetti/arduino-prototyping/src/master/mosfet-module/sot23-16/

8. Conclusion

Un module 8 ou 16 MOSFETs est simple à concevoir et son prix de revient est ridicule.


Cordialement

Henri

9. Mises à jour

06/07/2021 : 5. Pilotage

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.

Après adaptation d'un manchon de cuivre Ø3mm / Ø4mm voici le résultat :
Ce moteur semble avoir une vitesse inférieure à ce qui est annoncé. De plus il n'a pas résisté bien longtemps. Au bout de quelques ouvertures les engrenages ont lâché sur un blocage moteur en fin de course.

Ce moteur est à déconseiller lorsque l'on utilise une détection de fin de course par mesure du courant.

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

Il est important que le couple moteur soit suffisamment faible pour d'éviter que les dents de la poulie ne forcent trop sur celles de la courroie. C'est une histoire de compromis entre la puissance du moteur, le diamètre de la poulie et la vitesse d'ouverture.
Avec le moteur que j'utilise (60 tours / minute) et une poulie de 10mm (16 dents), la valeur minimale du PWM pour que le moteur puisse soulever la porte de 250g est de 100 (le maximum est de 255). En choisissant une valeur de 120 le temps d'ouverture est de 22 secondes.

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

Il est possible aussi 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

En pilotant le moteur en PWM le courant est irrégulier et il y a des pics allant  jusqu'à 220mA.

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 quelques milliers de µF .

J'ai ajouté un condensateur de 3300µF. Le fonctionnement est optimal.

Avec un rapport PWM de 120 les temps d'ouverture et de fermeture sont de 22 et 17 secondes.
L'arrêt moteur est réglé sur 50mA, grâce au condensateur.

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 par le chargeur le matin aussitôt que le soleil se lève.

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 la recharge est terminée et le TP4056 n'absorbe plus de courant, 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. IDE ARDUINO

Quelques librairies sont nécessaires :

Celles-ci sont optionnelles en fonction des options choisies dans options.h :

8. Évolutions

Dans sa dernière version le schéma a évolué :
 

8.1. Filtrage de la mesure du courant moteur

Un condensateur de 3300µF a été ajouté en parallèle sur la résistance de mesure de courant moteur R8 (version moteur continu). Ce condensateur permet d'amortir la tension aux bornes de la résistance et d'obtenir une mesure plus stable, et donc de régler le courant de blocage du moteur plus finement.
 
La mesure de courant moteur est elle-même moyennée dans le logiciel, afin de lisser la mesure. D'autre part la mesure n'est pas effectuée pendant 1 seconde au démarrage du moteur, afin d'éviter le pic de courant.

8.2. Servomoteur sans fin de course

Dans sa version servomoteur il est possible de se passer de contact de fin de course. Un servomoteur est composé d'un moteur continu, d'un certain nombre d'engrenages et d'un potentiomètre qui est utilisé par un circuit électronique afin de déterminer la position.
Il faut ouvrir le servomoteur et souder un fil sur le curseur du potentiomètre de celui-ci. Sur un MG996R c'est facile :
Il faut dévisser les 4 vis du servomoteur, enlever le capot du côté câble, et souder un fil sur le point milieu du potentiomètre (le fil blanc ci-dessus). Avant de refermer il faut agrandir de 1mm l'ouverture réservée au passage du câble, et refermer le tout.
 
Il vaut mieux éviter de retirer le capot du côté axe moteur, les engrenages risquent de tomber, et il serait dommage de perdre le petit axe du pignon central.

Le potentiomètre délivre environ 0V en position ZÉRO et 2.5V en position 180°.
 
On pourra ainsi mesurer la tension du curseur afin de déterminer la position du servomoteur. Le fil doit être branché en lieu et place du contact fin de course sur la broche 13 de l'ARDUINO.
Il suffit d'activer une option USE_SERVO_POT dans le code (options.h), et de désactiver l'option USE_LIMIT_SWITCH :

// limit switch is used (recommanded in a servomotor version)
//#define USE_LIMIT_SWITCH

// use the servomotor potentiometer voltage (needs a modification of the servo)
#define USE_SERVO_POT


Remarque : on peut aussi acheter un servomoteur avec retour de position analogique, si l'on en trouve un qui convient. En général il s'agit plutôt de petits modèles.

8.3. Ports auxiliaires

Un expander MCP23008 a été ajouté. Il permettra d'ajouter des entrées / sorties supplémentaires, pour de future évolutions :
  • distributeur de nourriture
  • approvisionnement en eau
  • etc.
Ce composant est une option.

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

jeudi 2 juillet 2020

INA138 et MAX4372 : Current Monitoring



INA138 et MAX4372

Current Monitoring


Nous allons aujourd'hui mettre en œuvre L'INA138 et le MAX4372, deux amplificateurs de courant.

Ces composants permettent d'amplifier la tension présente aux bornes d'un shunt de mesure afin d'envoyer une tension mesurable sur l'entrée analogique d'un microcontrôleur.

La sortie de l'INA138 est un générateur de courant. Le gain est donc réglable à l'aide d'une simple résistance.

La sortie du MAX4372 est un générateur de tension. Le gain est fixe et dépend du modèle :
  • MAX4372T : 20
  • MAX4372F : 50
  • MAX4372H : 100
La première question que l'on peut se poser : pourquoi utiliser un amplificateur analogique alors que des modèles numériques existent ? :
  • INA219 (12 bits)
  • INA226 (16 bits)
Ces composants nous apporteraient une précision supérieure, mais ils ont un inconvénient majeur : leur temps de conversion est élevé, 140µS au minimum. Si l'on désire s'affranchir du bruit il est même recommandé d'adopter un temps de conversion supérieur : 1.1ms ou 8.244ms.
Deuxièmement le dialogue se fait en I2C, ce qui n'améliore pas les choses.
Bref le handicap est important si l'on a des variations de courant rapides à observer.

D'autre part, lorsque l'on mesure un courant, la précision n'est pas le critère principal. Il s'agit souvent de mesurer la consommation d'un montage ou d'un composant et de tracer sa variation dans le temps. Une précision de 0.1% ou 0.5% est totalement inutile.

Le montage suivant pourra être utilisé pour mesurer un courant avec une rapidité qui dépendra uniquement de celle de l'ADC du microcontrôleur.
On peut facilement obtenir plus de 38000 échantillons par seconde avec un ATMEGA328 :
Certains gros STM32 peuvent offrir plus d'un million d'échantillons par seconde !

La deuxième question que l'on peut se poser : un simple AOP monté en amplificateur ne pourrait-il pas faire le même travail ?
La réponse est non, car l'INA138 et le MAX4372 peuvent accepter sur leurs entrée des tensions largements supérieures à leur tension d'alimentation, ce que ne pourra pas tolérer un AOP.

1. L'INA138

Ce composant est capable de mesurer un courant côté "high side" (rail positif) uniquement. Il peut être alimenté entre 2.7 V à 36 V.
Un autre modèle, l'INA168, peut être alimenté entre 2.7 V à 60 V.


La résistance shunt RS produit une chute de tension proportionnelle au courant traversant la charge. Il convient donc de choisir sa valeur judicieusement, afin de ne pas perturber la charge.
Pour une mesure précise, il est recommandé également de ne pas dépasser 0.5V entre les entrées de l'INA138.

La résistance RL permet de fixer le gain de l'amplificateur (voir figure 9 de la datasheet) :
  • RL=50KΩ pour un gain de 10
  • RL=100KΩ pour un gain de 20
  • RL=250KΩ pour un gain de 50
  • etc.
Imaginons que l'on désire mesurer un courant maximal d'un ampère.
Si l'on admet 100mV de chute de tension dans le shunt, celui-ci aura une valeur de :

RS = 0.1V / 1A = 0.1Ω

Si l'on fixe le gain à 20, la résistance RL doit avoir une valeur de 100KΩ.

La tension maximale en sortie de l'INA138 vaudra :

Vo = Is * RS * RL / 5KΩ = 1A * 0.1Ω * 100KΩ / 5kΩ = 2V

L'entrée analogique du microcontrôleur mesurera donc 2V à pleine échelle.

On peut utiliser différentes références de tension (VREF) pour l'ADC :
  • référence par défaut : 5V ou 3.3V suivant la tension d'alimentation
  • référence interne 1.1V
  • référence interne 2.56V (ARDUINO MEGA)
Si l'on utilise la référence par défaut, la précision s'en ressentira légèrement.
Avec une référence 3.3V, la perte de précision sera faible.
Avec une référence 5V on perdra un bit sur les 10 de l'ADC. On peut augmenter le gain à 50 avec une résistance RL de 200KΩ. La tension maximale à mesurer sera de 5V. C'est limite.

Si l'on utilise la référence interne 1.1V l'ADC sera saturé. Il conviendra de diminuer la valeur du gain. On le fixera à 10 avec une résistance de 50KΩ. La tension maximale à mesurer sera de 1V.
Enfin, avec la référence interne 1.1V, si l'on conserve le gain de 20, le courant maximal que l'on pourra mesurer sera de 0.55A.

Sur une MEGA, la référence 2.56V sera le meilleur choix.

Il faut également tenir compte de la puissance dissipée par le shunt. La modèle que j'ai utilisé est une résistance 100mΩ CMS 2010 pouvant dissiper 1W.
Le courant maximal qu'elle pourra supporter est de :

I = √(P / R) = 3.16A

Comme c'est une limite absolue à ne pas dépasser, si l'on veut éviter un échauffement excessif, il serait bon d'appliquer une marge de sécurité.
Dans le cas où l'on dépasse le courant maximal admissible, il faudra adopter une résistance de puissance plus importante, mais cela se fera au détriment de la chute de tension dans RS :

U = R * I = 0.1 * 3.16 = 0.316V

On est loin des 100mV que l'on s'était fixé au départ. Il serait plus judicieux d'adopter un shunt de plus faible valeur, et d'augmenter le gain.

On peut résumer avec un petit tableau :

VREF
RS RL Gain Courant maxi Résolution
(ADC 10 bits)
5V 0.1Ω 200KΩ 50 1A 0.97mA
5V 0.1Ω 100KΩ 20 2.5A 2.44mA
5V
0.1Ω (*) 50KΩ 10 5A 4.88mA
5V
0.02Ω 200KΩ 50 6.25A 6.1mA
3.3V 0.1Ω 200KΩ 50 0.66A 0.64mA
3.3V 0.1Ω 100KΩ 20 1.65A 1.61mA
3.3V
0.1Ω (*) 50KΩ 10 3.3A 3.22mA
3.3V
0.02Ω 200KΩ 50 4.125A 4mA
1.1V 0.1Ω 200KΩ 50 0.22A 0.21mA
1.1V 0.1Ω 100KΩ 20 0.55A 0.53mA
1.1V 0.1Ω 50KΩ 10 1.1A 1.07mA
2.56V 0.1Ω 100KΩ 20 1.28A 1.07mA

(*) Ces deux configurations nécessiteront l'adoption d'un shunt d'au moins 3W, ou de diminuer sa valeur et d'augmenter le gain (voir ligne suivante dans le tableau).

Bien entendu avec d'autres microcontrôleurs possédant par exemple un ADC 12 bits ou des références internes de valeurs différentes ces paramètres seront différents.

On peut utiliser une référence de tension externe si l'on désire une plus grande précision ou une stabilité en température supérieure.


2. Le MAX4372

Le MAX4372 est plus simple. Il n'y a aucune résistance de réglage, mais les calculs restent les mêmes, et le tableau précédent reste valable.


3. Les schémas

3.1. L'INA138

Voici le schéma que j'utilise :
La sortie de l'INA138 est redirigée vers l'entrée d'un AOP OPA363 monté en suiveur (gain = 1), ceci afin de diminuer fortement l'impédance de sortie.
Cet étage est nécessaire si l'on désire faire des mesures de courant subissant des variations rapides ou utiliser plusieurs canaux ADC simultanément. Voir cet article :

Un condensateur de 100nF permet de découpler l'alimentation.

3.2. Le MAX4372

Voici le schéma que j'utilise :
Le MAX4372 a une impédance de sortie très faible, il n'a nul besoin d'un AOP suiveur pour abaisser celle-ci.

Ici aussi un condensateur de 100nF permet de découpler l'alimentation.

Que dire de plus ? Il est temps de passer aux essais.

3.3. Les branchements

Le connecteur IN-OUT des deux modules a le brochage suivant :
  • 1 : sortie
  • 2 : alimentation 5V ou 3.3V (l'OPA363 supporte au maxi 5.5V)
  • 3 : GND
  • 4 et 5 : V-
  • 6 et 7 : V+
La tension d'alimentation pour la charge doit être appliquée sur les broches 6-7. La charge est câblée entre les broches 4-5 et GND.

Les broches 4-5 et 6-7 sont doublées afin d'augmenter le courant admissible.

Sur ce schéma la charge est une résistance de 47Ω, elle consommera donc environ 100mA sous 5V.

On pourrait imaginer remplacer cette charge par un microcontrôleur quelconque pour en mesurer la consommation. Il est facilement imaginable également que le microcontrôleur reçoive lui-même l'information à mesurer sur une de ses propres entrées analogiques. Il pourra donc mesurer sa propre consommation en temps réel.

Un module de ce type peut être mis en place pendant la phase de test d'un projet et retiré ensuite, une fois que la consommation est connue.
On peut par exemple prévoir un connecteur femelle à 7 points sur la carte pour enficher le module, et le remplacer ensuite par un cavalier entre les pins 5 et 6.

4. Le sketch

4.2. L'INA138

Voici un petit sketch pour un ARDUINO :

#define VREF          1.073
#define SHUNT         0.100
#define INA138_GAIN   19

void setup()
{
  Serial.begin(115200);
  analogReference(INTERNAL);
}

void loop()
{
  unsigned int adc = analogRead(A0);
  Serial.print(F("ADC: ")); Serial.println(adc);
  float voltage = adc * VREF / 1023;
  Serial.print(F("voltage: ")); Serial.print(voltage, 3);  Serial.println(" V");
  float current = voltage / SHUNT / INA138_GAIN;
  Serial.print(F("current: ")); Serial.print(current, 3); Serial.println(" A");
  delay(2000);
}


On voit que la tension de référence vaut 1.073V. Cette tension est mesurée sur la sortie AREF de l'ARDUINO.

Sur une PRO MINI cette broche n'existe pas, mais on pourra la fixer à 1.1V sans problème. On ajustera la valeur du gain dans le code afin de compenser.

Dans ce sketch la valeur du gain est de 19. Pourquoi cette valeur alors que sa valeur théorique est de 20 ?
Ce n'est qu'une histoire de précision de composants. Le shunt de 0.1Ω a été acheté chez un fournisseur sérieux. Il a une précision de 1%. La résistance RL que j'ai utilisé fait partie d'un jeu de résistances CMS dont j'ignore la précision (AliExpress).

J'ai donc ajusté la valeur du gain dans le code afin que le résultat affiché soit identique à la valeur du courant mesuré par mon multimètre.
Si l'on utilise une résistance RL à 1% la correction à réaliser sera plus faible.

L'ARDUINO, après avoir ajusté ces constantes affiche ceci :

ADC: 168
voltage: 0.176 V
current: 0.099 A
ADC: 167
voltage: 0.175 V
current: 0.098 A
ADC: 167
voltage: 0.175 V
current: 0.098 A
ADC: 166
voltage: 0.174 V
current: 0.098 A

Le voltage affiché est celui lu sur l'entrée A0. Comme le gain de l'INA138 est fixé à 20, la tension aux bornes du shunt est donc 20 fois inférieure.

La mesure est très stable.

4.2. Le MAX4372

Le sketch est légèrement différent (j'ai utilisé un MAX4372F avec donc un gain de 50) :

#define VREF          1.073
#define SHUNT         0.100
#define MAX4372_GAIN  50

void setup()
{
  Serial.begin(115200);
  analogReference(INTERNAL);
}

void loop()
{
  unsigned int adc = analogRead(A0);
  Serial.print(F("ADC: ")); Serial.println(adc);
  float voltage = adc * VREF / 1023;
  Serial.print(F("voltage: ")); Serial.print(voltage, 3);  Serial.println(" V");
  float current = voltage / SHUNT / MAX4372_GAIN;
  Serial.print(F("current: ")); Serial.print(current, 3); Serial.println(" A");
  delay(2000);
}

Ici il n'y a aucun besoin d'ajuster quoi que ce soit, mis à part la tension VREF.
Voici le résultat :

voltage: 0.514 V
current: 0.103 A
ADC: 487
voltage: 0.511 V
current: 0.102 A
ADC: 505
voltage: 0.530 V
current: 0.106 A
ADC: 490
voltage: 0.514 V
current: 0.103 A


La mesure est un peu moins stable, ceci étant dû probablement au gain plus élevé. Le modèle MAX4372T avec un gain de 20 serait probablement moins bruité.
Mais cela reste tout à fait exploitable.

5. Photos

Voici une photo des 2 modules :

INA138

MAX4372

Les 2 cartes font respectivement 23mm x 20mm et 20mm x 15mm.

On peut donc les utiliser comme des module ARDUINO classique, y compris sur une breadboard si le courant à mesurer est faible.

Si le courant à mesurer est supérieur à 1 ou 2 ampères il serait plus convenable d'opter pour un connecteur plus approprié.

6. Téléchargements

Ces deux projets sont téléchargeables ici :


7. Liens utiles

Les amplificateurs de courants.
Chez TEXAS :
Chez MAXIM :

8. Conclusion

La mesure de courant est largement facilitée par ces petits composants, avec un peit avantage pour le MAX4372, plus simple à mettre en oeuvre.
Il ne reste plus qu'à les exploiter sur une vraie application.

Une dernière chose : le MAX4372, l'INA138 et l'OPA363 se trouvent facilement sur AliExpress.
Le module INA138 a coûté 1.60€, le MAX4372 1.10€.


Cordialement
Henri

9. Mises à jour

03/07/2020 : le MAX4372