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 - nopxor

Pages: 1 ... 10 11 [12] 13 14
166
Shields et Modules / Re : Module de détection pour canton DCC
« le: avril 16, 2018, 02:08:38 am »
Bonjour,

Voici donc la version 2 avec pin Header en sortie et  double empreinte de transfo.
Tous les fichiers Eagle sont dans "Detection 4 cantons_v2.zip" y compris le Gerber zippé pour les fabricants de PCB.



167
Shields et Modules / Re : Module de détection pour canton DCC
« le: avril 15, 2018, 02:39:45 pm »
Bonjour,

Intéressant ces tests.

Les transfos HMCT103C 5A/5MA ont des spécifications différentes.
Sur certaines datasheet on trouve même un ratio = 1:2500
Le courant de base du transistor doit être diminué et le temps de réponse allongé.
La sensibilité semble amoindrie, mais ils sont à un prix attractif.

Les AS103 recommandées par Paisley ont un ratio = 1:300, L = 250mH @10kHz, R = 300Ω
 
Dans le premier lien que j'ai donné (sumidacrossing), l'auteur a effectué des tests de simulation comparatifs du circuit de Paisley et de Müller

Il est possible dans Eagle de définir une empreinte sur mesure pour le transfo avec un pitch de 10.16mm.

168
Shields et Modules / Re : Module de détection pour canton DCC
« le: avril 14, 2018, 07:03:34 pm »
Bonjour,

Mon réseau est en construction donc je n'ai pas effectué encore de tests en exploitation.
Ce schéma (Paisley) est pas mal utilisé outre atlantique donc je ne suis pas trop inquiet sur sa fiabilité.

169
JMRI et Arduino / Re : Carte 24 entrées 48 sorties pour JMRI
« le: avril 13, 2018, 09:42:19 am »

Les sorties peuvent délivrer jusqu'à 35mA, mais chaque circuit 74HC595 qui comporte 8 sorties peut délivrer 70mA au maximum.

Ci-joint les fichiers Eagle:

170
JMRI et Arduino / Carte 24 entrées 48 sorties pour JMRI
« le: avril 13, 2018, 09:40:38 am »
C'est une carte pilotée par un Arduino Nano et qui est l'équivalent d'une carte SMINI-C/MRI.
https://www.utrainia.com/65-arduinocmri-and-rs485



Elle peut commander par exemple des aiguillages, des éclairages ou des feux de signalisation.
On peut y connecter des modules de détection de cantons ou des boutons.

Elle est reliée au PC par un bus RS485 à 2 fils grâce à un adaptateur USB-RS485 (1€ sur Ebay)
On peut connecter ensemble plusieurs de ces cartes à JMRI en les chainant par ce bus.
Chaque carte est identifiée par un numéro de node dans JMRI.
http://jmri.org/help/fr/html/hardware/cmri/CMRI.shtml#iobits

La carte utilise 6 CI 74HC595 pour les 48 sorties et 3 CI 74HC165 pour les 24 entrées (pull-upées).
Ces registres à décalage 8 bits sont chainés et reliés par 2 x 3 fils au Nano.

J'ai utilisé Eagle pour la CAO du schéma et du PCB.





J'ai fait fabriquer par JLCPCB un PCB double face compact 100 x 100 mm. (2$ les 10 ! + 11€ de port)
Je fournis les fichiers en pièce jointe.
Pour commander des PCB chez JLCPCB il suffit d'uploader sur leur site Le fichier Arduino-CMRI_Gerber.zip
https://jlcpcb.com


Le programme du Nano est ultra simple grâce aux bibliothèques CMRI et Auto485 disponibles sur le site utrainia.
Il suffit de préciser le numéro de node affecté à la carte.

/**
 * C/MRI -> JMRI via RS485
 * =======================
 * Sets up an SMINI 24 inputs, 48 outputs with an Arduino Nano.
 * Uses an RS485 bus to transparently talk support multiple ArduinoCMRI nodes on one bus.
 * By passing in an Auto485 object to the CMRI constructor, we are able to automatically
 * control the DE and RE pins on our RS485 bus transceiver.
 * The PC with JMRI has an USB-RS485 adapter connected to the bus.
 *
 * IN control:
 * Nano pin:             74HC165 pin:
 *     9        LATCH ->     1
 *     13       SCK   ->     2
 *     12       MISO  ->     9
 *     
 *     
 * OUT control:   
 * Nano pin:             74HC595 pin:
 *     6      verrou ->     12
 *     7      donnee ->     14
 *     8     horloge ->     11
 *     
 *     
 * Change the CMRI_ADDR for each board.  Each node must have its own address.   
 * ====================================
 **/

#include <Auto485.h>
#include <CMRI.h>
#include <SPI.h>

#define CMRI_ADDR 0                  // select the CMRI node address
#define    DE_PIN 2                  // Arduino pin 2 -> MAX485 DE and RE pins

// pin 74HC165
const byte LATCH = 9;

// pins 74HC595
const byte verrou = 6;
const byte donnee = 7;
const byte horloge = 8;

Auto485 bus(DE_PIN);                 // RS485 bus transceiver
CMRI cmri(CMRI_ADDR, 24, 48, bus);   // sets up an SMINI. SMINI = 24 inputs, 48 outputs

void setup() {
  bus.begin(9600, SERIAL_8N2);       // open the RS485 bus at 9600bps
  pinMode(verrou, OUTPUT);
  pinMode(donnee, OUTPUT);
  pinMode(horloge, OUTPUT);
  SPI.begin ();                      // serial data protocol used to control 74HC165
  pinMode (LATCH, OUTPUT);
  digitalWrite (LATCH, HIGH);
}

void loop() {
  // 1: main processing node of cmri library
  cmri.process();
 
  // 2: update output
  digitalWrite(verrou, LOW);                                // on commence par mettre le verrou
  shiftOut(donnee, horloge, MSBFIRST, cmri.get_byte(5));    // on envoie la sixieme donnée d'abord
  shiftOut(donnee, horloge, MSBFIRST, cmri.get_byte(4));    // on envoie la cinquieme donnée ensuite
  shiftOut(donnee, horloge, MSBFIRST, cmri.get_byte(3));    // on envoie la quatrieme donnée ensuite
  shiftOut(donnee, horloge, MSBFIRST, cmri.get_byte(2));    // on envoie la troisieme donnée ensuite
  shiftOut(donnee, horloge, MSBFIRST, cmri.get_byte(1));    // on envoie la seconde donnée ensuite
  shiftOut(donnee, horloge, MSBFIRST, cmri.get_byte(0));    // et on envoie la première donnée
  digitalWrite(verrou, HIGH);                               // et on relache le verrou pour mettre à jour les données
   
  // 3: update inputs
  digitalWrite (LATCH, LOW);                                // pulse the parallel load latch
  delay(1);                                                 // wait while data loads
  digitalWrite (LATCH, HIGH);
  cmri.set_byte(0, ~(SPI.transfer(0)));
  cmri.set_byte(1, ~(SPI.transfer(0)));
  cmri.set_byte(2, ~(SPI.transfer(0)));
}

Il y a 2 jumpers sur la carte reliés à RX et TX.
Il faut les enlever pour la programmation du Nano et les remettre après celle-ci.

L'alimentation 5V se fait sur un bornier.
Il faut la déconnecter lors de la programmation du Nano par la prise USB.

Il y a 2 borniers de connection au bus RS485 pour faciliter le chainage des cartes.
Pas besoin de résistances de terminaison de 120 ohm pour le RS485 lorsque les liaisons ne font que quelques metres.

A noter qu'une carte SMINI en kit coute 100€ (160€ assemblée).
Celle-ci devrait vous couter moins de 10€ !

La liste des composants est dans le dossier Arduino-CMRI_Eagle.zip.
Ils se trouvent couramment sur Ebay.
Les connecteurs sont au pas de 3.5mm comme ceux-là:
https://www.ebay.fr/itm/262957982206

171
Bonjour,

Pour illustrer concrètement l'emploi des machines à états sur Arduino, il y a un excellent tutoriel là:
https://forum.arduino.cc/index.php?topic=470879.0

172
Discussions ouvertes / Re : Balises img du forum
« le: avril 03, 2018, 12:01:00 pm »
OK merci Jean-Luc, tout s'explique !

173
Discussions ouvertes / Re : Balises img du forum
« le: avril 03, 2018, 11:49:48 am »
Ah oui, c'est peut être pas le bon... désolé  :-\

https://photos.app.goo.gl/ANHebI2mv3LOb7nx1


175
Discussions ouvertes / Re : Balises img du forum
« le: avril 03, 2018, 11:28:42 am »
Bonjour Jean-Luc,

Le lien est sur mon PC et je ne suis pas chez moi.
Je le mettrai ici quand je rentre.

176
Discussions ouvertes / Balises img du forum
« le: avril 02, 2018, 11:46:22 pm »
Bonjour,

Quelqun pourrait-il m'expliquer le fonctionnement des balises img du forum ?

Lorsque j'insère une URL de la façon habituelle: [img)URL de l'image[/img) l'image n'est pas affichée.

(J'ai volontairement remplacé les parenthèses fermantes pour l'affichage de la phrase)

177
Vos projets / servotiny13
« le: mars 22, 2018, 08:14:24 pm »
Bonjour,

Je souhaite équiper mon réseau de sémaphores avec feux pour la signalisation.
L'idée est d'utiliser un petit ATtiny13 (1k Flash) pour commander le servo qui va contrôler chaque sémaphore.

Les librairies classiques de contrôle de servos ne peuvent pas être utilisées avec un ATtiny13 qui ne dispose que d'un seul timer (8bits).
J'ai donc reprogrammé le timer pour qu'il génère une base de temps compatible avec les impulsions classiques de commande de servos.

Ci-joint le code qui utilise moins de la moité de la Flash:  ;)
/*
 servotiny13

 Permet le contrôle d'un servomoteur sur un ATtiny13 à 9.6 MHz.
 le programme configure le timer pour générer une interruption toutes les 10us soit à une fréquence de 100 kHz.
 Toutes les 20ms (50Hz) on active la sortie pour une durée d'impulsion comprise entre 1ms et 2ms.
 La fonction classique delay() n'est plus disponible puisqu'on a reprogrammé l'unique timer.
 Le programme utilise une fonction locale: delay_() pour ralentir les mouvements du servo.
 Cette fonction "attend" pendant un nombre de ticks multiple de 10us correspondant au délai souhaité.
*/


volatile unsigned int Tick;       // 100KHz pulse
volatile unsigned int sPulse;     // Servo pulse variable
volatile unsigned int Tick_10us;  // base time for delay_ function

void setup() {
  pinMode(3, OUTPUT);     // Servo pin on PB3 = pin 2 ATtiny
 
  cli();                  // Disable global interrupts
  TCCR0A = 0;             // Initialize timer 0 registers
  TCCR0B = 0; 
  TCCR0A |= (1<<WGM01);   // Configure timer 0 for CTC mode (Clear Timer on Compare Match)
  TIMSK0 |= (1<<OCIE0A);  // Enable CTC interrupt
  OCR0A = 95;             // Set CTC compare value for 100kHz interrupt
  TCCR0B |= (1<<CS00);    // No prescaler -> 9.6 MHz
  sei();                  // Enable global interrupts

  Tick = 0;
  sPulse = 100;           // 100 x 10us = 1 ms
  Tick_10us = 0;
 
}

ISR(TIM0_COMPA_vect)      // 100 KHz interrupt frequency
{
  Tick_10us += 1;
 
  if(Tick >= 2000)        // servo frame (20ms)
     {
        Tick = 0;
     }

  Tick += 1;
 
  if(Tick <= sPulse)        // Generate servo pulse
  {
    digitalWrite(3, HIGH);  // Servo pulse high
  }
  else
  {
    digitalWrite(3, LOW);   // Servo pulse low
  }
}


void loop() {
  for(int i=0; i<=100; i++)  // Servo test
    {
      sPulse = sPulse + 1;
      delay_(2000);          // delai 2000 x 10 us = 20 ms
    }

    sPulse = 200;

    for(int i=0; i<=100; i++)
    {
      sPulse = sPulse - 1;
     delay_(2000);
    }
    sPulse = 100;
}

  void delay_(int nombre)
  {
    Tick_10us = 0;                  // initialisation pour début de comptage
    while (Tick_10us < nombre) {}   // attend jusqu'à le nombre de ticks soit atteint
  }
 

178
Bonjour,

J'ai commencé à monter les moteurs d'aiguillages sous le réseau.
J'ai installé sur chacun un inverseur (PECO PL-13) commandé par la tige du solénoïde pour alimenter le coeur d'aiguille electrofrog.
En fait cela génère quelques frottements supplémentaires et l'alimentation de 10.35V s'est révélée insuffisante.

PECO préconise du 16V et c'est effectivement la tension requise pour un fonctionnement correct des moteurs.
Peu importe alternatif ou continu du moment que l'ampérage est suffisant.
J'utilise une alimentation de laptop 16V DC 4A.

179
Le logiciel DCC++ / Re : e-stop emergency stop avec DCC++
« le: mars 16, 2018, 05:59:58 am »
Bonjour,

Pour un arrêt d'urgence, pourquoi ne pas utiliser la commande <0>, coupure générale de l'alimentation DCC ?

180
Shields et Modules / Re : Module de détection pour canton DCC
« le: mars 14, 2018, 01:13:49 am »
Ci-joint une photo du module:


Le schéma:


Le PCB:

Pages: 1 ... 10 11 [12] 13 14