Tableau de bord DIY

[Bacab]

Bonjour,

Dans la lignée de ma boîte à boutons je me suis attaqué à la construction d'un altimètre codeur le plus petit possible.

Il se compose d'une Arduino Uno, d'un moteur pas à pas 28BYJ48 (l'interface entre l'Arduino Uno et le moteur est un ULN2003A) et d'un écran Oled de 0.96" (128*64 pixels). L'habillage est réalisé en imprimante 3D (PLA) et sont de ma conception

Pour le moment c'est un prototype: je n'ai pas fixé le micro-switch qui permet la détection du "zéro" du moteur pas à pas et il n'y a pas de potar pour régler la pression de référence...

Néanmoins ça marche plutôt pas mal comme vous pouvez le voir dans cette petite vidéo :


Elle montre le passage à plusieurs altitudes en monté et en descente. Pour le moment les altitudes sont envoyées par la liaison série de l'Arduino mais à terme je voudrais l'interfacer avec les simulateurs que j'utilise.

Cette vidéo permet aussi de voir une des limites du montage : la vitesse maximale du moteur pas à pas qui est trop basse. Malheureusement je ne peux rien y faire en soft, c'est le matériel qui me limite : il faudra que je remplace ce moteur par un autre plus véloce dans la version définitive.

Il est donc possible que je finisse par utiliser ce proto avec une petite centrale inertielle équipée d'un capteur de pression atmosphérique (en ce cas la vitesse de l'aiguille ne risque pas de me gêner, je ne marche pas si vite que ça !).

Quelques photos en plus :
L'intégralité du montage


Vue de face :


Vue de face avec un stylo pour donner une idée de la taille :

[Hombre]

Magnifique, belle mécanique...

[Cat]

Pas mal !

[Milos]

Le stylo donne une idée de la taille de l'engin ...

[Bacab]

Merci !

Une petite question en passant :
Est-ce que quelqu'un a une idée de la vitesse maximale à laquelle un altimètre peut tourner ?

[Cat]

Très vite !

[EnZo34]

Est-ce que quelqu'un a une idée de la vitesse maximale à laquelle un altimètre peut tourner ?

Comme le dit Cat', ça peut tourner très vite, oui . Tout dépend évidemment de ton taux de montée (ou de descente); sur Mirage 2000, le vario est gradué jusqu'à 6000 ft/mn, et la plupart du temps, l'aiguille est en butée...

[Bacab]

Actuellement j'atteins les 15000 ft/mn (15 tours par minutes et 1 tour = 1000 ft). Je trouve ça lent par rapport à mon ressenti sur simulateur. Dans le commerce il existe le même moteur avec des réducteurs différents (/32 ou /15 plutôt que /64) ce qui me permettrait d'augmenter la vitesse (au détriment de la précision mais c'est secondaire et ça ne devrait pas se voir). Avec un réducteur 32 je double (presque) la vitesse et avec le 15 je passe à 50 RPM ce qui devrait me donner du 50000ft/min ou 830 ft/s. Est-ce suffisant ou faut il que je cherche plus véloce ?

[Cat]

Oh je crois que 50.000ft/mn c’est suffisant...

[matbog]

Ce moteur n'est pas vraiment adapté pour ton utilisation. Il est plus fait pour pour des applications où il y a besoin d'un peu de couple.
Je partirais plus sur de X27 si j'étais toi, c'est fait pour motoriser des aiguilles.

[Bacab]

Le x27 je ne le trouve chez aucune boîte d'électronique sérieuse sinon c'était mon premier choix.

Je me suis basé pour le choix du stepper sur le site simvim.com où les 2 moteurs le miens et le x27 sont listés.

[Bacab]

J'ai repris la construction de mon mini-cockpit il y a deux semaines et ça a un peu évolué. Je vous laisse en juger par vous même :

Ce sera plus évident une fois les graduations collées mais vous pouvez voir :
un anémomètre | un compas
un altimètre | un vario

Tout ça fonctionne au poil lorsque je fais mes tests et l'heure est venue d'essayer de s'interfacer avec DCS Bios. Sauf que horreur et damnation ! Il n'y a pas de documentation (enfin si, si vous connectez une led ou un bouton, la c'est bon, mais pour le reste c'est pas Byzance). J'ai installé le plugin commondata qui me donne des méthodes pour récupérer les données qui m'intéressent mais je ne comprends pas comment les obtenir sur mon Arduino. Je pensais qu'en déclarant un callback branché sur l'adresse qui va bien le tour était dans le sac mais manifestement non. oui si en fait ça marche mais pas sur tous les avions, le common a pas l'air d'être si common que ça ...

Donc maintenant mes cadrans bougent ! Sauf que que c'est n'importe quoi, comme si DCS Bios ne m'envoyait pas les bonnes valeurs. J'ai vérifié dans l'interface Web mais je ne vois pas les valeurs aberrantes circuler (tout à l'air normal). Je pense néanmoins que c'est DCS bios le problème car dés que je met pause les cadrans se mettent tous à la bonne position !

Ça marche !! Malloc à la con va

Voici le code :

#define DCSBIOS_IRQ_SERIAL

#include <Stepper.h>
#include <Tiny4kOLED.h>
#include <DcsBios.h>
#include "font16x32digits.h"

#define I2C_SLAVE2_ADDRESS 11
#define x27_STEP_PART 630
#define x27_STEP_CONT 720
#define CW_IAS -1
#define CW_HDG -1
#define HDG_ZERO_POS 519
#define IAS_ENABLE_1 6
#define IAS_ENABLE_2 7
#define HDG_ENABLE_1 12
#define HDG_ENABLE_2 13
#define HDG_ZERO_SENSOR 14
#define IAS_1 2
#define IAS_2 3
#define IAS_3 4
#define IAS_4 5
#define HDG_1 8
#define HDG_2 9
#define HDG_3 10
#define HDG_4 11

const DCfont *currentFont = FONT16X32DIGITS;
unsigned int IAS_step_position = 0;
unsigned int HDG_step_position = 0;
unsigned int IAS_current_pos = 0;
unsigned int HDG_current_pos = 0;

int delta_IAS = 0;
int delta_HDG = 0;
int i = 1;

int previous_alt = 0;

Stepper IAS_stepper(x27_STEP_PART, IAS_1, IAS_2, IAS_3, IAS_4);
Stepper HDG_stepper(x27_STEP_CONT, HDG_1, HDG_2, HDG_3, HDG_4);

void onIasUsIntChange(unsigned int new_IAS)
{
unsigned int IAS_knots = 0;

IAS_knots = constrain(new_IAS, 0, 800);
IAS_step_position = map(IAS_knots, 0, 800, 0, x27_STEP_PART);
}
DcsBios::IntegerBuffer iasUsIntBuffer(0x042e, 0xffff, 0, onIasUsIntChange);

void onHdgDegChange(unsigned int new_HDG)
{
unsigned int HDG_degrees = 0;

HDG_degrees = new_HDG % 360;
HDG_step_position = map(new_HDG, 0, 359, 0, x27_STEP_CONT);
}
DcsBios::IntegerBuffer hdgDegBuffer(0x0436, 0x01ff, 0, onHdgDegChange);

void onAltMslFtChange(unsigned int new_ALT)
{
// char* altitude_affich = (char *)malloc(6*sizeof(char));
char altitude_affich[6];
int th_feet_prev = previous_alt/1000;
int th_feet_new = new_ALT/1000;
byte LSBbyte, MSBbyte;

LSBbyte = new_ALT & 0xFF;
MSBbyte = new_ALT >> 8;

Wire.beginTransmission(I2C_SLAVE2_ADDRESS);
Wire.write(MSBbyte);
Wire.write(LSBbyte);
Wire.endTransmission();

if(th_feet_new!=th_feet_prev);
{
sprintf(altitude_affich, "%05d", th_feet_new*1000);
oled.clear();
oled.setCursor(48, 0);
oled.print(altitude_affich);
oled.switchFrame();
}
previous_alt = new_ALT;
// free(altitude_affich);
}
DcsBios::IntegerBuffer altMslFtBuffer(0x0434, 0xffff, 0, onAltMslFtChange);

void setup()
{
DcsBios::setup();
pinMode(IAS_1, OUTPUT);
pinMode(IAS_2, OUTPUT);
pinMode(IAS_3, OUTPUT);
pinMode(IAS_4, OUTPUT);
pinMode(IAS_ENABLE_1, OUTPUT);
pinMode(IAS_ENABLE_2, OUTPUT);
pinMode(HDG_1, OUTPUT);
pinMode(HDG_2, OUTPUT);
pinMode(HDG_3, OUTPUT);
pinMode(HDG_4, OUTPUT);
pinMode(HDG_ENABLE_1, OUTPUT);
pinMode(HDG_ENABLE_2, OUTPUT);
pinMode(HDG_ZERO_SENSOR, INPUT);

digitalWrite(IAS_ENABLE_1, HIGH);
digitalWrite(IAS_ENABLE_2, HIGH);
digitalWrite(HDG_ENABLE_1, HIGH);
digitalWrite(HDG_ENABLE_2, HIGH);

IAS_stepper.setSpeed(60);
IAS_stepper.step(-1 * CW_IAS * x27_STEP_PART);

HDG_stepper.setSpeed(60);
while(digitalRead(HDG_ZERO_SENSOR))
{
HDG_stepper.step(CW_HDG);
}
while(!digitalRead(HDG_ZERO_SENSOR))
{
HDG_stepper.step(-CW_HDG);
}

HDG_current_pos = HDG_ZERO_POS;

oled.begin();
oled.setFont(currentFont);
oled.setRotation(180);
oled.on();
oled.switchRenderFrame();
oled.clear();
oled.setCursor(48, 0);
oled.print("01337");
oled.switchFrame();
}

void loop()
{
DcsBios::loop();
delta_IAS = IAS_step_position - IAS_current_pos;
delta_HDG = HDG_step_position - HDG_current_pos;

if(abs(delta_HDG) > x27_STEP_CONT/2)
{
if(delta_HDG < 0)
{
HDG_stepper.step(CW_HDG);
HDG_current_pos = (HDG_current_pos + 1) % x27_STEP_CONT;
}
else if(delta_HDG > 0)
{
if(HDG_current_pos == 0)
{
HDG_current_pos = x27_STEP_CONT;
}
HDG_stepper.step(-CW_HDG);
HDG_current_pos = (HDG_current_pos - 1);
}
}
else
{
if(delta_HDG > 0)
{
HDG_stepper.step(CW_HDG);
HDG_current_pos++;
}
else if(delta_HDG < 0)
{
HDG_stepper.step(-CW_HDG);
HDG_current_pos--;
}
}

if(delta_IAS > 0)
{
IAS_stepper.step(CW_IAS);
IAS_current_pos++;
}
else if(delta_IAS < 0)
{
IAS_stepper.step(-CW_IAS);
IAS_current_pos--;
}
}

EDIT : en vidéo avec les cadrans :

[steph737]

Ce moteur n'est pas vraiment adapté pour ton utilisation. Il est plus fait pour pour des applications où il y a besoin d'un peu de couple.
Je partirais plus sur de X27 si j'étais toi, c'est fait pour motoriser des aiguilles.

c'est multi tour un x27 ? je n'ai pas l'impression... donc pas bon pour alti, compas,.... mais pour tout le reste si ? Toujours si j'ai bien compris, il y a un capteur de référence inclus dedans ?

[matbog]

Il me semble qu'il y a seulement une butée qui sert pour l'initialisation du moteur. Si tu enlèves la butée et que tu rajoutes un capteur pour l'initialisation il devient multitour. C'est ce que j'en ai compris en tout cas.

[Bacab]

Il me semble qu'il y a seulement une butée qui sert pour l'initialisation du moteur. Si tu enlèves la butée et que tu rajoutes un capteur pour l'initialisation il devient multitour. C'est ce que j'en ai compris en tout cas.

C'est ça, il suffit d'ouvrir le moteur, de couper et poncer la butée et tu obtiens un moteur pas à pas multi-tours. Pour l'initialiser au début il faudra par contre un capteur (comme les photodiodes que vous pouvez voir) afin de lui permettre de se recaler.

[Bacab]

Et donc 3 ans plus tard, ce cockpit et bien c'était vraiment beaucoup de travail pour rien ==> les X27 sautent des pas aléatoirement même à petite vitesse et donc tous les instruments finissent par afficher nawak. Bref, ça a rapidement fini dans un placard. Reste que l'idée d'en faire une V2 me trottait dans la tête depuis un moment. Et j'ai fini par sauter le pas. Mais cette fois fini les demi-mesures :
- exit les copies de moteurs pas à pas de mauvaises qualités et bonjour les NEMA 17
- les petits instruments c'est mignon mais ça complexifie trop le design, allez hop je double la taille (presque) de tout ce petit monde
- et puis quatre instruments c'est batard comme nombre, il y a un sentiment de trop peu comme avec les frites à la cantine, et hop je t'en mets 2 de plus
- coté technique les 2 Arduino qui communiquent pour piloter le bordel c'est suboptimal. En exploitant jusqu'à la dernière broche d'une Uno et en utilisant des drivers de moteurs pas à pas au lieu de simples ponts en H, tout tien sur une carte
- ah et l'USB c'est trop limite pour l'alimentation, donc je passe sur une alimentation dédiée de 12 V, 6.5 A avec régulateur & Co pour fournir un rail 5V pour la logique et les servos

Donc je reprend la modélisation :



Et j'imprime !


A faire :
- la peinture : en cours (4/6 terminés)
- l'impression, le découpage et le collage des quadrants (tous modélisés avec Qcad, c'est le feu ce logiciel ! *)
- l'impression 3D du boitier( en deux pièces qui mettront 8h30 à s'imprimer)
- l'impression 3D du fond de boitier et y fixer les connecteurs, prises et le convertisseur de tension
- trouver un service de découpe de plexiglas et commander la glace frontale
- profitez ? (en espérant que le code que j'ai écris fonctionne sans trop de soucis).

* : voyez par vous même:

Hyper facile à prendre en main si vous avez l'habitude des logiciels de CAO. Le plus dur ça a été de trouver comment activer/désactiver certaines options mais le design en lui même m'a pris moins d'une heure sans connaître le logiciel. Et c'est dispo gratuitement pour une utilisation non commercial.

Si vous voulez vous lancer (attention c'est du WIP), je mets tous sur Thingiverse :
Anémomètre : https://www.thingiverse.com/thing:6554036
Compas : https://www.thingiverse.com/thing:6554022
Indicateur de virage : https://www.thingiverse.com/thing:6554762
Altimètre : https://www.thingiverse.com/thing:6554779
Bonus, écran LCD d'appoint pour l'écran radar : https://www.thingiverse.com/thing:6554791