Décodeur avec une carte Arduino pour moteur CONRAD

[Bernyca]

Bonjour,
Depuis un certain temps, j'essaie de fabriquer un décodeur d'accessoires avec une carte Arduino UNO pour commander 8 ou 16 aiguillages avec des moteurs Conrad.
Le moteur Conrad est alimenté en 16 volt AC puis transformé en DC par 2 diodes qui inverse le sens de marche du moteur.
En outre le moteur Conrad est équipé de contacts de fin de course qui arrête l'alimentation automatiquement.
On peut donc lui envoyer un signal permanent sur l'une ou l'autre de ses entrées. (Marche avant/marche arrière)
Je voudrais commander chaque moteur Conrad par "un signal ON ou OFF provenant d'une seule pin de la carte Arduino" qui va commander un relais inverseur.
Cet inverseur va envoyé le courant sur l'une ou l'autre entrées du moteur Conrad. "Selon la position du relais ON ou OFF.
J'ai trouvé beaucoup de programme qui utilise 2 sorties Arduino par commande d'aiguillage.

Je cherche donc un programme Arduino qui va recevoir les commandes DCC de la centrale sur la pin 2 et qui va simplement utiliser une seul pin de sortie en ON ou OFF (Pas en impultion) pour commander chaque relais qui va envoyer le signal sur chaque moteurs Conrad.

Quelqu'un aurait-il un tel programme?
Je suis encore trop débutant pour l'écrire moi-même.
Je joint un shema pour mieux comprendre.

Merci bien.
Bernyca

[BrutDePomme]

Bonjour Bernyca,

Je n'ai pas de programme tout fait pour répondre à ton problème.
Je pense que tu peux trouver des éléments de réponse sur le site LOCODUINO.
Le lien pointe sur un exemple d'utilisation de l'Arduino avec des aiguillages.

Bonjour chez vous,

Brut de Pomme

[Bernyca]

Bonjour Brut de pomme,
Merci pour ta réponse.
J'ai déjà fouillé sur le site Locoduino pour un programme de décodeur d'accessoire mais ce sont souvent des programmes prévus pour des servo-moteurs et je ne trouve pas de programme pour simple commande ON ou Off sur chaque Pin de sortie Arduino.
Bien à toi,
Bernyca

[Petitrain]

Bonjour Bernyca,

Si je comprend ton problème, tu as besoin d' adaptater un programme pour actionner des relais avec une seule broche de sortie de l'Arduino.
Le plus dur, à mon avis, dans ton projet, c'est de décrypter les paquets DCC que tu vas recevoir en entrée de l'Arduino. Si cette partie est acquise, le reste est assez simple :
-tu fais un test conditionnel sur la variable reçue avec un if() et tu fais un
digitalWrite( broche du relai, HIGH);pour une position du moteur conrad et
digitalWrite(broche du relai,LOW); pour l'autre position.
Mais c'est le moteur Conrad qui gère tout( la vitesse, les fins de courses,le coeur d'aiguille). J'avais fait ça avant, mais j'ai grillé quelques moteurs, des fois, les fins de courses ne marchaient pas et le moteur se grille facilement.
Je suis passé maintenant à des servos et c'est l'Arduino qui gère le tout.
Si tu as des difficultés à adapter ton sketch, mets le en pièce jointe, je pourrais essayer de t'aider.

[Bernyca]

Oui, c'est bien cela que je veux faire.
Tes conseils vont m'aider pour la procédure à suivre mais je dois encore faire des progrès dans la programation en Arduino!
Je vais encore glaner quelques exemples ici et là et je vais essayer.
J'espère que mes moteurs ne vont pas griller

Bonne soirée.
Bernnyca

[Petitrain]

Pour les moteurs, il faut bien vérifier qu'ils ne restent pas branchés....
Pour le code, si tu pars sur le code que tu as mis sur l'autre post, tu vas avoir beaucoup de mal à le modifier, le sketch est dur à comprendre pour quelqu'un qui débute avec la programmation.
En cherchant un peu sur internet cet après-midi, j'ai trouvé ça :http://www.train35.fr/dcc18.html#Ancre9 va voir si cela correspond a ce que tu veux faire, on peut essayer de monter le code ensemble.
Je pense qu'il vaut mieux réfléchir et écrire son code, que d'essayer de modifier le code de quelqu'un d'autre....
As-tu déja pu capter les trames DCC sur ton Arduino?
Tu pourrais aussi essayer de faire fonctionner un moteur Conrad avec un relai branché sur l'Arduino. Pour la commande, tu peux monter un simple bouton ou même un fil que tu met au +5v ou à la masse : tu as ainsi deux états pour ton entrée : HIGH et LOW.
et comme dit plus haut, 2 tests if(...){......;}
A+

[Bernyca]

Super, j'ai récupéré le code Arduino qui est bien plus simple sur le site que Petitrain m'as indiqué et je l'ai transformé par essais et erreurs.
J'ai enlevé 1 ligne sur 2 et rendu la sortie ON ou off en permanence .
J'ai ensuite rajouté le même code pour les 17 sorties possibles de l'Arduino uno.
Chaque Pin de sortie est envoyée à un relais inverseur.
Une alimentation 14 volt AC attaque le contact central de l'inverseur et les contacts latéraux attaquent les diodes inversées sur les entrées marche avant/arrière du moteur Conrad.
Je l'ai testé avec un relais et un moteur Conrad et c'est OK.
Je suis stupéfait moi-même que cela fonctionne car je ne suis pas un spécialiste du Arduino.
Il y a surement encore moyen d'améliorer mais je suis déjà bien content.

Merci bien à Brut de pomme de m'avoir encouragé et à Petitrain pour le lien adéquat qu'il m'a envoyé.

J'ai fait une petite Vidéo visible sur ma Dropbox:
https://www.dropbox.com/s/fhmwzw6115bba ... s.mov?dl=0

Voici le code transformé:

Décodeur DCC sur Arduino UNO pour Commander 17 aiguillages avec moteur Conrad

_______________________________________________________________
#include <NmraDcc.h>




NmraDcc Dcc ;
DCC_MSG Packet ;

int pinf3 = 3;
int pinf4 = 4;
int pinf5 = 5;
int pinf6 = 6;
int pinf7 = 7;
int pinf8 = 8;
int pinf9 = 9;
int pinf10 = 10;
int pinf11 = 11;
int pinf12 = 12;
int pinf13 = 13;
int pinf14 = A0;
int pinf15 = A1;
int pinf16 = A2;
int pinf17 = A3;
int pinf18 = A4;
int pinf19 = A5;


// This function is called whenever a normal DCC Turnout Packet is received
void notifyDccAccState( uint16_t Addr, uint16_t BoardAddr, uint8_t OutputAddr, uint8_t State)
{
Serial.print("notifyDccAccState: ") ;
Serial.print(Addr,DEC) ;
Serial.print(',');
Serial.print(BoardAddr,DEC) ;
Serial.print(',');
Serial.print(OutputAddr,DEC) ;
Serial.print(',');
Serial.println(State, DEC) ;
// commande des accessoires de numéros 1 à 4
if (Addr==1 && OutputAddr==0 && State==8 ) digitalWrite(pinf3, HIGH);

if (Addr==1 && OutputAddr==1 && State==8 ) digitalWrite(pinf3, LOW);

if (Addr==2 && OutputAddr==2 && State==8 ) digitalWrite(pinf4, HIGH);

if (Addr==2 && OutputAddr==3 && State==8 ) digitalWrite(pinf4, LOW);

if (Addr==3 && OutputAddr==4 && State==8 ) digitalWrite(pinf5, HIGH);

if (Addr==3 && OutputAddr==5 && State==8 ) digitalWrite(pinf5, LOW);

if (Addr==4 && OutputAddr==6 && State==8 ) digitalWrite(pinf6, HIGH);

if (Addr==4 && OutputAddr==7 && State==8 ) digitalWrite(pinf6, LOW);

// (Ajout de Bernyca) commande des accessoires de numéros 5 à 17

if (Addr==5 && OutputAddr==0 && State==8 ) digitalWrite(pinf7, HIGH);

if (Addr==5 && OutputAddr==1 && State==8 ) digitalWrite(pinf7, LOW);

if (Addr==6 && OutputAddr==2 && State==8 ) digitalWrite(pinf8, HIGH);

if (Addr==6 && OutputAddr==3 && State==8 ) digitalWrite(pinf8, LOW);

if (Addr==7 && OutputAddr==4 && State==8 ) digitalWrite(pinf9, HIGH);

if (Addr==7 && OutputAddr==5 && State==8 ) digitalWrite(pinf9, LOW);

if (Addr==8 && OutputAddr==6 && State==8 ) digitalWrite(pinf10, HIGH);

if (Addr==8 && OutputAddr==7 && State==8 ) digitalWrite(pinf10, LOW);


if (Addr==9 && OutputAddr==0 && State==8 ) digitalWrite(pinf11, HIGH);

if (Addr==9 && OutputAddr==1 && State==8 ) digitalWrite(pinf11, LOW);

if (Addr==10 && OutputAddr==2 && State==8 ) digitalWrite(pinf12, HIGH);

if (Addr==10 && OutputAddr==3 && State==8 ) digitalWrite(pinf12, LOW);

if (Addr==11 && OutputAddr==4 && State==8 ) digitalWrite(pinf13, HIGH);

if (Addr==11 && OutputAddr==5 && State==8 ) digitalWrite(pinf13, LOW);

if (Addr==12 && OutputAddr==6 && State==8 ) digitalWrite(pinf14, HIGH);

if (Addr==12 && OutputAddr==7 && State==8 ) digitalWrite(pinf14, LOW);


if (Addr==13 && OutputAddr==0 && State==8 ) digitalWrite(pinf15, HIGH);

if (Addr==13 && OutputAddr==1 && State==8 ) digitalWrite(pinf15, LOW);

if (Addr==14 && OutputAddr==2 && State==8 ) digitalWrite(pinf16, HIGH);

if (Addr==14 && OutputAddr==3 && State==8 ) digitalWrite(pinf16, LOW);

if (Addr==15 && OutputAddr==4 && State==8 ) digitalWrite(pinf17, HIGH);

if (Addr==15 && OutputAddr==5 && State==8 ) digitalWrite(pinf17, LOW);

if (Addr==16 && OutputAddr==6 && State==8 ) digitalWrite(pinf18, HIGH);

if (Addr==16 && OutputAddr==7 && State==8 ) digitalWrite(pinf18, LOW);


if (Addr==17 && OutputAddr==0 && State==8 ) digitalWrite(pinf19, HIGH);

if (Addr==17 && OutputAddr==1 && State==8 ) digitalWrite(pinf19, LOW);

}

void setup()
{
Serial.begin(9600);

pinMode(pinf3, OUTPUT);
pinMode(pinf4, OUTPUT);
pinMode(pinf5, OUTPUT);
pinMode(pinf6, OUTPUT);
pinMode(pinf7, OUTPUT);
pinMode(pinf8, OUTPUT);
pinMode(pinf9, OUTPUT);
pinMode(pinf10, OUTPUT);
pinMode(pinf11, OUTPUT);
pinMode(pinf12, OUTPUT);
pinMode(pinf13, OUTPUT);
pinMode(pinf14, OUTPUT);
pinMode(pinf15, OUTPUT);
pinMode(pinf16, OUTPUT);
pinMode(pinf17, OUTPUT);
pinMode(pinf18, OUTPUT);
pinMode(pinf19, OUTPUT);

Serial.println("NMRA DCC Example 1");
// Call the main DCC Init function to enable the DCC Receiver
Dcc.init( MAN_ID_DIY, 10, FLAGS_OUTPUT_ADDRESS_MODE | FLAGS_DCC_ACCESSORY_DECODER | FLAGS_ENABLE_INT0_PULL_UP, 0 );
Serial.println("Init Done");
}

void loop()
{

Dcc.process();


}
________________________________________________________

Bernyca

[Petitrain]

Bravo Bernyca, belle réalisation.
Il n'y a plus qu'à faire un beau tuto et le proposer à LOCODUINO pour qu'il le mette en ligne, il y a beaucoup de modélistes qui demandent de l'aide pour les moteurs Conrad. (je plaisante, mais, bon....)
La vidéo aussi est très bien.

[Bernyca]

Merci

[Bernyca]

Voici le shema et le premier prototype de la carte qui transforme le signal DCC provenant de la centrale pour l'envoyer sur la pin 2 de l'Arduino.

Bernyca