Cliquer pour masquer
Résumé
Cet article présente le test fonctionnel de l’affichage des fréquences de rotation des moteurs du pont élévateur du diorama de la Batcave, sur un écran OLED i2c, via la carte Arduino Nano R4 du système électronique de contrôle.… Lire la suite →
Première publication :
Dernière mise à jour :
Temps de lecture :
Mots clés :
Contexte de l’intégration d’un écran OLED i2c avec Arduino Nano R4
L’article précédent présente l’intégration d’une carte Arduino Nano R4 au sein de l’architecture électronique du système de contrôle dédié à la régulation de vitesse de rotation des moteurs du pont élévateur du diorama de la Batcave. Cet article expose, dans un premier temps, les motivations ayant conduit au remplacement des circuits imprimés (PCB) de conversion fréquence–tension par une carte Arduino UNO. Dans un second temps, il analyse les raisons techniques justifiant l’évolution vers une carte Arduino Nano R4.
Au-delà de la correction de dysfonctionnements identifiés dans les versions antérieures, l’intégration d’une carte Arduino Nano R4 dans l’armoire électrique de contrôle du pont élévateur ouvre la voie à l’intégration de nouvelles fonctionnalités. Parmi celles-ci figure notamment la possibilité d’un affichage local des données de traitement, directement au plus près du système. Cet article se concentre ainsi sur la validation fonctionnelle de cette capacité d’affichage.
Choix technologique et implantation fonctionnelle
Pourquoi choisir un écran OLED i2c avec Arduino Nano R4
Comme indiqué précédemment, les motivations ayant conduit à l’utilisation d’une carte Arduino Nano R4 dans cette architecture sont détaillées dans un article antérieur.
L’écran OLED i2c, piloté par la carte Arduino Nano R4 intégrée à l’armoire électrique de commande, a pour vocation d’assurer un affichage local des données au plus près du système de contrôle et de régulation de la vitesse des moteurs. Il permet notamment de visualiser les valeurs mesurées des fréquences de rotation des quatre moteurs.
Ce dispositif répond à un double objectif. D’une part, il facilite les phases de mise au point de la chaîne matérielle et logicielle dédiée à l’acquisition des données. D’autre part, il permet de vérifier la bonne transmission ainsi que le traitement cohérent de ces informations jusqu’à la console de commande centralisée.
Contraintes d’intégration dans l’armoire électrique de contrôle
Le choix d’un écran de 1,3″ résulte d’un compromis entre l’encombrement physique et la capacité d’affichage requise. En effet, ses dimensions doivent rester compatibles avec une intégration sur la porte de l’armoire électrique de commande, au sein de laquelle est implantée la carte Arduino Nano R4.
Parallèlement, cet écran doit offrir une surface d’affichage suffisante pour permettre une visualisation exploitable des quatre valeurs de fréquences de rotation correspondant aux moteurs du système. À ce titre, sa définition de 128 × 64 pixels permet d’envisager un affichage simultané et lisible de l’ensemble de ces informations.
Conception mécanique réalisée à l’aide de FreeCAD
La conception mécanique de l’intégration de l’écran i2c OLED 1,3″ a été réalisé avec le logiciel FreeCAD.
Dans la mesure où le présent article est spécifiquement consacré à l’intégration électrique de l’écran OLED au sein du système de contrôle du pont élévateur du diorama de la Batcave, les aspects relatifs à la conception mécanique des deux armoires constituant le système de commande seront traités dans une publication ultérieure.
FreeCAD est un modeleur 3D paramétrique open-source.
Schéma de montage
Conception du schéma électronique sous KiCad
Le schéma électronique a été réalisé à l’aide de la suite logicielle KiCad.
La présentation détaillée du schéma complet du système électronique de commande du pont élévateur du diorama de la Batcave, dont les différentes feuilles sont illustrées dans la capture d’écran figurant en en-tête de ce paragraphe, fera l’objet d’un article dédié à venir.
KiCad est une suite logicielle open source pour la conception électronique.
Périmètre de l’étude et perspectives de validation globale
Le schéma présenté se concentre exclusivement sur l’intégration de l’écran OLED en interface i2c avec la carte Arduino Nano R4.
Un article ultérieur sera consacré à la validation complète de la chaîne d’acquisition et de traitement des données, depuis les capteurs jusqu’à la console de commande centralisée.
Mise en place du banc de test et simulation du signal moteur
Dans le cadre de ce test fonctionnel de l’affichage des valeurs de fréquences, une carte Arduino UNO a été utilisée pour générer un signal carré de fréquence fixe 512 Hz, simulant ainsi les signaux issus des capteurs optiques des plateformes motorisées.
Ce même signal a été transmis aux 4 broches de la carte Arduino Nano R4 dédiées aux mesures de la fréquence de rotation des moteurs. Ce qui justifie que la même valeur soit affichée sur l’écran pour les 4 fréquences.
Rôle des résistances pull-up dans la communication I²C
Ce schéma met en évidence la présence de deux résistances de 4,7 kΩ. Il s’agit de résistances de tirage, couramment appelées résistances de pull-up. Leur rôle est d’assurer un niveau logique haut stable (ici 5 V) sur les lignes de communication, notamment lorsque celles-ci ne sont pas activement pilotées par un dispositif du bus.
En effet, sur un bus comme l’I2C, les composants ne génèrent pas directement un niveau haut. Ils peuvent seulement tirer la ligne vers le bas (niveau 0). Sans résistance de pull-up, la ligne resterait alors dans un état indéterminé lorsqu’elle n’est pas sollicitée. Ces résistances agissent donc comme un rappel vers le niveau haut, garantissant un signal propre et exploitable pour tous les éléments connectés au bus.
Spécificités du câblage i2c avec Arduino Nano R4
La difficulté rencontrée lors de la mise au point de ce montage, pourtant en apparence simple, tient au fait que la version précédente, basée sur une carte Arduino UNO, ne nécessitait pas l’ajout de résistances de pull-up. Le raccordement direct des lignes SDA et SCK de l’écran à celles de l’Arduino suffisait alors pour obtenir un fonctionnement correct de l’affichage.
En revanche, lors du remplacement de la carte Arduino UNO par une NANO R4, l’écran est resté totalement inactif. Ce comportement s’explique par une différence de conception interne des broches SDA et SCK entre les deux cartes. Contrairement à l’UNO, la NANO R4 ne permet pas un fonctionnement fiable du bus I2C sans l’ajout explicite de résistances de pull-up externes.
Source : https://docs.arduino.cc/tutorials/nano-r4/user-manual/
Le code
#include <pwm.h>
#include <Adafruit_SH110X.h>
const int MaxReadNumber = 10;
const int MaxPulseNumber = 1;
const int pinIn[] = {2, 4, 7, 8};
int Freq[] = {0,0,0,0};
int Period[] = {0,0,0,0};
float FreqInFloat = 0.0;
float PeriodInFloat = 0.0;
// PWM Duty Cycle
int DUTY_CYCLE_READ = 0;
int DUTY_CYCLE_INIT = 0;
float DUTY_CYCLE_SET = 0.0;
const int PIN_DUTY_CYCLE = A7;
const int PIN_FREQ0 = 2;
const int PIN_FREQ1 = 4;
const int PIN_FREQ2 = 7;
const int PIN_FREQ3 = 8;
const int PWM_D5_PIN = 5;
const int PWM_D6_PIN = 6;
const int PWM_D9_PIN = 9;
const int PWM_D10_PIN = 10;
PwmOut PWM_D5(PWM_D5_PIN);
PwmOut PWM_D6(PWM_D6_PIN);
PwmOut PWM_D9(PWM_D9_PIN);
PwmOut PWM_D10(PWM_D10_PIN);
Adafruit_SH1106G display = Adafruit_SH1106G(128, 64, &Wire, -1);
void setup()
{
pinMode(PIN_FREQ0, INPUT);
pinMode(PIN_FREQ1, INPUT);
pinMode(PIN_FREQ2, INPUT);
pinMode(PIN_FREQ3, INPUT);
pinMode(PWM_D5_PIN, OUTPUT);
pinMode(PWM_D6_PIN, OUTPUT);
pinMode(PWM_D9_PIN, OUTPUT);
pinMode(PWM_D10_PIN, OUTPUT);
PWM_D5.begin(25000.0f, 0.0f);
PWM_D6.begin(25000.0f, 0.0f);
PWM_D9.begin(25000.0f, 0.0f);
PWM_D10.begin(25000.0f, 0.0f);
MotorFrequencySetUp();
Serial1.begin(9600);
display.begin(0x3c, true);
display.clearDisplay();
//display.drawRect(0, 0, 128, 64, 1);
display.setTextSize(1);
display.setTextColor(SH110X_WHITE);
display.setCursor(0, 0);
display.println("BATLab112 Project");
display.println("Lifter Bridge Control");
display.setCursor(0, 24);
display.println("Freq.1 = Hz");
display.setCursor(0, 34);
display.println("Freq.2 = Hz");
display.setCursor(0, 44);
display.println("Freq.3 = Hz");
display.setCursor(0, 54);
display.println("Freq.4 = Hz");
display.display();
delay(500);
}
void loop()
{
for(int i=0; i<4; i++)
{
Period[i] = ReadPeriod(pinIn[i]);
PeriodInFloat = Period[i] * 1.0;
if(PeriodInFloat!=0)
{
FreqInFloat = (1000000/PeriodInFloat);
}
else
{
FreqInFloat = 0;
}
Freq[i] = floor(FreqInFloat);
}
DisplayFrequency();
}
float ReadPeriod(int signal)
{
float SignalPeriod = 0;
int PulseCounter = 0;
int HighTime = 0;
int LowTime = 0;
while(PulseCounter < MaxPulseNumber)
{
while (HighTime == 0)
{
HighTime = pulseIn(signal,HIGH);
}
while (LowTime == 0)
{
LowTime = pulseIn(signal,LOW);
}
SignalPeriod = HighTime + LowTime;
PulseCounter++;
}
SignalPeriod = SignalPeriod / PulseCounter;
return SignalPeriod;
}
void DisplayFrequency()
{
display.setTextColor(SH110X_WHITE, SH110X_BLACK);
for(int i=0; i<4; i++)
{
if (Freq[i]>999)
{
Freq[i] = 999;
}
}
display.setCursor(53, 24);
display.println(Freq[0]);
display.setCursor(53, 34);
display.println(Freq[1]);
display.setCursor(53, 44);
display.println(Freq[2]);
display.setCursor(53, 54);
display.println(Freq[3]);
display.display();
}
Cet extrait du sketch implémenté sur une carte Arduino Nano R4 se concentre spécifiquement sur la gestion de l’affichage des fréquences de rotation des moteurs via un écran OLED utilisant une interface I2C.
La fonction setup() assure l’initialisation de l’affichage en définissant une trame graphique structurée. Celle-ci comprend notamment des lignes de titre ainsi que des libellés associés aux différentes mesures, sous la forme « Freq.x = … Hz », permettant de préparer un cadre de visualisation clair et stable pour l’utilisateur.
La fonction DisplayFrequency() est, quant à elle, dédiée à la mise à jour des valeurs numériques affichées. Son fonctionnement repose sur une logique séquentielle simple consistant à écrire, à des positions prédéfinies de l’écran, les fréquences correspondant aux différents canaux mesurés. Cette fonction est appelée à l’issue de la phase d’acquisition des signaux, réalisée par la fonction ReadPeriod(), ainsi qu’après le traitement permettant de convertir les périodes mesurées en fréquences.
Validation fonctionnelle et perspectives d’évolution du système de contrôle Arduino Nano R4
Le test fonctionnel relatif à l’affichage des fréquences de rotation des quatre moteurs du pont élévateur du diorama de la Batcave s’avère concluant. Les résultats obtenus permettent d’ores et déjà de valider la capacité de la carte Arduino Nano R4 à acquérir et mesurer de manière stable et précise les signaux issus des capteurs optiques des plateformes motorisées.
Des travaux complémentaires demeurent toutefois nécessaires. Dans un premier temps, il conviendra d’évaluer la précision des mesures en conditions dynamiques, c’est-à-dire en présence de variations de fréquence induites par les comportements mécaniques du pont élévateur.
Dans un second temps, lors de l’intégration du système électronique de régulation avec la structure électromécanique du pont, il sera nécessaire de valider la mise en œuvre complète de la boucle logicielle de régulation des vitesses, afin d’assurer un pilotage cohérent et robuste de l’ensemble du dispositif.
BATLab112 