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

Pages: 1 2 3 [4] 5 6
46
En effet, msport, c'est là que je pense que la solution se trouve !
Mais je ne suis pas non plus un expert, loin de là, c'est pourquoi j'ai demandé l'aide du forum.

47
Bonjour à vous tous,
Et tout d'abord, merci pour votre aide.
Je vais essayer de préciser un peu plus le problème : il s'agit de gérer les accessoires en général, les aiguillages en particulier, à partir de la centrale DCC++ elle-même, et non à partir du port série. Voici la question.
Pourquoi en ai-je besoin, si j'ai déjà le bluetooth ? Eh bien, pour jouer, Dominique, pour apprendre, par pure curiosité, il n'y a pas d'autre raison.

Et je peux vous dire qu'après avoir étudié la bibliothèque DCC++, je pense connaître le moyen de l'obtenir : le fichier Turnouts.cpp. Il se trouve que pour l'instant, tout cela est trop pour mes connaissances limitées, mais je vais continuer à enquêter.
Meilleures salutations,

Juan.

48
En effet, Dominique. Mon unité de commande fonctionne parfaitement, et je peux commander les aiguillages par série, soit par PC, soit par smartphone.

Et maintenant, j'aimerais pouvoir commander les aiguillages avec des boutons-poussoirs également. Tout en étant capable d'utiliser les commandes série, bien sûr.

49
Bonjour Dominique,
Non, ce n'est ni l'un ni l'autre, c'est plutôt le mélange. Voyons voir :

Je veux commander les aiguillages (connectés à un décodeur DCC (les neuf aiguillages connectés à un Nano) avec des boutons poussoirs connectés à la centrale DCC.

Merci beaucoup,
Juan

50
Désolé, j'ai envoyé le texte sans le traduire :

Je connais très bien le code de Greg Berman, le problème est de savoir comment envoyer ces séquences depuis l'intérieur du central DCC lui-même, avec un bouton poussoir qui est physiquement attaché au central DCC.

Meilleures salutations,
Juan

51
Merci beaucoup à msport pour votre aide, mais ce n'est pas le problème.

il faut envoyer sur le Rx de la centrale DCC++ les séquences prévues par Greg E. Berman

Yo conozco muy bien el código de Greg Berman, el problema es cómo envío esas secuencias desde dentro de la propia central,  con un pulsador que está unido físicamente a la central.

Un saludo,
Juan,

52
Merci beaucoup Dominique, mais après une première lecture du Va et Vient, ... je n'ai rien clarifié. Je veux gérer les aiguillages, et il n'y en a pas dans le VV.
Pourriez-vous être un peu plus explicite ?
Encore une fois, merci beaucoup,
Juan

53
Bien que le titre de ce nouveau sujet puisse sembler être le même que le précédent, le sujet est différent.
Je fais fonctionner mon modèle avec un central DCC++ avec la bibliothèque Locoduino, et une connexion Bluetooth. Mon projet comporte 9 aiguillages à solénoïde qui sont actionnés par un décodeur composé d'un Nano, d'un multiplexeur MCP23017 et de l'ULN2803 correspondant. Et tout fonctionne parfaitement, et je contrôle tout avec un smartphone, ou avec le PC (RocRail, JMRI,..).

J'ai récemment ajouté un écran tactile TFT au central avec lequel je peux contrôler quatre locomotives simultanément, avec leurs fonctions correspondantes (j'inclus une photo).
Et maintenant je voudrais ajouter 9 boutons poussoirs pour contrôler les aiguillages, sans oublier le Bluetooth et le contrôle par PC.
Aucune idée, aucune aide,
Merci beaucoup à tous,
Juan

54
Bibliothèques / Re : Analog pushes avec Commanders
« le: juin 03, 2021, 09:13:05 am »
Pas de problème, profitez de vos vacances.

55
Bibliothèques / Re : Analog pushes avec Commanders
« le: mai 30, 2021, 06:07:45 pm »
Eh bien, comme je l'ai annoncé ce matin, voici le résumé du code. C'est la première fois que je le fais, j'espère que c'est compris.
Nous commençons par l'introduction des variables et ainsi de suite :
Ceci concerne les multiplexeurs, MCP23017, trois sont définis, MCP0, MCP1 et MCP2.
//***************************************************
//   Se define el valor ID para identificar origen:
//       ID <  FIRST_ID_MCP                          => arduino
//       ID >= FIRST_ID_MCP and <FIRST_ID_MCP+16     => MCP0
//       ID >= FIRST_ID_MCP+16 and <FIRST_ID_MCP+32  => MCP1
//       ID >= FIRST_ID_MCP+32                       => MCP2
//***************************************************
//////////////////////MCP23017///////////
#include <Wire.h>
#include <Adafruit_MCP23017.h>

Adafruit_MCP23017 mcp0;
Adafruit_MCP23017 mcp1;
Adafruit_MCP23017 mcp2;
 #define addr0 0
 #define addr1 1
 #define addr2 2
 
const byte maxaccessories = 32;
#define FIRST_DCC_MCP 16  // primera dirección para los MCP (central Lenz)
#define FIRST_ID_MCP  10  // primer número de orden de los MCP
///////////////////////////////////////////////////////////////////////////////
Il continue avec les termes de la bibliothèque Commanders, pour gérer 16 boutons poussoirs en série, et avec la structure de chaque accessoire :
////__________ COMMANDERS ________________________________________________
#include <Commanders.h>
// Analog push buttons
ButtonsCommanderAnalogPushes pushes;
#define NUMBER_OF_ANALOG_PUSHES  16
int pushes_values[NUMBER_OF_ANALOG_PUSHES] =
        { 58,114,174,233,290,348,404,463,519,578,638,698,760,824,889,955 }; 
unsigned long pushes_ids[NUMBER_OF_ANALOG_PUSHES] =
        {101,102,103,104,105,106,107,108,109,110,111,112,123,114,115,116};
////_______________________________________________________________________
//////////////////////////////////////
// Estructura de cada accesorio //////

typedef struct {
  int     address;       // User Configurable. DCC address to respond to
  int     ID;            // User Configurable. para identificar MCP0 ó MCP1
  byte    outputPin;     // User Configurable. Arduino pin where accessory is connected to
  byte    onoff;         // User Configurable. Initial state of accessory output: 1=on, 0=off (ON = pin LOW)
  byte    onoffmcp;      // User Configurable. Initial state of accessory mcp: 1=on, 0=off (ON = pin LOW)
  byte    previous;      // User Configurable. The previous reading from the input pin
  byte    dccstate;      // Internal use. DCC state of accessory: 1=on, 0=off
}
DCCAccessoryAddress;
DCCAccessoryAddress accessory[maxaccessories];

void ConfigureDecoderFunctions()
{
  for (int k = 0; k <16; k++)
  {
    accessory[FIRST_ID_MCP+k].address = FIRST_DCC_MCP+k; // DCC address empezando en FIRST_DCC_MCP
    accessory[FIRST_ID_MCP+k].outputPin = k;
    accessory[FIRST_ID_MCP+k].ID = FIRST_ID_MCP+k;
  }
  for (int k = 16; k <32; k++)
  {
    accessory[FIRST_ID_MCP+k].address = FIRST_DCC_MCP+k; // DCC address empezando en FIRST_DCC_MCP
    accessory[FIRST_ID_MCP+k].outputPin = k-16;
    accessory[FIRST_ID_MCP+k].ID = FIRST_ID_MCP+k;
  }
}  // END ConfigureDecoderFunctions
//____________________________
Le setup:
void setup()
{
  Serial.begin(115200); 
  Commanders::begin();
  DccCommander.begin(0x00, 0x00, digitalPinToInterrupt(2)); 
  pushes.begin(A1, NUMBER_OF_ANALOG_PUSHES, pushes_ids, pushes_values, 20);

  ConfigureDecoderFunctions();
  DCC.SetBasicAccessoryDecoderPacketHandler(BasicAccDecoderPacket_Handler, true);
 
  mcp0.begin(addr0);
  mcp1.begin(addr1);
  mcp2.begin(addr2);
 
  for(int k=0; k<16; k++)
  {
    mcp0.pinMode(accessory[FIRST_ID_MCP+k].outputPin, OUTPUT);
    mcp0.digitalWrite(accessory[FIRST_ID_MCP+k].outputPin, LOW);
    accessory[FIRST_ID_MCP+k].previous = LOW;
  }
 for(int k=16; k<32; k++)
  {
    mcp1.pinMode(accessory[FIRST_ID_MCP+k].outputPin, OUTPUT);
    mcp1.digitalWrite(accessory[FIRST_ID_MCP+k].outputPin, LOW);
    accessory[FIRST_ID_MCP+k].previous = LOW;
  }
} // END setup
Le loop (uniquement pour les cinq premiers boutons-poussoirs):
void loop()

  DCC.loop(); // Loop DCC library
  activation();
    unsigned long ret;
    ret = Commanders::loop();   
    switch(ret)
  {
//******** Guardavias  ************
case 101:  // Orden = 28       
       pulsadoresmcp1(28);
       break; 
//******** Estación  ************
    case 102:   // Orden = 11
       pulsadoresmcp0(11);
       break;
    case 103:  // Orden = 12
       pulsadoresmcp0(12);
       break;
    case 104:    // Orden = 10
       pulsadoresmcp0(10);
       break;
//******** Farolas  (Doble circuito, 14 y 15)************
    case 105: // Orden = 14 y 15
       pulsadoresmcp0(14);
       pulsadoresmcp0(15);
       break;                       
  }          /////////////  // End switch ret
} //END loop
Enfin, les différentes fonctions définies : l'activation des accessoires :
void activation()
{
  static int addr = 0;
  if( ++addr >= maxaccessories ) addr = 0; // Next address to test

  if (accessory[addr].dccstate)  accessory[addr].onoff = 1;
  else  accessory[addr].onoff = 0; 
      if ((accessory[addr].onoff==1) && (!accessory[addr].onoffmcp))
      {
        if (accessory[addr].ID < FIRST_ID_MCP+16) {
          mcp0.digitalWrite(accessory[addr].outputPin, HIGH);
        }
        if (accessory[addr].ID > FIRST_ID_MCP+15) {
          mcp1.digitalWrite(accessory[addr].outputPin, HIGH);
        }
        accessory[addr].onoffmcp = true;
      }
      if ((accessory[addr].onoff==0) && (accessory[addr].onoffmcp))
      {
        if (accessory[addr].ID < FIRST_ID_MCP+16) {
          mcp0.digitalWrite(accessory[addr].outputPin, LOW);
        }
        if (accessory[addr].ID > FIRST_ID_MCP+15) {
          mcp1.digitalWrite(accessory[addr].outputPin, LOW);
        }
        accessory[addr].onoffmcp = false;
      }
}///// FIN ACTIVACION //////////////////////
Celles relatives aux boutons poussoirs de Commanders
  //////////////////
  // Pulsadores MCP0
  /////////////////
  void pulsadoresmcp0(int orden)
  {
     if (accessory[orden].previous == HIGH) {
          if (accessory[orden].onoffmcp == HIGH) accessory[orden].onoffmcp = LOW;
          else accessory[orden].onoffmcp = HIGH;
       }             
       mcp0.digitalWrite(accessory[orden].outputPin, !accessory[orden].onoffmcp);
       accessory[orden].previous = !accessory[orden].onoffmcp;
  } //END Pulsadores MCP0
  //------------------------------------------------------
  //////////////////
  // Pulsadores MCP1
  //////////////////
  void pulsadoresmcp1(int orden)
  {
      if (accessory[orden].previous == HIGH) {
          if (accessory[orden].onoffmcp == HIGH) accessory[orden].onoffmcp = LOW;
          else accessory[orden].onoffmcp = HIGH;
       }             
       mcp1.digitalWrite(accessory[orden].outputPin, !accessory[orden].onoffmcp);
       accessory[orden].previous = !accessory[orden].onoffmcp;   
  } //END Pulsadores MCP1
Et la gestion des paquets DCC
  ///////////////////////////////
  // DCC accessory 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[i].address)
      {
        if (enable) accessory[i].dccstate = 1;
        else accessory[i].dccstate = 0;
      }
    }
  } //END BasicAccDecoderPacket_Handler

Et avec tout ça, que se passe-t-il ? Eh bien, il se trouve que, tel que le code est, les boutons poussoirs fonctionnent parfaitement, allumant et éteignant les lumières correspondantes, mais la partie DCC ne fonctionne pas (les lumières s'allument et s'éteignent de manière erratique).
Cependant, si j'annule (commente) la sentence
//   ret = Commanders::loop();ensuite les boutons poussoirs cessent de fonctionner (évident), mais la partie DCC fonctionne parfaitement ! !!

Quelqu'un peut-il m'expliquer ? ! !!!!
Muchas gracias a todos ppor vuestro interés.
Un saludo,
Juan.


56
Bibliothèques / Re : Analog pushes avec Commanders
« le: mai 30, 2021, 01:49:26 pm »
Bien sûr Dominique, pour comprendre le problème il faudra que j'envoie un résumé du code, je ne l'ai pas fait dans le message précédent pour ne pas trop l'étendre.
Je suis en train de préparer un tel résumé explicatif, dès que je l'aurai, je l'enverrai.

57
Bibliothèques / Re : Analog pushes avec Commanders
« le: mai 30, 2021, 01:45:55 pm »
J'ai oublié les photos. Et dire aussi qu'évidemment, tout le code correspondant est à votre disposition, si cela intéresse quelqu'un.

58
Bibliothèques / Re : Analog pushes avec Commanders
« le: mai 30, 2021, 12:54:58 pm »
Bonjour, Dominique, et tous les autres.
Je vais essayer de résumer mon projet actuel, qui consiste à construire des décodeurs accessoires pour compléter un central DCC (soit DCC++, DCCpp, ou simplement DCC, comme le Lenz XpressNet, ce n'est pas le moment de parler des centraux).

Après plusieurs essais, j'ai décidé de classifier les accessoires de mon modèle en trois catégories : les aiguillages (solénoïdes dans mon cas), les sémaphores, et un troisième groupe avec le reste des effets "décoratifs" : lumières, sons, moteurs, relais, (même servos). Le deuxième groupe, les feux de signalisation, nous l'oublions pour le moment, puisque je n'ai pas encore commencé avec lui.
Pour chacun des groupes, je construis une carte avec un Nano, deux ou plusieurs multiplexeurs (MCP23017) pour avoir un nombre suffisant de contacts, et deux ULN2803 pour chaque multiplexeur, pour avoir assez de tension et de puissance pour déplacer les différents accessoires.

En principe, c'est tout à fait normal, et il existe de nombreux exemples déjà réalisés, mais mon projet présente deux difficultés supplémentaires, à savoir :
1.- Les multiplexeurs. Cela ne devrait pas être un problème majeur, mais comme je l'ai dit, je ne suis pas un expert en programmation de l'arduino. Quoi qu'il en soit, je pense avoir surmonté cette difficulté.
2.- L'inclusion d'un TOC. Voici le problème : je veux que tous les accessoires, en plus d'être gérés par des commandes DCC, puissent également être actionnés par des interrupteurs (boutons-poussoirs ou switches), en ajoutant également des LEDs qui indiquent l'état de chaque accessoire.

Eh bien, c'est mon projet. Qu'est-ce que j'ai accompli jusqu'à présent ? Bon, aussi étrange que cela puisse paraître, la partie la plus difficile, les aiguillages, fonctionne parfaitement. (J'inclus quelques photos illustratives du tableau et de la COT). J'ai basé le sketch correspondant sur le "Décodeur pour aiguillage à solénoïdes sur Arduino" de JPClaude, pour le DCCpp, et la bibliothèque "Commanders" de Thierrry pour gérer les boutons poussoirs. Comme je l'ai dit, cela fonctionne parfaitement, mais après de nombreuses tentatives.

Cependant, je n'arrive pas à faire fonctionner le troisième groupe, disons les lumières, pour simplifier. Et ça semble plus facile, mais je n'arrive pas à le faire fonctionner. Je m'explique : je peux gérer les lumières par des commandes DCCpp, sans aucun problème. Et je peux allumer et éteindre ces lumières avec des boutons poussoirs (grâce à la bibliothèque du Commandant). Mais je n'arrive pas à faire fonctionner les deux méthodes en même temps. Dès que j'active (sans commentaire) la commande ret = Commanders::loop() ; la partie TOC fonctionne, mais la partie DCCpp échoue, montrant un comportement erratique.

Bref, je suis désolé d'avoir été si long. J'espère que je ne vous ai pas trop ennuyé.
Dans l'attente de vos commentaires, meilleures salutations de
Juan

Traduit avec www.DeepL.com/Translator (version gratuite)

59
Bibliothèques / Re : Analog pushes avec Commanders
« le: mai 29, 2021, 06:50:42 pm »
Bon après-midi,
Et bien après de nombreuses tentatives je peux annoncer que le décodeur fonctionne ... à demi-chemin.
Bref, demain j'essaierai de résumer mon projet, et je m'expliquerai avec cette demi-œuvre.
Meilleures salutations,
Juan.

60
Bibliothèques / Re : Analog pushes avec Commanders
« le: mai 28, 2021, 08:20:20 pm »
Bonsoir,
Le problème est que j'ai essayé tout l'après-midi d'appliquer la méthode précédente à mon croquis, et je n'y arrive pas. Je ne parviens pas à intégrer la méthode dans les Commanders, en utilisant les ButtonsCommanderAnalogPushes.
La vérité est que ma connaissance de la programmation en Arduino est très limitée.
Une aide ?
Merci beaucoup,
Juan.

Pages: 1 2 3 [4] 5 6