Messages

1

Vos projets / Re : RailCom: Générateur de CutOut

« le: Aujourd'hui à 06:02:49 am »

CODE PART 4:

Code: [Sélectionner]


void setup()
{
  INIT_PINS(); //init first PINS

  //SIMPLE_AMPLIFICATOR = digitalRead(SIMPLE_AMPLIFICATOR_MODE_INPUT_PIN);
  AMPLIFICATOR_MODE = PORTC.IN & PIN4_bm; //faster

  if(AMPLIFICATOR_MODE == false)
  {   
    LED_SIMPLE_AMPLIFICATOR_MODE_PIN_OFF;

    INIT_TCB();

    INIT_ADDITIONNAL_PINS();

    //RAILCOM = digitalRead(RAILCOM_MODE_SELECTOR_INPUT_PIN);
    RAILCOM = PORTC.IN & PIN3_bm; //faster

    INIT_SYSTEM_WITH_RAILCOM();

    if (RAILCOM == false) //NO RAILCOM
    {
      //force these states out:
      LOGIC_ENABLE_OUT_PIN_ON;
      LOGIC_CUTOUT_OUT_PIN_ON;

      LED_RAILCOM_ENABLE_PIN_OFF;
    }
    else
    {
      LED_RAILCOM_ENABLE_PIN_ON;
    }
  }
  else
  {
    LED_RAILCOM_ENABLE_PIN_OFF;
    RAILCOM = false;
    LED_SIMPLE_AMPLIFICATOR_MODE_PIN_ON;
   
    INIT_SYSTEM_SIMPLE_AMPLIFICATOR();
  }

}


void loop(){

  //NOTHING TO DO! ALL IS AUTOMATIC :)

}





Plus qu'a se pencher sur un dessin de PCB pour donner vie à ce dispositif!

Ltr

2

Vos projets / Re : RailCom: Générateur de CutOut

« le: Aujourd'hui à 06:01:40 am »

CODE PART2:

Code: [Sélectionner]


void INIT_SYSTEM_WITH_RAILCOM(){

  //COMPARATOR:

  //when inverting > non inverting ==> AC OUT = high
  //measured current will be connected to inverting input (L6203 SENSE PIN trough a 10K resistor)
   
    Comparator.input_p = comparator::in_p::in1; //inverting PIN_PB5
    Comparator.input_n = comparator::in_n::in1; //non inverting PIN_PB4
    Comparator.reference = comparator::ref::disable;
    Comparator.hysteresis = comparator::hyst::disable;
    Comparator.output = comparator::out::disable; // No output pin, signal not inverted internally

    Comparator.init();
   
    Comparator.start(); // Start comparator
 
  //DEFINE CCL LUT3:
    //NEED EVENT CHANNEL FIRST TO ROUTE INSIDE LUT3: USE EVENT CHANNEL 3

    Event3.assign_generator_pin(gen3::pin_pa6);   //PIN_PA6 AS EVENT CH3 SOURCE
    Event3.set_user(user::ccl3_event_a);          //EVENT A OF LUT3

    Event3.start();

    Logic3.enable;                       //ENABLE LUT3
    Logic3.input0 = logic::in::ac;       //AC0 level OUT
    Logic3.input1 = logic::in::event_a;  //EVENT_A from EVENT CH3
    Logic3.input2 = logic::in::masked;   //not used
    Logic3.output = logic::out::disable; //NOT USED, use EVENT CH2 instead
    Logic3.truth = 0x04;     

    Logic3.init();


    Event2.assign_generator(gen::ccl3_out);
    Event2.set_user(user::evouta_pin_pa7);

    Event2.start();   
 
  //DEFINE CCL LUT0: 
    Logic0.enable;                       //ENABLE LUT0
    Logic0.input0 = logic::in::masked;   //UDPI NOT USED
    Logic0.input1 = logic::in::pin;      //PIN_PA1
    Logic0.input2 = logic::in::pin;      //PIN_PA2
    Logic0.output = logic::out::disable; //NOT USED, use EVENT CH5 instead
    Logic0.truth = 0x04;                 // Set truth table

    Logic0.init();

    Event5.assign_generator(gen::ccl0_out); //source LUT0 OUT
    Event5.set_user(user::tcb0_capt);       //route to TCB0
    Event5.set_user(user::ccl1_event_a);    //event A CCL1
    Event5.set_user(user::ccl2_event_a);    //event A CCL2

    Event5.start();

    Event1.assign_generator_pin(gen1::pin_pa3); //PA3 INPUT
    Event1.set_user(user::ccl1_event_b);        //event B CCL1
    Event1.set_user(user::ccl2_event_b);        //event B CCL2

    Event1.start();

    Logic1.enable;                        //ENABLE LUT1
    Logic1.input0 = logic::in::event_a;   //logic1 in0 event A
    Logic1.input1 = logic::in::event_b;   //logic1 in1 event B
    Logic1.input2 = logic::in::masked;    //not used
    Logic1.output = logic::out::disable;  //OUTPUT NOT USED, OUT STATE will go to EVENT CH0
    Logic1.truth = 0x01;                  // Set truth table

    Logic1.init();

    Event0.assign_generator(gen::ccl1_out);
    Event0.set_user(user::evoutb_pin_pb2);

    Event0.start();

    Logic2.enable;                        //ENABLE LUT2
    Logic2.input0 = logic::in::event_a;   //logic2 in0 event A
    Logic2.input1 = logic::in::event_b;   //logic2 in1 event B
    Logic2.input2 = logic::in::masked;    //not used
    Logic2.output = logic::out::enable;   //PIN_PB3 OUTPUT TO DRIVE L6203 IN
    Logic2.truth = 0x02;                  // Set truth table

    Logic2.init();

    Event4.set_generator(gen::ac0_out);    //source AC0 out
    Event4.set_user(user::evoutc_pin_pc2); //manage LED_SHORCUT_OVERLOAD

    Event4.start();
   
    Logic0.start();
    Logic1.start();
    Logic2.start();
    Logic3.start();

}

void INIT_SYSTEM_SIMPLE_AMPLIFICATOR(){

  //COMPARATOR:
   
    Comparator.input_p = comparator::in_p::in1;
    Comparator.input_n = comparator::in_n::in1;
    Comparator.reference = comparator::ref::disable;
    Comparator.hysteresis = comparator::hyst::disable;
    Comparator.output = comparator::out::disable_invert; // No output pin, signal inverted internally

    Comparator.init();
   
    Comparator.start(); // Start comparator

  //EVENT CH1:
    Event1.assign_generator_pin(gen1::pin_pa1);   //PIN_PA1 AS EVENT CH1 SOURCE
    Event1.set_user(user::ccl1_event_a);          //EVENT A OF LUT0
    Event1.set_user(user::ccl2_event_a);          //EVENT B OF LUT2

    Event1.start();

  //EVENT CH2:
    Event2.assign_generator_pin(gen2::pin_pa2);   //PIN_PA2 AS EVENT CH2 SOURCE
    Event2.set_user(user::ccl1_event_b);          //EVENT A OF LUT0
    Event2.set_user(user::ccl2_event_b);          //EVENT B OF LUT2

    Event2.start();

  //LOGIC LUT1:
    Logic1.enable;                       //ENABLE LUT3
    Logic1.input0 = logic::in::event_a;  //AC0 level OUT
    Logic1.input1 = logic::in::event_b;  //EVENT_A from EVENT CH3
    Logic1.input2 = logic::in::masked;   //not used
    Logic1.output = logic::out::disable; //NOT USED, use EVENT CH0 instead
    Logic1.truth = 0x04;   

    Logic1.init();

  //EVENT CH0:
    Event0.assign_generator(gen::ccl1_out);
    Event0.set_user(user::evoutb_pin_pb2);

    Event0.start();

  //LOGIC LUT2:
    Logic2.enable;                        //ENABLE LUT2
    Logic2.input0 = logic::in::event_a;   //logic1 in0 event A
    Logic2.input1 = logic::in::event_b;   //logic1 in1 event B
    Logic2.input2 = logic::in::masked;    //not used
    Logic2.output = logic::out::enable;   //OUTPUT PIN_PB3
    Logic2.truth = 0x02;                  // Set truth table

    Logic2.init();

  //LOGIC LUT3:
    Logic3.enable;                       //ENABLE LUT3
    Logic3.input0 = logic::in::ac;       //AC0 level OUT
    Logic3.input1 = logic::in::masked;   //not used
    Logic3.input2 = logic::in::masked;   //not used
    Logic3.output = logic::out::disable; //NOT USED, use EVENT CH2 instead
    Logic3.truth = 0x02;     

    Logic3.init();

  //EVENT CH3:
    Event3.assign_generator(gen::ccl3_out);
    Event3.set_user(user::evouta_pin_pa7); //L6203_ENABLE_PIN

    Event3.start();

  //EVENT CH4:
    Event4.assign_generator(gen::ac0_out);
    Event4.set_user(user::evoutc_pin_pc2);

    Event4.start();

  //START LOGIC NODES:
    Logic1.start();
    Logic2.start();
    Logic3.start();


}



CODE PART3:

Code: [Sélectionner]


void CUTOUT(bool RAILCOM_ACTIV_OR_NOT){
 
  if(RAILCOM_ACTIV_OR_NOT == false) //NO RAILCOM CUTOUT TO INSERT
  {
    //BY PASS CUTOUT: FORCE SOME PINS STATE ON:
    LOGIC_ENABLE_OUT_PIN_ON;
    LOGIC_CUTOUT_OUT_PIN_ON;

    return;
  }

  //RAILCOM ACTIV: NEED TO INSERT CUTOUT
 
  //TIMER B IS ALREADY STARTED AND CNT GO UP     
  if(TCB0.CNT < ENABLE_STOP_TIME) //< 26us
  {
    //ENABLE ON
    LOGIC_ENABLE_OUT_PIN_ON;
    while(TCB0.CNT < ENABLE_STOP_TIME) {;}; //WAIT TILL IS OVER
  }
  else if((TCB0.CNT < CUTOUT_START_TIME) && (TCB0.CNT >= ENABLE_STOP_TIME)) // >=26us & <30us
  {
    //ENABLE OFF
    LOGIC_ENABLE_OUT_PIN_OFF;
    while(TCB0.CNT < CUTOUT_START_TIME) {;}; //WAIT TILL IS OVER
  }
  else if((TCB0.CNT < CUTOUT_STOP_TIME) && (TCB0.CNT >= CUTOUT_START_TIME)) // >=30us & <484us
  {
    //MAKE CUTOUT:
    LOGIC_CUTOUT_OUT_PIN_ON;
    while(TCB0.CNT < CUTOUT_STOP_TIME) {;}; //WAIT TILL IS OVER
  }
  else if((TCB0.CNT < ENABLE_START_TIME) && (TCB0.CNT >= CUTOUT_STOP_TIME)) // >=484 us & < 488us
  {
    //STOP CUTOUT
    LOGIC_CUTOUT_OUT_PIN_OFF;
    while(TCB0.CNT < ENABLE_START_TIME) {;}; //WAIT TILL IS OVER
  }
  else if ((TCB0.CNT >= ENABLE_START_TIME)) // >=488us
  {
    //ENABLE PIN ON:
    LOGIC_ENABLE_OUT_PIN_ON;

    //CUTOUT IS OVER

  }
}


//------------------------------------------ DCC Interrupt -------------------------------------------


//------------------------------------------- ISR Timers ----------------------------------------------------
ISR(TCB0_INT_vect) {

  TCB0.EVCTRL ^= TCB_EDGE_bm;                          // Change the event edge at which we trigger
  uint16_t  delta = TCB0.CCMP;                        // Delta holds the time since the previous interrupt
  uint8_t DccBitVal;

  if ((delta >= ONE_BIT_MIN) && (delta <= ONE_BIT_MAX)) {
    if (dccHalfBit & EXPECT_ONE) {                     // This is the second part of the 1 bit
      dccHalfBit = EXPECT_ANYTHING;
      DccBitVal = 1;
    }
    else if (dccHalfBit & EXPECT_ANYTHING) {           // This is the first part of the 1 bit
      dccHalfBit = EXPECT_ONE;
      return;
    }
    else {                                             // We expected a 1, but received 0 => abort
      TCB0.EVCTRL ^= TCB_EDGE_bm;                     // Likely J/K should be changed
      dccHalfBit = EXPECT_ANYTHING;
      dccrecState = WAIT_PREAMBLE;
      dccrec.bitCount = 0;
      return;
    }
  }
  else if ((delta >= ZERO_BIT_MIN) && (delta <= ZERO_BIT_MAX)) {
    if (dccHalfBit & EXPECT_ZERO) {                    // This is the second part of the 0 bit
      dccHalfBit = EXPECT_ANYTHING;
      DccBitVal = 0;
      }
    else if (dccHalfBit & EXPECT_ANYTHING) {           // This is the first part of the 0 bit
      dccHalfBit = EXPECT_ZERO;
      return;
    }
    else {                                             // We expected a 0, but received 1 => abort
      dccHalfBit = EXPECT_ANYTHING;
      dccrecState = WAIT_PREAMBLE;
      dccrec.bitCount = 0;
      return;
    }
  }
  else {
    // We ignore other halfbits, to avoid interference with orther protocols.
    // In case railcom would be implemented, here we could detect the cutout start (26..32us)
    return;
  } 


  dccrec.bitCount++;

  switch( dccrecState )
  {
  // According to NMRA standard S9.2, a packet consists of:
  // - Preamble
  // - Packet Start Bit
  // - Address Data Byte:
  // - Data Byte Start Bit + Data Byte [0 or more times]
  // - Packet End Bit


  case WAIT_PREAMBLE:
      // The preamble to a packet consists of a sequence of "1" bits.
      // A digital decoder must not accept as a valid, any preamble
      // that has less then 10 complete one bits
      if( DccBitVal )                                   // a "1" bit is received
      {
        if( dccrec.bitCount > 10 )
          dccrecState = WAIT_START_BIT;
      }
      else
      {
        dccrec.bitCount = 0;                            // not a valid preamble.
      }
  break;

  case WAIT_START_BIT:
    // The packet start bit is the first bit with a value of "0"
    // that follows a valid preamble. The packet start bit terminates the preamble
    // and indicates that the next bits are an address data byte
    if( !DccBitVal )                                  // a "0" bit is received
    {
      dccrecState = WAIT_DATA;
      dccrec.tempMessageSize = 0;
      // Initialise all fields
      uint8_t i;
      for(i = 0; i< MaxDccSize; i++ )
      {
        dccrec.tempMessage[i] = 0;
      } 
      dccrec.bitCount = 0;     
    }

  break;

  case WAIT_DATA:
    //==================
     if( dccrec.bitCount == 8 )                        // byte is complete
    {
      if(dccrec.tempMessageSize == MaxDccSize )       // Packet is too long - abort
      {
        dccrecState = WAIT_PREAMBLE;
        dccrec.bitCount = 0;
      }
      else
      {
        dccrecState = WAIT_END_BIT;                  // Wait for next byte or end of packet
      }
    }

  break;

  case WAIT_END_BIT:
    // The next bit is either a Data Byte Start Bit or a Packet End Bit
    // Data Byte Start Bit: precedes a data byte and has the value of "0"
    // Packet End Bit: marks the termination of the packet and has a value of "1"
 
    if(DccBitVal) // End of packet?
    {
      // Complete packet received and no errors
      // we are in a CUTOUT AREA NOW
      noInterrupts(); //no new external event change the sequence actions queue above till queue is over, just add ~500ms latency on AC0 notifications
     
      CUTOUT(RAILCOM); //proceed cutout till end of it
     
      //cutout is over now, continue

      dccrecState = WAIT_PREAMBLE; //next step will be at this state

      interrupts();   
   
    }
    else  // Get next Byte   
    {
      dccrecState = WAIT_DATA;
      dccrec.bitCount = 0;                              // prepare for the next byte 
    }   
 
  break;
  }
}

ISR(AC0_AC_vect) {
 
    AC0.INTCTRL = 0; 

}




Ltr

3

Vos projets / Re : RailCom: Générateur de CutOut

« le: Aujourd'hui à 06:00:50 am »

Bonjour


J'ai comme prévu passe un peu de temps sur une implémentation "qui va bien" avec un cœur AVRx.

J ai retenu les TINY x6 de la serie 2: ATTINY426, 826 1626, 3226.
Le code est également 100% compatible avec leur dérivés x7 ATTINY 427,827,1627,3227.

Bien que désignés par le terme ATTINY il s agit de "MEGATINY" dont le cœur et les mécanismes sont plus proches des AVR Dx et ATMEGA serie 0 ( x08,x09) que des TINY historiques.

Ici on met à contribution la hard natif du chip ( TIMER B, LOGIC, COMPARATEUR pour la protection, EVENT pour lier le tout.)

Au final la boucle principale est ... vide de code!
 
Tout se gère via des mécanismes internes et il n'y a plus qu'à "profiter" du résultat pour piloter le pont H L6203 par ses broches ENABLE, IN1 et IN2.

Le MAPPING retenu est en commentaire dans le code ci joint avec un brochage SOIC20.

Le code va permettre de traiter 3 cas de figure:

SIMPLE BOOSTER: amplifie les signaux reçus sur les entrées PIN_PA1 et PIN_PA2, assure une protection contre les CC et surcharges.(avec sortie LED temoin,...)
Rm: Ce signal peut déjà comporter un CUTOUT RAILCOM, il sera alors reproduit.
BOOSTER GERANT LES TIMINGS SANS CUTOUT RAILCOM: on laisse ici le hard redécouper les trames pilotant le pont en H par les inputs sur PIN_PA1 et PIN_PA2.
BOOSTER AVEC CUTOUT RAILCOM: on insère le CUTOUT dans un signal en entrée sans CUTOUT sur PIN_PA1 et PIN_PA2.

A tester sans modération!

CODE PART1:

Code: [Sélectionner]

#include <Arduino.h>

/*
  author: LTR Laurent ROEKENS
  version v0.0.1
  last update date: 01/05/2024
*/


/*
  CUTOUT GENERATOR:

  Select mode:

  Simple BOOSTER (H bridge driven by input signals)
  BOOSTER without RAILCOM (H bridge drive by this CPU timings)
  BOOSTER WITH RAILCOM (H bridge drive by this CPU timings)

  In all modes CURRENT LIMITOR is activated (by measure on COMPARATOR AC0)

*/

/*
  HOW IS IT?:
  FROM DCC SIGNAL INPUTS IN PINS PA_PA2 & PIN_PA3:
  analyses DCC messages
  if required introduce CUTOUT at end of DCC messages with security GAP to drive L6203 H BRIDGE PINS

  use of EVENT software
  use of LOGIC hardware
  use of COMPARATOR for protection (overload/shorcut)
  use TCB0 counter in capture frequency mode
  L6203 IN1 and IN2 are driven by logic outputs 
  L6203_ENABLE_PIN is driven by logic output


// Connect the Attinyx26 as follows in SOIC20 SUPPORT:

//
//                            --------U--------
//     VCC (+5V)             -| 1 VCC   GND 20|- GND
//     LOGIC_CUTOUT_OUT_PIN  -| 2 PA4   PA3 19|- LOGIC_CUTOUT_IN_PIN
//     LOGIC_ENABLE_OUT_PIN  -| 3 PA5   PA2 18|- DCC_PIN_L
//     LOGIC_ENABLE_IN_PIN   -| 4 PA6   PA1 17|- DCC_PIN_R
//     L6203_ENABLE_PIN      -| 5 PA7   PA0 16|- UDPI
//     COMP_IN+              -| 6 PB5   PC3 15|- RAILCOM_MODE_SELECTOR_INPUT_PIN
//     COMP_IN-              -| 7 PB4   PC2 14|- LED_SHORCUT_OVERLOAD
//     L6203_IN2             -| 8 PB3   PC1 13|- LED_RAILCOM_ENABLE
//     L6203_IN1             -| 9 PB2   PC0 12|- LED_SIMPLE_AMPLIFICATOR_MODE
//     EXT_START_STOP_PIN    -|10 PB1   PB0 11|- SIMPLE_AMPLIFICATOR_MODE_INPUT_PIN
//                            -----------------

// CODE & PIN MAPPING FULY COMPATIBLE WITH ATTINYx27

*/

#include "Logic.h"
#include "Event.h"
#include "Comparator.h"

//RM: MILLIS_USES_TIMERB1

#define MaxDccSize 6                         // DCC messages can have a length upto this value

struct {
  uint8_t bitCount;                           // Count number of preamble bits / if we have a byte
  volatile uint8_t tempMessage[MaxDccSize];   // Once we have a byte, we store it in the temp message
  volatile uint8_t tempMessageSize;           // Here we keep track of the size, including XOR
} dccrec;                                     // The received DCC message is assembled here


#define dccrecState       GPIOR0              // fast: saves 3 clock cycli, but requires a free GPIOR
#define dccHalfBit        GPIOR1              // fast
#define RAILCOM           GPIOR2              // fast
#define AMPLIFICATOR_MODE GPIOR3              // fast


//******************************************************************************************************
// Defines, definitions and instantiation of local types and variables
//******************************************************************************************************
// Values for half bits from RCN 210, section 5: http://normen.railcommunity.de/RCN-210.pdf
#define ONE_BIT_MIN                             F_CPU / 1000000 * 52
#define ONE_BIT_MAX                             F_CPU / 1000000 * 64
#define ZERO_BIT_MIN                            F_CPU / 1000000 * 90
#define ZERO_BIT_MAX                            F_CPU / 1000000 * 119


// Possible values for dccrecState
#define WAIT_PREAMBLE                           (1<<0) //WAIT_PREAMBLE = 0;
#define WAIT_START_BIT                          (1<<1) //WAIT_START_BIT = 1;
#define WAIT_DATA                               (1<<2) //WAIT_DATA = 2;
#define WAIT_END_BIT                            (1<<3) //WAIT_END_BIT = 3;

// Possible values for dccHalfBit
#define EXPECT_ZERO                             (1<<0) //EXPECT_ZERO = 0;
#define EXPECT_ONE                              (1<<1) //EXPECT_ONE = 1;
#define EXPECT_ANYTHING                         (1<<2) //EXPECT_ANYTHING = 2;

// Values for half bits from RCN 217,
#define ENABLE_STOP_TIME                        F_CPU / 1000000 * 26    // CUTOUT MIN START VALUE
#define ENABLE_START_TIME                       F_CPU / 1000000 * 488  // CUTPOUT MAX STP¨VALUE

// Value according OPEN DCC best pracitces:
#define CUTOUT_START_TIME                       F_CPU / 1000000 * 30   //4us security gap cutout at start
#define CUTOUT_STOP_TIME                        F_CPU / 1000000 * 484   //4us secutity gap cutout at stop


#define DCC_TIMER                               TCB0

#define DCC_PIN_R                               PIN_PA1  //DCC FROM R INPUT SIGNAL DRIVEN BY LUT0 IN1
#define DCC_PIN_L                               PIN_PA2  //DCC FROM L INPUT SIGNAL DRIVEN BY LUT0 IN2

//PIN_PA3:
#define CUTOUT_LOGIC_IN_PIN                     PIN_PA3 //EVENT CHANNEL 1 IN

//PIN_PA4:

#define LOGIC_CUTOUT_OUT_PIN                    PIN_PA4
#define LOGIC_CUTOUT_OUT_PIN_ON                 PORTA.OUTSET = PIN4_bm
#define LOGIC_CUTOUT_OUT_PIN_OFF                PORTA.OUTCLR = PIN4_bm

//
//RM: HARDWARE SHOULD LINK PIN_PA3 WITH PIN_PA4
//

//PIN_PA5:

#define LOGIC_ENABLE_OUT_PIN                    PIN_PA5
#define LOGIC_ENABLE_OUT_PIN_ON                 PORTA.OUTSET = PIN5_bm
#define LOGIC_ENABLE_OUT_PIN_OFF                PORTA.OUTCLR = PIN5_bm

//PIN_PA6:

#define LOGIC_ENABLE_IN_PIN                     PIN_PA6

//
//RM: HARDWARE SHOULD LINK PIN_PA5 WITH PIN_PA6
//

//PIN_PA7:
#define L6203_ENABLE_OUT_PIN                    PIN_PA7 //L6203_ENABLE_PIN

//PIN_PB2:
#define L6203_IN1                               PIN_PB2 //DRIVEN BY EVOUTB

//PIN_PB3:
#define L6203_IN2                               PIN_PB3 //DRIVEN BY LUT2 OUTPUT

#define RAILCOM_MODE_SELECTOR_INPUT_PIN         PIN_PC3 //RAILCOM SWITCH ENABLE/DISABLE

#define LED_SHORCUT_OVERLOAD_PIN                PIN_PC2 //LED INDICATOR FOR OVERLOAD OR SHORCIRCUIT

#define LED_RAILCOM_ENABLE_PIN                  PIN_PC1
#define LED_RAILCOM_ENABLE_PIN_ON               PORTC.OUTSET = PIN1_bm
#define LED_RAILCOM_ENABLE_PIN_OFF              PORTC.OUTCLR = PIN1_bm

#define LED_SIMPLE_AMPLIFICATOR_MODE_PIN        PIN_PC0
#define LED_SIMPLE_AMPLIFICATOR_MODE_PIN_ON     PORTC.OUTSET = PIN0_bm
#define LED_SIMPLE_AMPLIFICATOR_MODE_PIN_OFF    PORTC.OUTCLR = PIN0_bm

#define EXT_STOP_START_INPUT_PIN                PIN_PB1 //STOP_START_INPUT_PIN: DRIVE EXTERNAL STOP /START

#define SIMPLE_AMPLIFICATOR_MODE_INPUT_PIN      PIN_PB0 //AMPLIFICATOR MODE: SIMPLE APLIFICATOR OR TIMINGS MANAGE BY THIS HARDWARE DRIVING L6203
             

void INIT_PINS(){

  //RAILCOM_MODE_SELECTOR_PIN:
  //pinMode(RAILCOM_MODE_SELECTOR_INPUT_PIN,INPUT); //INPUT slow
  PORTC.DIRCLR = PIN3_bm; //INTPUT fast
  //PORTC.PIN3CTRL |= PORT_PULLUPEN_bm; /// use the internal pullup resistor on PC3
  PORTC.PIN3CTRL &= ~PORT_PULLUPEN_bm;  // don't use the internal pullup resistor on PC3
 

  //AMPLIFICATOR_MODE_MODE_SELECTOR_INPUT_PIN:
  //pinMode(SIMPLE_AMPLIFICATOR_MODE_INPUT_PIN,INPUT); //INPUT slow
  PORTB.DIRCLR = PIN0_bm; //INTPUT fast
  //PORTC.PIN0CTRL |= PORT_PULLUPEN_bm; /// use the internal pullup resistor on PB0
  PORTC.PIN0CTRL &= ~PORT_PULLUPEN_bm;  // don't use the internal pullup resistor on PB0

  //STOP_START_PIN:
  //pinMode(EXT_STOP_START_INPUT_PIN,INPUT); //INPUT slow
  PORTB.DIRCLR = PIN1_bm;
  //PORTB.PIN1CTRL |= PORT_PULLUPEN_bm; /// use the internal pullup resistor on PC2
  PORTB.PIN1CTRL &= ~PORT_PULLUPEN_bm;  // don't use the internal pullup resistor on PC2

  //LED_RAILCOM_ENABLE
  //pinMode(LED_RAILCOM_ENABLE_PIN,OUTPUT); //OUTPUT slow
  PORTC.DIRSET = PIN1_bm; //OUTPUT fast
  PORTC.DIRCLR = PIN1_bm; //INIT STATE OFF

  //LED_SIMPLE_AMPLIFICATOR_MODE
  //pinMode(LED_SIMPLE_AMPLIFICATOR_MODE_PIN,OUTPUT); //OUTPUT slow
  PORTC.DIRSET = PIN0_bm; //OUTPUT fast
  PORTC.DIRCLR = PIN0_bm; //INIT STATE OFF

  //LED_SHORCUT_OVERLOAD_PIN PIN_PC2
  //pinMode(LED_SHORCUT_OVERLOAD_PIN,OUTPUT); //OUTPUT slow
  PORTC.DIRSET = PIN2_bm; //OUTPUT fast
  PORTC.DIRCLR = PIN2_bm; //INIT OFF

}

void INIT_ADDITIONNAL_PINS(){
  //INIT PINS DONT MANAGED BY LUT OR YET SET:

  //LOGIC_CUTOUT_OUT_PIN:
  //pinMode(LOGIC_CUTOUT_OUT_PIN,OUTPUT); //slow
  PORTA.DIRSET = PIN4_bm; //OUTPUT fast
  PORTA.OUTCLR = PIN4_bm; //INIT STATE OFF

  //LOGIC_CUTOUT_IN_PIN:
  //pinMode(CUTOUT_LOGIC_IN_PIN,INPUT); //slow
  PORTA.DIRCLR = PIN3_bm; //INPUT fast
  //PORTA.PIN3CTRL |= PORT_PULLUPEN_bm; // use the internal pullup resistor on PA3
  PORTA.PIN3CTRL &= ~PORT_PULLUPEN_bm;  // don't use the internal pullup resistor on PA3

  //LOGIC_ENABLE_OUT_PIN
  //pinMode(LOGIC_ENABLE_OUT_PIN,OUTPUT); //slow
  PORTA.DIRSET = PIN5_bm; //OUTPUT fast
  PORTA.OUTCLR = PIN5_bm; //INIT STATE OFF

  //LOGIC_ENABLE_IN_PIN:
  //pinMode(LOGIC_ENABLE_IN_PIN,INPUT); //slow
  PORTA.DIRCLR = PIN6_bm; //INPUT FAST
  //PORTA.PIN6CTRL |= PORT_PULLUPEN_bm; /// use the internal pullup resistor on PA6
  PORTA.PIN6CTRL &= ~PORT_PULLUPEN_bm;  // don't use the internal pullup resistor on PA6

  //L6203_IN1: PB2
  //pinMode(L6203_IN1,OUTPUT); //slow
  PORTB.DIRSET = PIN2_bm; //OUTPUT fast
  PORTB.OUTCLR = PIN2_bm; //INIT STATE OFF

  //L6203_IN2:PB3: already done by LOGIC block init
  //pinMode(L6203_IN2,OUTPUT);

  //L6203_ENABLE_PIN
  //pinMode(L6203_ENABLE_OUT_PIN,OUTPUT); //OUTPUT slow
  PORTA.DIRSET = PIN7_bm; //OUTPUT fast
  PORTA.OUTCLR = PIN7_bm; //INIT STATE OFF

}

void INIT_TCB(){
  // Reset registers. See the data sheets for details
    noInterrupts();
  // Clear the main timer control registers. Needed since the Arduino core creates some presets
      DCC_TIMER.CTRLA = 0;
      DCC_TIMER.CTRLB = 0;
      DCC_TIMER.EVCTRL = 0;
      DCC_TIMER.INTCTRL = 0;
      DCC_TIMER.CCMP = 0;
      DCC_TIMER.CNT = 0;
      DCC_TIMER.INTFLAGS = 0;

  // Set values:
      DCC_TIMER.CTRLA = TCB_ENABLE_bm;
      DCC_TIMER.CTRLB = TCB_CNTMODE_FRQ_gc;
      DCC_TIMER.EVCTRL = TCB_CAPTEI_bm | TCB_FILTER_bm;
      DCC_TIMER.INTCTRL |= TCB_CAPT_bm;

    interrupts();
}



4

Vos projets / Re : centrale DCC / analogique modulaire

« le: mai 01, 2024, 07:39:46 pm »

Hello Marc

C est beau!
Y a du travail derrière!!Belle œuvre appréciable

Rm sur les utilisations: avec le retour d'expérience des satellites autonomes qui font appel à des détecteurs "ponctuels" placés aux extrémités de zone(s) via des capteurs optiques ( sortie 0-1) sur comparateur , est ce que cela  n'arrangerait il pas tes usages ? La zone pilotée par le PONT H serait alors composée d' un seul segment ("canton") et si besoin des capteurs aux extrémités viennent informer de l'occupation "locale" selon les zones ou le tain se situe en plus de la détection globale par conso au niveau "canton"?

Pour ce qui est du calcul des couts avec les NE556 ( x2)/555(x1) et les coils selon, leur nombre (5 à priori)  le cout est assez faible mais c est plus une question d encombrement qui sera probablement supérieur à ton dispositif actuel à base de diodes. et avec des montages externes pour les capteur locaux.

la SS34 est une Schottky à faible chute (mais rapide)  aussi tu risques d'avoir quelques surprises avec cette faible chute qui sera plus franche avec une diode "classique" avec un Vdrop plus haut.
.

Ltr

5

Vos projets / Re : RailCom: Générateur de CutOut

« le: avril 30, 2024, 05:46:08 pm »

Y a bien une petit ligne qui le dit:

Code: [Sélectionner]

#ifdef __AVR_ATmega328P__                    // --- Arduino AVR --
Donc oui pour le TINY pas de sujet mais si 328P /MEGA ou autre le mapping brochage est à revoir pour être sur INT0 ( PD2) comme PB2 l'est sur le TINYx5

Ltr

6

Vos projets / Re : centrale DCC / analogique modulaire

« le: avril 30, 2024, 05:43:15 pm »

Hello

Si je me souviens bien des hypothèses de départ l' idée  était de réduire le nombre de composants "externes" au delà du CPU .

Si on peut en ajouter pourquoi alors ne pas partir sur un montage externe qui dans tous les cas donnera la "vérité" sur l'occupation 0/1 de la zone en question? ( montage à diodes + opto? montage  à base de COIL, COIL +NE555/556..?)

Si on désire avoir toutes les mesures de conso local alors on acceptera de poser de petit TINY et remonter cela d une façon ou d une autre...

Pour la détection en analogique une solution peut consister à envoyer un bref temps un courant qui indiquera en retour l'état...

Ltr

7

Vos projets / Re : RailCom: Générateur de CutOut

« le: avril 30, 2024, 04:28:46 pm »

Bonjour

@Christophe, l'adaptation pour le 328P ne devrait elle pas plutôt avoir PD2 comme entrée (INT0) pour le signal DCC ? et passer les broches de pilotage sur le PORTB ? ( PB2 ne gère pas des interruptions externes me semble t il?)

Je regarde de mon cote pour porter cela sur AVRx ( MAGTINY AVRx série 0 ou 1 (Atmegax08 x09, NANOEVERY et AVR Dx ( DA DB DD)...)
Je pense cependant plus à un hardware disposant de 2 timer B dans ce lots de candidats...

Ltr

8

Vos projets / Re : RailCom: Générateur de CutOut avec booster

« le: avril 29, 2024, 05:29:11 pm »

Voici a quoi va ressembler la partie d initialisation des I/O utilisés par la circuiterie interne avec la confiuration ad hoc pour piloter le BOOSTER.

On va inclure ceci:

Code: [Sélectionner]


#include <Event.h>
#include <Logic.h>
#include <Comparator.h>


Puis en exploiter les éléments

Code: [Sélectionner]

noInterrupts();

  //define COMPARATOR IN/OUT
  #if defined(__AVR_DA__) || defined(__AVR_DB__)      //use COMPARATOR 0 (AC0)
    Comparator0.input_p = comparator::in_p::in3;      // Use positive input 3 PIN_PD6
    Comparator0.input_n = comparator::in_n::in2;      // Use negative input 2 PIN_PD7
    Comparator0.hysteresis = comparator::hyst::disable;
    Comparator0.reference = comparator::ref::disable;
    Comparator0.output = comparator::out::disable_invert; // No output pin, signal inverted internally;

    // Initialize comparator
    Comparator0.init();

    // Start comparator
    Comparator0.start();
 
  #endif

  #if defined(__AVR__DD__) //default comparator value = AC0

    Comparator.input_p = comparator::in_p::in3;      // Use positive input 3 PIN_PD6
    Comparator.input_n = comparator::in_n::in2;      // Use negative input 2 PIN_PD7
    Comparator.hysteresis = comparator::hyst::disable;
    Comparator.reference = comparator::ref::disable;
    Comparator.output = comparator::out::disable_invert; // No output pin, signal inverted internally;

    // Initialize comparator
    Comparator.init();

    // Start comparator
    Comparator.start();

  #endif

  #if defined(__AVR_ATmegax08__) || defined(__AVR_ATmegax09__) //default comparator value = AC0
    Comparator.input_p = comparator::in_p::in2;      // Use positive input 2 PIN_PD6
    Comparator.input_n = comparator::in_n::in2;      // Use negative input 2 PIN_PD7 
    Comparator.hysteresis = comparator::hyst::disable;
    Comparator.reference = comparator::ref::disable;
    Comparator.output = comparator::out::disable_invert; // No output pin, signal inverted internally;

    // Initialize comparator
    Comparator.init();

    // Start comparator
    Comparator.start();

  #endif 
 
 
  //DEFINE CCL LUT0: 
  Logic0.enable;                       //ACTIV LUT0
  Logic0.input0 = logic::in::ac;       //AC0 OUT
  Logic0.input1 = logic::in::pin;      //PIN_PA1
  Logic0.input2 = logic::in::masked;   //NOT USED
  Logic0.output = logic::out::enable;  //PIN_PA3
  Logic0.truth = 0x04;                 // Set truth table

  Logic0.init();


  Event1.assign_generator_pin(gen1::pin_pa7); //PIN_PA7 as input
  Event1.set_user(user::ccl1_event_b);        //user
  Event1.set_user(user::ccl3_event_b);        //user too
  Event1.start();                             //start event channel1

  //DEFINE CCL LUT1:
  Logic1.enable;                      //ACTIV LUT1
  Logic1.input0 = logic::in::ac;      //AC0 OUT
  Logic1.input1 = logic::in::event_a; //event_a
  Logic1.input2 = logic::in::event_b; //event_b
  Logic1.output = logic::out::enable; //PIN_PC3
  Logic1.truth = 0xc1;                // Set truth table

  Logic1.init();

  //DEFINE CCL LUT2:
  Logic2.enable = true;                 //ACTIV LUT2
  Logic2.input0 = logic::in::ac;        //AC0 OUT
  Logic2.input1 = logic::in::pin;       //PIN_PD1
  Logic2.input2 = logic::in::pin;       //PIN_PD2
  Logic2.output = logic::out::disable;  //NO OUTPUT DIRECTLY SO USE EVENT CHANNEL 0 INSTEAD
  Logic2.truth = 0x04;                  //Set truth table

  Logic2.init();

  Event0.assign_generator(gen::ccl2_out);

  #if defined(DCC_USES_TIMERB0)
    Event0.set_user(user::tcb0_capt); //route to TCB0
  #elif defined(DCC_USES_TIMERB1)
    Event0.set_user(user::tcb1_capt); //route to TCB1
  #elif defined(DCC_USES_TIMERB2)
    Event0.set_user(user::tcb2_capt); //route to TCB2
  #elif defined(DCC_USES_TIMERB3)
    Event0.set_user(user::tcb3_capt); //route to TCB3
  #else
    Event0.set_user(user::tcb0_capt); //route to TCB0 by default
  #endif


  Logic3.enable = true;                //ACTIV LUT2
  Logic3.input0 = logic::in::ac;       //AC0 OUT
  Logic3.input1 = logic::in::event_a;  //event_a
  Logic3.input2 = logic::in::event_b;  //event_b
  Logic3.output = logic::out::disable; ///NO OUTPUT DIRECTLY SO USE EVENT CHANNEL 2 INSTEAD TO ROUTE TO PIN_PF2
  Logic3.truth = 0xc4;                 //Set truth table

  Logic3.init();

  Event2.assign_generator(gen::ccl3_out);
  Event2.set_generator(event::user::evoutc_pin_pc2);

  Event3.assign_generator(event::gen::ac0_out);
  Event3.set_user(event::user::evoutf_pin_pf2);
  Event3.start();

  Logic::start(); //start all logic bloc activated


  interrupts();


Pour memo

1 TIMER B est utilisé pour la gestion du décodage des trames DCC en entrée
1 TIMER B est utilise pour un compteur interne avec les timings utilisés pour les opérations de CUTOUT
1 Comparateur (AC0)
4 LUT ( Logique programmable) pour combiner et traiter le pilotage des broches du pont H ( et des leds autours)
4 Events pour liaisonner le tout.

La partie CUTOUT va être celle ci dessous

CUTOUT_PIN et ENABLE_PIN, présentes ici  vont en fait être des pins de SORTIES LOGIQUES.
Elles ne pilotent pas directement  la broche ENABLE ou une broche CUTOUT
Elles sont utilisées en les liant à des pins d entrée des CCL LIUT: elle agiront comme signaux dans la circuiterie qui va auto réagir vers les broches de pilotage des composants  les broches réelles qui drive le L6203: ENABLE PIN, IN1 IN2 et les leds diverses.

Toute la partie CCL est hardware et ne dépend pas des cycles du CPU.
La réaction est donc (quasi) immédiate (qq nano secondes suffisent!)

Les valeurs de références sont calculées selon la vitesse du CPU ( F_CPU) ( pour les timings suivant en us: 26, 30,484,488):

Code: [Sélectionner]


#define ENABLE_STOP F_CPU / 1000000 * 26    // CUTOUT MIN START VALUE
#define ENABLE_START F_CPU / 1000000 * 488  // CUTPOUT MAX STP¨VALUE
#define CUTOUT_START F_CPU / 1000000 * 30   //4us security gap cutout at start
#define CUTOUT_STOP F_CPU / 1000000 * 484   //4us secutity gap cutout at stop



Code: [Sélectionner]

void CUTOUT(void)
  {   
    //TIMER B IS ALREADY STARTED AND CNT GO UP     
    if(TICK_TIMER.CNT < ENABLE_STOP) //< 26us
    {
      //L6203_ENABLE_PIN ON
      ENABLE_PIN_ON;
    }
    else if((TICK_TIMER.CNT < CUTOUT_START) && (TICK_TIMER.CNT >= ENABLE_STOP)) // >=26us & <30us
    {
      //L6203_ENABLE_PIN OFF
      ENABLE_PIN_OFF;
    }
    else if((TICK_TIMER.CNT < CUTOUT_STOP) && (TICK_TIMER.CNT >= CUTOUT_START)) //>=30us & <484us
    {
      //MAKE CUTOUT
      CUTOUT_PIN_ON;
    }
    else if((TICK_TIMER.CNT < ENABLE_START) && (TICK_TIMER.CNT >= CUTOUT_STOP)) // >=484 us & < 488us
    {
      //STOP CUTOUT
      CUTOUT_PIN_OFF;
    }
    else if ((TICK_TIMER.CNT >= ENABLE_START)) // >=488us
    {
      //ENABLE PIN ON:
      ENABLE_PIN_ON;

      //CUTOUT IS OVER => STOP TICK COINTER
      STOP_TICK_TIMER();
    }
  }




Le pilotage des broches IN1 et IN2 L6203_ENABLE_PIN ne passent pas par le cœur du CPU mais par les portes logique (CCL LUT) qui vont les commander selon les valeurs des tables.

Astucieux?

9

Vos projets / Re : RailCom: Générateur de CutOut

« le: avril 28, 2024, 09:12:00 pm »

De ma compréhension le SECURITY GAP intervient lorsqu'un véhicule est à cheval entre sur 2 boosters. Ceux ci pilotant des électroniques qui peuvent avoir un temps de réaction "élastique" l'un vis à vis de l'autre pour être certain de ne pas être dans un cas où l'un a déjà fini et pas l'autre, on ajoute cette temporisation ce qui pourrait avoir des effets de bords sur les décodeurs mobiles.
C est donc un temps mort de sécurité mis à chaque bout du cutout.

(on pourrait aussi avoir en tête les fameux 4us de précision de delta des AVR avec micro?)

On pourra surement voir avec un L18200 et les ponts similaires comment traiter cela.

Ltr

10

Vos projets / Re : RailCom: Générateur de CutOut

« le: avril 28, 2024, 05:17:13 pm »

Bonjour

J ai une question qui va aider la recherche d éventuels autres pont H.

D après OPEN DCC il faut insérer un "SECURITY GAP" de 4us  sur le L6203 entre son activation/désactivation ( broche ENABLE) et la commande de mise en "CC" ( via IN 1 et IN2)
Ceci est (fortement) recommandé notamment dans le cas de la présence de plusieurs boosters.

Comment gérer cela au niveau du L298 ( que je ne connais pas) ou d'autres ponts H qui ne reposent pas sur la présence de broche ENABLE? ( et donc intégrer cela au dispositif en cours de mise au point pour LABOX)

Ltr

11

Vos projets / Re : RailCom: Générateur de CutOut avec booster

« le: avril 28, 2024, 04:50:51 pm »

Les mêmes "config" sous AVR Dx.

Ici un AVR DB (un peu plus doté que le l AVR DD qui tient plus lui de l'ATMEGA4808 question ressources hardware)

12

Vos projets / Re : RailCom: Générateur de CutOut avec booster

« le: avril 28, 2024, 04:35:48 pm »

Bonjour

Nous avons collectivement discuté des apports de RAILCOM.
Les récents projets exposés par Christophe et Marcel notamment avec l'identificateur RAILCOM ou les satellites autonomes de Christophe nous apporte une plus value importante à l'utilisation de cette technologie.

Toutefois LA BOX Locoduino comme d'autres centrales n'est nativement pas capable de générer "correctement" le "cutout" railcom.

De quoi est il question: c est la fenêtre de temps durant laquelle la transmission des informations du décodeur vers la centrale est permise par interruption des émissions de trames DCC de la centrale vers les consommateurs (décodeurs de locos...)

Aussi plusieurs solutions ont été évoquées.
Parmi celles ci figure l'utilisation de BOOSTER DCC offrant la capacité de générer le CUTOUT.

Pour cela il y a comme toujours les solutions commerciales et celles auxquelles nous sommes attachées en DIY (esprit Locoduino!)

Dans les solutions en DIY citons celles les plus connues que sont:
A//le BOOSTER CDE de PACO CANADA (technologie PIC)
https://usuaris.tinet.cat/fmco/railcom_en.html#booster

B//le BOOSTER OPEN DCC ( ATTINY2313):
https://www.opendcc.de/french/Amplification/booster2_f.shtml

Les sites présentant ces réalisations décrivent les mécanismes et préconisent aussi des "optimums" (gap de sécurité par exemple en cas de boosters multiples)

Ayant moi même réalisé des montages du BOOSTER de PACO je voulais aussi m'approprié une solution plus contemporaine à base d'AVR/ATTINY inspirée aussi de la réalisation d'OPEN DCC que je juge plus complète.

Pour cela il fallait comprendre les mécanismes, chercher & trouver des réponses, optimiser le tout.

Plusieurs pistes étaient possibles.

J'ai retenu l'option de réduire le nombre total de composants à implanter et de bénéficier du même coup des apports des CPU de type AVR récents.
Ceux ci sont particulièrement bien adaptés à l'usage visé.

Inspiré de la partie HARD du BOOSTER OPEN DCC je suis finalement arrivé sur l'utilisation des AVR 32 broches de type AVR4808 ( AVRx série 0, celle du NANOEVERY) , AVR Dx ( DA DB DD,...) ( AVRx série 1) qui offrent sans fioriture ce dont nous avons besoins:
1//des TIMERS de type B
2//des CCL "GLUE LOGIC" configurables (assimilable à des portes logiques "sur mesure")
3//la possibilité de liaisonner les éléments via "EVENT"
4//un comparateur (pour la gestion de seuil en cas de cout circuit)

Ces CPU étant compatibles avec ces données en entrée la seconde étape a été de chercher le MAPINGS des différents I/O à placer pour correspondre à la couverture des besoins.

Plusieurs essais ont été requis pour arriver à une solution transposable sur plusieurs CPU: ATMEGA4808, AVDxxDA32, AVRxxDB32, AVRxxDD32
Leurs fonctionnements internes étant très similaires seul diffèrent quelques éléments "cosmétiques" de paramétrages.

Les librairies MEGACOREX ( AVR4808) et DXCORE ( AVR Dx) sont mises à contribution et facilitent la mise en œuvre du code.

L'utilisation de ATMEL START m'a beaucoup aidé pour visualiser les interactions entre les éléments et trouver une combinaison avec l'ensemble des besoins et contraintes à couvrir.

Des lors il restait à vérifier la couverture et dessiner ensuite.
Le code étant dans un second temps l'étape complémentaire à assurer.

Il est encore possible d'utiliser certaines ressources non encore utilisées sur ces CPU.
Parmi les piste possibles en réflexion:
i//gestion de la tension de sortie DCC sur les plots J/K via ajustement du niveau de PWM en entrée.(configuration par CV) via la broche PF4
i//gestion de seuils de déclanchement de protection différenciés (sélection mécanique par DIP SWITCH)

Voila les bases posées.
Ltr

13

Vos projets / RailCom: Générateur de CutOut avec booster

« le: avril 28, 2024, 01:52:35 pm »

Bonjour

Quelques compléments également sur la proposition que j'ai dessinée:
C'est bien un BOOSTER à part entière. Compatible avec les entrées CDE. (j'ignore juste le "level" de ces signaux (5V?,16V?)
Il reçoit en entrée un signal DCC "pure" sans CUTOUT qu'il va ou non générer (configuration via CV)

On peut aussi par CV lui préciser le nombre de bits de préambule. à utiliser.

Ce montage reprend plusieurs recommandations importantes:
1//Opto isolation entre l'entrée et l'étage d'amplification/sortie

2//Il dispose d une liaison inter BOOSTER qui est une "masse commune". ( un "0" commun pour aligner les mesures des tensions sur une même base: on compte les étages à partir du même référentiel "0" comme avec l'altitude avec le niveau de la mer) ce qui permet de mettre plusieurs boosters sur un même réseau si nécessaire.( en parallèle sur des sections indépendantes: coupure des 2 rails entres sections)

3//Il intègre aussi les recommandations de "security gap" qu'indique le site OPEN DCC dans le pilotage du pont H:
https://www.opendcc.de/info/railcom/railcom_f.shtml

Ceci sécurise notamment en cas de passage d'un booster vers un autre ce que pour le moment n'est pas repris (encore) dans le montage de lebelge2 ni LABOX.

J ai pris par principe que le pole C porte la "phase" du signal et traite la sortie J du booster via le IN1 du pont, respectivement le plot D traite le signal K via le IN2 du pont du L6203.
Il serait très simple de permuter logiciellement le cas par les tables de vérités de CCL LUT du CPU qui sont utilisés ici.

Par ailleurs les entrées provenant des signaux C et D passent par une unité CCL LUT sur une porte XOR ce qui filtre le porteur avant injection vers le TIMER B et les autres CCL LUT
Ainsi tous les consommateurs des signaux C & D appliqueront le même traitement vers les mêmes sorties.

Ma recommandation est de n'utiliser (pour la traction à minima) que des boosters identiques et de laisser la sortie de la centrale sans usage ou aux seuls accessoires si elle est suffisante pour l'ensemble du réseau.

On peut sur une version "labox remaniée" mettre les sorties qui alimentent le pont H à destination des "inputs" des boosters externes (plots CDE) sinon je ne vois pas comment celle ci gèrera le cas de multiple boosters ( sauf à en interdire en usage?)

Le hardware reprend notamment:
A//le filtre sur la sortie du pont (BOOSTER OPEN DCC)
B//Entrées CDE
C//indicateurs (leds) visuels des états des principaux I/O
D//une réserve locale d'énergie (condensateurs en entrée du montage)
E//un convertisseur DC-DC local (max 600mA)

Des pistes de compléments:
// i) régulateur de tension de sortie (via PWM sur un MOS en entrée de montage)
// ii) sélection ( via dip switchs) de seuils multiples pour déclanchement de la protection (ici calée au max = 4A)
// iii)une interface CAN nécessite d'utiliser des CPUs à 48 broches type AVR DB ou ATMEGA4809  pour libérer un port SPI (ici le SPI0 alors sur le port E - PE0 à PE3) afin d ajouter un transceiver CAN, possible donc mais pas immédiat.

Ltr

14

Vos projets / Re : RailCom: Générateur de CutOut avec booster

« le: avril 28, 2024, 04:21:36 am »

Bonjour

J'arrive un peu après la bataille... désolé

Toutefois je vous présente le "petit dernier".

BOOSTER RAILCOM(Able) avec toute la circuiterie qui va autours! Elle est ici très réduite du fit des apports des composants natifs du CPU. (Events, CCL, AC, Timer B, ...)

Le cœur est un CPU à 32 broches AVR type ATmega 4808 (celui du Nanoevery) ou un AVR Dx ( idéalement les DB et DD).

(On peut avec certains TINY de la série 2 arriver à quelque chose de très similaire, sinon il faut re ajouter des composants externes)

Le hard  reprend les signaux DCC d une centrale n'émettant pas de CUTOUT sur sa sortie signal. Entrée sur les plots C D E normalisés.
La conversion de puissance est confiée à un L6203
La protection est fixé à 4A
Alim DC DC locale pour alimenter le montage depuis l'entrée puissance.
De nombreuses leds sont ici présentes pour faciliter le décodage/troubleshooting des I/O.

J'ai passé un peu de temps à sélectionner les répartitions des pins au mieux de capacités/restrictions des CPU 32 broches.
L idée était d utiliser le plus possible tous leurs composants internes pour piloter l'ensemble du montage.

Fortement inspiré des montages BOOSTER CDE de PACO et du DCC BOSTER d'OPEN DCC est ici une évolution vers un CPU plus contemporain.

Que du classique...

Cote code je pars de la librairie d'AIKO PRAS ( AP DCC LIBRARY) qui doit être complétée pour ce montage.
Comme elle permet lors de l'assemblage d'identifier le bit 1 de fin de trame on sait alors partir de ce point pour générer le cutout et piloter les différents I/O.

A noter que le composant COMPARATEUR AC0 est utilisé pour la protection et que son déclanchement coupera le fonctionnement du montage ( AC0 OUT est mixé dans les CCL LUT dont es tables de vérités sont adaptées)

Ltr

15

Vos projets / Re : Les SATELLITES AUTONOMES: évolutions du socle initial

« le: avril 15, 2024, 12:32:19 pm »

Bonjour

Le bouclier assurant les détections est arrivé. 
Ici en panneau 3x3 il faut encore l'équiper de ses composants "traversants" dont les "COILS" et le passage du fil dans l'anneau.
L'empreinte pour les COILS est adaptée pour différents modèles.
Illustrés ici sur les photos le cas de ZMCT103C de 1000 tours.

Quelques essais restent donc encore à mener pour les valider.

Pour memo ils sont basés sur le montage "PAISELY" proposé par NOXPOR (Eric) qui a été ici adapté au contexte "satellites" en approche modulaire.
Le NE555 remplace le NE556 puisque seule une "entrée" est utilisée.
Un opto assure la conversion de tension (5V ou 3V3) de l'état de sortie pour aller vers le CPU.
Des indicateurs lumineux (ROUGE = OCCUPE) ( VERT = libre) complètent le dispositif en affichant l'état sur la zone de détection.

En complément il est possible d'inverser l'état de sortie haut ou bas qui traversera l'optocoupleur pour indiquer au CPU l'état d'occupation.

Ltr