En cherchant sur internet sur de nombreux sites (voir article précédent) j’ai finalement choisi d’utiliser le libraire nRFlite pour gérer les transmissions radio en 2.4ghz.

Je souhaite faire une télécommande se rapprochant d’un basique transformateur de train électrique, donc avec la moitié de la course du potentiomètre pour la marche avant et l’autre moitié pour la marche arrière. Au centre le train s’arrête.

Je ne vous rappel pas les bases de la programmation de l’Arduino ni les règles de connections des alimentations surtout concernant les tensions, tout ceci est repris dans tous les sites que j’ai mentionné dans mon introduction. Allez y faire un tour si vous partez de 0 comme moi.

Voici donc après un peu de tâtonnement mon premier montage de test :

  • 2 Arduino Nano
  • 2 émetteurs/récepteurs nRF24L01
  • 1 shield L298n
  • 1 potentiomètre 5Kohm dans mon cas mais il semble que 10 serait mieux
  • 1 batterie Lipo 2S donc 7.4v pour ce premiers essais
  • 1 moteur de récup
  • 1 plaquette d’essais et les fils associés

Connexions des modules nRF24L01 vers l’arduino :

  • broche VCC ==> broche 3V3 fils orange
  • broche GND ==> broche GND fils noir
  • broche CSN ==> broche D9 fils bleu
  • broche CE ==> broche D10 fils jaune
  • broche MOSI ==> broche D11 fils marron
  • broche SCK ==> broche D13 fils gris
  • broche MISO ==> broche D12 fils violet

Connexions L298n vers l’arduino :

  • broche ENA ==> broche D5 fils vert
  • broche IN1 ==> broche D4 fils marron
  • broche IN2 ==> broche D3 fils orange

Connexions L298n autres :

  • broche +12v ==> + batterie
  • broche GND ==> – batterie et aussi GND arduino
  • broche 5v ==> broche 5v arduino
  • 2 broches OUT ==> moteur

Connexions du potentiomètre :

  • broche 1 ==> broche GND
  • broche 2 ==> broche A2 de l’arduino
  • broche 3 ==> broche +5v

Code pour l’émetteur :

/*
Transmission de la valeur du potentiomètre pour piloter un moteur  CC 
avec un module L298n
*/

#include "SPI.h"
#include "NRFLite.h"

const static uint8_t RADIO_ID = 1;             // Identifiant de l'émetteur
const static uint8_t DESTINATION_RADIO_ID = 0; // Identifiant du récepteur
const static uint8_t PIN_RADIO_CE = 9;
const static uint8_t PIN_RADIO_CSN = 10;

NRFLite _radio;

int valeur = 0; // variable ou on stock la valeur du potentiometre

void setup()
{
    pinMode(A2, INPUT); // pin pour le potentiometre
    Serial.begin(9600); //initialisation comm serie
    
    if (!_radio.init(RADIO_ID, PIN_RADIO_CE, PIN_RADIO_CSN))
    {
        Serial.println("Cannot communicate with radio");
        while (1);
    }
  
}

void loop()
{
    valeur = analogRead(A2); // on lit les données pin A2
    
    Serial.print("Envoi : ");
    Serial.println(valeur);
    
    if (_radio.send(DESTINATION_RADIO_ID, &valeur, sizeof(valeur)))
    {
        Serial.println(" ...Succes");
    }
    else
    {
        Serial.println(" ...Echec");
    }

    delay(1000);
}

Code pour le récepteur :

/*
Réception de la valeur du potentiomètre et pilotage du moteur 
marche avant - arrière - stop
*/

#include "SPI.h"
#include "NRFLite.h"

const static uint8_t RADIO_ID = 0;       // Identifiant du récepteur
const static uint8_t PIN_RADIO_CE = 9;  
const static uint8_t PIN_RADIO_CSN = 10;

NRFLite _radio;
int valeur = 0; // variable reception potentiometre
int in1 = 4; // sens rotation
int in2 = 3; // sens rotation
int ENA = 5; // pwm moteur

void setup()
{
    pinMode(4, OUTPUT); // pin 4 sortie pour in1 
    pinMode(3, OUTPUT); // pin 3 sortie pour in2
    pinMode(5, OUTPUT); // pin 5 sortie ENA PWM moteur
    Serial.begin(9600); // on ouvre le port série
    
    if (!_radio.init(RADIO_ID, PIN_RADIO_CE, PIN_RADIO_CSN))
    {
        Serial.println("Cannot communicate with radio");
        while (1);
    }
}

void loop()
{
    while (_radio.hasData()) // Attente de réception d'un caractère
    {
        _radio.readData(&valeur); // lecture variable valeur 

               
        if(valeur < 450)
        {
         int mappedval = map(valeur,450,0,0,255); //on map la moitie de la course du potentiometre en marche avant

        Serial.print("Reception Avant : ");
        Serial.println(valeur); // affichage de la valeur du potentiometre
      
        digitalWrite(in1, LOW);
        digitalWrite(in2, HIGH);
        analogWrite(ENA, mappedval); // commande vitesse moteur pin 5

        delay(30);
        } 
        else if (valeur > 570)
        {
        int  mappedval = map(valeur,570,1024,0,255); // on map la moitie de la course du potentiomètre en marche arriere

        Serial.print("Reception Arrière : ");
        Serial.println(valeur); // affichage de la valeur du potentiometre
        
        digitalWrite(in1, HIGH);
        digitalWrite(in2, LOW);
        analogWrite(ENA, mappedval); // commande vitesse moteur pin 5

        delay(30);
        }
        else if (450 > valeur < 570)
        {
        Serial.print("Reception Stop : ");
        Serial.println(valeur); // affichage de la valeur du potentiometre
          
          digitalWrite(in1, LOW); // frein en coupant l'alimentation
          digitalWrite(in2, LOW);
        }
          
     }
}

Comme vous pouvez le voir la valeur du potentiomètre est lue dans l’émetteur puis transmise tel quel vers le récepteur. Une fois reçue j’ai scindé la plage de mappage en 3 parties :

  • Marche avant de 0 à 450 : on map cette plage entre 0 et 255 pour la vitesse du moteur et on active IN1 LOW et IN2 HIGH ce qui lance le moteur dans un sens
  • STOP en simulant un neutre au milieu de la course du potentiomètre de 450 à 570, on ne renseigne pas de vitesse par contre IN1 et IN2 sont à LOW le moteur n’est pas du tout alimenté
  • Marche arrière de 570 à 1024: on map cette plage entre 0 et 255 pour la vitesse du moteur et on inverse IN1 HIGH et IN2 LOW

Ce code me parait assez simple mais il est peut être améliorable. N’hésitez pas à le mettre en commentaire.

La prochaine étape sera d’ajouter un bouton poussoir à l’émetteur pour faire un Arrêt d’urgence qui mettra IN1 et IN2 en LOW comme pour le stop.