Essais dynamiques de la gare d'échange Nouvelle Génération

 La période estivale n'est pas forcément synonyme de ralenti. Nous avons mis à profit le mois d'Août pour effectuer des essais sur un grand réseau.

Le Poste Opérateur:

Le Poste permet de commander les itinéraires mais aussi la traction dans l'ensemble de la gare d'échanges. Le logiciel Orchestra fonctionne sous Linux avec un PC ayant une configuration matérielle minimaliste.

Ci-après une photo de l'interface utilisateur. La commande des itinéraires est à droite de l'écran avec deux fenêtres (voie intérieure et voie extérieure). Lorsqu'un itinéraire est sélectionné, celui-ci apparait en vert. 

Les commandes traction des locos est faite avec un curseur. Voir au milieu de l'écran. 

Une fenêtre générale (en bas à gauche) sert à démarrer le poste et gérer les configurations de la gare d'échanges.

Poste Opérateur avec l'IHM Orchestra 

Vue des itinéraires et commande traction

Les interfaces:

Il y a un boitier qui interface le PC et la traction des voies de la gare d'échange. Ce boitier contient deux modules LPTNextGen.

Boitier de connexion 

Les câbles de sortie des deux modules LPTNextGen viennent se raccorder sur la prise type PTT du réseau.

Connexions sur le réseau

La communication entre le PC et un troisième module LPTNextGen situé dans un des caissons est assurée via une liaison I2C.

Adaptateur I2C/USB au milieu sur la photo

Vue des relais de commande des voies et de l'interface I2C

Vidéo :

Une vidéo pour illustrer les circulations:

La mise au point continue. A suivre

Serre Lumineuse

 En modélisme, il est assez fréquent de réutiliser des objets et de les détourner de leur usage initial. Pour éclairer une petite serre de jardin dans un décor, on peut s'orienter vers un montage classique avec une ou deux LEDs RVB. Nous avons déjà réalisé ce type de montage qui fonctionne très bien mais il nécessite un circuit (Arduino, WEEMOS, ...) pour piloter les LEDs et une alimentation 5V adaptée.

La serre lumineuse

Vous avez certainement déjà vu des lampes de jardin avec des LEDs multicolores. Avec le temps celles-ci commencent à avoir des faiblesses et en particulier les photopiles et l'accumulateur qui ne se rechargent plus totalement. Ces lampes peuvent avoir une seconde vie. Après avoir retiré l’accumulateur (à recycler) et nettoyé l'intérieur avec une vielle brosse à dents (pour enlever les insectes) inspectez bien les contacts et regarder s'il y a des traces d'oxydation (vert-de-gris). Vous pouvez nettoyer les contacts avec un cutter et un coton tige imbibé d'alcool à brûler ou isopropylique.

 

Vous pouvez tester le circuit avec une alimentation ou une simple pile de 1,5V. Attention avec l'alimentation de ne pas dépasser 2V car l'accumulateur est souvent du 1,5V et en mettant une tension trop élevée le circuit serait grillé. On pourra remplacer l'accumulateur par un neuf.

 

Dans notre exemple, nous avons réutilisé la lampe "papillon" avec une LED multicolore qui a une longue tige flexible contenant le cable qui relie la LED au boîtier abritant l’électronique et l'accumulateur. Nous n'avons rien enlevé à par le papillon décoration qui était emboîté sur la LED... 

Nous avons d'abord percé un trou pour faire passer la LED, puis nous avons fixé le boîtier sous un module de train à l'aide d'une simple agrafe. Les deux photopiles sont masquées par un adhésif opaque pour déclencher l'éclairage. En effet, l'éclairage de la LED ne se produit que lorsque la luminosité ambiante est faible. Cela dit il y a un petit interrupteur marche/arrêt sur le boîtier.     

Installation de la lampe de jardin sous le module

Simple et facile à mettre en oeuvre, c'est un bon moyen de faire une petite animation lumineuse!

 

Une petite vidéo pour illustrer:

Sonorisation : quelques compléments

 Toujours à l'affut de composants ou montages électroniques intéressants, nous avons fait quelques trouvailles qui touchent à la sonorisation et qui pourraient vous intéresser. 

Les HP ne sont pas que circulaires. Le modèle ci-dessous rectangulaire est bien plus adapté à nos montages dans les wagons (voire locomotives/tender). Le rendu sonore est tout aussi bon.

Cela s'interface très bien avec une petite carte sonore dont nous avons déjà parlé dans les articles précédents (composant ISD 1820).

La carte son en kit est aussi un excellent moyen d'apprendre à souder et réaliser sa carte et de comprendre un peu mieux son fonctionnement.

Les composants et le circuit imprimé

Le kit est accompagné d'un schéma d'implantation et il y a souvent une sérigraphie sur la face composants pour identifier les composants à implanter manuellement. C'est relativement simple et il y a peu de risque de se tromper. Avant de mettre sous tension, demandez à un œil expert de vérifier.

La carte montée et qui fonctionne

L'amplificateur sonore peut aussi être une bonne idée. Il y a des petits amplis sonores qui fonctionnent très bien mais attention à leur puissance et aussi à leur alimentation.

Exemple d'ampli sonore pour essai dans voiture disco

A vous de jouer avec ces petits montages!

L' écran TFT sur la maquette du vélodrome

La maquette du vélodrome de Montigny le Bretonneux est terminée et c'est avec un grand plaisir que l'on a pu intégrer l'écran TFT avec son habillage (impression 3D).

Prêt pour les J.O. de 2024!

Une petite vidéo pour illustrer la superbe réalisation des modélistes des passionnés du train LPT

Plus de détails sur les réalisations sur https://lespassionnesdutrain.blogspot.com

 

Vidéo surveillance des trains

 La vidéo surveillance est de plus en plus présente dans notre environnement et il est aussi de plus en plus facile de la déployer avec du matériel du commerce. Les différentes caméras miniatures sont désormais de très bonne qualité, pas chères, et en plus sont de véritables objets connectés. Pour notre loisir, il est intéressant de l'essayer pour savoir si cela est valable pour surveiller les trains sur un réseau miniature.

La suite ici.

Joystick pour accessoires

 Les télécommandes sont toujours utiles pour des applications très variées en modélisme (ex: la commande de portique). Nous nous sommes intéressés à une télécommande de type Joystick. Certes, il en existe toute faite et qui fonctionnent très bien mais nous allons voir comment en faire une à partir d'éléments Arduino.

Le Principe:

Le montage sera très simple puisqu'il consiste à assembler un module Arduino Méga et le module Joystick Shield. A noter que l'on peut aussi utiliser un Arduino Uno. Peu de chance de se tromper lorsque l'on assemble les deux modules mais pour éviter toute mauvaise surprise une petite astuce: les alimentations 5V et 3,3V sont repérées sur le module Joystick Shield (en bas à gauche sur la photo ci-après) et aussi sur les connecteurs de l'Arduino. Il suffit de les faire coïncider (alimentation externe et prise USB à gauche sur la photo ci-après). Bien mettre l'interrupteur en bas à gauche du module Joystick Shield sur 3,3V.

L'ensemble des modules est alimenté par l'Arduino (prise externe ou par USB). Une LED témoin indique que le module Joystick Shield est sous tension.

Vue de l'ensemble Arduino Méga et du Joystick Shield

Pour notre exemple, nous avons câblé deux servo-moteurs (deux modèles différents) sur les sorties D9 et D10 du Joystick Shield (en haut à gauche sur la photo). Les alimentations 3,3V et GND pour les servos sont prises sur le même connecteur du module Shield.

Vue du montage avec les deux servos

Il nous reste plus qu'à écrire le petit programme pour piloter ces servos.

Le code:

Il faut utiliser la librairie servo pour initialiser et commander ceux-ci. Les boutons (de couleur jaune et bleu) sont définis en fonctions des directions (UP = HAUT, DOWN = BAS, LEFT = GAUCHE, RIGHT = DROITE). A noter qu'il y a deux boutons E et F de réserve (en noir à gauche de boutons de couleur). Les axes X et Y du Joystick sont les entrées analogiques A0 et A1 (défini par câblage). La fonction map est importante car elle adapte l'échelle de conversion des valeurs analogique en numérique pour assurer un contrôle adapté.

[code]
#include <Servo.h>

// define global variables for analog pins.
Servo myservo_x;
Servo myservo_y;
int value_x = 0;
int value_y = 0;
// X values will be read from pin 0 and Y from pin 1

#define PIN_ANALOG_X A0
#define PIN_ANALOG_Y A1
#define BUTTON_UP 2
#define BUTTON_RIGHT 3
#define BUTTON_DOWN 4
#define BUTTON_LEFT 5
#define BUTTON_E 6
#define BUTTON_F 7
#define DELAY 500
#define PIN_SERVO_X 9
#define PIN_SERVO_Y 10

void setup() {
 // Start serial because we will observe values at serial monitor
 Serial.begin(9600);
 // to enable pull up resistors first write pin mode
 // and then make that pin HIGH

 pinMode(BUTTON_UP, INPUT);
 digitalWrite(BUTTON_UP, HIGH);
 pinMode(BUTTON_RIGHT, INPUT);
 digitalWrite(BUTTON_RIGHT, HIGH);
 pinMode(BUTTON_DOWN, INPUT);
 digitalWrite(BUTTON_DOWN, HIGH);
 pinMode(BUTTON_LEFT, INPUT);
 digitalWrite(BUTTON_LEFT, HIGH);
 pinMode(BUTTON_E, INPUT);
 digitalWrite(BUTTON_E, HIGH);
 pinMode(BUTTON_F, INPUT);
 digitalWrite(BUTTON_F, HIGH);

 myservo_x.attach(PIN_SERVO_X);
 myservo_x.write(180);
 delay (1500);
 myservo_y.write(0);
 myservo_y.attach(PIN_SERVO_Y);
 myservo_y.write(180);
 delay (1500);
 myservo_y.write(0);
}

void loop() {
 // Print x axis values
 Serial.print("x: ");
 value_x = analogRead(PIN_ANALOG_X);
 value_x = map(value_x ,0, 1023, 0, 180);
 Serial.println(value_x);
 myservo_x.write(value_x);
 delay(DELAY);
 // Print y axis values
 Serial.print("y: ");
 value_y = analogRead(PIN_ANALOG_Y);
 value_y = map(value_y ,0, 1023, 0, 180);
 Serial.println(value_y);
 myservo_y.write(value_y);
 // Some delay to clearly observe your values on serial monitor.
 if(digitalRead(BUTTON_UP) == LOW) {
   Serial.println("Button A is pressed");
   myservo_y.write(180);
   delay(DELAY);
  }
  else if(digitalRead(BUTTON_RIGHT) == LOW) {
    Serial.println("Button B is pressed");
    myservo_x.write(180);
    delay(DELAY);
  }
  else if(digitalRead(BUTTON_DOWN) == LOW) {
   Serial.println("Button C is pressed");
   myservo_y.write(0);
   delay(DELAY);
  }
  else if(digitalRead(BUTTON_LEFT) == LOW) {
   Serial.println("Button D is pressed");
   myservo_y.write(0);
   delay(DELAY);
 }
}
[/code]

Vous pouvez observer les valeurs avec la console série.

Une petite vidéo pour illustrer :

A vous de jouer!

Valise de test des locos remise à jour

 La valise de test de test des locomotives équipées en DCC a été mise à jour. Elle permet de vérifier et configurer les décodeurs DCC de tous types, pour du 2 rails et 3 rails.

Le PC de commande est complétement remis à jour avec le SPROG 3. 

Valise de test avec le PC de commande

La platine de test ESU permet de tester les décodeurs qui ne sont pas encore montés dans les locomotives.  

Module de test ESU avec un décodeur en test

Merci à Yannick pour cette mise à jour et n'hésitez pas à l'utiliser lors des réunions LPT!

Mini écrans : affichage d'images

 Les essais avec les écrans se poursuivent avec cette fois-ci le grand modèle 3.5 pouces 320 * 480 HD qui s'insère directement sur un Arduino MEGA2560. Avec cela l'affichage des images c'est du sérieux!

 

Vue de l'écran monté sur l'Arduino MEGA2560

Aucune difficulté de montage ni de risque de se tromper dans le branchement. Au dos de l'écran on trouve un lecteur de carte SD intégré.

Il est très important de bien préparer les images avec le bon outil et surtout au bon format. Sans cela aucun affichage...

Pour cet écran, les images sont à retailler en 320 * 480 px et à sauvegarder en bitmap (.bmp) 24 bits.

Faites aussi attention de bien inverser l'image car le programme affiche en miroir!

Exemple de préparation de fichier image

 Le nommage des images doit être cohérent des noms dans le code ci-après (01.bmp à 04.bmp).

Le code: 

Le code de cette démonstration est issu de LCDWIKI (à consulter car beaucoup d'informations intéressantes ici) avec notre adaptation. Le nombre de fichiers peut être facilement augmenté en modifiant le nombre de fichiers (en rouge ci-après) et ajoutant des instructions dans le setup().

 

[code]
// IMPORTANT: LCDWIKI_KBV LIBRARY MUST BE SPECIFICALLY
// CONFIGURED FOR EITHER THE TFT SHIELD OR THE BREAKOUT BOARD.

//This program is a demo of how to show a bmp picture from SD card.

//Set the pins to the correct ones for your development shield or breakout board.
//the 16bit mode only use in Mega.you must modify the mode in the file of lcd_mode.h
//when using the BREAKOUT BOARD only and using these 16 data lines to the LCD,
//pin usage as follow:
//             CS  CD  WR  RD  RST  D0  D1  D2  D3  D4  D5  D6  D7  D8  D9  D10  D11  D12  D13  D14  D15
//Arduino Mega 40  38  39  /   41   37  36  35  34  33  32  31  30  22  23  24   25   26   27   28   29

//Remember to set the pins to suit your display module!

#include <SD.h>
#include <SPI.h>
#include <LCDWIKI_GUI.h> //Core graphics library
#include <LCDWIKI_KBV.h> //Hardware-specific library

//the definiens of 16bit mode as follow:
//if the IC model is known or the modules is unreadable,you can use this constructed function
LCDWIKI_KBV my_lcd(ILI9486,40,38,39,-1,41); //model,cs,cd,wr,rd,reset

#define  BLACK   0x0000
#define BLUE    0x001F
#define RED     0xF800
#define GREEN   0x07E0
#define CYAN    0x07FF
#define MAGENTA 0xF81F
#define YELLOW  0xFFE0
#define WHITE   0xFFFF

#define PIXEL_NUMBER  (my_lcd.Get_Display_Width()/4)
#define FILE_NUMBER 4
#define FILE_NAME_SIZE_MAX 20

uint32_t bmp_offset = 0;
uint16_t s_width = my_lcd.Get_Display_Width();  
uint16_t s_heigh = my_lcd.Get_Display_Height();
//int16_t PIXEL_NUMBER;

char file_name[FILE_NUMBER][FILE_NAME_SIZE_MAX];

uint16_t read_16(File fp)
{
    uint8_t low;
    uint16_t high;
    low = fp.read();
    high = fp.read();
    return (high<<8)|low;
}

uint32_t read_32(File fp)
{
    uint16_t low;
    uint32_t high;
    low = read_16(fp);
    high = read_16(fp);
    return (high<<8)|low;   
 }
 
bool analysis_bpm_header(File fp)
{
    if(read_16(fp) != 0x4D42)
    {
      return false;  
    }
    //get bpm size
    read_32(fp);
    //get creator information
    read_32(fp);
    //get offset information
    bmp_offset = read_32(fp);
    //get DIB infomation
    read_32(fp);
    //get width and heigh information
    uint32_t bpm_width = read_32(fp);
    uint32_t bpm_heigh = read_32(fp);
    if((bpm_width != s_width) || (bpm_heigh != s_heigh))
    {
      return false;
    }
    if(read_16(fp) != 1)
    {
        return false;
    }
    read_16(fp);
    if(read_32(fp) != 0)
    {
      return false;
     }
     return true;
}

void draw_bmp_picture(File fp)
{
  uint16_t i,j,k,l,m=0;
  uint8_t bpm_data[PIXEL_NUMBER*3] = {0};
  uint16_t bpm_color[PIXEL_NUMBER];
  fp.seek(bmp_offset);
  for(i = 0;i < s_heigh;i++)
  {
    for(j = 0;j<s_width/PIXEL_NUMBER;j++)
    {
      m = 0;
      fp.read(bpm_data,PIXEL_NUMBER*3);
      for(k = 0;k<PIXEL_NUMBER;k++)
      {
        bpm_color[k]= my_lcd.Color_To_565(bpm_data[m+2], bpm_data[m+1], bpm_data[m+0]);
        m +=3;
      }
      for(l = 0;l<PIXEL_NUMBER;l++)
      {
        my_lcd.Set_Draw_color(bpm_color[l]);
        my_lcd.Draw_Pixel(j*PIXEL_NUMBER+l,i);
      }    
     }
   }    
}

void setup()
{
    Serial.begin(9600);
   my_lcd.Init_LCD();
   my_lcd.Fill_Screen(BLUE);
   //s_width = my_lcd.Get_Display_Width();  
   //s_heigh = my_lcd.Get_Display_Height();
   //PIXEL_NUMBER = my_lcd.Get_Display_Width()/4;
   if(PIXEL_NUMBER == 60)
   {
       strcpy(file_name[0],"flower.bmp");
       strcpy(file_name[1],"tiger.bmp");
       strcpy(file_name[2],"tree.bmp");
       strcpy(file_name[3],"RedRose.bmp");
   }
   else
   {
       strcpy(file_name[0],"01.bmp");
       strcpy(file_name[1],"02.bmp");
       strcpy(file_name[2],"03.bmp");
       strcpy(file_name[3],"04.bmp");
   }
  //Init SD_Card
   pinMode(53, OUTPUT);
   
    if (!SD.begin(53))
    {
      my_lcd.Set_Text_Back_colour(BLUE);
      my_lcd.Set_Text_colour(WHITE);    
      my_lcd.Set_Text_Size(1);
      my_lcd.Print_String("SD Card Init fail!",0,0);
    }
}

void loop()
{
    int i = 0;
    File bmp_file;

    my_lcd.Set_Rotation(1);
    my_lcd.Set_Text_Mode(0);
    my_lcd.Set_Text_colour(RED);
    my_lcd.Set_Text_Back_colour(BLACK);
    my_lcd.Set_Text_Size(1);
    my_lcd.Print_String("a b c d e f g h i j k l m n o p q r s t u v w x y z", 87, 10);
    my_lcd.Print_String("A B C D E F G H I J K L M N O P Q R S T U V W X Y Z", 87, 20);

    my_lcd.Set_Text_colour(GREEN);
    my_lcd.Set_Text_Size(2);
    my_lcd.Print_String("a b c d e f g h i j k l m", 90, 40);
    my_lcd.Print_String("n o p q r s t u v w x y z", 90, 60);
    my_lcd.Print_String("A B C D E F G H I J K L M", 90, 80);
    my_lcd.Print_String("N O P Q R S T U V W X Y Z", 90, 100);
 
    my_lcd.Set_Text_colour(BLUE);
    my_lcd.Set_Text_Size(3);
    my_lcd.Print_String("a b c d e f g h i j k l m", 15, 130);
    my_lcd.Print_String("n o p q r s t u v w x y z", 15, 160);
    my_lcd.Print_String("A B C D E F G H I J K L M", 15, 190);
    my_lcd.Print_String("N O P Q R S T U V W X Y Z", 15, 220);
 
    my_lcd.Set_Text_colour(CYAN);
    my_lcd.Set_Text_Size(1);
    my_lcd.Print_String("0 1 2 3 4 5 6 7 8 9", 183, 255);
    my_lcd.Set_Text_colour(WHITE);
    my_lcd.Set_Text_Size(2);
    my_lcd.Print_String("0 1 2 3 4 5 6 7 8 9", 126, 265);
    my_lcd.Set_Text_colour(MAGENTA);
    my_lcd.Set_Text_Size(3);
    my_lcd.Print_String("0 1 2 3 4 5 6 7 8 9", 69, 285);  
    //display 1 times string
    delay(2000);
    my_lcd.Set_Rotation(0);
    my_lcd.Fill_Screen(0x0000);
    my_lcd.Set_Text_colour(RED);
    my_lcd.Set_Text_Back_colour(BLACK);
    my_lcd.Set_Text_Size(1);
    my_lcd.Print_String("EXPO LPT!", 0, 0);
    my_lcd.Print_Number_Float(01234.56789, 2, 0, 8, '.', 0, ' ');  
    my_lcd.Print_Number_Int(0xDEADBEF, 0, 16, 0, ' ',16);
    //my_lcd.Print_String("DEADBEF", 0, 16);
 
    //display 2 times string
    my_lcd.Set_Text_colour(GREEN);
    my_lcd.Set_Text_Size(2);
    my_lcd.Print_String("EXPO LPT!", 0, 40);
    my_lcd.Print_Number_Float(01234.56789, 2, 0, 56, '.', 0, ' ');  
    my_lcd.Print_Number_Int(0xDEADBEF, 0, 72, 0, ' ',16);
    //my_lcd.Print_String("DEADBEEF", 0, 72);
 
    //display 3 times string
    my_lcd.Set_Text_colour(BLUE);
    my_lcd.Set_Text_Size(3);
    my_lcd.Print_String("EXPO LPT!", 0, 104);
    my_lcd.Print_Number_Float(01234.56789, 2, 0, 128, '.', 0, ' ');  
    my_lcd.Print_Number_Int(0xDEADBEF, 0, 152, 0, ' ',16);
   // my_lcd.Print_String("DEADBEEF", 0, 152);
 
    //display 4 times string
    my_lcd.Set_Text_colour(WHITE);
    my_lcd.Set_Text_Size(4);
    my_lcd.Print_String("EXPO LPT!", 0, 192);
 
    //display 5 times string
    my_lcd.Set_Text_colour(YELLOW);
    my_lcd.Set_Text_Size(5);
    my_lcd.Print_String("EXPO LPT!", 0, 224);
 
    //display 6 times string
    my_lcd.Set_Text_colour(CYAN);
    my_lcd.Set_Text_Size(6);
    my_lcd.Print_String("EXPO LPT!", 0, 266);
 
    //display 7 times string
    my_lcd.Set_Text_colour(RED);
    my_lcd.Set_Text_Size(7);
    my_lcd.Print_String("EXPO LPT!", 0, 315);
 
    //display 8 times string
    my_lcd.Set_Text_colour(MAGENTA);
    my_lcd.Set_Text_Size(8);
    my_lcd.Print_String("EXPO LPT!", 0, 372);
    delay(2000);
    my_lcd.Fill_Screen(0x0000);

    
    for(i = 0;i<FILE_NUMBER;i++)
    {
       bmp_file = SD.open(file_name[i]);
       if(!bmp_file)
       {
            my_lcd.Set_Text_Back_colour(BLUE);
            my_lcd.Set_Text_colour(WHITE);    
            my_lcd.Set_Text_Size(1);
            my_lcd.Print_String("didnt find BMPimage!",0,10);
            while(1);
        }
        if(!analysis_bpm_header(bmp_file))
        {  
            my_lcd.Set_Text_Back_colour(BLUE);
            my_lcd.Set_Text_colour(WHITE);    
            my_lcd.Set_Text_Size(1);
            my_lcd.Print_String("bad bmp picture!",0,0);
            return;
        }
          draw_bmp_picture(bmp_file);
         bmp_file.close();
         delay(2000);
     }
}
[/code]

Une petite vidéo pour illustrer:

A vous de jouer!

Mini-écrans

 Les écrans sont partout! Il suffit de se déplacer dans le métro pour constater que même les affiches sont progressivement remplacées par des grands écrans. Idem dans certaines communes où les informations communales et des publicités sont diffusées non-stop. Nous vous proposons de découvrir comment mettre en œuvre de petits écrans pour moderniser les décors de vos réseaux où pour d'autres applications en modélisme.

La suite ici

Commande PWM en action

Le module PWM a été mis en œuvre sur le module mini-Fête foraine afin de remplacer l'ancienne commande qui était réalisée avec un Arduino et une carte de puissance. Le fonctionnement de cette solution Arduino était hélas perturbée durant la dernière grande exposition et finalement difficilement exploitable.

Le module PWM a été connecté directement sur la prise associée aux rails du petit circuit autour de la fête foraine. L'alimentation est faite par un adaptateur secteur délivrant du 12V continu.

Câblage du module PWM

Une petite vidéo pour illustrer avec 3 locos et un ralenti assez bon :

La prochaine étape consistera à intégrer le module PWM dans un petit boitier de commande et utiliser le bus d'alimentation des accessoires qui délivre du 12V.