Piloter l'éclairage de son modèle facilement
Histoire de ne plus me poser de questions sur les fréquences, j'ai acheté un module (FrSky) afin de passer ma bonne vieille FC18 en 2.4Ghz.
Malheureusement cette modification entraîne le dysfonctionnement des modules "multiswitch" "multiprop" ou "éclairage camion". Il est pourtant possible d'acheter des kits de la marque d'origine de votre radio, ou un kit JETI mais aussi SERVONAUT (et quelques autres aussi), qui eux fonctionnent parfaitement mais qui sont d'un coût assez élevé !!!
1 Version simple
L'éclairage étant indispensable sur un camion, je viens donc de réaliser un kit permettant de commander 8 fonctions a partir d'une simple voie proportionnelle. Il est quasiment compatible avec toutes les radios et facile a adapter aux besoins de chacun, et d'un coût très raisonnable (environ 30€ pour équiper la radio et le véhicule).
L'idée de base n'est pas de moi et je me suis largement inspiré de différentes sources trouvées sur internet. La solution que je vous propose ci dessous est celle que j'ai adaptée pour mon utilisation.
- Côté émetteur
Le but est de créer un tableau de commande comportant 8 boutons poussoirs et quelques résistances pour les raccorder sur une voie proportionnelle de la radio.
Le montage est vraiment très simple puisqu'il est possible de souder les fils et résistances directement sur les poussoirs, il n'est donc pas nécessaire de réaliser un circuit imprimé. Avec une radio de type PUPITRE il suffit d'utiliser les emplacements prévus pour les modules MULTI, alors que pour les autres radios il faudra fabriquer un support. Pour raccorder ce pupitre sur la radio, vous pouvez utiliser un câble récupéré sur un vieux servo qui ne fonctionne plus.
Le principe de ce tableau de commande est tout simplement de simuler une position différente bien précise d'un manche (ici c'est comme si nous avions un manche avec 8 positions).
SI vous utilisez un module son TBS (www.benedini.de) cette méthode vous permettra de piloter jusqu'à 16 fonctions.
- Côté récepteur
il est nécessaire de créer un module de commutation et j'ai choisi pour cela le système ARDUINO qui peut être programmé afin d'obtenir le résultat désiré. D'ailleurs, si l'on raccorde un servo sur la voie utilisée par le multi, on peut observer que celui ci se déplace selon 8 positions distinctes en fonction du poussoir qui est activé. On va téléverser le sketch suivant sur l'ARDUINO afin que celui si soit en mesure de capter les informations transmises par le récepteur.
/*================= Eclairage ========================
Commande 7 fonctions pour un éclairage de camion + 2 fonctions pour le son du camion
======================================================*/
int signal = 0; // Raccorder sur l'INPUT DIGITAL 0 le fil SIGNAL provenant du récepteur
int val1;
int s1 = 1; int s2 = 2; int s3 = 3; int s4 = 4; int s5 = 5; int s6 = 6; int s7 = 7; int s8 = 8; int s9 = 9; int s10 = 10;
int e1 = 0; int e2 = 0; int e3 = 0; int e4 = 0; int e5 = 0; int e6 = 0; int e7 = 0; int e8 = 0; int e9 = 0;
int mini = 1000;
int maxi = 2000;
void setup()
{
pinMode(s1,OUTPUT); pinMode(s2,OUTPUT); pinMode(s3,OUTPUT); pinMode(s4,OUTPUT);
pinMode(s5,OUTPUT); pinMode(s6,OUTPUT); pinMode(s7,OUTPUT); pinMode(s8,OUTPUT);
pinMode(s9,OUTPUT); pinMode(s10,OUTPUT);
}
//==============================================================================================
void loop()
{
val1 = 0;
val1 = pulseIn(signal, HIGH),30000;
val1 = map(val1,mini,maxi,950,2000);
// val1=constrain(val1, 900, 2000);
delay (50);
if (val1 > 2000 || val1 < 980 ) { val1 = 1500; }
//veilleuses ; codes
if (val1 > 1790 && val1 < 1860 && e1 == 0) { e1 = 1; val1 = 0; delay(300);}
if (val1 > 1790 && val1 < 1860 && e1 == 1) { e1 = 2; val1 = 0; delay(300);}
if (val1 > 1790 && val1 < 1860 && e1 == 2) { e1 = 0; e3 = 0; e4 = 0; e5 = 0; val1 = 0; delay(300);}
// demar moteur / arret moteur
if (val1 > 1900 && val1 < 1980 && e2 == 0) { e2 = 1; val1 = 0; delay(300);}
if (val1 > 1900 && val1 < 1980 && e2 == 1) { e2 = 0; val1 = 0; delay(300);}
//phares
if (val1 > 1660 && val1 < 1740 && e3 == 0) { e3 = 1; e5 = 0; val1 = 0; delay(300);}
if (val1 > 1660 && val1 < 1740 && e3 == 1) { e3 = 0; e4 = 0; val1 = 0; delay(300);}
//longues portees
if (val1 > 1560 && val1 < 1640 && e4 == 0 && e3 == 1) { e4 = 1; val1 = 0; delay(300);}
if (val1 > 1560 && val1 < 1640 && e4 == 1) { e4 = 0; val1 = 0; delay(300);}
//antibrouillard
if (val1 > 1360 && val1 < 1440 && e5 == 0 && e3 == 0 && e1 == 2) { e5 = 1; val1 = 0; delay(300);}
if (val1 > 1360 && val1 < 1440 && e5 == 1) { e5 = 0; val1 = 0; delay(300);}
//cligno gauche
if (val1 > 1140 && val1 < 1220 && e6 == 0) { e6 = 1; val1 = 0; delay(300);}
if (val1 > 1140 && val1 < 1220 && e6 == 1) { e6 = 0; val1 = 0; delay(300);}
//cligno droit
if (val1 > 1250 && val1 < 1340 && e7 == 0) { e7 = 1; val1 = 0; delay(300);}
if (val1 > 1250 && val1 < 1340 && e7 == 1) { e7 = 0; val1 = 0; delay(300);}
//KLAXON
if (val1 > 1010 && val1 < 1100) { digitalWrite(s8,HIGH); val1 = 0; delay(300); digitalWrite(s8,LOW);}
if (e1 == 1) { digitalWrite(s1,HIGH); } //veilleuse
if (e1 == 2) { digitalWrite(s1,HIGH); digitalWrite(s9,HIGH); }// code
if (e1 == 0) { digitalWrite(s1,LOW); digitalWrite(s9,LOW); } // arret veilleuse code
if (e2 == 1) { digitalWrite(s2,HIGH); } else { digitalWrite(s2,LOW); } // demarrage arret moteur
if (e3 == 1) { digitalWrite(s3,HIGH); } else { digitalWrite(s3,LOW); } //phares
if (e4 == 1) { digitalWrite(s4,HIGH); } else { digitalWrite(s4,LOW); } // longues portees
if (e5 == 1) { digitalWrite(s5,HIGH); } else { digitalWrite(s5,LOW); } // anti-brouillard
if (e6 == 1) { digitalWrite(s6,HIGH); } else { digitalWrite(s6,LOW); } // cligno Gauche
if (e7 == 1) { digitalWrite(s7,HIGH); } else { digitalWrite(s7,LOW); } // cligno droit
}
//============================ FIN DU PROGRAMME =================================================
En modifiant ce code il est possible de faire des tonnes de choses, et ainsi de l'adapter pour les besoins de chacun. Dans cet exemple, On obtient ainsi le comportement suivant :
- Bouton 1 => Veilleuses => les veilleuses restent allumées et les feux de croisements s'allument => arrêt des veilleuses et des feux de croisement
- Bouton 2 => Son de démarrage moteur => Son d'arrêt du moteur
- Bouton 3 => Les phares s'allument => les phares s'éteignent
- Bouton 4 => Les longues portées s'allument seulement si les phares sont actifs => Les longues portées s'éteignent
- Bouton 5=> Les anti-brouillard s'allument seulement si les feux de croisement sont actifs et si les phares sont éteint => Les anti-brouillard s'éteignent
- Bouton 6 =>Les clignotant gauche s'allument => Les clignotant gauche s'éteignent
- Bouton 7 => Les clignotant droite s'allument => Les clignotant droite s'éteignent
- Bouton 8 => coup de klaxon
2 - Version spécifique USM
Dans mes véhicules, j'utilise maintenant le module USM-RC2 (de la marque BEIER) pour gérer l'éclairage et le son.
J'ai donc créé un module multifonctions qui est spécifiquement adapté à la commande EKMFA de l'USM, et me permet de transmettre 9 commandes sur une seule voie. Je pourrais en transmettre plus (le mode EKMFA peut recevoir jusque 30 commandes) mais je n'en ai pas besoin.
- Principe du mode EKMFA
Ce mode est assez simple et impose certaines limitations, néanmoins il permet de commander presque toutes les fonctions sur une seule voie.
Il compte le nombre d'impulsions envoyées afin d'activer la fonction correspondant.
Même s'il est facile d'utiliser ce mode avec un simple manche sur la radio (ou un switch 3 positions), cela devient vite galère quand il faut compter plus de 3 impulsions, sachant qu'il faut aussi retenir a quelle fonction correspond chaque nombre d'impulsions.
- Côté émetteur
Il y a un gros travail de câblage a réaliser sur cette version car il est nécessaire de raccorder chaque switch sur des entrées de l'arduino, mais il faut aussi lui donner une alimentation, sans oublier de mettre deux opto-coupleurs sur deux sorties de ce même arduino.
Le sketch suivant transmettre un certain nombre d'impulsions en fonction du switch activé.
/*================= TDB USM ========================
Commande 10 fonctions pour piloter un USM-RC2
======================================================*/
int pinplus = 10; // position D
int pinmoins = 11; //position A
#define E1_PIN 2 // gyro
#define E2_PIN 3 // phares
#define E3_PIN 4 //cligno d
#define E4_PIN 5 // cligno g
#define E5_PIN 6 // veilleuses
#define E6_PIN 7 // detresse
#define E7_PIN 8 // klaxon
#define E8_PIN 9 //demarreur
#define E9_PIN 12 //anti brouillard
#define E10_PIN 13 //option
#define NBR_ENTREES 10
uint8_t IdxToPin[NBR_ENTREES] ={ E1_PIN, E2_PIN, E3_PIN, E4_PIN, E5_PIN, E6_PIN, E7_PIN, E8_PIN, E9_PIN, E10_PIN };
int cmd;
void setup()
{
uint8_t Idx;
for(Idx = 0;Idx < NBR_ENTREES;Idx++)
{
pinMode(IdxToPin[Idx], INPUT);
digitalWrite(IdxToPin[Idx], HIGH); /* Activation des pull-ups internes */
}
pinMode(pinplus, OUTPUT);
pinMode(pinmoins, OUTPUT);
}
void loop()
{
uint8_t Idx;
for(Idx = 0;Idx < NBR_ENTREES;Idx++)
{
if(digitalRead(IdxToPin[Idx]))
{
cmd = 0;
} else {
cmd = Idx+1;
switch (cmd) { // on faite un test de la valeur de cet octet
case 1 :
impuls(pinmoins,4);
break;
case 2 :
impuls(pinplus,2);
break;
case 3 :
impuls(pinplus,1);
break;
case 4 :
impuls(pinmoins,1);
break;
case 5 :
impuls(pinmoins,2);
break;
case 6 :
impuls(pinmoins,5);
break;
case 7 :
impuls(pinplus,3);
break;
case 8 :
impuls(pinmoins,3);
break;
case 9 :
impuls(pinplus,4);
break;
case 10 :
impuls(pinplus,5);
break;
default:
cmd=0;
}
}
}
delay(20);
}
void impuls(int x,int y)
{
uint8_t Idx;
for(Idx = 0;Idx < y;Idx++)
{
digitalWrite(x, HIGH);
delay(50);
digitalWrite(x, LOW);
delay(50);
}
delay(250);
}
- Côté récepteur
Là, c'est très simple puisque c'est l'USM qui décode lui même les commandes. Il suffit donc de raccorder le récepteur avec l'USM, et le tour est joué. Attention de ne pas avoir oublié de configurer correctement l'USM.
Voici la configuration qui correspond au sketch précédent :
3 - CTI PS4o et PS4u
Ces deux modules de la marque CTI fonctionnent de la même manière que le mode EKMFA de l'USM, en comptant les impulsions sur une voie. chaque module, pilote quatre commandes, ce qui fait 8 commandes si vous mettez les deux modules sur la même voie du récepteur.
/*================= TDB CTI ========================
Commande 8 fonctions pour piloter PS4u et PS4o
======================================================*/
int pinplus = 10; // position D
int pinmoins = 11; //position A
#define E1_PIN 2 // gyro
#define E2_PIN 3 // phares
#define E3_PIN 4 //cligno d
#define E4_PIN 5 // cligno g
#define E5_PIN 6 // veilleuses
#define E6_PIN 7 // detresse
#define E7_PIN 12 //anti brouillard
#define E8_PIN 13 //anti brouillard
#define NBR_ENTREES 8
uint8_t IdxToPin[NBR_ENTREES] ={ E1_PIN, E2_PIN, E3_PIN, E4_PIN, E5_PIN, E6_PIN, E7_PI, E8_PINN };
int cmd;
void setup()
{
uint8_t Idx;
for(Idx = 0;Idx ; NBR_ENTREES;Idx++)
{
pinMode(IdxToPin[Idx], INPUT);
digitalWrite(IdxToPin[Idx], HIGH); /* Activation des pull-ups internes */
}
pinMode(pinplus, OUTPUT);
pinMode(pinmoins, OUTPUT);
}
void loop()
{
uint8_t Idx;
for(Idx = 0;Idx < NBR_ENTREES;Idx++)
{
if(digitalRead(IdxToPin[Idx]))
{
cmd = 0;
} else {
cmd = Idx+1;
switch (cmd) { // on faite un test de la valeur de cet octet
case 1 :
impuls(pinmoins,4);
break;
case 2 :
impuls(pinplus,2);
break;
case 3 :
impuls(pinplus,1);
break;
case 4 :
impuls(pinmoins,1);
break;
case 5 :
impuls(pinmoins,2);
break;
case 6 :
impuls(pinmoins,3);
break;
case 7 :
impuls(pinplus,3);
break;
case 8 :
impuls(pinplus,4);
break;
default:
cmd=0;
}
}
}
delay(20);
}
void impuls(int x,int y)
{
uint8_t Idx;
for(Idx = 0;Idx < y;Idx++)
{
digitalWrite(x, HIGH);
delay(50);
digitalWrite(x, LOW);
delay(50);
}
delay(250);
}