Messages

1

Débuter / Re : utilisation LMD18200 et mesure du courant

« le: juin 22, 2023, 03:29:24 pm »

merci!

2

Débuter / Re : utilisation LMD18200 et mesure du courant

« le: juin 22, 2023, 10:54:51 am »

super intéressant. Merci à vous 2: du coup ce n'est pas conseillé de brancher les LMD en //.
Pour les ACS712 je comprends de la datasheet que la mesure du DC est possible. AZ Delivery fournit aussi qlq pistes pour le brancher.
Sinon le driver BTS7960B a l'air vraiment bien et pas cher du tout.
merci bcp!!!

3

Débuter / utilisation LMD18200 et mesure du courant

« le: juin 22, 2023, 06:41:25 am »

Bonjour,
D'après les caractéristiques du LMD18200, le courant max est 3A et 6A sur les crêtes pendant 200ms. Je fais tourner 2 trains LGB sur mon circuit avec qlq accessoires. Afin de prévenir les courts-circuits, j'évite de faire tourner l'ensemble à fond. Grosso modo, avec tout qui fonctionne je m'en tire avec une conso de 2A que je mesure avec un générateur de labo qui alimente l'ensemble.
J'ai bien noté que le max471 présente des inconvénients du coup je vais essayer de mesurer le courant avec des capteurs ACS712 à effet de Hall. J'ai vu aussi que le pin8 du LMD18200 pouvait être utilisé pour mesurer son courant mais bon vu mon niveau je ne vais pas me lancer sur cette voie.
Pour augmenter la capacité de mon petit réseau avec une 3ème et 4ème loco je voulais savoir si conceptuellement on pouvait ajouter un 2ème booster qui viendrait piloter les 2 autres machines? Je n'pas vu de schéma qui va dans ce sens mais je pose tout de même la question. Sinon est-il concevable de monter 2 booster en parallèle pour augmenter le courant de 3A a 6A? Je n'ai rien vu de tel mais là encore je me risque de poser la question.
merci et bonne journée.

4

Débuter / Re : signal DCC directement récupéré sur arduino

« le: septembre 04, 2022, 01:20:30 pm »

optocoupleur pardon et "choisie". désolé pour les erreurs de frappe.

5

Débuter / signal DCC directement récupéré sur arduino

« le: septembre 04, 2022, 10:34:50 am »

Bonjour dans ce schéma le signal DCC arrive directement dans le PIC. Dans un autre montage j'ai vu que celui-ci arrivait sur la PIN2 d'un atteny85 qui est analogique sauf erreur de ma part. Une résistance entre 22 et 27kOhms est choisis. Savez-vous comment cette résistance est calibrée pour ce type de signal? L'intérêt est que cette méthode permet de rationaliser le circuit et d'éviter l'octocoupleur.

6

Débuter / Re : utilisation de la bibliothèque NMRADCC

« le: août 27, 2022, 02:15:50 pm »

re bonjour
j'ai trouvé la réponse. Pour celles et ceux que cela intéresse:
https://forum.arduino.cc/t/nmradcc-utilisation/1026078
Désolé pour le dérangement
bonne journée

7

Débuter / utilisation de la bibliothèque NMRADCC

« le: août 27, 2022, 08:23:20 am »

Bonjour à tous,
J'essaie d'utiliser NMRADCC pour lire les trames d'accessoires.
Lorsque j'envoie par exemple la trame suivante:
11111111111111111111  0 10100111  0 11011001  0 01111110  1
il s'agit de l'adresse 167
on a bien reconstitué l'octet 010100111 pour 167
le port 1 est sélectionné actif et ouvert.
Pourtant le programme renvoie 665 comme adresse au lieu de 167.
J'ai fabriqué la centrale moi-même. Tout fonctionne pour les locos (les décodeurs sont des massoth eMotion L). Par contre je n'arrive pas à utiliser nmradcc.
Est ce que quelqu'un a déjà rencontré cette situation? peut-être s'agit-il d'un paramètre manquant?
Merci bcp.

Code: [Sélectionner]

#include <NmraDcc.h>

#define DCC_PIN 2

NmraDcc Dcc;

void notifyDccAccTurnoutOutput(uint16_t Addr, uint8_t Direction, uint8_t OutputPower) {

  Serial.print("Addr: ");Serial.print(Addr);
  Serial.print("Direction: ");Serial.print(Direction);
  Serial.print("OutputPower: ");Serial.print(OutputPower);
  Serial.println("-----------------------------");
 
}


void setup() {
Serial.begin(115200);
pinMode(RED_LED, OUTPUT);
pinMode(GREEN_LED, OUTPUT);
 Dcc.pin(digitalPinToInterrupt(DCC_PIN),DCC_PIN, false);
Dcc.init( MAN_ID_DIY, 10, CV29_ACCESSORY_DECODER | CV29_OUTPUT_ADDRESS_MODE, 0 );

}

void loop() {
  Dcc.process();


}


8

Débuter / Re : Questions conceptuelles: alimentation et aiguille LGB

« le: juillet 27, 2022, 10:20:44 pm »

Je peux rajouter une résistance après les condensateurs pour les délester de leur courant une fois la centrale éteinte?

9

Débuter / Re : Questions conceptuelles: alimentation et aiguille LGB

« le: juillet 27, 2022, 03:26:30 pm »

Je vous remercie! C'est trèsn juste mais il faut bien commencer par s'y mettre. Du coup c'est plus clair pour moi.  Merci bcp

10

Débuter / Re : Questions conceptuelles: alimentation et aiguille LGB

« le: juillet 27, 2022, 02:56:59 pm »

Pour le pont redresseur il yn a un compsant clé en main? sinon je prends quel type de diodes? Désolé pour toutes ces questions où les réponses doivent être évidentes pour vous. merci bcp!

11

Débuter / Re : Questions conceptuelles: alimentation et aiguille LGB

« le: juillet 27, 2022, 01:44:55 pm »

Merci beaucoup. Je ne suis pas du tout spécialiste de tout cela mais au début: un pont redresseur pour transformer le courant alternatif en courant continu, ensuite une série de diodes. Le dessin IN OUT GND représente un composant particulier? Merci bcp

12

Débuter / Questions conceptuelles: alimentation et aiguille LGB

« le: juillet 27, 2022, 07:24:06 am »

Bonjour à tous,
J'aimerais faire fonctionner un aiguillage LGB avec un décodeur de fonction. J'ai trouvé une vidéo que je trouve intéressante:

Le moteur que je souhaite utiliser est là:https://www.maerklinshop.de/en/54374/turnout-mechanism
J'ai vu plusieurs tuto, notamment ceux de Rudy avec le schéma https://rudysmodelrailway.wordpress.com/software/
Mes questions sont en supposant mon alimentation vient des rails +18V ou des signaux DCC parcourent la voie: je relie les rails à l'octocoupleur et l'idée est d'utiliser un attiny85 avec un  drv8871 comme sur la video .
1/ comment puis-je faire: le signal dcc arrive sur l'octocoupleur mais comment je peux alimenter en courant l'attiny85 en 5v?
2/ le moteur d aiguillage LGB demande un courant 14-20V max du coup est ce que je peux alimenter le drv8871 avec le courant de la voie?
J'ai posé les questions à Earl Earl la personne très talentueuse de cette vidéo mais pas de réponse et pas de schéma.
Un grand merci
et bonne journée ou/et bonnes vacances
ElGringo

13

Vos projets / Re : centrales dcc esp32 trimarco232

« le: juin 26, 2022, 09:16:34 am »

Bonjour à tous,

Je continue avec l'idée de Trimarco. J'ai repris qlq lignes. Je suis du coup sur paltformio. Tout compile correctement par contre dans l'interruption l'égrenage des bits ne semble pas fonctionner. Sur l'oscilloscope j'obtiens que le bit 0. J'ai remplacé le scheduler par une série de switch aussi pour simplifier et tester de manière simple.
J'ai peu être déraillé qlq part. Ci dessous mon code.

Code: [Sélectionner]

#include <Arduino.h>
#include "driver/ledc.h"

volatile uint8_t schedule_p3[16], schedule_p3n=0; // variable volatile stockée dans RAM
volatile uint8_t schedule_p2[16], schedule_p2n=0;
volatile uint8_t schedule_p1[16], schedule_p1n=0;
volatile uint8_t schedule_p0[128], schedule_p0p=1,schedule_p0n=0 ;
volatile uint8_t packet_bits[128];
volatile uint8_t packets_length[128], packet_bit_pointer, packet_to_send=0;

volatile int scheduler_case;
volatile int prio;


// DEFINITION DE LA SORTIE PWM
#define DCC_PIN 22

// ON DEFINIT LES PULSIONS PWM
const uint16_t DCC_BIT_1_FREQ = 8621; // 116 microsecondes
const uint16_t DCC_BIT_0_FREQ = 5000; // 200 microsecondes
const int dcc_pin_channel = 0; // CANAL PWM 0
const int dcc_sig_resolution =1; // on est sur 1 bit de resolution 2^1 2 valeurs possibles
const int dcc_sig_duty=1; // on est sur 1 bit de resolution 1/2^1 50%
//initialisation de la frequence
uint32_t dcc_sig_freq=DCC_BIT_1_FREQ;


void example(void) {

packet_bits[0]=(uint64_t)0b111111111011111111011111111011111111111111111111; // case 0
packet_bits[1]=(uint64_t)0b111001111011101111011110011011111111111111011111; // case 4
packet_bits[2]=(uint64_t)0b111001111011101111011110011011111111111101111111; // case 3 on le renvoie 3 fois de suite
packet_bits[3]=(uint64_t)0b111001111011101111011110011011111111110111111111; // case 3
packet_bits[4]=(uint64_t)0b111001111011101111011110011011111110111111111111; // case 6
packet_bits[5]=(uint64_t)0b111001111011101111011110011011111110111111111111; // case 6

packets_length[0]=48;
//schedule_p0n++;schedule_p0[schedule_p0n]=1;
packets_length[1]=48;
//schedule_p0n++;schedule_p0[schedule_p0n]=2;
packets_length[2]=48;
//schedule_p0n++;schedule_p3[schedule_p3n]=3;
packets_length[3]=48;
schedule_p3n++;schedule_p0[schedule_p0n]=4;
packets_length[4]=48;
//schedule_p0n++;schedule_p0[schedule_p0n]=5;
packets_length[5]=48;
//schedule_p0n++;schedule_p0[schedule_p0n]=5;


scheduler_case=(schedule_p3n)?3:0;


}

// declration des voids
void scheduler(void);
void dcc_sig_isr();
void setup_ledc(void);
//static uint8_t parti=0; // test packet parti

void setup() {
  // put your setup code here, to run once:
  Serial.begin(460800);
  setup_ledc();
  example();
 // pour commencer
 //packet_to_send=0;
 Serial.print("packet bit pointer:");Serial.println(packet_bit_pointer);

}

void loop() {
 // if (packet_bit_pointer>48){
   // packet_bit_pointer=0;
  //  Serial.print("err_pbp>5: ");Serial.print(packet_bit_pointer);
 // }else if (packet_bit_pointer != 0) {
  scheduler();
 packet_bit_pointer=packets_length[packet_to_send];
  //Serial.print("packet:   ");Serial.print(packet_to_send); Serial.print("    pbp   :"); Serial.println(packet_bit_pointer);
 // }

//Serial.print(packet_bit_pointer);
//delay(1000);
}

void dcc_sig_isr() {
  //if (dcc_sig_freq ==DCC_BIT_0_FREQ) dcc_sig_freq = DCC_BIT_1_FREQ ; // inverse la valeur du bit dcc précédent
 //else dcc_sig_freq = DCC_BIT_0_FREQ;
  static uint32_t old_dcc_sig_freq ; // fréquence précédente
 
  if (packet_bit_pointer==0) {
   dcc_sig_freq=DCC_BIT_1_FREQ; //on continue d envoyer des 1 tant qu on recoit rien
  }else{
 
      --packet_bit_pointer;
      Serial.println(packet_bit_pointer);
    uint64_t bit_pointer_mask=(uint64_t)1<<packet_bit_pointer;

            if (bit_pointer_mask&packet_bits[packet_to_send]) {

                    dcc_sig_freq=DCC_BIT_1_FREQ; // si tu pointes 1 envoie 1

           }else{

                   dcc_sig_freq=DCC_BIT_0_FREQ;  // si tu pointes 0 envoie 0
            }
  }
 
  if (dcc_sig_freq !=old_dcc_sig_freq) {
    ledc_set_freq(LEDC_HIGH_SPEED_MODE, LEDC_TIMER_0,dcc_sig_freq);
   dcc_sig_freq=old_dcc_sig_freq;
  }

}


void setup_ledc() {
  ledcSetup(dcc_pin_channel,dcc_sig_freq,dcc_sig_resolution);
  ledcAttachPin(DCC_PIN,dcc_pin_channel);
  ledcWrite(dcc_pin_channel,dcc_sig_duty);
  attachInterrupt(DCC_PIN,dcc_sig_isr,RISING);
 
}


void scheduler(void) {
   


switch (scheduler_case) {
 
  case 0:

            switch (prio) {
                case 0:
                //Serial.println("prio 0 send 1");
                packet_to_send=0;
                prio=4;
                break;
             
                case 4:
               // Serial.println("prio 0 send 1");
                packet_to_send=1;
                prio=5;
                break;


                case 5:
               // Serial.println("prio 0 send 2");
                packet_to_send=2;
                prio=6;
                break;

                case 6:
               // Serial.println("prio 0 send 2");
                packet_to_send=4;
                prio=7;
                break;

                case 7:
               // Serial.println("prio 0 send 3");
                packet_to_send=5;
                scheduler_case = 3;
                break;
            }
  //scheduler_case = 3;
  break;

  case 1:
 // Serial.println("prio 1 send 3");
  scheduler_case = 0;
  packet_to_send=3;
  prio=0;
  break;

  case 2:
 // Serial.println("prio 1 send 2");
  packet_to_send=3;
  scheduler_case = 1;
  break;

 case 3:
 // Serial.println("prio 1 send 1");
  packet_to_send=3;
  scheduler_case=2;
  break;

}

}

Ndlm : avec la balise code c'est plus joli !

14

Vos projets / tentative de petite centrale DCC sur ESP32

« le: mai 21, 2022, 08:57:45 am »

Bonjour, voilà grâce à des aides précieuses je me suis tenté une petite expérience pour créer une centrale DCC sur esp32.
Ma démarche est elle bonne? mon programme s'inspire des idées de Trimarco.
Si je suis sur le bon chemin est ce que je dois utiliser memcpy pour garder le bit paquet en mémoire ou bien est ce que je peux utiliser une structure pour l'envoyer comme message struct t_message?
en gros dans la fonction d'interruption, le signal pwm se répète tant que le bit ne change pas. Ainsi pour les 20 premiers bit 1, il n'y a pas d interruption. Dès que le bit start est atteint on envoie une interruption et ainsi de suite. ma synchro est elle bonne?

la fonction SpeedAndDir( 3, CRAN_1,128, 1);
permet dans le loop de sélectionner la loco 3, une vitesse sur 28 pas et une marche avant (j ai normé la vitesse a 128 pas discrets avec une interpolation linéaire).

Merci pour votre aide (et je ne suis qu'un humble débutant).

Code: [Sélectionner]


#include "driver/ledc.h"

uint64_t paquet;//=0b... 48 bits
uint64_t NewPacket;//0b.. 48bits;
uint64_t masque;
uint64_t dccBit;
bool alter =1;
bool previous=0;


#define CRAN_0 0
#define CRAN_1 1
#define CRAN_2 2
#define CRAN_IDLE 5

byte dccSpeed;
byte addr;
byte adresse;
byte vitesse;
byte cksum;
uint64_t paquet_start=0b111111111111111111110;  // 20 bits + bit start
byte startBit=0;
byte stopBit=1;

const int dcc_pin = 19;  // Sortie du signal DCC

// setting PWM properties
#define dcc_sig_1_freq 8621 //  = 115,99 microS
#define dcc_sig_0_freq 5000 // 200µs 5000 Hz donne 200 microS
const int dcc_pin_channel = 0; // on ouvre un canal qu on reliera à une sortie PWMN
const int dcc_sig_resolution = 1; // correspond à une résolution de 1 bit => 2^1bit =2 pas discrets0 et 100%.
const int dcc_sig_duty = 1; // correspond à une résolution de 1 bit => 2^1bit =2 pats discrets 0 et 100%.
uint32_t dcc_sig_freq = dcc_sig_1_freq; // on part de la fréquence du bit 1 toutes les trames commencent par une série de 20 bits a 1



void dcc_sig_isr() {

dccBit=!!(paquet&masque);  // les bits différents de 0 valent 1
masque>>=1; // le masque permet de parcourir les bits
if (dccBit==previous) {  // si le bit parcouru est == 0 alors il faut envoyer une interruption, alter qui valait 1 au début se transforme en 0
alter=!alter;
//Serial.print(alter);
alter?dcc_sig_freq =dcc_sig_1_freq:dcc_sig_freq =dcc_sig_0_freq;
}


ledc_set_freq(LEDC_HIGH_SPEED_MODE, LEDC_TIMER_0, dcc_sig_freq); // new -or not - period value
 //speed_mode: Select the LEDC channel group with specified speed mode. Note that not all targets support high speed mode.
//timer_num: LEDC timer index (0-3), select from ledc_timer_t
//freq_hz: Set the LEDC frequency
// est ce que je dois laisser cette ligne de code? quelle est son utilité ici? je comprends qu elle permet de selectionner le timer 0 mais pourquoi la mettre ici et pas ailleurs?
}

void setup() {
  Serial.begin(115200);
uint64_t paquet =0; // on initialise la trame
uint64_t NewPacket=0; // on utilise une trmne reformatée plus simple pour limiter les interruptions et aider l'esp32

 // configuration du canal pwm 0 avec une fréquence et la résolution
  ledcSetup(dcc_pin_channel, dcc_sig_freq, dcc_sig_resolution); // on set up le canal avec une résolution de 1 bit cad 50%
  ledcAttachPin(dcc_pin, dcc_pin_channel); /// et ensuite on l attache au PIN19
  ledcWrite(dcc_pin_channel, dcc_sig_duty);
  // programme l'interruption à la fin de la période
// je n'ai pas trouvé de manière élégante pour le faire avec le timer, alors je me suis rabattu pragmatiquement sur une interruption provoquée ... par le basculement de la pin
  attachInterrupt(dcc_pin, dcc_sig_isr, RISING); // l'interruption "dcc_sig_isr" provoquée à la fin de chaque période (voire au début de la suivante) =>moi non plus
 
}




/// Select Cran = 14,28 ou 128
/// Select Speed = 0......128
/// Select Direction 1 Avant, 2 Arriere, 0 Arret

struct __attribute__((packed)) t_message {
  byte adresse;
  byte vitesse;
  byte cksum;
}; t_message unMessage;




// fonction de calcul 3 octets
void SpeedAndDir( byte addr=0b11111111, byte SelectCran=0b00000000, byte SelectSpeed=0b00000000, bool SelectDirection=0) // vecteur de direction et de vitesse
{
  byte type;
  byte ext;
  byte data;
  byte cksum=0;
  uint64_t paquet=0;


      switch(SelectCran) {

          case 0:   ////DCC_PACKET_TYPE_STEP_14
              dccSpeed=map(SelectSpeed,0,128,0,14);
              if (dccSpeed) dccSpeed++; // pas de cran 1
              data=(SelectDirection?0x60:0x40)|dccSpeed;
              cksum=addr^data;
              break;

             
          case 1: ///DCC_PACKET_TYPE_STEP_28

              dccSpeed=map(SelectSpeed,0,128,0,28);
              if (dccSpeed) dccSpeed+=3; // pas de cran 1,2,3
              ext=(((dccSpeed&0x01)<<5)|dccSpeed)>>1;   ///
              data=(SelectDirection?0x60:0x40)|ext;
              cksum=addr^data;
              break;
             
          case 2:  //DCC_PACKET_TYPE_STEP_128;
               dccSpeed=map(SelectSpeed,0,128,0,126);
              if (dccSpeed) dccSpeed++; // pas de cran 1
              data=(SelectDirection?0x60:0x40)|dccSpeed;
              cksum=addr^data;
              break;

           case 5:  //IDLE;
               data=0b00000000;
              cksum=addr^data;
              break;             
      }

                       //unMessage.adresse=addr;
                      // unMessage.vitesse=data;
                      // unMessage.cksum = unMessage.adresse ^ unMessage.vitesse;

                            //memcpy(payload, &unMessage, sizeof unMessage);
                            //DccByteCount=sizeof unMessage;

paquet=(paquet_start << 27) |(addr<<19)|(startBit<<18)|(data<<10)|(startBit<<9)|(cksum<<1)|(stopBit<<0);


}





void loop() {
SpeedAndDir( 3, CRAN_1,128, 1);
delay(50000);
}




15

Vos projets / cabbage

« le: mai 14, 2021, 01:45:48 pm »

Bonjour,
j'ai opté pour ce type d'organisation. pour le courant j'ai un générateur de labo qui fournit le courant. Si je veux étendre mon circuit à une voie de programmation sans avoir un 2ème générateur, que puis-je prendre comme bornier ou domino qui va répartir le courant sur les 2 voies à partir du même générateur? merci bcp