Recepteur commande d'aiguille sans fil

Récepteur commande d'aiguille sans fil

Voici la suite de l'article sur la commande sans fil des aiguilles. Nous allons détailler, autant que possible avec des explications, chaque étapes de la réalisation de ce récepteur qui vous surprendra par son efficacité.

Principe du récepteur de la commande d'aiguilles

Le schéma bloc de principe du récepteur qui commande les aiguilles est illustré ci-après:

Figure 1

Le principe est assez simple et il se base sur la réutilisation du module de commande des trains en y ajoutant la sélection des sorties (les moteurs d'aiguille) par des relais. Le module réutilisé est composé d'une partie radio pour la réception des commandes envoyées par la mini-commande, d'une partie traitement qui abrite le programme qui pilote les entrées/sorties, un module de puissance.

Les composants nécessaires sont principalement les mêmes que pour le récepteur de la commande de train sauf les relais qui ont été ajoutés pour la sélection du moteur d'aiguilles. La figure ci-dessous montre, de haut en bas, le régulateur de tension, l'Arduino, la radio, l'amplificateur, le module 8 relais.

Figure 2

On va retrouver l'Arduino Nano, qui est est particulièrement intéressant car il est bien pourvu en entrée/sorties permettant la commande de la partie radio, amplificateur de puissance et des relais.

Cette version d'Arduino a des avantages certains car elle possède une liaison USB et aussi une interface de programmation.

Cette interface de programmation va nous être très utile pour télécharger rapidement (quelques secondes) le programme du PC dans la mémoire du Arduino.

Quant à la liaison USB c'est une liaison série qui servira pour visualiser les affichages pour vérifier le bon fonctionnement du programme.

Le petit module radio est identique à celui de l’émetteur.

L'amplificateur possède deux sorties. Nous n'aurons besoin que d'une seule de ces sorties pour la commande des aiguilles car celle-ci sera séquentielle. Comme sur les installations ferroviaires réelles, la commande des aiguilles se fait en décalé.  

La seconde sortie sera réservée soit pour une extension de commande des relais, soit pour commander un train.

Le petit régulateur est indispensable car l'Arduino et surtout la radio fonctionnent en 3.3V

Ci-dessous le schéma détaillé de la partie réutilisée du récepteur:

Figure 3

Un second régulateur 5V sera ajouté pour l'alimentation de la partie commande des relais.

Enfin, la nouveauté est le module des relais. Nous avons pris un module de 8 relais en prévision de futures évolutions. Il existe des modules 4 relais qui peuvent très bien convenir (et réduire un peu le coût du récepteur). 

Ci-dessous le schéma détaillé de la connexion avec l'amplificateur et le module 8 relais:

Figure 4

Réalisation

La réalisation commence par le montage du module de réception (donc sans les relais) dont les étapes sont bien détaillées sur la page dédiée (cliquer ici) 

Toujours respecter les consignes  suivantes pour éviter les problèmes:

- Bien régler le régulateur à 3.3V avant de connecter l'alimentation à la radio

- Enlever le composant sur l'Arduino pour désactiver l'alimentation à partir de la prise USB

- Suivre le schéma de câblage et prendre des fils de couleur pour faciliter la vérification

- Vérifier toutes les connexions avec un testeur de continuité

 Une fois cette première partie terminée, procéder à une mise sous tension pour vérifier que les LED du Arduino et de l'amplificateur s'allument.

Vérifiez les tensions d'alimentation pour le 3.3V.

Il est temps de passer à la réalisation de la seconde partie. Les opérations suivantes sont à faire:

 - Placer un régulateur 5V avec un petit radiateur (figure 5)

 - Câbler le module relais suivant la figure 4

Figure 5

Un point particulièrement important pour le module relais est d'enlever le cavalier (en bleu sur la photo) pour permettre d'alimenter le module via le +5V. Pour cela il suffit de relier la broche en bas au +5V.

Figure 6

Le programme

Après avoir réalisé la première partie pratique, il reste à passer à la partie programmation.
Le programme du récepteur de la commande d'aiguille est réalisé en langage C et il est structuré par un programme principal appelé le main.c. Ce programme fait appel à des bibliothèques permettant de piloter la radio et la liaison série.

Le principe consiste à réceptionner un paquet de la radio. Une fois vérifié que le paquet est valide, on en extrait le numéro de l'aiguille. Puis on active le relais par le port C et envoie une impulsion avec l'amplificateur par le port D pendant un temps donné (0.5 seconde). Le relais est ensuite désactivé.

Les impulsions sont soit positives +12V (signal IN1 de l'amplificateur actif), soit négatives -12V (signal IN2 de  l'amplificateur actif).

Cela est fait indéfiniment (boucle sans fin).

Afin de pouvoir vérifier le bon fonctionnement, le programme envoie sur la liaison série des informations telles que:

Nano Station : Indique que le programme a démarré
Radio OK : Indique que la radio fonctionne
T : Indique que la réception est en attente d'un paquet

R : Indique que le récepteur reçoit des paquets valides

Analog : Indique que l'on est en mode analogique (réservé pour un usage futur)

A à H : Indique l'activation, désactivation des relais et envoi de l'impulsion de commande du moteur d'aiguille

Pour mieux comprendre le programme, sans pour autant vous noyer dans les instructions et syntaxe du langage C, nous vous proposons de survoler les principales instructions réalisées. 

// Programme de commandes de Aiguilles
// Version 1.1 - Jan 2018
// F. LORRAIN - E. ZANDER
//
// 1 sortie ampli pour la commande des aiguilles

// Bibliothèques
#include "elcheapo_remote.h"
#include "organizer.h"
#include "timer0.h"
#include "dcc_timer.h"
#include "hal_nrf_reg.h"
#include "hal_nrf.h"
#include "radio.h"
#include "HardwareSerial.h"

// Variables globales
int16_t adc_value;
uint8_t radio_data[RF_PAYLOAD_LENGTH];
tmode mode;
uint8_t Aig1_pos = 0;
uint8_t Aig2_pos = 0;
uint8_t Aig3_pos = 0;
uint8_t Aig4_pos = 0;

//Constantes
#define POINT_MORT_MARGIN 16
// Réinitialise radio après n secondes
#define MAX_TIMEOUTS 5

int main(void) {
    uint8_t status;
    uint8_t count;
    uint16_t speed;
    uint8_t aig = 0;
    uint8_t Aig1 = 0;
    uint8_t Aig2 = 0;
    uint8_t Aig3 = 0;
    uint8_t Aig4 = 0;
    uint16_t tempo_relais = 500; //0.5 seconde

    // Configuration des ports
    // Les sorties I/O sont mises à 1, les entrées sont à no pull-up
    // Désactive le comparateur pour les analogiques
    // Désactive la fonction entrée digital des entrées ADC (PORTC)
    // Ne désactive pas la fonction digitale sur PD6/PD7
    // Initialise les relais
    // Initialisation de la liaison série
    // Autorise les interruptions
    // Signe de vie du récepteur
    Serial.println();
    Serial.println(F("Nano Station"));

    // Radio active en réception
   // Si le bit de poids fort est à 0 alors il y a un problème ... de câblage
   // Chip Enable (CE) pin niveau haut pour activer le récepteur

    // Détection du mode analogique ou digital
    while (1) {
         // Réception du paquet radio
        if (status == OK) {
            Serial.write('R');
            if (radio_data[0]==2) {
                mode = analog;
                break;
            }
        } else { // Timeout sur réception radio paquet, réinitialise la radio
            if (check_radio_timeout()) { // Réinitialise radio si rien reçu après 5 sec...
                Serial.write('T');
               // Chip Enable (CE) pin niveau haut pour activer le récepteur
            }
        };
    }

    // analogique
    Serial.println(F("Analog"));

    //Initialise la commande Ampli
    //Test relais
    // Traitement du contenu des paquets radio
    while (1) {
        status = radio_get_packet(radio_data, &count);
        if (status == OK ) {
            set_radio_timeout(1000/4);
            switch (radio_data[0]) {

            case 1:
           // Réservé
            break;

            case 2:
                // Cas paquet single remote
                // Commande des aiguilles
                aig = radio_data[2];
                Aig1 = (aig & 0x10);
                // Aiguille 1 dans position 1
                if ((Aig1 == 0) & (Aig1_pos == 0)){
                    // Commande relais aiguille 1 PORTC A0
                    Serial.write('A');
                    // Envoi du pulse positif de la commande signal IN1 avec le enable à  1,
                    // Temporisation
                    // IN1 avec enable à  0
                    // Désactive relais
                    // Mémorise la position de l'aiguille
                    Aig1_pos = 1;
                }
                // Aiguille 1 dans position 2
                if ((Aig1 != 0) & (Aig1_pos == 1)){
                    // Commande aiguille 1 PORTC A0
                    Serial.write('B');
                    // Envoi du pulse négatif de la commande
                    // Désactive relais 
                    // Mémorise la position de l'aiguille
                    Aig1_pos = 0;
                }
                // Aiguille 2 dans position 1
                Aig2 = (aig &0x20);
                if ((Aig2 == 0)& (Aig2_pos == 0)) {
                    // Commande aiguille 2 PORTC A1
                    Serial.write('C');
                    // Envoi du pulse positif de la commande signal IN1 avec le enable à  1,
                    // Temporisation
                    // IN1 avec enable à  0
                    // Désactive relais
                    // Mémorise la position de l'aiguille
                    Aig2_pos = 1;
                }
                // Aiguille 2 dans position 2
                if ((Aig2 != 0)&(Aig2_pos == 1)) {
                    // Commande aiguille 2 PORTC A1
                    Serial.write('D');
                   // Envoi du pulse négatif de la commande
                    // Désactive relais 
                    // Mémorise la position de l'aiguille
                    Aig2_pos = 0;
                }
                // Aiguille 3 dans position 1
                Aig3 = (aig & 0x40);
                if ((Aig3 == 0)&(Aig3_pos == 0)) {
                    Serial.write('E');
                    // Commande aiguille 3 PORTC A2                    
                    // Envoi du pulse positif de la commande signal IN1 avec le enable à  1,
                    // Temporisation
                    // IN1 avec enable à  0
                    // Désactive relais
                    // Mémorise la position de l'aiguille
                    Aig3_pos = 1;
                }
                // Aiguille 2 dans position 2
                if ((Aig3 != 0) & (Aig3_pos == 1)) {
                    Serial.write('F');
                    // Commande aiguille 3 PORTC A2 
                    // Envoi du pulse négatif de la commande
                    // Désactive relais 
                    // Mémorise la position de l'aiguille
                    Aig3_pos = 0;
                }
                Aig4 = (aig & 0x80);
                // Aiguille 4 dans position 1
                if ((Aig4 == 0)& (Aig4_pos == 0)) {
                    Serial.write('G');
                    // Commande aiguille 4 PORTC A3                    
                    // Envoi du pulse positif de la commande signal IN1 avec le enable à  1,
                    // Temporisation
                    // IN1 avec enable à  0
                    // Désactive relais
                    // Mémorise la position de l'aiguille
                    Aig4_pos = 1;
                }
                // Aiguille 4 dans position 2
                if ((Aig4 != 0)& (Aig4_pos == 1)) {
                    Serial.write('H');
                    // Commande aiguille 4 PORTC A3                    
                    // Envoi du pulse négatif de la commande
                    // Désactive relais 
                    // Mémorise la position de l'aiguille
                    Aig4_pos = 0;
                }
                break;
            default:
                break;
            }
        } else { // pas de paquet radio
            if (check_radio_timeout()) { // Réinitialise la radio si rien reçu après 1 sec...
                Serial.write('T');
                 //Chip Enable (CE) pin niveau haut pour activer le récepteur
                // Pas de paquet reçu pendant 1 sec - met à OFF les sorties
            }
        };
    } // While
}

Nous nous sommes réservé une sortie de l'ampli (signaux IN3 et IN4) au cas où l'on voudrait une autre application pour la suite (commander un train ou commander une autre série de relais).

Le code source de ce programme sera mis à disposition sur une page dédiée.

Une fois écrit, ce code est compilé et un fichier .elf est généré afin de pouvoir

le télécharger sur l'Arduino Nano.

Téléchargement du programme

Pour télécharger le fichier .elf sur le Arduino, il est nécessaire d'avoir un adaptateur USBASP.
L’USBASP est un programmateur « in circuit » pour les microcontrôleurs AVR (notamment la famille Arduino 8bits). Pour quelques euros, ceci permet de connecter le port USB du PC au connecteur de programmation de l'Arduino.

ATTENTION, bien choisir un adaptateur qui accepte le 3.3V et le configurer en conséquence. 
Lorsque la radio est connectée, celle-ci n'accepte que du 3.3V. Sinon on peut la détruire avec le 5V.

L'environnement dans lequel est développé le programme est LINUX et plus particulièrement ECLIPSE. Il est nécessaire d'installer le compilateur, éditeur de liens, module de téléchargement pour travailler sur le programme et pour le mettre au point. Cette opération nécessite quelques compétences et de la patience. Néanmoins il est possible de se limiter au téléchargement du programme en utilisant AVRDUDE sous LINUX ou BITBURNER sous WINDOWS.

Utilisez la commande suivante pour charger le programme:
avrdude -c usbasp -P usb -p m328p -U f:w:NanoStation-aig.elf
 

Tests préliminaires

Les tests à réaliser sont relativement simples. 

La première chose est de s'assurer que la réception est bonne. Pour cela vous pouvez utiliser la liaison série (via un câble USB) à connecter directement sur l'Arduino et à relier à votre PC. Cette liaison affichera sur l'écran des informations permettant de vérifier la réception et l'envoi des commandes au module des relais.

Un affichage typique sera le suivant:

Nano Station
Radio OK
TRRRRRRRRRRRRRRRRRRRRAnalog
ABCDEFGH
TTTTTTTTTTTTTTTT

Ce qui correspond à :

Nano Station démarrée
la radio fonctionne
T : Indique que la réception est en attente d'un paquet

R : Indique que le récepteur reçoit des paquets valides

Analog : Indique que l'on est en mode analogique (réservé pour un usage futur)

A: activation du premier relais Aiguille 1, envoi de l'impulsion positive de commande du moteur d'aiguille, désactivation du premier relais Aiguille 1
B: activation du premier relais Aiguille 1, envoi de l'impulsion négative de commande du moteur d'aiguille, désactivation du premier relais Aiguille 1

C: activation du second relais Aiguille 2, envoi de l'impulsion positive de commande du moteur d'aiguille, désactivation du second relais Aiguille 2
D: activation du second relais Aiguille 2, envoi de l'impulsion négative de commande du moteur d'aiguille, désactivation du second relais Aiguille2

E: activation du troisième relais Aiguille 3, envoi de l'impulsion positive de commande du moteur d'aiguille, désactivation du troisième relais Aiguille 3
F: activation du troisième relais Aiguille 3, envoi de l'impulsion négative de commande du moteur d'aiguille, désactivation du troisième relais Aiguille 3

G: activation du quatrième relais Aiguille 4, envoi de l'impulsion positive de commande du moteur d'aiguille, désactivation du quatrième relais Aiguille 4
H: activation du quatrième relais Aiguille 4, envoi de l'impulsion négative de commande du moteur d'aiguille, désactivation du quatrième relais Aiguille 4

T : Indique que la réception est en attente d'un paquet (On a coupé l'émetteur radio)

A noter que si l'on rallume l'émetteur radio, on peut envoyer à nouveau des commandes. Le récepteur attend simplement de recevoir des paquets valides à nouveau.

Ci-dessous une illustration de la connexion avec la liaison série.

Figure 7

Une fois cette vérification effectuée alors vous pouvez connecter des moteurs d'aiguilles pour faire un test complet.

Veuillez bien à prendre une alimentation pouvant délivrer au moins 0.5 A car les moteurs d'aiguilles consomment quand même un peu.

Figure 8

Une vidéo vaut mieux qu'un long discours alors cliquez ici

Mise en boitier du récepteur

Votre récepteur fonctionne bien et il faut désormais à le protéger en le mettant en boitier. 

Les dimensions du boitier que je vous recommande sont les suivantes: 185 x 125 x 65 mm

Ce boitier a les faces latérales amovibles. Ceci facilitera la mise en place des connecteurs pour les moteurs d'aiguilles (voir figures 9 et 10). Espacer les bornes de 20 mm et positionner à 25 mm du bord.

Figures 9 et 10

Ci-après un détail de la connexion aux bornes vu de l'intérieur du boîtier. Les fils sont soudés sur les œillets. Au total, prévoir 4 bornes rouges et 4 bornes noires de 4 mm de diamètres pour les connexions aux moteurs d'aiguille, 1 borne noire et 1 jaune pour l'alimentation du récepteur.

Figure 11

Le placement des éléments du récepteur est fait en les fixant sur une plaque plastique elle-même vissée sur le fond du boîtier. Ainsi le module relais est fixé par deux vis directement sur la plaque plastique (plus facile à enlever). Le module Arduino-radio et ampli et maintenu par emboitement dans un logement découpé dans la carte plastique (le radiateur vient simplement dans le logement).

Une fois l'ensemble monté vous obtiendriez le résultat ci-dessous:

Figure 12

Il ne restera plus qu'à ajouter un interrupteur pour le marche/arrêt du récepteur et bien repérer les sorties pour les aiguilles ainsi que les bornes d'alimentation.

Figure 13

Tests avec aiguilles

 Les tests avec une véritable aiguille peuvent enfin commencer. Il y a quelques opérations de base à effectuer pour un résultât optimal. 

Ne reliez pas les câbles au moteur d'aiguille.

Le moteur doit être correctement positionné par rapport à la tringle de manœuvre de l'aiguille. 

Relier la tringle de manœuvre de l'aiguille à la partie mobile du moteur. 

Vérifier que le calage de l'aiguille est bon dans les deux positions (manœuvrer doucement à la main).

Nettoyer à l'essence type F la partie plate sur laquelle se déplace la lame d'aiguille.

Puis faire un graissage avec de l'huile pour mécanique fine et effectuer quelques manœuvres.

Vous pouvez relier les câbles au moteur d'aiguille. Mettez en marche le récepteur puis l'émetteur.

Au démarrage du récepteur, vous entendrez les relais commuter. Il s'agit d'un autotest sans commande des moteurs (pas de risque de fausse manœuvre).

 

Avec la télécommande basculer l'interrupteur et vérifier si l'aiguille se déplace. Si ce n'est pas le cas alors basculer l'interrupteur dans la position inverse. Notez bien la position sur votre télécommande.

Ci-dessous, des illustrations de l'aiguille en voie directe puis en voie déviée (à droite par rapport à la pointe d'aiguille). 

 Figure 14

Figure 15

En vous souhaitant une bonne réalisation et d'obtenir une belle commande que vous aurez fait vous-même. Quant à moi j'attends les beaux jours pour monter cela dans mon jardin et vous donne rendez-vous pour de nouveaux articles.