Exposition de modélisme à Montigny-le-Bretonneux

 Ce week-end a eu lieu la troisième exposition de modélisme à la ferme du Manet à Montigny-le-Bretonneux. De nombreuses belles réalisations y étaient présentées et en particulier pour le ferroviaire. Beau succès avec 5000 visiteurs !

Sur le grand réseau en HO, il y avait la fête foraine qui était au top de sa forme avec des manèges, la grande roue, le restaurant panoramique et le petit train radiocommandé par le système développé et mis au point par des membres des passionnés du train (LPT). 

Le réseau en N avait présenté sa scène musicale avec une animation lumineuse à base de WLED!

Il y avait aussi beaucoup d'autres animations telles que le portique portuaire sur lequel nous reviendrons.

Bravo à tous les modélistes qui ont œuvré sans relâche depuis plus d'un an pour ce fabuleux week-end!

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.

Le retour de la mini Fête Foraine

 La mini fête foraine est de retour pour se refaire une beauté! Vous aviez été nombreux à l'admirer lors de l'exposition à la ferme du Manet en 2019. Pour la prochaine exposition, toujours au Manet, cet automne 2023, nous avons fait une révision complète et des améliorations. C'est parti pour une petite revue des changements.

La première modification est la mise en boitier de la toute la partie électronique. Auparavant cela était dans un boiter de PC récupéré. Nous avons désormais mis tout cela aux normes avec une prise sécurisé pour le secteur et intégré tous les connecteurs au boitier. Plus aucun paquet de fils et toujours avec un système de détrompeur pour ne pas faire d'erreur dans les raccordements. Cela permettra à tous les membres de faire facilement le montage!

Première étape, tout rentrer dans le boitier

Deuxième étape, tout retester avec les nouveaux connecteurs

La deuxième modification consiste à inhiber les boutons de déclenchement des manèges. Les boutons ne seront pas démontés mais simplement inhibés dans le programme de mini-fête. Cela a été l'occasion d'installer tout l'environnement de développement (avec Python et le compilateur et linker) sur un PC et d'apprendre à faire les modifications grâce à François. Les manèges, les éclairages et la musique sont séquencés automatiquement toutes les minutes.  

La troisième modification est pour la commande de l'éclairage du grand bandeau. Nous avons fait une petite séquence de 3 couleurs (blanc, orange, rouge) que nous pourrons modifier à loisir. 

Une vidéo pour illustrer :

Nous allons nous attaquer à la fiabilisation des manèges et ceci n'est pas une mince affaire. 

A bientôt pour la suite avec la team mini-fête. 

Module sonore simple et puissant

 Nous vous proposons un petit montage simple pour la sonorisation de vos réseaux. Encore un ! Oui mais celui-ci, le DFPlayer, a quelque chose de plus que les précédents car il est facilement adaptable pour de nouveaux sons. 

Description du DFPlayer :

Le DFPlayer Mini MP3 Player est un petit module MP3 à bas prix avec une sortie amplifiée directement sur le haut-parleur. Le module peut être utilisé comme un module autonome avec une batterie, un haut-parleur et des boutons poussoirs ou utilisé en combinaison avec un Arduino UNO ou tout autre module ayant des capacités de liaison série (Rx/Tx). Il faut bien sûr une carte SD qui contienne les fichiers sonores MP3.

Vue du DFPlayer dans son montage le plus simple réalisé par Christian Rémy

Les caractéristiques principales sont :

- Fréquences d'échantillonnage supportées (kHz) : 8/11.025/12/16/22.05/24/32/44.1/48,

- Sortie convertisseur Numérique/Analogique (DAC) 24 bits, 

- Gamme dynamique de 90dB,

- Rapport Signal/Bruit (SNR ) de 85dB,

- Compatible des systèmes de fichiers FAT16 et FAT32, 

- 32 G bytes maxi pour la carte TF, 

- 64M bytes mémoire NORFLASH,

- Une variété de modes de contrôle, mode de contrôle I/O, mode série, mode de contrôle par bouton,

- Fonction de pause du son de la publicité, la musique peut être suspendue. lorsque la publicité est terminée, la musique continue à jouer,

- Données audio triées par dossier, supporte jusqu'à 100 dossiers, chaque dossier peut contenir jusqu'à 255 fichiers sonores,

- Volume réglable sur 30 niveaux, égaliseur réglable sur 6 niveaux.

Le circuit est très compact et il peut être alimenté en 3,3V ou 5V. La puissance de sortie ne peut pas excéder les 3W mais cela est déjà bien suffisant.

Dans sa configuration la plus simple, seules les broches suivantes sont à câbler:

- 1 (Vcc) sur le +5V (ou +3,3V)

- 6 (SPK1) sur le HP +

- 8 (SPK2) sur le HP -

- 9 (IO 1) sur le Bouton Poussoir 1

- 10 (GND) sur la masse de l'alimentation

- 11 (IO 2) sur le Bouton Poussoir 2

- 12 (ADKEY1)  sur le Bouton Poussoir 3

Le bouton poussoir 1 sert à baisser le volume par un appui long. Il permet aussi de jouer le fichier sonore précédant par un appui court.

Le bouton poussoir 2 sert à augmenter le volume par un appui long. Il permet aussi de jouer le fichier sonore suivant par un appui court.

Le bouton poussoir 3 sert à jouer le premier fichier sonore.

Une petite vidéo pour illustrer et surtout écouter:

Merci à Christian de nous avoir fait découvrir ce petit circuit que nous emploierons bientôt dans nos décors.

Commande PWM pour les trains

 Un petit système de commande peut s'avérer bien utile pour piloter des trains. Jusqu'à présent, on s'oriente souvent vers une solution électronique mettant en œuvre le principe de modulation de largeur d'impulsions (PWM) car cela est fiable et bien adapté aux motorisations récentes des locomotives. Les schémas de principe disponibles sont nombreux (y compris avec Arduino) pour réaliser soi-même le montage, mais encore une fois l'intégration de l'électronique apporte une solution toute faite imbattable.

La commande PWM:

Sans rentrer dans les détails de la théorie sur modulation de largeur d'impulsions, retenez juste que cela permet de générer un signal analogique à partir de composants numériques et qu'en faisant varier la largeur des impulsions, on fait également varier la valeur moyenne du signal. 

La commande que nous vous présentons est le DC motor governor ZK-MG. 

Vue de la commande à côté de rails en HOe (F = 50 kHz)

C'est un module PWM de puissance pour moteur à courant continu  (5V, 12V, 24V) avec une gradation visible par LED, dans boîtier hyper compact, avec interrupteur, fréquence réglable, rapport cyclique réglable pour la limite supérieure et inférieure.

Caractéristiques techniques :

Les principales caractéristiques techniques sont le suivantes:

- Tension de fonctionnement : DC5V~30V, protection de l'entrée contre l'inversion de connexion.

- Courant nominal : 5A

- Courant maximum : 15A

- Puissance maximale : 150W

- Fréquence de travail : 1KHz~99KHz réglable, avec un pas de 1KHz

- Fréquence par défaut de 20KHz, précision d'environ 1%

- Cycle de travail : 0-100%, pas de 1%

- Taille  : 79mm*43mm*26mm

- Poids du produit : 41g

- Alimentation primaire nécessaire (vous avez sûrement un petit bloc d'alimentation en réserve)

Comment ça marche ?

Les connexions sont faites sur le bornier intégré. Deux entrée pour l'alimentation primaire et deux sorties pour l'alimentation des rails.

Tout se règle avec le bouton de l'encodeur numérique. Vous allez voir c'est très simple!

Un appui court permet de commuter le démarrage et l'arrêt du moteur.

Un appui long permet d'entrer dans l'interface de réglage.

Une rotation dans le sens inverse des aiguilles d'une montre diminue le rapport cyclique.

Une rotation dans le sens des aiguilles d'une montre augmente le rapport cyclique. 

Sous l'écran de réglage, on peut voir :

Par défaut le cycle de travail est affiché.

Le format d'affichage de la limite inférieure du cycle de travail est "L" suivie de deux chiffres.

Le format d'affichage de la limite supérieure du cycle de travail est "H" suivie deux chiffres ou "100".

Le format d'affichage de la fréquence de travail est "F" suivie deux chiffres (ex: F 50).

Un appui long provoque la sortie de l'interface de réglage.

La rotation dans le sens inverse des aiguilles d'une montre réduit la valeur.

La rotation dans le sens des aiguilles d'une montre augmente la valeur.

Vue de modulation à vide (50 kHz)

Sur la photo ci-dessus, on peut remarquer que le signal n'est pas rectangulaire. C'est normal car nous faisons une mesure à vide. La charge que nous ajouterons, lorsque la locomotive sera sur les rails, sera de type inductive et le signal sera alors rectangulaire. 

Essais et réglages:

Il est aussi très important de régler la fréquence du régulateur car si elle est trop basse, cela provoque l'ondulation de la puissance et une vibration du moteur. Si la fréquence est trop élevée, la perte de commutation est grande, le bruit électromagnétique est important.

La fréquence doit être choisie correctement, pour obtenir la puissance de sortie effective maximale du moteur.

La fréquence par défaut d'usine est de 20KHz, ceci peut répondre à la plupart des exigences du moteur. En matière de modélisme ferroviaire, il convient d'essayer afin de trouver la fréquence spécifique.

Vue de la commande (notez bien les 4 fils)

Pour nos essais, nous avons choisi des petites locomotives en HOe. Notre objectif étant d'utiliser cette commande sur un ensemble de modules pour une exposition. Nous avons utilisé une alimentation stabilisée de laboratoire (modèle analogique) comme source primaire et un oscilloscope professionnel pour effectuer les mesures.  

Ainsi, nous avons fait varier le rapport cyclique qui est le rapport entre la durée de l'état actif et la période. Dans l'exemple ci-après le rapport cyclique est d'environ 0,3 (300 /1000 microsecondes).

Vue de modulation en charge (F = 990 Hz,  rapport cyclique est de 0,3)

Dans cet autre exemple, la fréquence est inchangée mais le rapport cyclique est de 0,78 (780 /1000 microsecondes). La consigne programmée sur la commande était de 80.

Vue de modulation en charge (F = 990 Hz, rapport cyclique est de 0,8)

Après plusieurs essais, nous arrivons à de bons résultats avec un rapport cyclique autour de 0,16 et une fréquence de 14,7 KHz. Ceci n'est valable que pour les locomotives que nous avons testées. Le ralenti est très très bon. Cela est particulièrement intéressant pour piloter ces petits trains qui ont tendance à toujours aller trop vite avec une alimentation analogique standard.

rapport cyclique est de 0,42

Une petite vidéo pour illustrer :

Conclusions :

Cette commande est bien adaptée aux besoins du modélisme ferroviaire pour des petits réseaux.

Les points forts de cette commandes sont:

-  L'utilisation et réglages simples avec un seul bouton,

- Le bouton de l'encodeur numérique permet de régler la vitesse du moteur plus précisément qu'un potentiomètre ordinaire,

- Une fonction de démarrage progressif du moteur, ce qui peut le protéger efficacement et prolonger sa durée de vie.

- Le boîtier de l'appareil est hyper compact ce qui facilite son installation,

- Un prix très faible

Toutefois, il faudra ajouter un système d'inversion de la tension pour le rendre tout à fait adapté aux circulations ferroviaires (en particulier pour les manœuvres).

Merci à Jacques de nous avoir fait découvrir cette commande que nous utiliserons bien volontiers sur les modules LPT avec du HOe!