Voir les contributions

Cette section vous permet de consulter les contributions (messages, sujets et fichiers joints) d'un utilisateur. Vous ne pourrez voir que les contributions des zones auxquelles vous avez accès.


Messages - becbunsen

Pages: 1 2 [3] 4
31
Bus CAN / Re : Re : Question mise en place CAN dans la centrale DCC
« le: janvier 08, 2024, 12:51:49 am »
Michel a raison de metre le doigt sur l’aspect technique qui n’est pas, et de loin, le principal problème.

Faire circuler des messages CAN sur un bus, on sait faire.

Mais pour faire quoi et comment le faire au mieux. Et il a donc raison s’insister, qu’ai-je envie de faire sur mon réseau ? Car même si nous cherchons à standardiser le plus possible, nous aurons du mal à tout appréhender.

C’est vrai que j’ai beaucoup étudier les commandes CAN de Marklin et il faut franchement reconnaitre qu’ils ont fait un super boulot dont je suis persuadé nous devons nous inspirer.

C’est la messagerie qui est le cœur de la solution, la vraie valeur ajoutée. Combien d’appareils à piloter, dans quelles catégories (Traction, rétro signalisation de capteurs tout-ou-rien), de détection plus élaborées (Railcom, RFID, MFX…). Comment élaborer des messages aussi simples que possibles et portant le plus efficace possible. Voilà un petit aperçu.

Ce serait effectivement intéressant que vous soumettiez vos souhaits car je cherche à faire actuellement un inventaire des besoins pour voir le champ global de la réflexion.

S’inspirer de Marklin a ses limites car ils n’utilisent le CAN que pour la seule traction (au sens large tout de même) mais pas à la rétro signalisation par exemple qui reste en S88, même techniquement un peu amélioré.

Michel a encore raison, j’ai mis les doigts dedans (le CAN) et je n’ai pas l’intention de m’arrêter avant tout de suite. On en reparlera donc volontiers.

Sur l’aspect automatismes dont vous parlez, je vais publier très prochainement le début d’une série d’articles sur ce que j’ai appelé « les satellites autonomes ». Je crois que ça répond bien à votre attente. Il est associé à Railcom effectivement, car si LaBox n’a pas encore Railcom, nous avons tout de même des centrales compatibles Railcom. Avez-vous lu l’article : https://www.locoduino.org/spip.php?article334

Et ils utilisent un bus CAN pour communiquer. La vidéo ici n’est pas forcement très explicite mais elle montre comment une locomotive est tout d’abord ralentie puis arrêtée sans aucune intervention humaine quand le canton précédent est occupé. https://youtu.be/qTaGxd1uDpA?si=h6VSbw2_M5puNT3i

N'hésitez pas à revenir vers moi.

Bien amicalement

Christophe

Merci de vos retours, Je reviens ici tardivement, j'avoue que je cherche encore le mode de fonctionnement de mon réseau. Ce qui est sur: c'est que mon reseau est de type étagere (etroit) par module et évolutif. je ne travaille que sur un module à la fois (1,20m de long sur 30 de large) et je ne connais pas à l'avance mes futurs modules, j'envisage quand même une boucle de retournement d'un coté.
Le "modele" de ce que j'aimerai réaliser, en terme de taille et d'aspect serait (en toute modestie...) quelque chose comme celui-ci

Dans cet exemple, le fonctionnement des 2 gares pourrait être indépendant (il faut juste ne pas envoyer de trains de chaque coté comme c'est une voie unique)
Pour l'instant, J'attaque mon second module qui sera une simple gare à 2 voies + 1 voie de garage. J'ai conçu un connecteur en 3D pour bien aligner les modules et les extrémités des rails sont soudés sur une bande de PCB vissé dans le module. (il faut que je trouve comment mettre des photos.)
Concernant la connectique, j'ai envisagé une connection entre les modules par connecteurs Molex 6 poles : 2 pour le DCC, 2 pour un 12V et 2 pour le CAN.
La connection Can permet aux modules d'interagir avec la traction mais j'aimerai un maximum d'automatisation en local (feu et freinage en fonction des position d'aiguilles et des occupations de cantons.

Le but n'est pas forcement de planifier des itinéraires compliqués mais simplement d'éviter les collisions et provoquer des arrets en gare.
Bref je cherche encore
j'avais envisagé l'utilisation du freinage ABC avec une bonne configuration de chaque locomotive, mais le railcom simplifierait évidement la donne.

Pour l'instant, j'avoue être betement bloqué par l'impossibilité de controler mes aiguilles en DCC....impossible de decoder le signal, j'ai fait 3 montages, éssayé plusieurs valeurs..... j'ai commandé les composants de Labox pour voir si ca ne vient pas de ma centrale DCC.

32
Vos projets / Re : Code decodeur pour aiguillage à solenoides
« le: décembre 21, 2023, 09:00:27 pm »
Bonjour,

Oui, j'avais essayé justement ce matin mais sans resultat. Même les ordres loco ne sont pas reconnus alors qu'elles fonctionnent bien sur le réseau.
Merci en tous cas de continuer d'essayer de m'aider,
Je dois probablement passer à coté de quelque chose... ce n'est pourtant pas ma premiere réalisation.
je vais essayer de mesurer le signal au pin de 2 de l'arduino pour voir si il a la bonne amplitude.
je n'ai pas de petit condensateur pour pouvoir eventuellement mettre sur l'entrée DCC mais je vais essayer de m'en procurer.
C'est un peu rageant, car il y'a plein de choses à construire derriere un décodeur et je me trouve bloqué....
je vais tout reprendre une nouvelle fois....


33
Vos projets / Re : Code decodeur pour aiguillage à solenoides
« le: décembre 20, 2023, 10:26:20 pm »
Oui, j'avais noté ce point aprés mon message mais je n'avais pas modifié,
Cela dit, je suis arrivé parfois à un resultat dans mes tests: celui d'avoir le message d'interruption et controler la led 13 en mode 1.
Malheureusement, ce n'est pas reproductible, aujourd'hui, je n'arrive plus à rien....

J'ai refait un montage sur breadboard avec juste la partie signal et pas la partie alim. Que des composants neufs. j'ai à ma disposition un oscilloscope qui me montre bien un beau signal carré à la broche 2 de l'arduino, 2,6v au voltmetre. j'ai essayé 4 arduino, des uno, des nano, j'ai changé 2 fois l'optocoupleur.... rien n'y fait.

Je commence par mettre en doute ma centrale sur sa capacité à générer un beau signal pour accessoire. (mega+motor shield) pourtant 0 probleme avec les locos.

Le montage est décrit des centaines de fois sur internet, je ne comprend pas comment pourquoi je n'y arrive pas :(
D'autant que sans decodeur, on ne fait rien marcher du tout...

Bref, je ne sais plus quoi faire. achat d'un decodeur du commerce pour voir comment ça se comporte, réalisation d'une autre cenrale,...

34
Vos projets / Re : Code decodeur pour aiguillage à solenoides
« le: décembre 17, 2023, 10:22:30 am »
Bonjour, J'avoue que je suis un peu perdu.... :-[
J'ai installé le programme original que vous m'avez transmis.
J'ai modifié la ligne du début pour ecrire
const byte maxaccessories=1; //The number of switches you want to control with this Arduino

et utiliser dans un premier temps le mode 1:
 accessory[0].address = 1; // DCC address
 accessory[0].mode = 1; // Continuous: HIGH until DCC switches the address off again
 accessory[0].outputPin = 13; // Arduino pin to which this accessory is connected

La, miracle, ça fonctionne ( à l'envers ) la led s'éteind lorsque j'envoie <a 1 0 1>  et s'allume bien lorsque je fait <a 1 0 0>

j'avais un probleme de timer avec le mode 2 (1000ms n'était pas visible, il fallait que je mette 50000) mais c'est resolu

par contre, ca ne fonctionne pas si je modifie
 accessory[0].address = 2
 et que j'envoie <a 2 0 1>

Bref je continue mes recherches mais si vous avez une idée....



35
Bus CAN / Re : Question mise en place CAN dans la centrale DCC
« le: décembre 07, 2023, 09:02:26 am »
Mon réseau est plutôt du type étagère organisé en module que j’ajoute successivement, je n’ai pas la place pour un grand réseau permanent et je préfère m’appliquer par petit bout avec un module pleinement opérationnel avant de passer au suivant.

Je voudrais donc que chaque module ait un maximum d’automatismes avec un gestionnaire propre et limiter au mieux le recours à un gestionnaire central. Je n’ai de toutes façons pas un grand nombre de voies.
J’ai Jmri, ça fonctionne mais je ne veux pas l’utiliser
Il faut donc que je relie chaque gestionnaire de module à la centrale pour agir sur le Controle des loco.

La plus grosse difficulté est le Controle de la loco. Pour les tests, je peux spécifier l’adresse de la loco dans le code mais ce n’est pas satisfaisant si on veux utiliser n’importe quelle loco.
ABC permet des freinages et redémarrage sans connaître l’adresse, c’est la solution sur laquelle j’etais parti, notamment pour la sécurité ( canton occupé, aiguille non positionnée) et les arrêts en gare.

L’ideal serait railcom et j’attend avec impatience la centrale compatible!!
Le principe: une loco rentre sur le module, elle est identifiée et peut donc être contrôlée sur le module en fonction des détecteurs de celui-ci. Une fois sortie, c’est le gestionnaire de l’autre module qui prend le relais.




36
Bus CAN / Question mise en place CAN dans la centrale DCC
« le: décembre 06, 2023, 09:44:26 pm »
Bonjour,

J'envisage de mettre en place un bus CAN dans mon reseau pour la retrosignalisation et les automatismes.
J'ai 2 questions de débutants:

- Comment implanter le CAN dans la centrale DCC ? j'ai un Mega avec un shield moteur, je le commande trés facilement en liaison serie. je peux contourner le probleme avec un arduino qui va transcrire mes ordres CAN en messages serie pour la centrale mais je pense qu'on peut brancher directement l'interface CAN sur le mega de la centrale. je ne sais pas alors comment gerer le code

- Existe t'il un protocole "tout fait" pour les messages CAN concernant le modelisme ferroviaire ou chacun crée le sien selon ses besoins?

Merci de vos retours
Julien

37
Vos projets / Re : Code decodeur pour aiguillage à solenoides
« le: décembre 05, 2023, 11:37:40 am »
Oui,
Ca ne marche pas... :-[ Je séche pour le moment.... je vais reprendre depuis le début en réassemblant une carte avec uniquement la partie DCC vers Arduino (sans le circuit de puissance uln) et essayer de comprendre le code de la bibliotheque pour allumer juste une led.
Je n'ai même plus le message de l'interruption, j'ai peut-être grillé quelque chose avec mon montage volant...

Merci tout de même pour votre aide, je pense que je n'etais pas loin,

(j'aurais probablement du placer ce post dans la partie débutant...)

38
Vos projets / Re : Code decodeur pour aiguillage à solenoides
« le: décembre 01, 2023, 06:28:15 pm »
Oui, mon shield moteur allume ses leds et je peux controler mes locomotives, je n'ai pas de retour dans le moniteur serie. je ne sais pas si c'est attendu.
Par contre, il me semble qu'une commande <a xxx x x> devrait renvoyer <A xxx x x> dans le moniteur.

Je n'ai pas encore pu investiguer depuis mon précédent message mais le fait que le décodeur affiche bien l'interruption est encourageant, je vais refaire des essais. (je pense pourtant avoir testé votre commande)

Le probleme est que que je n'étais pas du tout sûr de la commande à transmettre et donc je ne savais pas d'ou venait le non fonctionnement. je vais déja pouvoir essayer avec la bonne commande.
Sinon, il faudra que je me penche un peu sur la bibliotheque Decoder

Je vous tiens au courant

39
Vos projets / Re : Code decodeur pour aiguillage à solenoides
« le: décembre 01, 2023, 01:24:12 pm »
Bonjour,
Merci de votre aide mais pour être sur de bien comprendre, avec le code en état, quel ordre faut il que j'envoie à ma centrale DCC pour que faire fonctionner le connecteur K1?

40
Vos projets / Re : Code decodeur pour aiguillage à solenoides
« le: novembre 30, 2023, 11:31:05 pm »

Merci pour votre réponse
Oui, j'ai bien effectué le montage comme décrit avec l'alimentation séparée (12v continu pour ma part)
L'arduino seul est par contre alimenté d'office par le circuit du DCC sur ce montage (d'après ce que j'ai compris...)

Pour vérifier mon montage, j'ai réalisé le petit test qu'avait ecrit un autre membre ici:
https://forum.locoduino.org/index.php?topic=1620.msg17335#msg17335

j'ai donc bien +/-2,5v en presence de DCC à la borne D2 du nano
j'ai installé le petit sketch avec le timer, il affiche bien "l'interruption s'est déclenchée" sur le moniteur serie lorsque j'envoie par exemple <a 200 2 1>


Relisez :
Tel qu’il est configuré, le programme permet de commander l’aiguillage sur le connecteur K1 à l’adresse 1, K2 à l’adresse 2 et ainsi de suite jusqu’à K8 à l’adresse 8. Vous pouvez commander les aiguillages aux adresses de votre choix en décalant par pas de 8 les adresses 1 à 8 dans le programme fourni. (ex : 9 à 17)
C'est justement ce que je n'ai pas compris : comment spécifie t'on qu'on utilise la plage 1 à 8? Il me semblait avoir lu quelque part qu'on utilisait aussi les sous adresses mais c'est peut être dans un autre montage

Merci
Julien



 


41
Vos projets / Re : Code decodeur pour aiguillage à solenoides
« le: novembre 30, 2023, 09:46:33 pm »
Le code:

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Arduino DCC Solenoid Switch Decoder.
// Author: Ruud Boer - January 2015.  This sketch turns an Arduino
// into a DCC decoder to drive max 8 dual coil solenoid switches. pins 14 to 19 for A0 to A5
// The DCC signal is optically separated and fed to pin 2 (=Interrupt 0). Schematics: www.mynabay.com
// Many thanks to www.mynabay.com for publishing their DCC monitor and -decoder code.
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// msport version for Locoduino paper 27 03 2022 and dilc3 pcb
// https://www.locoduino.org/spip.php?article318
//
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// IMPORTANT: GOTO lines 22 and 47 to configure some data!                                                                       <---- je ne sais pas ce qu'il faut faire!!
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#include <DCC_Decoder.h>
#define kDCC_INTERRUPT 0

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// FILL IN
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const byte maxaccessories=8; //The number of switches you want to control with this Arduino
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

typedef struct
{
  int               address;         // Address to respond to
  byte              output;          // State of accessory: 1=on, 0=off (for internal use only)
  int               outputPin;       // Arduino output pin
  int               outputPin2;      // Arduino output pin2, used for solenoid junctions
  byte              highlow;         // State of outputpin: 1=HIGH, 0=LOW
  byte              highlow2;        // State of outputpin2: 1=HIGH, 0=LOW
  boolean           finished;        // Memory location that says the oneshot is finished
  boolean           finished2;       // Memory location that says the second oneshot (for solenoid) is finished
  int               durationMilli;   // ms flash time
  unsigned long     onMilli;         // for internal use
  unsigned long     offMilli;        // for internal use
}
DCCAccessoryAddress;
DCCAccessoryAddress accessory[maxaccessories];

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Initialization: COPY - PASTE the structure as many times as you have switches and fill in the values you want.
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void ConfigureDecoderFunctions() // The amount of accessories must be same as in line 19 above!
{
  accessory[0].address = 1; // K1 connector
  accessory[0].durationMilli = 250;
  accessory[0].outputPin = 4;
  accessory[0].outputPin2 = 3;
  accessory[0].highlow = 0; // Do not change this value
  accessory[0].highlow2 = 0; // Do not change this value
  accessory[0].finished = false; // Do not change this value
  accessory[0].finished2 = true; // Do not change this value
  accessory[0].output = 0; // Do not change this value

  accessory[1].address = 2; // K2 connector
  accessory[1].durationMilli = 250;
  accessory[1].outputPin = 6;
  accessory[1].outputPin2 = 5;
  accessory[1].highlow = 0; // Do not change this value
  accessory[1].highlow2 = 0; // Do not change this value
  accessory[1].finished = false; // Do not change this value
  accessory[1].finished2 = true; // Do not change this value
  accessory[1].output = 0; // Do not change this value
 
  accessory[2].address = 3; // K3 connector
  accessory[2].durationMilli = 250;
  accessory[2].outputPin = 8;
  accessory[2].outputPin2 = 7;
  accessory[2].highlow = 0; // Do not change this value
  accessory[2].highlow2 = 0; // Do not change this value
  accessory[2].finished = false; // Do not change this value
  accessory[2].finished2 = true; // Do not change this value
  accessory[2].output = 0; // Do not change this value

  accessory[3].address = 4; // K4 connector
  accessory[3].durationMilli = 250;
  accessory[3].outputPin = 10;
  accessory[3].outputPin2 = 9;
  accessory[3].highlow = 0; // Do not change this value
  accessory[3].highlow2 = 0; // Do not change this value
  accessory[3].finished = false; // Do not change this value
  accessory[3].finished2 = true; // Do not change this value
  accessory[3].output = 0; // Do not change this value

  accessory[4].address = 5; // K5 connector
  accessory[4].durationMilli = 250;
  accessory[4].outputPin = 12; 
  accessory[4].outputPin2 = 11;
  accessory[4].highlow = 0; // Do not change this value
  accessory[4].highlow2 = 0; // Do not change this value
  accessory[4].finished = false; // Do not change this value
  accessory[4].finished2 = true; // Do not change this value
  accessory[4].output = 0; // Do not change this value

  accessory[5].address = 6; // K6 connector
  accessory[5].durationMilli = 250;
  accessory[5].outputPin = 15;   // A1
  accessory[5].outputPin2 = 14;  // A0
  accessory[5].highlow = 0; // Do not change this value
  accessory[5].highlow2 = 0; // Do not change this value
  accessory[5].finished = false; // Do not change this value
  accessory[5].finished2 = true; // Do not change this value
  accessory[5].output = 0; // Do not change this value

  accessory[6].address = 7; // K7 connector
  accessory[6].durationMilli = 250;
  accessory[6].outputPin = 17; // A3
  accessory[6].outputPin2 = 16; // A2
  accessory[6].highlow = 0; // Do not change this value
  accessory[6].highlow2 = 0; // Do not change this value
  accessory[6].finished = false; // Do not change this value
  accessory[6].finished2 = true; // Do not change this value
  accessory[6].output = 0; // Do not change this value

  accessory[7].address = 8; // K8 connector
  accessory[7].durationMilli = 250;
  accessory[7].outputPin = 19; // A5
  accessory[7].outputPin2 = 18; // A4
  accessory[7].highlow = 0; // Do not change this value
  accessory[7].highlow2 = 0; // Do not change this value
  accessory[7].finished = false; // Do not change this value
  accessory[7].finished2 = true; // Do not change this value
  accessory[7].output = 0; // Do not change this value
 
  // Setup output pins
  for(int i=0; i<maxaccessories; i++)
  {
    if( accessory.outputPin )
      {
      pinMode( accessory.outputPin, OUTPUT );
      digitalWrite( accessory.outputPin, LOW);
    }
    if( accessory.outputPin2 )
      {
      pinMode( accessory.outputPin2, OUTPUT );
      digitalWrite( accessory.outputPin2, LOW);
    }
  }
} // END ConfigureDecoderFunctions

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// DCC packet handler
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void BasicAccDecoderPacket_Handler(int address, boolean activate, byte data)
{
  // Convert NMRA packet address format to human address
  address -= 1;
  address *= 4;
  address += 1;
  address += (data & 0x06) >> 1;

  boolean enable = (data & 0x01) ? 1 : 0;

  for(int i=0; i<maxaccessories; i++)
   {
    if( address == accessory.address )
      {
      if( enable ) accessory.output = 1;
      else accessory.output = 0;
    }
  }
} // END BasicAccDecoderPacket_Handler

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Setup (run once)
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void setup()
{
  DCC.SetBasicAccessoryDecoderPacketHandler(BasicAccDecoderPacket_Handler, true);
  ConfigureDecoderFunctions();
  DCC.SetupDecoder( 0x00, 0x00, kDCC_INTERRUPT );
  pinMode(2,INPUT_PULLUP); //Interrupt 0 with internal pull up resistor (can get rid of external 10k)
  pinMode(13,OUTPUT);
  digitalWrite(13,LOW); //turn off Arduino led at startup

  for (int n=0; n<maxaccessories; n++) accessory[n].output = 0; //all servo's to min angle and functions to 0
} //END setup

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Main loop (run continuous)
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void loop()
{
  static int addr = 0;

  DCC.loop(); // Loop DCC library

  if( ++addr >= maxaccessories ) addr = 0; // Bump to next address to test

  if (accessory[addr].output == 1)
   {
      if (!accessory[addr].highlow && !accessory[addr].finished)
      {
         accessory[addr].highlow = 1;
         accessory[addr].offMilli = millis() + accessory[addr].durationMilli;
      }
      if (accessory[addr].highlow && millis() > accessory[addr].offMilli)
      {
         accessory[addr].highlow = 0;
         accessory[addr].finished = true;
      }
      accessory[addr].finished2 = false;
  }

  else // output==0
  {
      accessory[addr].highlow=0;
      accessory[addr].finished = false;
      if (!accessory[addr].highlow2 && !accessory[addr].finished2)
      {
         accessory[addr].highlow2 = 1;
         accessory[addr].offMilli = millis() + accessory[addr].durationMilli;
      }
      if (accessory[addr].highlow2 && millis() > accessory[addr].offMilli)
      {
         accessory[addr].highlow2 = 0;
         accessory[addr].finished2 = true;
      }
  }

  if (accessory[addr].highlow) digitalWrite( accessory[addr].outputPin, HIGH);
  else digitalWrite( accessory[addr].outputPin, LOW);
  if (accessory[addr].highlow2) digitalWrite( accessory[addr].outputPin2, HIGH);
  else digitalWrite( accessory[addr].outputPin2, LOW);

} //END loop

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

42
Vos projets / Code decodeur pour aiguillage à solenoides
« le: novembre 30, 2023, 09:45:00 pm »
Bonjour à tous,

Je viens de réaliser le décodeur pour aiguillages à solenoides
https://www.locoduino.org/spip.php?article318

J'ai suivi scrupuleusement la liste des composants, je comprend bien le schema electronique mais je bute sur la partie logicielle:
J'ai chargé tel quel le code fourni sur la page, mais je ne sais pas à quelle adresse il répond, ou faut il l'indiquer, quelle commande DCC faut il envoyer, j'utilise "ma premiere centrale DCC" avec un arduino mega et un shield moteur. les locomotives fonctionnent bien.

Je ne suis pas sur non plus de la commande à envoyer, j'ai essayé <a 001 0 1> et d'autres combinaisons et adresses mais sans succés. je ne sais pas si mon arduino reçoit bien les trames DCC.
il me manque peut-être le petit condensateur ceramique à rajouter sur l'optocoupleur.

Bref, si vous avez une idée pour tester....

J'ai cherché si il y'avait eu un forum concernant ce montage mais je n'ai pas trouvé

Merci de votre aide

43
Bus DCC / Re : Alimenter arduino decodeur DCC par le DCC
« le: mai 01, 2023, 06:38:47 pm »
Merci beaucoup pour votre réponse, reste plus qu'a mettre en pratique...

44
Bus DCC / Re : Alimenter arduino decodeur DCC par le DCC
« le: avril 26, 2023, 06:08:10 pm »
Voila qui m'arrangerait bien!
J'ai commandé les PCB pour la carte décodeur d'aiguillages.
https://www.locoduino.org/spip.php?article318
Peut-on brancher l'alimentation des ULN2803 avec le courant alternatif du DCC (filtré)?
Ou votre montage redresse t-il le courant ?

Si vous aviez un schéma à partager....
Merci beaucoup

45
Bus DCC / Re : Alimenter arduino decodeur DCC par le DCC
« le: avril 24, 2023, 02:59:11 pm »
En effet, pas mal du tout ce module. j'avais repéré le schéma mais je n'avais pas vu avec le PCB et la façon dont l'alimentation est prise.
j'aurais bien aimé prendre le courant qui alimente les solénoïdes directement sur le dcc également mais c'est certainement générateur de parasites.

De façon plus générale, dans mon système qui n'est pas un vrai reseau mais plutôt une succession de scènes, je peux réduire le cablage entre les scenes à :
- Le DCC pour tout le contrôle du réseau et ses accessoires
- une alim continue
- éventuellement dans un 2eme temps, un bus CAN pour la gestion du reseau avec retrosignalisation

Pour l'alim continue, quel voltage choisir ? : j'ai le 18v à l'entrée de ma centrale DCC, c'est peut-être un peu de trop pour les solénoïdes.  Si je veux étendre l'électronique pour d'autres arduino avec le CAN ou pour de l'éclairage, il faudra peut-être que j'utilise cette alim plutôt que celles des rails.
Est ce qu'il faut la descendre à 15v à la source ou même 12v ce qui permet de brancher des arduinos sans soucis.
Je pense que ça reste suffisant pour les solenoides

Merci de vos avis




Pages: 1 2 [3] 4