Les Électroniciens.com

Je pense que ce site peut être intéressant pour toi ainsi que celui-ci et enfin sur youtube  pour ne pas réinventer l'eau chaude !

Bonjour,

il existe un petit module assez sympa sur ali 

tu peux générer un pwm de 3.3v a 30v selon la tension d'entrée et choisir le duty et la frequence de 1 hz a 150khz si tu veux faire des test voici le lien ( il existe aussi avec potentiometre).

https://fr.aliexpress.com/item/32839042221.html?spm=a2g0s.9042311.0.0.27426c37C0WWPn

si ca peut aider

Salut,
je ne suis pas sûre d'avoir compris complètement ta problématique.

L’arduino va générer un signal qui va se 0V à 5V. Il suffit de mettre un condensateur de liaison et il devient alternatif de +2.5v/-2.5v.

Pour moi ce n'ai pas exactement ça, l'arduino va générer des états logiques (0v, +5V) qui vont piloté par exemple des transistors, AOP qui vont te fornir le signal voulu avec les bornes voulus(ex +12V, -12V ou même +3V, -10V si besoin).

Du coup si tu utilise 2 sorties arduino pour piloter 2 transistors.
Par contre je n'ai pas bien compris qu'elle est ta composante continue dans ton signal carré?

Juste un petit truc pourquoi ne pas faire la télécommande par WIFI, pas cher petit et performant ! Possibilité de piloter depuis un pc jusqu'à 250 locomotives voir plus en bidouillant un peu !

si tu fais ta propre commande de puissance, tu peux avoir les tensions que tu veux symétrique ou pas et avec un courant max dépendant des transistors que tu utilises(5A, 10A, 20A, ...) avec la fréquence que tu veux dans la limite de l'arduino et de la rapidité de commutation des transistor.

quel est l'espace disponible dans tes loco?
Car je pense que le Wifi reste une bien meilleur solution pour quelques € par loco!

Si je comprend bien le système de commande du moteur électrique qui réagi en fonction du rapport des créneaux sur l'alimentation des rails PWM0 il suffit effectivement d'une part de redresser celui ci pour obtenir un courant continu qui permettra d'alimenter par exemple l'éclairage des wagons et la puissance pour le moteur de traction. D'autre par de calculer le rapport des créneaux sur une onde pour en déduire 1 le sens de rotation du moteur et 2 la vitesse de ce dernier.

Pour ce faire il faut, grâce à un Arduino mettre un Chronomètre à zéro (T0 =0) sur le passage d'un niveau à un niveau bas de ce PWM0 +ou - 12 volts. Puis de prendre de chronométré le temps T1 au passage au niveau haut de ce même PWM et T2 enfin le retour au niveau bas.

Fort de ces valeurs il faut calculer le rapport R entre T1 et T2 soit R = T1/T2, si celui-ci est R = 0.5 le moteur est à l'arrêt, si R > 50% le moteur tourne dans un sens, et si R est < 50%  le sens de rotation est inversé.

En ce qui concerne la vitesse cette fois ci il faut que l'Arduino recrée un autre signal PWM1 qui lui servira à alimenté le moteur de traction de la manière suivante :

Soit T3 la valeur moyenne du PWM0 donc 50% de  T2  (Valeur d'une demi onde du PWM0) T1 lui peut varié de 0% de T2 à 100% de T2

Donc si on prend par exemple T2 = 2 ms T3= 1 ms et T1 peut varié de 0 à T2 donc de 0 ms à 2 ms

Ce qui fait que PWM1 respecte la formule  PWM1 =  (50 - PWM0) * 5.12 ;

En faisant un tableau sous excel avec un pas de 0.2 pour T1 on obtient :

On voit bien que la valeur PWM1 varie de 255 à font dans un sens à -255 à font dans le sens inverse en passant par 0 lorsque les créneaux de PWM0 sont à 50%.

Avec le schéma suivant :

Ce calcul permet d'établir le code suivant en utilisant les interruptions sur la pin N° 2 de l'arduino !

const byte interruptPin = 2;
const byte pinPWM = 3;
const byte pinSens = 4;

unsigned long volatile T0;
float T1, T2, T3, Onde, Alter;
int PWM0, PWM1, Sens, n;

void setup() {

  setPwmFrequency(3, 1);
  // Serial.begin(1000000);
  pinMode(pinPWM, OUTPUT);
  pinMode(pinSens, OUTPUT);
  pinMode(interruptPin, INPUT);
}

void ISR1() {
  T0 = micros();
}

void loop() {
  cli();
  attachInterrupt(digitalPinToInterrupt(interruptPin), ISR1, FALLING);
  T0 = 0;
  sei();
  while (T0 == 0) {  }
  T1 = T0;
  attachInterrupt(digitalPinToInterrupt(interruptPin), ISR1, RISING);
  T0 = 0;
  while (T0 == 0) {  }
  T2 = T0;
  attachInterrupt(digitalPinToInterrupt(interruptPin), ISR1, FALLING);
  T0 = 0;
  while (T0 == 0) {  }
  T3 = T0;
  Serial.println("***************");
  Onde = T3 - T1;
  Alter = T2 - T1;
  //  Serial.print("PWM0 :");
  PWM0 = 0.5 + (1 - (Alter / Onde)) * 100;
  //  Serial.print(PWM0);
  //  Serial.println(" %");
  //  Serial.print("PWM1 :");
  //  Serial.println(abs(PWM1));
  PWM1 =  (50 - PWM0) * 5.12 ;
  //  Serial.print("Sens :");
  if (PWM1 == 0)
    digitalWrite(pinSens, HIGH);
  //    Serial.println("Arrêt");
  else if (PWM1 < 0)
    digitalWrite(pinSens, HIGH);
  //    Serial.println("Avant");
  else
    digitalWrite(pinSens, LOW);
  //    Serial.println("Arrière");
  delay(20);
  analogWrite(pinPWM, PWM1);
}

void setPwmFrequency(int pin, int divisor) {
  byte mode;
  if (pin == 5 || pin == 6 || pin == 9 || pin == 10) {
    switch (divisor) {
      case 1: mode = 0x01; break;
      case 8: mode = 0x02; break;
      case 64: mode = 0x03; break;
      case 256: mode = 0x04; break;
      case 1024: mode = 0x05; break;
      default: return;
    }
    if (pin == 5 || pin == 6) {
      TCCR0B = TCCR0B & 0b11111000 | mode;
    } else {
      TCCR1B = TCCR1B & 0b11111000 | mode;
    }
  } else if (pin == 3 || pin == 11) {
    switch (divisor) {
      case 1: mode = 0x01; break;   // 31370 Hz
      case 8: mode = 0x02; break;   // 3920 Hz
      case 32: mode = 0x03; break;  // 980 Hz
      case 64: mode = 0x04; break;  // 490 Hz
      case 128: mode = 0x05; break; // 244 Hz
      case 256: mode = 0x06; break; // 122 Hz
      case 1024: mode = 0x7; break; // 30 Hz
      default: return;
    }
    TCCR2B = TCCR2B & 0b11111000 | mode;
  }
}

Voilà qui n'est pas trop compliqué, je n'ai pas testé mais il ne devrait pas y avoir trop d'erreur  !

la sortie pinPWM est a raccordée à l'entrée d'un driver PWM de ce type par exemple

et la sortie pinSens à raccordée à l'entrée d'un pont en H. de ce type par exemple

on peut se passer du driver PWM en augmentant la fréquence du PWM

avec le code suivant que j'ai déjà  intégré dans le code au dessus en gras !

avec la ligne

setPwmFrequency(3, 1);

dans le setup, les fréquences indiquées ont été mesurées sur mon fréquencemètre

void setPwmFrequency(int pin, int divisor) {

   byte mode;

   if(pin == 5 || pin == 6 || pin == 9 || pin == 10) {

      switch(divisor) {

         case 1: mode = 0x01; break;

         case 8: mode = 0x02; break;

         case 64: mode = 0x03; break;

         case 256: mode = 0x04; break;

         case 1024: mode = 0x05; break;

         default: return;

      }

      if(pin == 5 || pin == 6) {

         TCCR0B = TCCR0B & 0b11111000 | mode;

      } else {

         TCCR1B = TCCR1B & 0b11111000 | mode;

      }

   } else if(pin == 3 || pin == 11) {

      switch(divisor) {

       case 1: mode = 0x01; break;   // 31370 Hz
      case 8: mode = 0x02; break;   // 3920 Hz
      case 32: mode = 0x03; break;  // 980 Hz
      case 64: mode = 0x04; break;  // 490 Hz
      case 128: mode = 0x05; break; // 244 Hz
      case 256: mode = 0x06; break; // 122 Hz
      case 1024: mode = 0x7; break; // 30 Hz

         default: return;

      }

      TCCR2B = TCCR2B & 0b11111000 | mode;

   }

}

Je n'ai pas compris pourquoi intercepter un PWM pour en créer un autre.
le but n'est pas de passer par l'écran tactiles pour définir la vitesse des locos et donc générer le PWM?

Bonjour,

ce qu'il veut s'est obtenir un éclairage permanent dans les wagons tout en ayant la loco a l'arret ou en marche et tout ca par les rails donc si je comprends bien il veut un pwm pour la vitesse du moteur et un autre signal pour l'eclairage ,  une sorte de multiplexage . peut être un signal alternatif haute fréquence qui pourrait être redressé ensuite pour l'eclairage des wagons et filtrer par la loco pour laisser passer que le pwm .  est ce que c'est possible ?

Hercule c'est exactement cela, l'Arduino recrée un PWM dans la loco pour son moteur de traction par contre il reste un petit problème c'est que le 24 volts devient uniquement 12 V quand le PWM des Rails attends les 100% j'espère ce cela n'arrive jamais !

Le seule autre solution c'est comme je l'ai dit au début c'est la wifi ! Là plus aucun soucis !

Ok, mais d'ou vient le PWM décodé par l'arduino et pourquoi le recréer?

pourquoi l'arduino ne créé pas le PWM a partir des informations fournis par l'écran tactile ?

Walter on est plusieurs à avoir compris alors pourquoi pas toi ????

Bon je vais essayer de t'expliqué.

Le système utilise un artifice avec PWM pour communiquer entre la station de commande et la loco via les rails. Le principe est que lorsque le PWM envoyé dans les rails est de 50% la loco ne doit pas bouger !! Donc pas possible d'utiliser ce courant tel quel ! lorsque les créneaux de de PWM que j'appelle PWM0 varie avec des créneaux positif plus long que les créneaux négatif la loco se déplace dans un sens et proportionnellement  au rapport entre les deux créneaux et inversement quand les créneaux positifs sont plus courts que les négatifs !

Donc si on envoie directement le PWM0 au moteur il aura toujours le même sens mais à 50% du PWM0 il tournera à 50% de la vitesse alors que l'on veut qu'il reste immobile !

As tu compris ?

Ba non car ce n'est pas ma question, parce que ce que je ne comprend pas, c'est pas le PWM désiré, mais pourquoi tu parle d'une station de commande qui enverrais un PWM (+0V, +xV), alors qu'il parle d'un système propriétaire qu'il est entrain de développé à base d'arduino.

Donc je suppose qu'il définit la vitesse de son train via son écran tactile et qu'il veut que son arduino crée le pwm (-12V, +12V) .

Je ne ferrais pas de remarque, sur ta première phrase afin de ne pas jeter de l'huile sur le feu, mais était-elle vraiment nécessaire?

Houla cela ne correspond pas dutout à ce que j'avais compris, désolé mais j'abandonne là !

J'ai trouveé un groupe d'rticle qui répond à 100 %  à votre problèmatique, tout y est expliqué pour

Piloter des trains et des accessoires par DCC  et cerise sur le gâteau c'est en français !

Par contre en lu le principe de codage cela n'a absolument rien à voir avec les explications que tu nous as fournies !

De plus il existe des libraries toutes faites pour faire des modules maison compatibles LENZ à partir de carte Arduino !

Voir aussi ici

Je n'y connais rien en maquettes ferroviaires et cela ne m'intéresse pas donc je suis désolé de te laisser ici  mais bonne chance pour la suite

Par contre j'ai testé le code que j'ai mis en ligne il y a un problème avec micros(). qui n'est pas fiable. Comme je n'ai pas le matériel pour le testé en réel je le suis servi d'un fréquencemètre et d'un générateur de signaux, cela ne fonctionne pas ! Je vais chercher une solution pour résoudre de problème.

J'ai trouvé la parade le code initial est à jour  !

Dans un premier temps j'ai créer un code pour vérifier le bon fonctionnement de mon algorithme dont le code est ci-dessous.

const byte interruptPin = 2;
unsigned long volatile T0;
float T1, T2, T3, Onde, Alter;
int PWM0, PWM1, Sens;n;

void setup() {
  Serial.begin(1000000);
  pinMode(interruptPin, INPUT);
}

void ISR1() {   T0 = micros();}

void loop() {
  cli();
  attachInterrupt(digitalPinToInterrupt(interruptPin), ISR1, FALLING);
  T0 = 0;
  sei();
  while (T0 == 0) {  }
  T1 = T0;
  attachInterrupt(digitalPinToInterrupt(interruptPin), ISR1, RISING);
  T0 = 0;
  while (T0 == 0) {  }
  T2 = T0;
  attachInterrupt(digitalPinToInterrupt(interruptPin), ISR1, FALLING);
  T0 = 0;
  while (T0 == 0) {  }
  T3 = T0;
  Serial.println("***************");
  Onde = T3 - T1;
  Alter = T2 - T1;
  PWM0 = 0.5 + (1 - (Alter / Onde)) * 100;
 PWM1 =  (50 - PWM0) * 5.12 ;
   Serial.print("PWM0 :"); Serial.print(PWM0);  Serial.println(" %");
  Serial.print("PWM1 :"); Serial.println(abs(PWM1));
  Serial.print("Sens :");
  if (PWM1==0)   Serial.println("Arrêt");
  else if (PWM1 < 0)     Serial.println("Avant");
  else     Serial.println("Arrière");
  delay(20);
}

Il semble bon, vous pourrez le constater sur la vidéo qui suit. Je modifierai le code initial un peu plus tard !

Mon générateur de fréquence offre la possibilité d'être piloté depuis un PC via un programme donc vous pourrez constater que lorsque PWM0 (sortie générateur) =50 % le PWM1 (généré par l'Arduino) est à 0 donc le sens est à l'Arrêt.

Pour une valeur Supérieure de PWM0 le sens est en Avant et PWM1 proportionnel à l'écart de PWM0 avec 50% et pour une valeur Inférieure c'est le sens qui passe en Arrière.

Par contre il vaudrait mieux utiliser le système DCC qui te permet de piloter tout un tas de loco et accessoires, je me pencherais peut être dessus !