Hardware

Matériel nécessaire

Il vous faut:

• Un Raspberry PICO, version 1 ou 2 peu importe.

• Un moteur pas à pas 12v de type NEMA17 (personnellement j’utilise un modèle 17HE15-1504S)

• Un driver TMC2208 ou TMC2209 qui va permettre de convertir les instructions en 3.3v envoyées par le microcontrôleur en 12v vers les bobines du moteur pas à pas. Ces drivers sont miniatures, efficaces et permettent un contrôle du moteur sans aucun bruit. La carte fonctionnera aussi avec un driver A4988, mais ils sont dépassés, et bien moins efficaces que les drivers TMC.

• Une alimentation DC 12v 60Watts (5A) avec un connecteur Jack DC. Attention à ne pas prendre une alimentation 5v.

• 1 micro-switch DIP avec 3 boutons, pour configurer les micro-steps de chaque moteur. Seuls les 2 premiers boutons sont utiles pour les drivers TMC (le troisième ne sert que pour les driver A4988).

• 1 condensateur 25v 100uf, les plus petits en hauteur (il faut les loger sous les drivers TMC).

• 1 led 5mm pour visualiser la mise sous tension de la carte (j’ai opté pour une led rouge).

• 1 résistance 1/4watts de 220ohms (pour la led).

• 1 convertisseur 12v-5v TRACO TSR: leur rendement est excellent (>90%).

• 1 connecteur JackDC à souder avec 3 pattes.

• 2 pin header mâle 4 pins pour connecter le moteur et une interface i2c optionnelle (pour un écran OLED déporté).

• 2 pins header femelles 8 pins afin d’y connecter le driver sans avoir à les souder sur la carte.

• 2 pins headers femelles 20 pins afin d’y connecter le raspberry pico sans avoir à le souder sur la carte.

• bien entendu la carte PCB que vous pouvez re-faire fabriquer à partir des fichiers GERBER fournis dans ce Github dans le dossier PCB, ou bien vous pouvez me contacter pour voir s’il men reste en stock.

Schéma électronique

Assemblage de la carte

Aucune difficulté, il ne faut pas se tromper de sens avec la soudure de la diode (Cathode matérialisée avec une petite barre horizontale à souder sur le K), de la led (patte la plus courte sur la masse), du condensateur (patte la plus courte sur la masse) et du convertisseur 12v-5v: la sérigraphie aide à se repérer. Connectez dans le bon sens aussi le Raspberry PICO (port usb dans la même direction que la prise Jack) et le driver TMC (vis de réglage vers l’extérieur de la carte), sinon ils seraient détruits dès la mise sous tension du système. Le micro-dip switch sérigraphié est en position OFF.

Le moteur se branche sur les pin header localisés à côté de l’alimentation Jack DC.

Micro-stepping du moteur

Le micro-stepping du moteur (full, 1/2pas, 1/4pas, 1/8pas etc …) est défini à l’aide du DIP micro-switch: 3 positions on/off sont nécessaires pour un A4988, mais seuls les 2 1er on/off seront nécessaires pour les TMC2208 et TMC2209. Suivez les instructions de votre driver pour paramétrer correctement le micro-stepping souhaité.

Attention: ne pas modifier les positions des DIP-SWITCH lorsque le moteur est en train de fonctionner: il faut le faire hors tension.

Boîtier imprimé 3D

Un boîtier minimaliste à imprimer en 3D est disponible dans la section /STL du Github du projet.

Software

Github du projet.

Installation bibliothèque

Installez bien la dernière version MicroPython sur votre microcontrôleur. Cet article détaille comment s’y prendre avec un Raspberry PICO.

Tout le code micropython est à récupérer sur le Github du projet dans la section micropython.

Tous les modules sont à uploader à la racine du PICO.

• /gcode: fichier gcode au format json

• /sm: module de gestion de la machine à état qui gère l’interface parallèle 16bits.

• /stepper: module qui gère le driver TMC (ou A4988).

• main.py: progamme principal qui s’exécute au démarrage du système.

Usage

Le pilotage du moteur se fait grâce au fichier gcode déposé dans le dossier /gcode. Pour comprendre comment écrire un fichier gcode pour ce système, je vous encourage à lire la section fichier de trajetoire de cet article.

Avertissement

Ce projet et ce guide sont fournis à des fins purement éducatives. Ils ont pour but de montrer comment collecter des données de marché sur les crypto actifs, effectuer des calculs d’analyse technique et automatiser des tâches comme l’envoi de reports par e-mail avec Python sur un Raspberry Pi. Les informations et analyses générées par cette application ne constituent en aucun cas un conseil en investissement. L’investissement dans les cryptomonnaies est très risqué et vous devez faire vos propres recherches. L’auteur de ce projet et de ce guide ne saurait être tenu responsable de toute décision financière que vous prendriez.

Résumé Fonctionnel et Technique

Résumé Fonctionnel

RasCrypto est une application web locale conçue pour automatiser l’analyse technique de paires de cryptomonnaies (exple: BTCUSDC, ETHEUR …). Ses fonctionnalités principales sont :

• Serveur web local: l’application se consulte via un navigateur web connecté au même réseau local: elle n’est pas ouverte sur l’extérieur.

• Génération de graphiques: Elle crée des graphiques dynamiques en chandeliers (OHLCV - Open, High, Low, Close, Volume) pour visualiser l’évolution du cours d’une cryptomonnaie sur une période donnée (jour, semaine, mois, année(s)).

• Calcul d’indicateurs techniques: Sur ces graphiques, elle superpose plusieurs indicateurs clés de l’analyse technique :

Moyennes Mobiles (court terme et long terme)

Niveaux de Support et de Résistance

RSI (Relative Strength Index)

MACD (Moving Average Convergence Divergence)

• Reporting par email: L’application peut envoyer automatiquement et de manière quotidienne, hebdomadaire ou mensuelle un rapport complet par email sur une paire de cryptomonnaie, incluant une analyse complète avec les graphiques en pièce jointe.

• Monitoring: L’application permet de consulter la température interne du Raspberri pi, l’occupation des CPUs, RAM et espace Disque.

• Automatisation: Le système est conçu pour être démarré automatiquement au démarrage du raspberry pi.

Stack Technique

Langage : Python 3, avec une approche orientée objet pour structurer le code.

Framework Web : Flask, un framework web utilisé pour créer l’interface web de l’application.

Base de Données : SQLite, un moteur de base de données léger, utilisé pour stocker l’ordonnancement des reportings envoyés par e-mail.

Bibliothèques Python Principales :

• Flask pour gérer le front-end en python.

• python-binance pour récupérer les données de marché des cryptomonnaies.

• polars pour la manipulation et l’analyse des données.

• plotly pour la génération de graphiques dynamiques

• mplfinance pour la création des graphiques financiers attachés aux mails.

• schedule pour gérer l’ordonnanceur de génération des rapports.

Préparation du Raspberry pi

Installation de l’OS Headless 64-bits

Ce serveur va fonctionner avec une version d’OS sans interface graphique (Headless). A l’heure où j’écris et article, j’ai installé l’OS Raspberry PI OS Lite 64Bits à l’aide du software Rasbperry Pi Imager depuis mon ordinateur personnel qui fonctionne sous Linux Mint. J’ai configuré ma Box internet en DNS dynamique pour qu’elle attribue toujours la même adresse IP en local au Raspberry pi, que j’accède en SSH depuis mon ordinateur personnel pour installer et configurer l’application RasCrypto.

J’ai opté pour une configuration fanless avec un boîtier ArgonOne M2 et un disque SSD Nvme pour installer le système: l’installation de l’OS, les reboots et redémarrages du Raspberry pi sont incomparablement plus rapides (reboot + démarrage en 10 secondes) qu’avec une carte SD. Le boîtier ArgonOne sert de refroidissement passif au CPU, il n’atteint jamais la température qui déclenche le petit ventilateur (constatation après 1 mois de fonctionnement h24 7j sur 7): c’est en cela que je le considère “fanless” alors qu’il y a bien un ventilateur pour le protéger au cas où les températures s’emballent.

Pour connaître l’adresse IP du Raspberry pi, utilisez cette commande et repérez dans la section wlan0 l’adresse inet qui ressemble à 192.168.xx.yy: notez la dans un coin car le serveur WEB sera accessible à cette adresse (via le port 5000).

ifconfig

Installation de l’Application RasCrypto

Mise à jour système

Le système étant fraîchement installé, il faut d’abord le mettre à jour et en profiter pour installer les bibliothèques qui vont nous permettre de créer un environnement virtuel, afin de gagner un temps précieux pour installer toutes les dépendances de l’application.

sudo apt update
sudo apt full-upgrade -y
sudo apt install -y python3-pip python3-venv git

Création d’un environnement virtuel

Ces étapes doivent être réalisées depuis votre session SSH sur le Raspberry Pi. Nous allons installer le code dans le répertoire personnel de l’utilisateur (/home/pi/ si je prends comme hypothèse que vous avez opté pour un utilisateur ‘pi’).Il est crucial d’utiliser un environnement virtuel pour isoler les dépendances du projet.

# Assurez-vous d'être dans le répertoire personnel
cd ~

# Créez l'environnement virtuel nommé .venv
python3 -m venv .venv

# Activez l'environnement virtuel
source .venv/bin/activate

Votre invite de commande devrait maintenant être préfixée par (.venv). Toutes les commandes suivantes doivent être exécutées avec l’environnement activé.

Clonage du Code depuis GitHub

Clonez le dépôt Git directement dans votre répertoire personnel.

# Assurez-vous d'être dans le répertoire personnel
cd ~

# Clonez le projet
git clone https://github.com/papsdroidfr/rascrypto.git

Ceci va créer un dossier /rascrypto contenant les sous-dossiers /cotation et /demo.

• le dossier /rascrpyto/cotation contient tout le code de l’application RasCrypto.

• Le dossier /rascrypto/demo contient le code d’une démo d’un serveur Web local dont j’ai écrit cet article si vous souhaitez voir un exemple simple de Serveur Web Local en Python avec Flask.

Installation des dépendances

Grâce à l’environnement virtuel, l’installation de toutes les bibliothèques Python requises pour le projet est très simple:

# Déplacez-vous dans le répertoire du code
cd ~/rascrypto/cotation

# Installez les paquets listés dans requirements.txt
pip install -r requirements.txt

Configuration de l’envoi d’email

L’application utilise un compte Gmail pour envoyer les rapports. Pour des raisons de sécurité, vous devez générer un mot de passe d’application spécifique.

Activer la validation en deux étapes : La création d’un mot de passe d’application requiert que la validation en deux étapes soit activée sur votre compte Google. Si ce n’est pas le cas, activez-la depuis les paramètres de sécurité de votre compte Google.

Générer le mot de passe :

• Allez sur la page de gestion de votre compte Google.

• Dans le menu de gauche, allez dans la section Sécurité.

• Descendez jusqu’à la section “Comment vous vous connectez à Google” et cliquez sur Mots de passe des applications. (Vous devrez peut-être vous reconnecter).

• Dans le menu déroulant “Sélectionner une application”, choisissez Autre (Nom personnalisé).

• Donnez-lui un nom explicite, par exemple RasCrypto, et cliquez sur GÉNÉRER.

• Un mot de passe de 16 caractères sera affiché. Copiez ce mot de passe immédiatement. Vous ne pourrez pas le revoir. C’est ce mot de passe que vous utiliserez dans le script, et non le mot de passe de votre compte Google.

Configuration du script de démarrage

Le script start.sh est le point d’entrée qui lance l’application. Vous devez le modifier pour y insérer vos informations personnelles. L’utilitaire nano va permettre de modifier ce fichier.

nano ~/rascrypto/cotation/start.sh

Modifiez les variables suivantes du fichier :

• export GMAIL_USER: Remplacez “MONEMAIL@GMAIL.COM” par votre adresse email Gmail qui va envoyer les rapports. Conservez bien les guilements.
• export GMAIL_APP_PASS: Remplacez “MON PASSWORD APPPLICATIF GMAIL” par le mot de passe d’application de 16 caractères que vous venez de générer. conservez bien les guillemets.

Ctrl O pour sauvegarder (puis ENTREE) et Ctrl X pour sortir de nano.

Rendez ensuite ce script exécutable:

chmod +x ~/rascrypto/cotation/start.sh

Configuration de l’application

le fichier info.py contient les paramètres principaux de l’application que vous pouvez ajuster en utilisant nano comme précédemment.

• TIME_SCHEDULEUR est l’heure à laquelle les reports sont générés et envoyés par e-mail.

• PERIOD_SHORT est le nombre de périodes pour le calcul de la moyenne mobile court terme.

• PERIOD_LONG est le nombre de périodes pour le calcul de la moyenne mobile long terme.

• PERIOD_SUPPORT est le nombre de périodes qui servent à calculer les niveaux de résistances et de support.

• CRYPTO est le dictionnaire des paires de cryptomonnaies que vous souhaitez suivre et qui vont apparaître dans le menu déroulant du dashboard principal de l’application.

Intégration dans Crontab

Pour un démarrage automatique, nous allons le préciser dans la crontab du Raspberry pi. Il faut aussi régulièrement rebooter le server, nous allons le programmer pour un reboot hebdomadaire (samedi à minuit)

sudo nano /etc/crontab -e

ajoutez ces 2 lignes à la fin (en supposant que ‘pi’ est l’utilisateur configuré sur le Raspberry pi):

@weekly root reboot
@reboot pi ~/rascrypto/cotation/start.sh &

Ctrl O pour sauvegarder (puis ENTREE) et Ctrl X pour sortir de nano

L’application est maintenant configurée pour s’exécuter automatiquement à chaque redémarrage du Raspberry Pi. Le serveur va redémarrer tous les samedi à minuit.

Pour redémarrer le Raspberry pi

sudo reboot

Il est important d’avoir noté l’adresse IP 192.168.xx.yy du Raspberry pi et de s’assurer que votre Box internet vous attribuera toujours la même adresse IP. Le serveur WEB local généré par l’application RasCrypto est alors accessible sur le port 5000 depuis l’adresse http://192.168.xx.yy:5000, en vous connectant sur le même réseau que le Raspberry pi (non accessible en dehors de votre réseau local).

Compte tenu de l’absence de sécurité mise en oeuvre pour protéger le réseau des menaces externes (il faudrait ajouter un serveur dédié pour la base de données, un serveur reverse proxy et un serveur WYSIWIG qui fait tampon avec le serveur applicatif, ainsi que protéger le mot de passe applicatif via un cryptage): je vous déconseille fortement de “bidouiller” ce projet pour le rendre accessible depuis l’extérieur. Il n’est pas du tout configuré pour, et vous exposeriez votre propre réseau interne à toutes les menaces du WEB où une grande majorité de bots malveillants viendraient repérer les failles de sécurité: ils se régaleraient dans ces conditions.

Structure Logicielle et Modèle de Classes

Le code est structuré de manière modulaire et orientée objet pour séparer les responsabilités.

appl.py

C’est le point d’entrée principal de l’application. Il contient la classe SiteWebLocal qui défini tout le front-end exécuté en tâche de fond, tandis que le thread principal faisant office de scheduler contrôle s’il faut générer et envoyer les reports par emails.

cotation.py

Contient la classe BinanceAPI. Elle va permettre de récupérer les données de marché.

• Responsabilité : Récupère les données brutes du marché pour une parie de cryptomonnaie (exple: BTCUSDC)

• Méthodes : Elle contient une méthode qui récupère dans un dataframe polars l’historiques des données OHLCV (Open price, High price, Low price, Close price, Volume) sur une profondeur d’historique donnée (start date) et des intervalles définis (exple 4h, 1h …)

analysis.py

Contient la classe TechnicalChartBuilder. C’est le cœur de l’analyse technique.

• Responsabilité : Construction d’analyses techniques modulaires

• Méthodes : Elle contient les méthodes pour calculer tous les indicateurs techniques qui sont ajouté au dataframe polars qui contient l’historique des cours (statistiques de performance, moyennes mobiles, oscillateurs RSI et MACD, générateur de graphique exporté en png.)

emailer.py

Contient la classe SimpleEmailer utilisée pour envoyer des emails avec pièces jointes.

• Responsabilité : Gérer l’envoi des emails.

• Méthodes : fabrique le corps d’un email au format HTML et envoie l’email à un destinataire avec des images en pièce jointe.

scheduleur.py

Contient la classe JobStore qui gère la base de données pour les tâches planifiées du scheduler.

• Responsabilité : Gérer les interactions avec la base de données SQLite.

• Méthodes : Créer les tables si elles n’existent pas, insérer les nouvelles données de reports à produire, les lister et éventuellement les supprimer.

Détail des Analyses Techniques Proposées

L’application calcule et affiche plusieurs indicateurs d’analyse technique standards.

Statistiques basiques

Pour une période choisie (par exemple 1 mois), l’application indique le cours de clôture à l’ouverture de la période, le cours de clôture à la fin de la période, la différence et la variation en %.

Affichage OHLCV

Le graphique de base est un graphique en chandeliers japonais. Chaque “bougie” représente un intervalle qui dépend de la profondeur choisie (5mn pour 1 journée, 1h pour 1 semaine, 4h pour 1 mois, 1 jour pour 1an, 1 semaine pour 5 ans) et affiche 4 informations clés.

Open : Cours à l’ouverture de la période.

High : Cours le plus haut de la période.

Low : Cours le plus bas de la période.

Close : Cours à la clôture de la période.

Le volume des transactions de chaque période est affiché sous forme d’histogramme en bas du graphique.

Pour un confort de lecture, les chandelles sont vertes quand le cours progresse (close > open) et rouge dans le cas contraire, bien que l’information soit visible sur le graphique sans les couleurs.

Moyennes Mobiles

Il s’agit d’indicateurs de tendance. Une moyenne mobile lisse les données de prix pour identifier la direction de la tendance. Une moyenne mobile sur N périodes est la moyenne du cours de clôture des N dernières périodes.

L’application calcule et affiche deux moyennes mobiles :

• Une courte (ex: 7 périodes) pour la tendance à court terme.

• Une longue (ex: 20 périodes) pour la tendance de fond.

Supports et Résistances

Ces niveaux sont des “planchers” (supports) et des “plafonds” (résistances) psychologiques où les prix ont tendance à stagner ou à rebondir. L’application identifie ces niveaux en détectant les points bas (minima locaux) et les points hauts (maxima locaux) significatifs sur une période donnée. Ils sont matérialisés par des lignes horizontales sur le graphique (en haut et en rouge on trouve les résistances, en bas en vert on retrouve les supports).

RSI (Relative Strength Index)

Il s’agit d’un indicateur de prédiction. C’est un oscillateur qui mesure la force et la vitesse des mouvements de prix. Il compare l’ampleur des hausses récentes à celle des baisses récentes. Le résultat est un indice oscillant entre 0 et 100. Un RSI au-dessus de 70 est souvent considéré comme un signal de “sur-achat” (le prix a monté trop vite), tandis qu’un RSI en dessous de 30 est considéré comme un signal de “sur-vente”. Les prix ont tendance à changer de direction dans ces cas.

Cet indicateur est positionné en dessous du graphe avec les chandeliers, sur la même échelle de temps.

MACD (Moving Average Convergence Divergence)

C’est encore un indicateur de prédiction de type oscillateur. Il montre la relation entre deux moyennes mobiles exponentielles (MME) du prix. Une moyenne mobile exponentielle va faire un calcul de moyenne pondérée au lieu de faire la moyenne des cours sur une période. Le MACD est calculé en soustrayant la MME longue (ex: 26 jours) de la MME courte (ex: 12 jours). Une “ligne de signal”, qui est une MME du MACD lui-même (ex: 9 jours), est également tracée.

L’histogramme du MACD (la différence entre les deux lignes) visualise l’élan de la tendance, tandis que le croisement de la ligne MACD avec sa ligne de signal peut prédire une forte probabilité à un retournement de situation.

Bandes de Bollinger

Les bandes de Bollinger permettent de visualiser la volatilité de l’actif. Elles sont constituées de 3 courbes: une moyenne mobile sur N périodes et deux courbes situées de part et d’autre de la moyenne mobile, chacune étant située à 2 fois l’écart type sur les N périodes qui ont servies à calculer la moyenne mobile. Si on admet que l’actif suit une loi normale, 95% des valeurs observées restent à l’intérieur des bandes de Bollinger.

Reporting automatiques par e-mail

L’application permet de planifier des envois de reports par e-mail tous les jours, toutes les semaines, tous les mois. Il suffit de s’abonner à un topic de l’onglet “Planification Emails” en précisant la paire de cryptomonnaie et la fréquence souhaitée.

à ce jour j’ai codé un report unique quelque soit la fréquence choisie (je ferai un update plus tard): le report génère une analyse technique sur un mois, et une autre sur une semaine, regroupant les 2 analyses dans un seul mail.

Et en plus il est poli!

Monitoring serveur

Enfin dernière touche personnelle sur ce serveur: une page de monitoring de la température interne, utilisation de la RAM, utilisation des CPU et espace disque. Les données sont rafraîchies toutes les 5 secondes.

Cet monitoring “temps réel” ne permet pas de voir ce qu’il se passe avec la RAM et les CPU lorsque le dashboard calcule et affiche les analyses techniques. Une évolution consisterai à sauvegarder en base de données les captures pour les afficher ensuite sous forme de graphe sur cette page. Cependant les calculs sont très rapides en polars, il faudrait capter les données plusieurs fois par secondes ce qui alourdirai à mon humble avis le travail de ce serveur. En attendant, vous pouvez aller regarder via ‘htop’ ce qu’il se passe en vous connectant en SSH sur le Raspberry pi.

Hardware

Un simple raspberry pi avec une connectivité wifi ou réseau est nécessaire. Dans mon cas je suis parti avec un Raspberry pi4 8Go dans un boîtier Argon One où le système est installé sur un SSD M.2 nvme de 128Go. Cette configuration me permet de bénéficier d’une solution fanless. Une sd card de 32Go est largement suffisante mais l’installation et le démarrage du système est beaucoup plus rapide avec un ssd M.2 nvme. J’ai utilisé l’OS LITE 64bit Raspberry pi OS car je n’ai pas besoin d’interface graphique.

Software

Structure

La structure du code minimale pour notre server web est la suivante:

• Le programme principal demo.py à la racine.

• Les dépendances à installer si vous passez par un environnement virtuel: requirements.txt.

• Un dossier /static dans lequel figure le dossier /css avec les styles de nos pages.

• Un dossier /templates dans lequel figurent les pages html du site.

Installation

Tout le code démo est à récupérer sur mon Github, dans le dossier /demo

Déposez tous les fichiers du répertoire /demo en respectant bien la structure décrite ci-dessus.

Si vous n’utilisez pas d’environnement virtuel (venv), il faut installer la bibliothèque Flask.

pip install Flask

Sinon, il suffit d’installer les dépendances du requirements.txt:

pip install -r requirements.txt

Usage

pour démarrer le serveur WEB, rien de plus simple, il suffit d’exécuter le programme demo.py

python demo.py

Le site WEB est alors accessible en local sous l’adresse http://127.0.0.1:5000

Un bashtop montre que cette configuration n’occupe que 1Go de RAM et 12% de CPU (sachant que bashtop perturbe bien la mesure)

Hardware

Matériel nécessaire

Il vous faut:

• 1 Raspberry PICO, toutes les versions 1 ou 2 sont compatibles.

• 1 petite diode Schottky 5v 1A, au format DO-41.
• 1 à 8 moteurs pas à pas 12v de type NEMA17 (j’utilise des modèles NEMA17HE15-1504S)

• 1 à 8 drivers de moteurs A4988(je ne recommande pas: ils sont très bruyants et peu fiables), ou bien TMC2208 en mode step/dir ou encore TMC2209 en mode step/dir. Attention à ne pas prendre des TMC2208 ou TMC2209 en mode UART: ils ne sont pas compatibles avec cette carte.

• Une alimentation DC 12v de 360 Watts si vous comptez utiliser 8 moteurs.

• 1 à 8 micro-switch DIP avec 3 boutons, pour configurer les micro-steps de chaque moteur.

• 9 condensateurs 25v 100uf, les plus petits en hauteur (il faut les loger sous les drivers TMC)

• 1 led 5mm pour visualiser la mise sous tension de la carte (j’ai opté pour une led rouge)

• 1 résistance 1/4watts de 220ohms (pour la led)

• 1 convertisseur 12v-5v TRACO TSR: leur rendement est excellent.

• 1 connecteur mâle 12v XT60

• 1 pin header mâle 4 pins pour connecter l’interface i2c (pour un écran OLED déporté)

• 1 pin header mâle 2 pins pour connecter un ventilateur 12v

• 1 à 8 connecteurs mâles 4 pins pour brancher les moteurs

• 1 connecteur JST mâle 3 pins pour brancher une interface UART

• 2 à 16 pins header femelles 8 pins afin d’y connecter les 1 à 8 drivers sans avoir à les souder sur la carte.

• 2 pins headers femelles 20 pins afin d’un connecter le raspberry pico sans avoir à le souder sur la carte.

• 1 ventilateur 12v 60mm: je recommande un Noctua NF-A6x15 FLX car il est très silencieux.
• bien entendu la carte PCB que vous pouvez re-faire fabriquer à partir des fichiers GERBER fournis dans ce Github dans le dossier hardware, ou bien vous pouvez me contacter pour voir s’il men reste en stock.

Assemblage de la carte

Si j’ai bien compté, il y a 333 soudures à faire sur cette carte. Les sérigraphies sont assez claires, il faut juste veiller à bien souder les condensateurs dans le bon sens (la patte la plus longue sur le +), ainsi que la led (idem patte la plus longue sur le +) et la diode Schottky dont la cathode est sérigraphiée sur le PCB. Les switch DIP doivent aussi être soudés comme indiqués sur la sérigraphie (“On” vers le “1”).

Pour souder les pins header femelle, je conseille vivement de les souder par paire avec les driver en place (idem pour les pins header femelle du Raspberry-PICO à souder avec le PICO en place): ceci afin de les souder bien droits.

Placez ensuite le Raspberry-pico dans le sens indiqué par la sérigraphie (prise usb vers le haut). Les drivers sont tous orientés dans le même sens, avec la petite vis de réglage vers la gauche comme sur la photo.

Impression 3D boîtier

Un boîtier à imprimer 3D est à disposition dans le Github du projet dans le dossier 3D_STL. Il y a une partie basse dans laquelle la carte se loge, et une partie haute qui permet de maintenir en place le ventilateur et le passage des câbles (alimentation 12v et moteurs). La partie haute est à imprimer à l’envers: face haute vers le bas, pour éviter de faire trop de supports.

Connection des moteurs

J’ai pris en référence un NEMA17HE15 qui a un connecteur 4 fils de 4 couleurs (Noir, Vert, Bleu, Rouge) avec 4 références qu’on retrouve sur chaque connecteur sérigraphié sur la carte (A+, B+, A-, B-). Si les branchements ne sont pas respectés en fonction du moteur choisi, il va vibrer au lieu de tourner correctement.

• Noir: A+,
• Vert: B+,
• Bleu: A-,
• Rouge: B-

Attention les moteurs doivent se brancher ou débrancher uniquement lorsque la carte est hors tension, sinon vous risquez de les détruire ainsi que les drivers.

Chaque moteur sur la carte est sérigraphié de M0 à M7.

Pour brancher le ventilateur il suffit de brancher les 2 fils +12v et Gnd sur l’emplacement adéquat sur la carte. Si vous avez un ventilateur 3 fils comme avec le Noctua NF A6-X15, repérez bien le fil rouge (+12v) et le fil noir (Gnd). Quand au fil jaune qui sert à mesurer la vitesse du ventilateur: vous pouvez le laisser débranché, la carte ne l’exploite pas.

Micro-stepping des moteurs

Le micro-stepping de chaque moteur (full, 1/2pas, 1/4pas, 1/8pas etc …) est défini à l’aide des DIP micro-switch: 3 positions on/off sont nécessaires pour un A4988, mais seuls les 2 1er on/off seront nécessaires pour les TMC2208 et TMC2209. Suivez les instructions de votre driver pour paramétrer correctement le micro-stepping souhaité.

Attention: ne pas modifier les positions des DIP-SWITCH lorsque les moteurs sont en train de fonctionner: il faut le faire hors tension.

Software

Le firmware de la carte en micro-python est conçu pour fonctionner avec un Raspberry PICO, version 1 ou 2 peut importe. L’interface parallèle 16 bits est gérée par une machine à état.

Micro-python

Si vous installez micro-python pour la première fois sur un Raspberry PICO, cet article en résume les étapes.

Firmware

Le firmware écrit en micro-python est à récupérer sur le Github du projet dans la section software. Il faut bien veiller à récupérer tous les modules.

• gcode: contient les fichiers de trajectoire en exemple, au format json.

• sm: module qui gère la machine à état pour l’interface parallèle 16 bits.

• stepper: module de gestion des drivers.

• main_automat.py: programme principal qui lance une animation parmi les fichiers de trajectoires qu’il y a sur la carte. Pour une exécution automatique au branchement de la carte, il suffit de renommer ce fichier en main.py. Sinon il faudra relier le Raspberry PICO à l’ordinateur via la prise USB pour démarrer le programme.

Manuel d’utilisation

Fichiers de trajectoires

Pour animer un automate avec 8 moteurs max, il faut préparer un fichier de trajectoires pré-calculées au format json à déposer dans le dossier /gcode sur le microcontrôleur. Ce fichier json a la structure suivante:

• “COMMENT”: ligne de commentaire

• “DRIVER”: il faut préciser ici les drivers utilisés entre A4988, TMC2208 ou TMC2209

• “FREQ-SM”: il s’agit de la fréquence de fonctionnement en Hz de la machine à état. Plus elle est élevée (exemple 700 Khz), et plus les moteurs vont tourner vite. Si vous dépassez 1Mhz (voire 600KhZ pour des A4988) ça ira trop vite les moteurs ne pourront pas suivre la cadence.

• “MODE”: il faut indiquer LOOP ou UNIQUE selon qu’on veut rejouer l’animation en boucle ou pas.

• “GCODE_SEQ”: on retrouve ici l’animation à jouer pour chaque moteur numéroté de 0 à 7.

Pour un moteur donné, une animation consiste en une liste d’ordres qui sont exécutés les uns après les autres. Chaque ordre de chaque moteur est synchronisé au cycle d’horloge près par l’interface parallèle. Un ordre est une chaîne de caractères qui doit respecter ce pattern: ax_sn_dy_vz où x, n ,y et z sont des entiers:

• a représente l’action: x vaut 1 ou 0. 1 signifie au moteur d’avancer, 0 signifie de stopper.

• s représente le nombre de steps: n est le nombre de steps où le moteur doit tourner (si x=1) ou le nombre de steps où il doit rester immobile (si x=0)

• d représente la direction de rotation du moteur: y vaut 1 pour le sens horaire, 0 pour le sens anti-horaire.

• v représente la vitesse de rotation. Dans ce mode le moteur bouge d’un step et marque un arrêt de z steps. Ainsi z=0 correspond à la vitesse maximale, tandis que z=1 fera tourner le moteur 2 fois plus lentement (1 step sur 2 il ne bouge pas), … , z=n fera tourner le moteur (n+1) fois plus lentement que z=0.

Exemples:

• a1_s400_d1_v0: le moteur tourne de 400 steps dans le sens horaire, vitesse maximale.

• a0_S400_d1_v0: le moteur s’arrête pendant 400 steps dans le sens horaire, vitesse maximale: cet arrêt va durer exactement le même temps que s’il tournait de 400 steps dans le sens horaire à vitesse maximale.

• a1_s300_d0_v2: le moteur fonctionne 300 steps dans le sens anti-horaire à la vitesse 2 (il bouge 1 step et marque un arrêt de 2 steps).

exécution d’un fichier de trajectoires

Rien de plus simple, il suffit d’instancier un objet Automat en précisant le fichier gcode à utiliser:

appl = Automat(gcode_file='gcode/test_automat.json')

Evolution en cours

Les évolutions suivantes sont en cours de réalisation:

• Interface WEB pour piloter la carte depuis son smart phone. Il faudra utiliser un Raspberry pico 1 ou 2 en version W.

• Interface UARt pour communiquer le fichier de trajectoires en série, depuis une autre machine.

Hardware

Matériel nécessaire

Il vous faut:

• Un Raspberry PICO, ou bien un ESP32 ou même un SMT32 qui dispose d’au moins 4 ports GPIO

• Un moteur pas à pas 12v de type NEMA17 (personnellement j’ai pris un modèle 17HE15-1504S)

• Un driver L298N qui va permettre de convertir les instructions en 3.3v envoyées par le microcontrôleur en 12v vers les bobines du moteur pas à pas.

• Une alimentation DC 12v ou 5v ça fonctionne très bien en 5v: le moteur 12v aura moins de couple s’il est commandé en 5v, mais il reste parfaitement fonctionnel dans un cadre où il n’a pas beaucoup de résistance lorsqu’il doit tourner.

• Des petits câbles de raccord Dupont, en respectant rigoureusement le schéma ci-dessous. Si le moteur “vibre” au lieu de tourner correctement, c’est que le branchement des câbles n’est pas correct.

Attention une erreur très facile à faire est d’oublier de relier toutes les masses entre elles. Le fil de masse noir qui relie la masse de l’alimentation à celle du driver LN298N doit aussi être relié à la masse du microcontrôleur: c’est indispensable. (Dans mon exemple j’ai opté pour un Raspberry PICO)

Fonctionnement moteur

Il faut comprendre dans les grandes lignes comment fonctionne un moteur pas à pas, pour savoir si c’est adapté à votre projet. Un tel moteur est composé de 2 bobines A et B, alimentée en 12v continu (5v ça marche aussi). Dans chaque bobine, on peut injecter du 12v par ses 2 entrées. Nommons ces 4 entrées A+, A-, B+, B-.

• C’est pour cette raison qu’il faut 4 ports GPIO disponibles pour pouvoir activer l’envoi de signaux 12v sur chaque entrée.

• Je ne connais aucun microcontrôleur capable d’envoyer du 12v en sortie: c’est aussi pour cette raison qu’il faut un driver L298N qui va convertir les signaux (généralement en 3.3v) de sortie du microcontrôleur en tensions 12v.

Un moteur pas à pas possède cette caractéristique de décomposer une rotation complète 360° en n “steps” égaux: on peut faire tourner le moteur d’un seul step, ce qui offre une très grande précision pour dire au moteur de tourner un angle précis, et ce sans aucun asservissement contrairement avec un moteur simple à courant continu. Les moteurs NEMA17 ont 200 steps, ce qui fait qu’on peut lui demander de tourner avec un angle multiple de 360/200 = 1.8° ! c’est très précis.

Pour que le moteur puisse tourner, il faut envoyer dans les entrées A+, A-, B+, B- un cycle précis de tensions 12v (ou 5v) et ce toutes les 5ms (ce délais d’attente est important sinon le rotor n’arrive pas à suivre le rythme). Ces tensions injectées dans les bobines ont pour conséquence de créer un champs électromagnétique qui va faire déplacer le rotor aimanté d’un “step”, et ce dans un sens comme dans l’autre selon le cycle qu’on envoie dans les bobines.

L’avantage d’un moteur pas à pas est donc de pouvoir le faire tourner dans un sens comme dans l’autre avec un angle précis sans aucun asservissement. Et bien entendu en lui disant de tourner 200 fois et de recommencer sans arrêt, il va tourner de fait en continu.

Il y a tout de même quelques inconvénients avec les moteurs pas à pas:

• Ils fonctionnent par saccades (le rotor est déplacé d’un step et attends 5ms la prochaine instruction): cela en fait des moteurs qui génèrent beaucoup de vibrations: il faut les atténuer avec du matériel qui absorbe les vibrations.

• Ils ne sont pas rapides: on ne peut pas envisager de tourner à 10 000 tours/minute avec un moteur qui se déplace par petits steps et attend 5ms entre deux.

• Il faut envoyer un cycle assez casse-tête via 4 entrées de commande en 12v. Ce n’est pas aussi simple que d’activer un moteur à courant continu: une programmation informatique à l’aide d’un microcontrôleur est indispensable.

Si vous avez besoin d’un moteur capable de tourner dans un sens comme dans l’autre, en continu ou bien avec des angles précis sans asservissement mais uniquement quelques codages informatiques, et que vous n’avez pas besoin de vitesse excessive avec les rotations: les moteurs pas à pas sont idéaux, associé avec cette bibliothèque écrite en MicroPython c’est un jeux d’enfant de l’animer sans se soucier des cycles précis à lui envoyer.

Software

Installation bibliothèque

Installez bien la dernière version MicroPython sur votre microcontrôleur. Cet article détaille comment s’y prendre avec un Raspberry PICO.

Tout le code micropython est à récupérer sur le Github du projet dans la section micropython.

Il faut ensuite importer tout le module stepper à la racine de son PICO: créer le dossier /stepper à la racine du microcontrôleur et y importer tous les programmes du module:

• __init__.py: initialisation du module

• pibolar.py: classe de gestion du moteur

• pinout.py: classe d’association des ports GPIO vers les entrées IN du driver LN298.

Usage

Ce programme montre quelques exemples de commande du moteur.

• Une rotation complète 200 pas, à la vitesse “medium.

• Un demi-tour dans l’autre sens, à pleine vitesse “high”

• 4 tours consécutifs à 90°

• Calcul d’un split de 200 pas en 7 tranches.

2 directions sont à utiliser: ‘backward’(par défaut) ou ‘forward’.

4 vitesses sont proposée: speed = “high”(par défaut), “medium”, “low”, ou “test”. La vitesse speed=’test’ permet de voir le moteur tourner step par step à très basse vitesse (1/2 secondes entre chaque): vous pouvez ainsi constater sur une dizaine de steps qu’il tourne bien toujours dans le même sens. Si ce n’est pas le cas, c’est que les branchements sont à revoir (et du coup il vibre au lieu de tourner à grande vitesse).

import utime
from stepper.bipolar import BipolarStepper

print('test module stepper')
bp = BipolarStepper(speed='medium')   

print('move 200 steps forward, speed medium') 
bp.next_steps(200)
bp.sleep()
utime.sleep(0.5)

print('move 100 steps backward highest speed')
bp.set_direction('backward')            
bp.set_speed('high')            
bp.next_steps(100)
bp.sleep()
utime.sleep(0.5)
    
print('move 4 times to 90°')
for _ in range(4):
    bp.next_angle(90)
    bp.sleep()
    utime.sleep(0.5)

print(f"split {bp.steps360} steps in 7: {bp.split_steps(7)}")

bp.sleep()
print('bye')

Si le moteur vibre au lieu de tourner correctement avec ce programme test, c’est que vos branchements sont à revoir.

Si vous voulez utiliser d’autres GPIO que ceux utilisés par défaut (GPIO_17:in1, GPIO_16:in2, GPIO_15:in3, GPIO_14:in4), il suffit de passer les paramètres pin1=mon_gpio1, pin2=mon_gpio2, pin3=mon_gpio3 et pin4=mon_gpio4 lors de l’instanciation d’un objet bp=BipolarStepper(), exemple ci-dessous avec les GPIO 10 à 13:

bp = BipolarStepper(speed='medium', in1=10, in2=11, in3=12, in4=13) 

Enfin si votre moteur pas à pas ne fait pas 200 steps, utilisez la variable steps360 (par défaut initialisée à 200) pour le préciser.

Notez bien que la méthode sleep() est très importante pour mettre le moteur en veille et ne plus envoyer de tension dans les 4 fils de commande. Dans ce cas, le moteur est relâché et ne consomme plus aucun courant. On peut le faire tourner à la main puisque le rotor n’est plus maintenu en place par un champs électromagnétique. Attention s’il subi un couple de contrainte trop importante il va se mettre à tourner tout seul pour retrouver son équilibre sans contrainte …

A l’inverse si vous ne mettez pas le moteur en veille avec cette méthode .sleep(), 2 des 4 fils restent sous tension et vont maintenir avec force le rotor en place: c’est quasiment impossible de le faire bouger à la main. Mais du 12v est envoyé en continu dans les bobines: le radiateur du LN298 va se mettre à pas mal chauffer !

Pour aller plus loin

• Vous pouvez vous amuser à brancher 4 leds (avec leur résistance) en // des 4 sortie GPIO et utiliser la vitesse ‘test’ pour les voir s’allumer selon le cycle de séquence programmé. Les autres vitesses vont trop vite pour nos yeux: vous aurez l’impression que les 4 leds sont tout le temps allumées.

• Si vous voulez commander plusieurs moteurs avec le même microcontrôleur il suffit d’instancier plusieurs objets BipolarStepper() mais avec des GPIO différents pour chaque moteur. Il faut 4 GPIO de libre par moteur.

Hardware

Un Raspberry PICO version 1 W(H) ou encore version 2, ainsi qu’une connexion WIFI. L’avantage d’utiliser un Raspberry PICO est qu’il dispose d’un double cœur: le multithread y est particulièrement efficace. Si vous utilisez un ESP32-S3 (aussi double cœur), il faut juste adapter le code de la led.py qui est spécifique à la led du PICO. Si vous utilisez un ESP32-C3 mono-cœur: les threads vont se marcher sur les pieds et rendre l’expérience assez désastreuse (serveur WEB qui ne répond pas tout de suite, ou événement traité par saccades et ralentissements)

A l’heure où j’écris cet article je n’ai pas encore reçu de PICO version 2 (pré-commandes fin août 2024). Une version PICO 2 est vivement conseillée car il dispose d’une architecture de sécurité basée sur Arm TrustZOne qui permet d’isoler et sécuriser tout le code micropython, et surtout le mot de passe de connexion wifi, ce que ne propose ni la version 1 du PICO, ni les ESP32-S3 où les password wifi circulent soient en clair dans les fichiers de configuration, ou alors cryptés mais avec le code python de décryptage ainsi que les clés à disposition: moi ça me prendrait 5 secondes à craquer un tel password crypté de cette façon.

Software

Installez bien la dernière version MicroPython sur votre Raspberry PICO. Cet article détaille comment s’y prendre.

Tout le code micropython est à récupérer sur le Github du projet.

Il faut ensuite importer tout le module web à la racine de son PICO: créer le dossier /web et y importer tous les programmes du module.

• __init__.py: initialisation du module
• config.py: variables globales utilisées par le module, on y retrouve le SSID et le PASSWORD wifi à utiliser, et qui serait en bien meilleure sécurité sur un Raspberry PICO 2.
• log.py: gestion interne des messages.

• led.py: gestion de la led du PICO (à adapter si vous n’utilisez pas un PICO)

• server.py: gestion du serveur web avec une page HTML par défaut “hello PICO WWWorld!”

• wifi.py: gestion du WIFI.

Usage

Le principe du serveur et géré dans le programme server.py où deux classes principales sont définies:

• classe Event(): Gère la création des évènements par le serveur. Cette classe défini le dictionnaire des actions à exécuter pour chaque évènement.

• classe Server(): Gère tout le serveur Web en commençant par se connecter au WIFI, puis démarre dans un thread dédié la lecture en boucle des événements pour agir en conséquence, et démarre ensuite le serveur WEB qui écoute les requêtes reçues dans le thread principal, pour générer un code HTML dynamique ainsi qu’un événement adéquat.

Ces 3 lignes de code vous permettent de démarrer un serveur WEB par défaut:

from web.wifi import Wifi
from web.server import Server

my_server = Server(wifi=Wifi(), debug=True)

On ne retrouve pas toutes les fonctionnalités de Python dans MicroPython, il n’y a pas de notion de classes abstraites qui eut été bien utile dans mon cas pour définir les classes génériques qui gèrent le serveur WEB et les évènements. Pour contourner cette limitation il suffit de recréer vos propres classes qui héritent chacune des classes Server() et Event() et de surcharger les fonctions principales, notamment le dictionnaire des évènements de la classe Event() et les méthodes Server._thread_loop_event(self) (réaction aux événements) ainsi que Server._gen_html() (le générateur dynamique de code HTML)

Exemple de code

Dans l’exemple de code ci-dessous, je souhaite créer un serveur WEB avec 5 événements pour contrôler le moteur de mon planétaire mécanique Soleil-Terre-Lune afin de simuler une journée, une semaine, un mois, ou bien de mettre en marche le moteur et bien entendu de pouvoir l’arrêter à tout moment.

On commence par les imports nécessaires.

import time
from web.wifi import Wifi
from web.server import Event, Server

Ensuite nous créons notre classe de gestion des évènements qui va hériter de la classe Event(), afin de sur-définir le dictionnaire des actions pour chaque évènement. Attention ne pas oublier d’appeler le constructeur de la classe mère super().__init__(). Pour l’exemple les actions ne sont que des prints sur la console, mais on peut imaginer commander un moteur, interagir avec des leds etc …

class EventPlanetarium(Event):
    """ This class manages event raised by the webserver to run planetarium"""
    def __init__(self)-> None:
        #Events managed by the web server
        super().__init__()
        
        #my own events
        self.EVENT_RUN1D: str = 'Tourne 1 jour'    #run planetarium for 1 day
        self.EVENT_RUN1W: str = 'Tourne 1 semaine' #run planetarium for 1 week
        self.EVENT_RUN1M: str = 'Tourne 1 mois'    #run planetarium for 1 month
        self.EVENT_RUN:   str = 'En marche'        #run planetarium
        self.EVENT_STOP:  str = 'STOP'             #stop planetarium
        
        #dictionnary of actions for each event name
        self.actions={
            self.EVENT_NONE: self.action_none,
            self.EVENT_RUN1D: self.action_run_1d,
            self.EVENT_RUN1W: self.action_run_1w,
            self.EVENT_RUN1M: self.action_run_1m,
            self.EVENT_RUN: self.action_run,
            self.EVENT_STOP: self.action_stop,
        }

    def action_run_1d(self):
        print('Start run 1D')
        time.sleep(0.5)
        print('End run 1D')
    
    def action_run_1w(self):
        print('Start run 1W')
        time.sleep(1)
        print('End run 1W')

    def action_run_1m(self):
        print('Start run 1M')
        time.sleep(4)
        print('End run 1M')

    def action_run(self):
        print('Start run')
        while self.event_raised == self.EVENT_RUN:
            print('...press STOP...')
            time.sleep(0.5)

    def action_stop(self):
        print('Action STOP')

Enfin nous créons notre propre classe de serveur web qui va hériter de la classe Server() afin de sur-définir notre propre générateur de code HTML _gen_html() et notre propre générateur d’évènements _raise_event().

class ServerWeb(Server):
    
    def __init__(self, debug:bool = False)-> None:
        super().__init__(wifi=Wifi(), event = EventPlanetarium(), debug=debug)
     
    def _gen_html(self)-> str:
 
        html = f"""<html>
            {self.HEAD_HTML}
            <body>
                <h1>Soleil-Terre-Lune</h1>
                <p><a href=https://papsdroidfr.github.io/tutoriels/soleil-terre-lune/> <Construire la maquette> </a></p>
                <p>Action en cours: <strong> {self.event_raised} </strong></p>
                <p><a href="/?event=runFull"><button class="button">Marche</button></a></p>
                <p><a href="/?event=run1D"><button class="button">1 jour</button></a></p>
                <p><a href="/?event=run1W"><button class="button">1 semaine</button></a></p>
                <p><a href="/?event=run1M"><button class="button">1 mois</button></a></p>
                <p><a href="/?event=stop"><button class="button button_red">STOP</button></a></p>
            </body>
        </html>"""
        
        return str(html)

    def _raise_event(self, request:str)-> None:
        """ Set event raised, depends on request"""
        if request.find('GET /?event=runFull') > -1:
            self.event.set_event(self.event.EVENT_RUN)
        elif request.find('GET /?event=stop') > -1:
            self.event.set_event(self.event.EVENT_STOP)
        
        elif self.event_raised != self.event.EVENT_RUN:
            if request.find('GET /?event=run1D') > -1:
                self.event.set_event(self.event.EVENT_RUN1D)
            elif request.find('GET /?event=run1W') > -1:
                self.event.set_event(self.event.EVENT_RUN1W)
            elif request.find('GET /?event=run1M') > -1:
                self.event.set_event(self.event.EVENT_RUN1M)
            else:
                self.event.set_event(self.event.EVENT_NONE)
        
        time.sleep(0.2)

Il reste à démarrer ce web serveur

#start web serveur
my_server = ServerWeb(debug=True)

Dans cet exemple, les actions ne sont matérialisées que par des “print” dans la console et un temps d’attente. Pour ce qui est de la réaction aux évènements, je met la priorité sur les événements STOP et MARCHE. Tous les autres évènements sont ignorés dès que l’utilisateur à cliqué sur le bouton “MARCHE”: il faudra d’abord appuyer sur STOP.

Pour aller plus loin

Dans un projet finalisé, il n’y aura pas besoin de faire tous ces print dans la log: il faudra instancier le ServerWeb avec l’option debug=False. Pour récupérer l’adresse du serveur WEB généré par le PICO il y a deux façons de faire:

• Utiliser un petit écran OLED ou LCD pour y afficher l’adresse du serveur WEB.

• Si vous utilisez un smartphone Android, l’application “Net Analyser” analyse et scanne tous les serveurs LAN actifs sur le réseau WIFI: on détecte ainsi facilement l’adresse du serveur WEB géré par le PICO.

Matériel nécessaire

Une imprimante 3D avec un plateau de dimension minimum 30cmx30cm minimum.

Quelques bobines de PLA (la maquette pèse 1,2 kg en tout), j’ai utilisé comme couleurs:

• Orange pour les pieds.
• Rouge pour tous les axes et roues dentées qui vont faire un tour complet pour 1 jour.
• Gris foncé pour les plateaux.
• Blanc pour les roues dentées.
• Noir pour les axes.
• Gris clair pour la Lune.
• Bleu pour la Terre.
• Jaune pour le Soleil.

De la colle pour assembler quelques pièces (le Soleil, la Terre et les pieds notamment).

Optionnel: des petits patins de protection (comme ceux que l’on met sous les pieds de chaise) pour limiter les vibrations des pieds lorsqu’on utilise un moteur.

Consignes

Tous les fichiers STL sont à disposition sur mon profil cults3D

J’encourage à imprimer les éléments d’une seule étape et de les assembler avant de passer à l’étape suivante. Si vous imprimez tout d’un coup, vous allez galérer à retrouver les bonnes roues dentées ou les bons axes de chaque étape. Si vous orientez correctement les pièces lors de l’impression (surface plate au sol) vous n’aurez pas besoin de support. Vous pouvez imprimer en définition 0.3mm pour gagner du temps, c’est largement suffisant car il n’y a pas de détail fin vertical (comme sur une figurine) qui nécessite d’imprimer en plus petites couches.

Attention certaines pièces font plus que 25cm de long (notamment les supports): cette maquette nécessite une surface d’impression d’au minimum 30cm x 30cm.

Chaque fichier STL commence par le numéro de l’étape afin de vous orienter dans le bon ordre d’impression. Les couleurs sont suggérées dans chaque image: pieds en orange, manivelle et tous les axes et roues qui tournent à la vitesse de 1 jour par tour en rouge, autres roues en blanc, axes en noir, supports en gris foncé. Soleil et son axe en jaune, Terre en bleu, Lune en gris clair. Une petite astuce concernant le plateau circulaire pour imprimer les lettrages en blanc sur fond gris foncé sera expliquée lors de cette étape.

Étapes

01: Pieds

Commencez par imprimer (couleur suggérée: orange) tous les pieds de l’étape 01. le pied_extérieur(x4) est à imprimer 4 fois. Le pied_intérieur(x3) est à imprimer 3 fois … vous aurez compris le principe pour la suite: j’indique à chaque fois s’il faut imprimer la même pièce plusieurs fois. Disposez ensuite les pieds à peu près comme sur la photo.

02: Plateau circulaire

Pour imprimer les 4 éléments circulaires de la base, j’ai utilisé 2 couleurs en commençant par du blanc sur les couches inférieures, puis du gris foncés sur les couches supérieures de manières à ce que les lettrages apparaissent en blanc sur fond gris foncé. Si vous optez en une définition de couche de 0.3mm, il faut changer de bobine au début de la 8ème couche pour obtenir cet effet. le socle_base quand à lui s’imprime en une seule couleur (gris foncé).

Assemblez les éléments comme sur la photo. N’hésitez pas à ébarber avec un cuter les surplus de matière qui empêcheraient d’assembler les 1/4 de cercle entre eux ainsi qu’au socle_base: c’est fait pour être serré, calculé au 1/10ème de mm près. Pour assembler le pied qui va maintenir le moteur et la manivelle, ne pas hésiter à tapper avec un petit marteau: ça rentre de justesse, c’est fait exprès. Pour les autres pieds vous pouvez utiliser de la colle pour les fixer sur le socle circulaire.

Optionnel: pour améliorer l’accroche de la maquette au sol, j’ai rajouté sous chaque pied des petits patins que l’on met habituellement sous les pieds de chaises pour éviter de cogner les parquets. Si vous utilisez un moteur: ça limitera les vibrations.

03: Manivelle

Les éléments de la manivelle sont imprimés en rouge. Pensez à bien orienter surface plate au sol la roue dentée et le volant (attention ils ont tous les deux une collerettes sur une face). Je conseille d’imprimer tous les axes à la verticale (pas besoin d’utiliser de bordure ni de radeau pour augmenter la surface d’accroche). Si vous les imprimez à l’horizontale, vous allez subir une petite déformation de la base au sol, et l’axe ne va pas bien tourner dans son logement après.

Mettez de côté tout cet ensemble pieds, plateau circulaire et manivelle. Vous aller dans les sections suivantes assembler tout le mécanisme du planétaire à part, et le poser sur le plateau circulaire en toute dernière étape.

04: Base

Les axes, roues dentées et collerettes sont à imprimer en rouge (toujours surface plate au sol, axe et collerettes à la verticale). J’ai imprimé les base_support_bas et haut en gris foncé. Pensez à bien réorienter la pièce base_support_haut dans l’autre sens: surface plate au sol et pas besoin de support dans cette configuration. Suivez la photo de gauche (cliquez dessous pour agrandir) pour voir comment assembler les pièces. Ne vous trompez pas entre les deux roues de 28 dents l’une est à disposer sur l’axe horizontal, l’autre sur l’axe vertical (elles sont différentes). N’oubliez pas les collerettes. Le mécanisme doit être fluide une fois que tout est assemblé.

La petite roue de 28 sur l’axe horizontal est difficile à poser à cause de l’axe hexagonal et le peu d’espace, mais on y arrive en essayant d’enfoncer l’axe tout en le tournant un peu pour qu’il se positionne bien dans le trou hexagonal de la roue.

05: Soleil

Bien entendu pour le soleil vous pouvez sortir une bobine jaune. Tout comme les autres éléments pensez à bien poser la surface plate au sol avant d’imprimer les pièces, et imprimez les axes verticalement pour ne pas les déformer. Assemblez d’abord la partie haute et basse du soleil avec le petit axe de fixation, puis posez ce soleil de côté: vous le placerez en tout dernier sur la maquette. Vous pouvez renforcer la fixation des deux parties du Soleil en utilisant de la colle.

Imprimez ensuite l’axe fixe interne et la petite collerette. La surface bombée de cette collerette doit se mettre en haut.

06: Révolution Terre

C’est parti pour imprimer l’engrenage qui permet de gérer la révolution de la Terre en 365,256 jours. Si vous voulez savoir comment les roues dentées ont été calculées pour obtenir cette précision, tout est expliqué dans cet article avec un rappel théorique sur le calcul d’un rapport de réduction. J’ai opté pour imprimer les axes en noirs, et les roues dentées en blanc.

Engrenage central

Commencez par enlever le support haut de la base, puis imprimez tous les axes (en noir, à la verticale). L’axe creux de 10mm se positionne sur l’axe central rouge en veillant à bien mettre la collerette de l’axe vers le haut. Les 3 autres axes de 5mm ont 3 tailles différentes: chacune va dans son logement approprié (du plus petit au plus haut).

Imprimez ensuite les roues dentées en blanc ainsi que la collerette de 12mm: 3 roues de 16 dents, 1 roue de 40 dents et 2 roues de 82 dents. Si les roues sont dures à insérer sur les axes mettez un coup de cutter pour débarrasser les surplus de matière gênants. Positionnez les comme sur le dessin:

• sur le petit axe: une roue de 40 et la roue de 16 au dessus.
• sur l’axe moyen: une roue de 82 et une roue de 16 au dessus.
• sur le grand axe: une roue de 82, la collerette de 12mm et une roue de 16 au dessus.

En tournant l’axe de la manivelle, la rotation des axes doit être fluide, sinon ébarbez avec un cutter ou un petit tournevis plat les surplus de matière qui gênent à l’intérieur des support des axes. Tout est calculé avec un jeux de 0,1mm pour que les axes ne partent pas dans tous les sens quand la rotation s’active.

Roue support du plateau

Vous pouvez remettre le support_haut de la base, et imprimez en blanc la collerette de 1mm ainsi que la grosse roue de 89 dents. N’oubliez surtout pas de positionner cette collerette de 1mm sous la roue de 89 dents.

Testez le mécanisme qui doit être parfaitement fluide lors de la rotation de la manivelle.

07: Rotation Terre

L’engrenage qui va gérer la rotation de la Terre sur elle-même va être supporté par un plateau qui va tourner au même rythme que le mécanisme qui gère la révolution de la Terre. Ce plateau va évoluer sur un pied qui va glisser le long du plateau circulaire fabriqué lors des premières étapes.

Commencez par imprimer le plateau ainsi que le pied et les 2 roues. Le plateau vient se fixer sur la grosse roue dentée de 89 dents de l’engrenage de la révolution de la Terre. Je conseille d’enlever cette roue pour la fixer sur le plateau en serrant fort (les encoches de la roue doivent être enfoncées au maximum sur le plateau), et de la remettre sur place avec son plateau bien fixé.

Vous pouvez ensuite imprimer les 5 axes et 6 roues dentées du mécanisme. Attention la toute première roue dentée de 29 dents (07_rotation_terre_gear29_axe_soleil) est différente des 3 autres roues de 29 dents (les dents n’ont pas le même profil). Ne vous mélangez surtout pas lorsqu’elles sont imprimées: sa place est sur l’axe central du Soleil (enlevez-le d’abord pour positionner cette roue). Les 3 petits axes sont identiques. Le grand axe est à reserver en bout de plateau pour l’axe de rotation de la Terre. Quand à l’axe moyen, il doit se positionner sur la 3ème roue comme sur la photo. Il va communiquer la rotation 1jour/tour au mécanisme de révolution de la Lune autour de la Terre.

Testez bien le mécanisme avant de passer à l’étape suivante: il doit être parfaitement fluide lors de la rotation de la manivelle. Si les roues du plateau ont tendance à sortir toutes seules de leur logement ce n’est pas grave: elles seront guidées par le plateau circulaire plus tard.

08: Inclinaison Terre

Ce nouveau plateau avec ses 3 roues dentées et 2 axes vont permettre de gérer l’engrenage qui maintient l’axe incliné de la Terre dans la même position tout au long de sa révolution autour du Soleil. Pour cela notez bien que la roue de 92 dents doit être fixe sur l’axe sur soleil qui est fixe: c’est curieux mais le rôle de cette roue dentée est bien de ne pas tourner.

Positionnez d’abord le plateau et enfoncez bien les petits renforts qui servent à maintenir les plateaux ensembles. Imprimez ensuite les 2 axes (à la verticale) pour finir avec les 3 roues de 92 dents, 90 (au centre) et 92 à nouveau sur l’axe de la Terre. Les collerettes présentes sur les roues doivent être orientées vers le haut. Le montage suivant devrait ressembler à l’image ci-dessous.

09: Révolution Lune

Nous enchaînons avec ce dernier plateau qui regroupe les 4 axes et 6 roues dentées qui vont gérer la révolution de la Lune en 27,32 jours autour de la Terre.

Commencez par imprimer le plateau (en gris foncé) et insérez-le bien fermement au dessus du plateau précédents: les encoches doivent être clipsées à fond. Disposez ensuite les 4 axes à imprimer en noir (à la verticale). Vous pouvez ensuite imprimer les 6 roues dentées. J’ai imprimé la première de 13 dents en rouge car elle tourne à la vitesse de 1 jour par tour. Les autres roues peuvent s’imprimer en blanc.

Assurez-vous bien que tous les mouvements soient bien fluides lorsque vous tournez la manivelle.

10: Lune

La Lune est composée d’un plateau qui se fixe via un petit socle sur la roue de 81 dents du plateau précédent (il y a un petit renfort rectangulaire sur cette roue pour y fixer le plateau de la Lune) et de deux 1/2 sphères (lune_bas et lune_haut) à fixer sur l’axe vertical.

11: Terre

La Terre quand à elle se compose d’un plateau, de deux roues de 28 dents (attention elles ne sont pas identiques), une collerette , deux 1/2 sphères avec une fixation interne, et un axe. J’ai opté pour tout imprimer en bleu à l’exception des deux roues et la collerette que j’ai imprimées en rouge.

Le plateau se fixe au centre de la roue dentée. Attention à bien disposer la roue terre_gear28_axe_terre sur l’axe de la terre, et l’autre sur l’axe vertical au milieu de la roue de 81 dents.

12: Assemblage final

A ce stade vous devriez avoir les deux parties ci-dessous: tout le mécanisme d’engrenage avec les plateaux et le socle circulaire sur ses pieds avec la manivelle.

Il suffit de les assembler en veillant à bien positionner l’axe de la roue rouge tout en bas des engrenages dans son logement sur le socle circulaire pour qu’elle soit positionnée juste au dessus de l’autre roue identique située sur la manivelle.

Cette maquette est maintenant terminée, il y a un logement pour un moteur (au dessus de la manivelle), un autre article va détailler la motorisation électronique de tout le mécanisme. En attendant elle est parfaitement fonctionnelle, chaque tour de manivelle représentant une journée.

Médias

Motorisation

Si vous savez souder des composants électroniques sur une carte PCB, vous pouvez motoriser ce planétaire avec un peu d’électronique bon marché et facilement accessible. Ce circuit va générer un petit serveur WEB local accessible depuis votre smartphone. Le moteur se positionne tout simplement sur son support: une petite encoche dans l’ouverture permet d’identifier où se trouve le méplat pour pouvoir faire rentrer l’axe du moteur à travers l’axe de la manivelle.

La notice de montage est disponible sur ce Github.

J’ai plusieurs PCB d’avance à ma disposition: vous pouvez me contactez si vous souhaitez en récupérer un.

Hardware

Matériel

Pour seul matériel, il faut:

• 1 ESP32 MINI D1 d’AZ-Delivery (tout autre ESP32 nécessitera d’adapter le socle de la veilleuse imprimé 3D)
• 1 petit anneau de 12 leds RGB WS2812B 5V, 37mm comme ceux qu’on trouve chez AZ-delivery
• 3 petits câbles en fil dur à souder
• 1 alimentation 5v micro-usb avec bouton on/off: un modèle 15w pour alimenter un raspberry-pi 3 avec bouton on/off sera parfait.

rien de plus !

assemblage

à l’aide de 3 fils à souder durs (pour maintenir l’anneau au dessus de l’ESP32 il est important d’utiliser des fils durs), reliez comme sur l’image:

• VCC +5V de l’ESP32 au VCC de l’anneau
• GND de l’ESP32 au GND de l’anneau
• GPIO16 de l’ESP32 au IN de l’anneau

Impression 3D

Le modèle de base à imprimer est disponible et gratuit sur Thingiverse. Il s’agit de cet hibou rigolo. J’ai retravaillé le socle afin de pouvoir y loger l’ESP32 au format carré ainsi que le cordon d’alimentation micro-usb: le socle de base ne le permet pas.

• Imprimez-donc le hibou du modèle de base avec un PLA translucide. Je conseille une hauteur de couche à 0,15mm pour avoir une belle définition des détails. L’usage des supports est obligatoire. un PLA translucide permettra de laisser passer la lumière.

• Imprimez ensuite le socle modifié que je mets à dispostion sur mon Github, dans la section /STL. une hauteur de couche en 0.3mm est suffisante pour le socle, et pas besoin de support.

Software

configuration ESP32

Il faut dans un premier temps flasher la dernière version de micro-python sur l’ESP32 à l’aide de l’IDE Thonny. L’opération est très simple et se passe en 4 temps:

• téléchargez la dernier firmware (c’est un fichier .bin) de micro-python pour ESP32 sur le site officiel micro-python. Pas besoin d’installer esptool , Thonny sait comment flasher un firmware sur un ESP32 relié par USB sur l’ordinateur. A l’heure où j’écris ces lignes, j’ai téléchargé la version v1.22.2(2024-02-22).bin

• Ouvrez Thonny, et connectez l’ESP32 à l’ordinateur à l’aide d’un cable USB.

• Allez dans Outils -> Options -> Interpréteurs et choisir “MicroPython (ESP32)”, puis cliquer sur “Installer ou mettre à jour le firmware”

• choisir le port dans la liste déroulante (normalement le bon port est reconnu dès le branchement de l’ESP32), puis sélectionnez l’image .bin téléchargée sur votre ordinateur.

Après une minute ou deux de mise à jour, ça y est le flash micropython sur l’ESP32 est prêt.

script micropython

Le script principal main.py est à récupérer sur le Github du projet dans la section /micropython. Il va lancer une petite animation qui dure quelques secondes et ensuite basculer sur une couleur avec un petit effet de crépitement.

Si vous souhaitez modifier la couleur (dans mon script j’utilise du violet = 50% bleu + 50% rouge) il suffit d’adapter la ligne 39

        for j in range(n):
            np[j] = (128+delta, 0, 128+delta)

la varialbe delta sert à simuler le crépitement. (128, 0, 128) représente du violet: mettez ce que vous voulez comme couleur sans oublier d’y rajouter +delta pour simuler le crépitement. Par exemple si vous voulez du vert: (0,128+delta,0) fera l’affaire. Ou bien (0,0,128+delta) pour du bleu, ou encore (0, 128+delta, 128+delta) pour obtenir du jaune (vert + bleu) etc … On peut simuler 65 millions de couleurs comme ça.

Hardware

Matériel

pour ce projet il faut:

• 1 PYBSTICK ESP32-C3 micro-usb avec les 2 rangées de pin headers 13 broches soudées. Cet ESP32-C3 est fabriqué en France.

• 1 PCB que vous pouvez faire fabriquer à partir des fichier Gerber fourni dans la section /PCB du Github du projet, ou bien me contacter pour savoir s’il m’en reste en stock.

• 1 écran LCD 16*02 avec backpack I2C

• 4 fils souples connecteurs dupont mâle-mâle pour relier le PCB à l’écran LCD.

• 1 connecteur coudé 4 pin 2.54mm à souder

• 1 capteur de température et humidité DHT22 avec 4 broches

• 1 diode Schottky SR560

• 1 résistance 10KΩ

• 1 condensateur céramique 100nf

• 1 prise jack DC 3 pin à souder

• 1 alimentation 5v 2A avec prise Jack

• 4 entretoises M2.5 15mm en nylon, femelle-mâle

• 4 entretoise M2.5 6mm en nylon, femelle-mâle

• 1 boîtier à imprimer 3D, les STL sont à récupérer dans la section /STL du Github du projet.

Électronique

La photo ci-dessus illustre les soudures à faire sur le PCB. Les instructions sont clairement sérigraphiées sur la carte. Ne vous trompez surtout pas de sens avec la PYPSTICK ESP32-C3 ainsi que la diode Schottky.

Assemblage

Le boîtier est composé d’une partie basse dans laquelle se loge le circuit rehaussé avec les entretoises M2.5 en nylon (mettre les petites de 6mm en dessous, elles se vissent sur les grandes de 15mm qui vont supporter l’écran LCD.). La partie haute se clipse autour du LCD correctement positionné sur les entretoises 15mm. Il faut couper au cutter à raz bord du PCB les vis mâles en nylon qui dépassent pour pouvoir fermer le boîtier.

Deux pieds inclinés (à coller avec de la colle PVC) peuvent se mettre sous le boîtier afin de faciliter la lecture de l’écran lorsqu’il est posé sur une table.

Software

scripts micropython

Tous les scripts sont à récupérer dans la section /micropython du Github du projet

• Cet article explique le fonctionnement d’un écran LCD avec un ESP32-C3

• Cet article explique comment utiliser un DHT22 avec un ESP32-C3

• Cet article détaille l’utilisation d’une API de météo avec l’ESP32-C3 afin de récupérer par WIFI les données météorologiques extérieures.

N’oubliez pas de mettre à jour quelques paramètres dans les scripts ci-dessous, en remplaçant les valeurs ‘xxxxx’:

• boot.py: indiquez votre WIFI_SSID et WIFI_PASSWORD pour que le boîtier se connecte à internet via votre WIFI

• api_meteo.py: indiquez votre TOKEN de connection à l’API comme expliqué dans cet article.

Calibration du capteur

Le DHT22 est un capteur sensible, il suffit de s’en approcher pour voir immédiatement quelques dixièmes de degrés supplémentaires apparaître. Comme il est soudé sur la carte, l’électronique à proximité va perturber les mesures bien que l’ESP32-C3 soit sobre en consommation: rien ne chauffe. Malgré tout, une petite dérive s’installe et il faut procéder à une calibration pour compenser cette dérive.

Principe

Il faudra vous équiper d’un thermomètre de référence, de préférence un tout simple non électronique au mercure. Le principe est de prendre 2 mesures assez éloignées avec 4 ou 5°C d’écart (une dans la pièce courante, et une à l’extérieur). Ensuite la calibration consiste à faire une interpolation linéaire à partir de ces 2 mesures.

Procédure

• Il faut tout d’abord régler sur Off la calibration (elle est sur On par défaut avec mes propres mesures): dans le programme dht22.py mettez la variable en ligne 6 QUALIBRATION = False (à la place de QUALIBRATION=True)

• Ensuite prenez vos deux mesures éloignées de quelques degrès, attendez bien à chaque fois un bon 1/4 d’h pour que les mesures soient stabilisées. Notez-les (T_DHT1, T_R1) et (T_DHT2, T_R2), T_DHTx étant la température indiquée par le DHT22, et T_Rx étant celle indiquée par votre thermomètre de référence.

• Reportez les valeurs dans le programme dht22.py, lignes 7 à 10, et remettez la variable QUALIBRATION = True en ligne 6

Le programme va alors calibrer la température T mesurée par le DHT22 selon cette formule:

Tc  =  r * T + T0
r = (T_R2 - T_R1) / (T_DHT2 - T_DHT1)
T0 = TR2 - r * T_DHT2

Et voilà la calibration est terminée: la température affichée par le DHT22 devrait être équivalente à celle du thermomètre de référence dans vote pièce principale.

Usage

La première ligne donne les valeurs du capteur interne DHT22: température et humidité. Ces valeurs sont mises à jour toutes les 5 secondes.

La seconde ligne affiche les données météorologiques externes récupérées sur internet et mises à jour toutes les 5 minutes.

• dans un premier temps on affiche la température externe et le taux d’humidité

• ensuite il s’affiche la vitesse du vent et la probabilité qu’il pleuve

• Enfin le bulletin météorologique est scrollé à l’écran.

Circuit électronique

Très simple: il faut relier VCC au +5V, GND à la masse, et SDA et SCL aux entrées soft I2C SDA et SCL de votre ESP32.

Code micropython

Bibliothèques

Pour pouvoir gérer l’écran LCD via I2C, il faut tout d’abord installer ces deux bibliothèques sur votre ESP32: copiez/collez le code micropython de ces 2 programmes, et nommez les exactement comme sur cette source Github:

• lcd_api.py
• i2c_lcd.py

Afficher un logo

Nous pouvons définir 8 petits logos personnalisés 5x8 pixels à l’aide d’un tableau de 8 codes hexadécimaux (8 lignes) qui codent les 5 pixels de chaque ligne. Il y a cet outil en ligne LCD Character Creator très pratique pour dessiner à l’écran votre logo et récupérer les codes hexadécimaux correspondants. Utilisez bien Data Type = Hex (et non pas Binary) pour récupérer les codes Hexa.

Si vous créez ce logo de robot, vous devriez obtenir cette liste de 8 codes hexa: 0x0E, 0x1F, 0x15, x1F, 0x1F, 0x11, 0x1F, 0x0E

code micropython

Le code ci-dessous défini une classe LCD dans laquelle des logos perso sont définis dans un dictionnaire de logos dic_char. C’est ici que l’on recopie les codes hexadécimaux récupérés depuis l’outil LCD Character Creator.

• dic_char: dictionnaire des logo {‘nom du logo’: ( id_logo de 0 à 7 , [liste des codes hexadécimaux] ) }

• get_char(self, name:str) ->chr: retourne un logo à partir de son nom.

• scroll(self, s:str, lig:int, col:int): scroll un texte de droite à gauche jusqu’en position (lig, col).

• get_i2c(self, sda_pin:int, scl_pin:int) ->SoftI2C : retourne l’adresse I2C du LCD branché sur les pin sda_pin et scl-pin. En cas de mauvais branchement, des messages d’erreur sont affichés dans la console si vous exécutez ce programme depuis un ordi.

from machine import Pin, SoftI2C
from lcd_api import LcdApi
from i2c_lcd import I2cLcd
from time import sleep
from sys import exit

I2C_ADDR = 0x27
SDA_PIN = 0
SCL_PIN = 1
TOTAL_ROWS = 2
TOTAL_COLUMNS = 16

class LCD(I2cLcd):
    def __init__(self, sda_pin:int=SDA_PIN, scl_pin:int=SCL_PIN):
        """ constructor """
        self.i2c = self.get_i2c(sda_pin, scl_pin)
        if self.i2c is not None:
            I2cLcd.__init__(self, self.i2c, I2C_ADDR, TOTAL_ROWS, TOTAL_COLUMNS)
            self.clear()
            
            # generator custom character: https://maxpromer.github.io/LCD-Character-Creator/        
            self.dic_char={'wifi'       : (0, bytearray([0x0E, 0x11, 0x00, 0x1F, 0x00, 0x0E, 0x00, 0x04]) ),
                           'thermometre': (1, bytearray([0x04, 0x0B, 0x0A, 0x0B, 0x0A, 0x17, 0x1F, 0x0E]) ), 
                           'soleil'     : (2, bytearray([0x00, 0x15, 0x0E, 0x11, 0x11, 0x11, 0x0E, 0x15]) ),
                           'pluie'      : (3, bytearray([0x15, 0x00, 0x0E, 0x1F, 0x04, 0x04, 0x14, 0x08]) ),
                           'nuages'     : (4, bytearray([0x03, 0x0F, 0x1E, 0x1E, 0x0C, 0x00, 0x00, 0x00]) ),
                           'neige'      : (5, bytearray([0x10, 0x05, 0x02, 0x05, 0x00, 0x14, 0x08, 0x14]) ),
                           'brouillard' : (6, bytearray([0x0E, 0x1F, 0x0A, 0x15, 0x0A, 0x15, 0x0A, 0x15]) ),
                           'papsdroid'  : (7, bytearray([0x0E, 0x1F, 0x15, 0x1F, 0x1F, 0x11, 0x1F, 0x0E]) ),
                           }
            for __cle, val in self.dic_char.items():
                self.custom_char(val[0], val[1])
            
        else:
            print('Revoir branchements écran LCD')
            exit(1)
          
    def get_char(self, name:str) ->chr :
        ''' return chr of named special char '''
        try:
            c = chr(self.dic_char[name][0])
        except:
            c =  chr(0)
        return c
    
    def scroll(self, s:str, lig:int, col:int):
        """ scroll string s rigth to left at (lig, col) """
        padding = ' ' * (16-col)
        padded_s = padding + s
        for i in range(len(padded_s)):
            lcd_text = padded_s[i:(i+16-col)]
            self.move_to(col,lig)
            self.putstr(lcd_text)
            sleep(0.3)
            self.move_to(col,lig)
            self.putstr(padding)
    
    def get_i2c(self, sda_pin:int, scl_pin:int) ->SoftI2C :
        ''' get i2c '''
        i2c = SoftI2C(scl=Pin(scl_pin), sda=Pin(sda_pin), freq=400000)
        devices =i2c.scan()      
        if len(devices) == 0:
             print("No i2c device !")
             return None
        else:
            print('i2c devices found:',len(devices))
            for device in devices:
                print("At address: ",hex(device))
            return i2c
        
if __name__ == '__main__':
    print('test lcd')            
    screen=LCD()
    screen.putstr(screen.get_char('papsdroid') + "  papsdroid  " + screen.get_char('papsdroid'))
    screen.move_to(0,1) #second line
    #print symbols
    screen.putstr(' '+screen.get_char('wifi'))
    screen.putstr(' '+screen.get_char('thermometre'))
    screen.putstr(' '+screen.get_char('soleil'))
    screen.putstr(' '+screen.get_char('nuages'))
    screen.putstr(' '+screen.get_char('pluie'))
    screen.putstr(' '+screen.get_char('neige'))
    screen.putstr(' '+screen.get_char('brouillard'))
    sleep(1)
    screen.scroll('https://papsdroidfr.github.io/', lig=0, col=2)
    screen.move_to(0,0)
    screen.putstr(screen.get_char('papsdroid') + "  papsdroid  " + screen.get_char('papsdroid'))