J’ai trouvé sur Youtube une vidéo présentant une petite locomotive diesel imprimée en 3D à l’échelle G ne comportant pas trop de pièce et utilisant un moteur tout simple d’Amazon. J’ai donc décidé de me lancer dans sa réalisation.

Le lien direct vers le model présenté dans Thingiverse :

https://www.thingiverse.com/thing:6183902

J’ai imprimé toutes les pièces en PETG blanc et noir pour une meilleure résistance en extérieur. Bien que mon matériel roulant ne sorte que pour les sessions de jeux, sinon il est stocké en boite.

Il y a un petit problème d’échelle avec les roues motrices.

Du coup j’ai utilisé les mêmes roues que pour mes wagons bennes en augmentant leur diamètre. Et pour les roues motrices j’ai ajouté les axes permettant de s’emboiter parfaitement sur le moteur.

J’ai mis ces roues à disposition sur Thingiverse :

https://www.thingiverse.com/thing:6961068

Les différentes pièces sont collées à la cyano puis l’ensemble est mastiqué afin d’avoir un effet plus lisse que brut d’impression. J’ai aussi passé 2 couches d’apprêt garnissant avant de peindre la cabine et le compartiment moteur en vert.

Electronique embarquée :

Toute la partie pilotage de la locomotive est assurée comme pour ma locomotive Rusty à base d’arduino et de ma télécommande TT2J. Il comprend dans la locomotive

  • Un Arduino nano
  • Un module nRF24L01
  • Un module L198N
  • 2 batteries 18650
  • Un interrupteur ON/OFF
  • 2 résistances pour la mesure de tension

Les différents éléments électroniques sont simplement collés à la colle chaude sur le châssis afin de rentrer sous le capot moteur.

Brochage Arduino Nano, L298N, nRF24L01 :

Installation et câblage du L298N :

Au vue de l’espace disponible, j’ai décidé de loger le L298N sous le capot rouge de la locomotive, mais en laissant le plomb à l’intérieur de ce capot.

Connexions L298n vers l’arduino :

  • broche ENA ==> broche D5
  • broche IN1 ==> broche D4
  • broche IN2 ==> broche D3
  • broche ENB ==> le cavalier reste en place pour l’allumage de la lampe avec la tension maximum
  • broche IN3 ==> broche D6
  • broche IN4 ==> broche D7

Connexions L298n autres :

  • broche +12v ==> + batterie
  • broche GND ==> – batterie et aussi GND Arduino
  • broche 5v ==> broche 5v Arduino
  • 2 broches OUT A ==> moteur
  • 2 broches OUT B ==> ampoule de phare (option)
  • Cavalier JMP1 laissé en place afin d’alimenter l’arduino par le 5v du module L298N.

Installation et câblage du nRF24L01 :

Connexions des modules nRF24L01 vers l’arduino :

  • broche VCC ==> broche 3V3
  • broche GND ==> broche GND
  • broche CSN ==> broche D9
  • broche CE ==> broche D10
  • broche MOSI ==> broche D11
  • broche SCK ==> broche D13
  • broche MISO ==> broche D12

Installation et câblage de la batterie et du switch ON/OFF :

Le moteur de cette locomotive étant prévu pour fonctionner entre 3 et 6v, la locomotive est donc alimentée par 2 batterie 18650, qui sont dans un porte pile adéquat installé dans la cabine. Un switch ON/OFF est installé sur le tableau de bord et j’ai aussi mis le même montage de mesure de tension pour protéger la batterie que sur la locomotive Rusty.

Mesure de tension et protection du système :

Une batterie au lithium de type 18650 ne devant pas avoir une tension de moins de 2.5v par élément je souhaite ajouter une protection dans mon système en prenant une marge de sécurité. Avec un pont diviseur de tension je vais pouvoir mesurer la tension de ma batterie de 8,4v max en la rapportant à une tension de 5v lisible par l’Arduino. J’utilise l’entrée A2 pour faire cette lecture de tension sur l’Arduino.

De très bonnes explications dans cette vidéo :

J’ai calculé le rapport de tension et déduit la valeur des résistances du pont.

5/8,4 = 0.595 rapport de tension
R1/(R1+R2) = 5/8,4

Après calcul les valeurs approchantes des résistances que je trouve :
R1 = 10 Kohms
R2 = 6,8 Kohms

Si on prend R1 = 10 Kohms alors R2 = 6.8 Kohms et le rapport R1/(R1+R2) = 10/16.8=0.595

Ce qui fait que pour une tension maximum de 8.4V la tension mesurée sur l’entrée A2 de l’Arduino sera de 8.4*0.595=4.998V

Avec une batterie pleine donc à 8,4v on mesurera une tension de 4.998v sur l’entrée analogue de l’Arduino ce qui correspondra après conversion analogique numérique par l’Arduino à :

(4.998*1023)/5=1022

Si je veux limiter la décharge de mes éléments à 2.7v soit une tension batterie de 5,4v alors la mesure de tension correspondante à l’entrée analogique sera de 5,4*0.595=3,213v; soit après conversion (3,213*1023)/5= 657.

Code de l’arduino :

/*
Transmission d'un unique caractère (réception)
(Basé sur l'exemple Basic_RX)

Code pour récepteur locomotive GEMINI

*/

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

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

NRFLite _radio;
int POT_Value = 0;    // variable reception potentiometre
int ARU = 0;          // variable arret d urence
int in1 = 4;          // sens rotation
int in2 = 3;          // sens rotation
int ENA = 5;          // pwm moteur
int in3 = 6;          // entrée lampe
int in4 = 7;          // entrée lampe
int LIGHT_Value = 0;  // variable eclairage

float analogVolt = 0;  // Pour lecture de la tension sur A2 ==> 0.....1023

//creation du paquet contenant les variables a envoyer

struct RadioPacket {
  int POT_Value;
  int ARU;
  int LIGHT_Value;
};

RadioPacket _radioData;  // declaration de la variable associée a la structure


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
  pinMode(6, OUTPUT);  // pin 6 sortie pour in3 lampe
  pinMode(7, OUTPUT);  // pin 7 sortie pour in4 lampe
  pinMode(A2, INPUT);  // pin A2 lecture tension batterie
  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(&_radioData);  // lecture variable radioData comprenant la structure des 3 variables POT_Value et ARU

    ARU = _radioData.ARU;  // recuperation des variables dans la structure recue dans la variable radioData
    POT_Value = _radioData.POT_Value;
    LIGHT_Value = _radioData.LIGHT_Value;

    Serial.print("Eclairage : ");
    Serial.println(LIGHT_Value);

    // **** vérification tension batterie si moins de 5.4v on arrête sinon on continue le programme
    // R1=10Kohm, R2=6.8Kohm rapport de 0.595 donc tension max des 2 batteries 8.4v*0.595=4.998v au max à la borne A2
    // (4.998x1023)/5=1022
    // donc pour une tension max de batterie on lira 1022 en borne A2
    // je veux limiter la décharge à 2.7v par élément soit 5.4v au mini à lire sur A2 ce qui correspond
    // à 5.4x0.595=3.213v
    // (3.213x1023)/5=657 donc pour limiter la tension à 2.7v par élément il faut limiter à une valeur de 657

    analogVolt = analogRead(A2);  // lecture sur broche A2 et inscription dans la variable analogVolt
      Serial.println("Mesure batterie: ");
      Serial.print(analogVolt);

    if ((ARU == 1) || (analogVolt <= 657))   // Si arret d urgence OU tension batterie <5.4v
    {
      digitalWrite(in1, LOW);  // frein en coupant l'alimentation
      digitalWrite(in2, LOW);

      digitalWrite(in3, LOW); // on eteind la lampe
      digitalWrite(in4, LOW);
      
      Serial.println("Etat arret urgence :");
      Serial.print(ARU);
      Serial.println("Si batterie <5.4v soit <657 alors la loco stop");
      Serial.println("Etat batterie =");
      Serial.print(analogVolt);
    }

    // ****  si pas d'arret d'urgence et batterie OK on pilote le moteur ****

    else {
      Serial.println("Etat arret urgence : OFF");

      if (POT_Value < 450) {
        int mappedval = map(POT_Value, 450, 0, 80, 255);  //on map la moitie de la course du potentiometre en marche avant on commence à 55 le mappage car c'est à partir de cette valeur que le moteur démarre

        Serial.print("Reception Avant : ");
        Serial.println(POT_Value);  // affichage de la POT_Value du potentiometre
        Serial.println(mappedval);  // affichage valeur mappé pour trouver a quel valeur moteur démarre

        digitalWrite(in1, HIGH);
        digitalWrite(in2, LOW);
        analogWrite(ENA, mappedval);  // commande vitesse moteur pin 5

        delay(30);
           } 
        else if (POT_Value > 570) {
        int mappedval = map(POT_Value, 570, 1024, 80, 255);  // on map la moitie de la course du potentiomètre en marche arriere on commence à 45 le mappage car c'est à patir de cette valeur que le moteur démarre

        Serial.print("Reception Arrière : ");
        Serial.println(POT_Value);  // affichage de la POT_Value du potentiometre
        Serial.println(mappedval);  // affichage valeur mappé pour trouver a quel valeur moteur démarre

        digitalWrite(in1, LOW);
        digitalWrite(in2, HIGH);
        analogWrite(ENA, mappedval);  // commande vitesse moteur pin 5

        delay(30);
           } 
        else if (450 > POT_Value < 570) {
        Serial.print("Reception Stop : ");
        Serial.println(POT_Value);  // affichage de la POT_Value du potentiometre

        digitalWrite(in1, LOW);  // frein en coupant l'alimentation
        digitalWrite(in2, LOW);
      }
      //********* si pas d'arret d'urgence on pilote l'eclairage lampe ************

      if (LIGHT_Value == 1) {
        digitalWrite(in3, HIGH);
        digitalWrite(in4, LOW);
      } else if (LIGHT_Value == 0) {
        digitalWrite(in3, LOW);
        digitalWrite(in4, LOW);
      }
    }
  }
}

Premier test de roulage avant finition de la locomotive :

Finition de la locomotive :

Après ces premiers test il s’avère que la locomotive patine et plante un peu sur les aiguillages. J’ai donc ajouté les bandes en caoutchouc et des poids comme indiqué dans la première vidéo.

J’ai aussi terminé la cabine en ajoutant des liserés jaunes et des vitres. Cette dernière est ensuite collée sur le châssis.

Le compartiment moteur tient en place grâce à des petits aimants Néodyme. Il est ainsi facile à ouvrir.