1.11.9

News

Page  1 sur 3  > >>

2019-01-16
Catégorie : Arduino
Posté par : xavier
Un Circuit imprimé pour plusieurs sketches
2018-06-07
Catégorie : Arduino
Posté par : xavier
Des pistes pour developper un projet a base d'Arduino
2017-09-23
Catégorie : Expositions
Posté par : xavier

Les 4/5 Novembre 2017, au parc Savoie Expo de Chambéry (Savoie), se tiendra l'exposition Savoie Modelisme.

CMS - 1.11.9 - Bartolome
 

Accessoire DCC

Décodeur Dcc

Comment utiliser un Arduino pour piloter un pont tournant par exemple à partir de sa centrale DCC? Il existe des décodeurs hors de prix adaptés à certains appareils mais souvent, rien n'est disponible...

Quelques notions pour continuer:

DCC

DCC est une norme initialisée par Lenz. Le signal digital qui passe dans les rails répond a cette norme, tout comme celui qui va de la centrale DCC au décodeurs d'aiguillages. On distinguera:

- Décodeurs accessoires

- Décodeurs machines

Une librairie est disponible (à télécharger). Il n'est pas nécessaire de comprendre comment elle fonctionne. Il suffit de savoir s'en servir

 

Programme N°13:

// ========================================================
// Accessoire DCC
// ========================================================

#include <DCC_Decoder.h>
// Définitions et structures
#define kDCC_INTERRUPT 0
typedef struct {
   int address; // Addresse décodeur
   byte output; // Etat de sortie 1=on, 0=off
   int outputPin; // Broche Arduino à commander
   boolean isDigital; // true=digital, false=analog.
Si analog, donner un champ analogValue
   boolean isFlasher; // true=flash output, false=no time, no flash.
   byte analogValue; // Valeur à utiliser pour une valeur analogique.
   int durationMilli; // temps de rétention en Millisecondes. 0 = indéfini
   unsigned long onMilli; // Utilisée en interne pour le timing
   unsigned long offMilli; //
}
DCCAccessoryAddress;
DCCAccessoryAddress gAddresses[8];

// ========================================================
// Decoder Init
// ========================================================
void ConfigureDecoder() {
   gAddresses[0].address = 714;
   gAddresses[0].output = 1;
   gAddresses[0].outputPin = 5;
   gAddresses[0].isDigital = true;
   gAddresses[0].isFlasher = false;
   gAddresses[0].analogValue = 250;
   gAddresses[0].durationMilli = 0;

   gAddresses[1].address = 715;
   gAddresses[1].output = 1;
   gAddresses[1].outputPin = 6;
   gAddresses[1].isDigital = true;
   gAddresses[1].isFlasher = false;
   gAddresses[1].analogValue = 0;
   gAddresses[1].durationMilli = 0;

   gAddresses[2].address = 814;
   gAddresses[2].output = 0;
   gAddresses[2].outputPin = 5;
   gAddresses[2].isDigital = false;
   gAddresses[2].isFlasher = true;
   gAddresses[2].analogValue = 250;
   gAddresses[2].durationMilli = 500;

   gAddresses[3].address = 815;
   gAddresses[3].output = 0;
   gAddresses[3].outputPin = 6;
   gAddresses[3].isDigital = true;
   gAddresses[3].isFlasher = true;
   gAddresses[3].analogValue = 0;
   gAddresses[3].durationMilli = 500;

   gAddresses[4].address = 914;
   gAddresses[4].output = 0;
   gAddresses[4].outputPin = 5;
   gAddresses[4].isDigital = false;
   gAddresses[4].isFlasher = false;
   gAddresses[4].analogValue = 250;
   gAddresses[4].durationMilli = 0;

   gAddresses[5].address = 915;
   gAddresses[5].output = 0;
   gAddresses[5].outputPin = 6;
   gAddresses[5].isDigital = true;
   gAddresses[5].isFlasher = false;
   gAddresses[5].analogValue = 0;
   gAddresses[5].durationMilli = 0;

   gAddresses[6].address = 0;
   gAddresses[6].output = 0;
   gAddresses[6].outputPin = 0;
   gAddresses[6].isDigital = false;
   gAddresses[6].isFlasher = false;
   gAddresses[6].analogValue = 0;
   gAddresses[6].durationMilli = 0;

   gAddresses[7].address = 0;
   gAddresses[7].output = 0;
   gAddresses[7].outputPin = 0;
   gAddresses[7].isDigital = false;
   gAddresses[7].isFlasher = false;
   gAddresses[7].analogValue = 0;
   gAddresses[7].durationMilli = 0
;

   // Setup output pins
   for(int i=0; i<(int)(sizeof(gAddresses)/sizeof(gAddresses[0])); i++) {
       if( gAddresses[i].outputPin ) {
         pinMode( gAddresses[i].outputPin, OUTPUT );
      }
   gAddresses[i].onMilli = 0;
   gAddresses[i].offMilli = 0;
   }
}

// ========================================================
// Basic accessory packet
// ========================================================
void BasicAccDecoderPacket_Handler(int address, boolean activate, byte data) {
   // Convertit le paquet adresse NMRA en adresse comprehensible
   address -= 1;
   address *= 4;
   address += 1;
   address += (data & 0x06) >> 1;

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

   for(int i=0; i<(int)(sizeof(gAddresses)/sizeof(gAddresses[0])); i++) {
      if( address == gAddresses[i].address ) {
         Serial.print("Basic addr: ");
         Serial.print(address,DEC);
         Serial.print(" activate: ");
         Serial.println(enable,DEC);

       if( enable ) {
            gAddresses[i].output = 1;
            gAddresses[i].onMilli = millis();
            gAddresses[i].offMilli = 0;
         }else{
            gAddresses[i].output = 0;
            gAddresses[i].onMilli = 0;
            gAddresses[i].offMilli = millis();
         }
      }
   }
}

// ========================================================
// Setup
// ========================================================
void setup() {
   Serial.begin(9600);
   DCC.SetBasicAccessoryDecoderPacketHandler(BasicAccDecoderPacket_Handler, true);
   ConfigureDecoder();
   DCC.SetupDecoder( 0x00, 0x00, kDCC_INTERRUPT );
}

// ========================================================
// Main Loop
// ========================================================
void loop() {
   static int addr = 0;
   // Bouucle sur la librairie DCC
   DCC.loop();
   // Saute a l’adresse suivante
   if( ++addr >= (int)(sizeof(gAddresses)/sizeof(gAddresses[0])) ) {
      addr = 0;
   }
   // Extinction sortie?
   if( gAddresses[addr].offMilli && gAddresses[addr].offMilli<millis() ) {
      // Clear off time
      gAddresses[addr].offMilli = 0;
      // Interdit la sortie
      if( gAddresses[addr].isDigital ) {
         digitalWrite( gAddresses[addr].outputPin, LOW);
      }else{
         analogWrite( gAddresses[addr].outputPin, 0);
      }
      // Si toujours autorisée, et clignotante, positionne le temps on
      if( gAddresses[addr].output && gAddresses[addr].isFlasher) {
         gAddresses[addr].onMilli = millis() + gAddresses[addr].durationMilli;
      }else{
         gAddresses[addr].output = 0;
      }
      return;
   }
   // Activation sortie?
   if( gAddresses[addr].onMilli && gAddresses[addr].onMilli<=millis() ) {
      // Clear off time
      gAddresses[addr].onMilli = 0;
      // Autorise la sortie
      if( gAddresses[addr].isDigital ) {
         digitalWrite( gAddresses[addr].outputPin, HIGH);
      }else{
         analogWrite( gAddresses[addr].outputPin, gAddresses[addr].analogValue);
      }
      // Si toujours autorisée, et clignotante, positionne le temps off
      if( gAddresses[addr].durationMilli ) {
         gAddresses[addr].offMilli = millis() + gAddresses[addr].durationMilli;
      }
      return;
   }
}


Commentaires

A partir de ce programme on pourrait envisager:

- ...

 

A remarquer:

- Le shield I2C serait à adapter en fonction des besoins!

-

 

Previous page: Pas touche !  Page suivante : Accessoire XpressNet