Choix carte Arduino en analogique

[UrsaBlack]

Bonjour,

Je souhaite contrôler mon réseau en analogique uniquement avec Arduino. Cela comprends le contrôle de la tension des voies via plusieurs modules L298N et des aiguillages via plusieurs servomoteurs. Il y a au total beaucoup d'entrées (interrupteurs, potentiomètre, bouton poussoir sur le TCO et ILS sur le réseau), de sortie digitales (leds sur le TCO et sens des voies sur les modules L298N) et de PWM (module L298N et servo). Il y en a une cinquantaine de chaque environ.

Savez-vous quelle(s) carte(s) Arduino dois-je utiliser pour contrôler tout ça?
Dois-je prendre des grosses cartes Mega ou plusieurs petites Nano répartie sur tout le réseau.
Je pense relier les cartes via le bus I2C.

Si je prends les cartes Mega (environ 3 pour avoir assez de sortie PWM), j'ai peur de dépasser le courant maximal de consommation qui est de 200mA si je branche toutes les entrées/sorties.

Voilà, si vous pouvez m'aider, je vous en remercie d'avance.
Cordialement

[Barbadidoua]

Bonsoir,

Je ne te conseille pas le bus I2C qui est limité en longueur à 2 m a moins d'utiliser des répéteurs.
L’intérêt du Mega ou du Uno c'est d'avoir des shields tout fait, contrairement au Nano qui lui a des connecteurs au pas de 2.54 (si tu souhaites faire toi même tes montages).
Si tu souhaites vraiment repartir ton système, pas besoin d'avoir beaucoup d'IO (Input/Output) : un Uno ou un Nano.
Si tu as besoin de beaucoup de calcul (pont tournant) tu auras besoin d'un Méga.

Cordialement,

[UrsaBlack]

Bonjour,

Merci de votre réponse.

Peut-on mettre plusieurs shield moteur les uns sur les autres sur une seule carte arduino? Et si oui, comment les contrôle-t-on?

Au final, est-ce que je peux contrôler mon réseau avec un seul arduino et d'autres cartes additionnelles (shield,...) qui me permettrait d'avoir plus d'IO?

Ou suis-je obligé d'avoir plusieurs arduino? Dans ce cas, comment les relier si l'I2C est limité en longueur ? Ou dois-je utiliser l'I2C en mettant toutes mes cartes très proches les unes des autres?

J'ai un pont tournant mais il ne sera pas commandé par arduino. L'arduino me servira surtout pour commander la tension des voies et les servomoteurs des aiguillages.

Cordialement

[Petitrain]

Bonjour,

J'ai un réseau modulaire qui sort souvent en expo, et commandé aussi avec Arduino.
J'ai choisi de mettre un arduino nano par module (environ 1m de longueur)
et il me commande vaillamment l'éclairage du réseau, l'éclairage des bâtiments,
mes aiguillages...
Tous mes nanos sont reliés entre eux par un bus, ce qui permet de pouvoir parler entre eux.
Pour le choix du bus, je vous déconseille le bus I2c (c'est un bus de communication entre différents composants sur un même circuit imprimé), vous allez avoir des problèmes.
Chez LOCODUINO, ils utilisent le bus CAN (des tutos à lire sur le site).
Vous pouvez aussi créer une arborescence avec des modules radio (nrf24L01+)
Mais dans toutes ces solutions, il faut rajouter des petits modules additionnels...
Pour ma part, j'ai préféré choisir un bus domotique (le bus PJON) il ne nécessite qu'une bibliothèque et un fil pour relier les arduinos entre eux. Il est très simple à mettre en oeuvre. Je n'ai pas eu de problème et, pourtant, j'ai le bus DCC tout près.
Ne craignez pas de multiplier les arduinos, ils ne sont pas très chers et ça permet de diviser le travail (plus facile à dépanner) .
De plus, pour commander les servos des aiguilles, j'ai eu des problèmes avec des distances de plus de 1m.
Pour la commande des trains, le problème est un peu différent: En effet, la PWM sortant de l'Arduino est amplifié par le shield de sortie (il existe plein de solutions autre que le L298N)souvent 12v et 3A, ce qui permet d'alimenter les voies sans trop de problème.
Voilà, si j'ai pu un peu vous éclairer, le travail du choix des composants demande de bien cerner ses besoins et, de ce choix, dépendra le code à venir.n'hésitez pas à poser des questions...

[UrsaBlack]

Bonjour,

Merci pour votre réponse.

Avez-vous de la documentation sur ce bus PJON pour pouvoir le coder?
Faut-il d'autres modules additionnels pour pouvoir utiliser ce bus ou suffit-il juste de relier les arduino par un câble?

Les informations que je dois envoyer d'un arduino à l'autre sont des booléens: par exemple, l'état d'une voie (occupée ou libre), l'état d'un feu (vert ou rouge), ou celui d'un ILS (enclenché ou pas).

De plus, pour commander les servos des aiguilles, j'ai eu des problèmes avec des distances de plus de 1m.

A quoi était dû ces problèmes?

La solution L298N est-elle si mauvaise que ça pour contrôler les trains?
Qu'utilisez-vous sur votre réseau pour les contrôler?

Cordialement

[Petitrain]

Bonjour,

La documentation du bus PJON:https://www.pjon.org/documentation.php
Le gros avantage pour nous, c'est que ce bus ne nécessite qu'un fil pour relier les arduinos. Essayez le pour voir s'il vous convient...
Il faut déclarer un tableau de valeur a transmettre:
les variables sont des "char"
on les récupère sur un autre arduino avec la fonction receiver.
la doc est bien faite et explique bien le process.
Je pense que pour les servos, l'information véhiculée par des fils longs est perturbée par les parasites du milieu, j'ai eu le même problème avec des commutateurs mis en entrée sur une broche analogique. ( une résistance de 10khoms entre le fil de donnée et le + améliore les choses.)
Prévoyez des liaisons courtes (choix de plusieurs arduinos)c'est la meilleure solution.
Non, le L298N n'est pas un mauvais choix, tout dépend de la consommation de courant que vous prévoyez (consommation des machines sur le réseau) et regardez bien si le L298N a une détection de court circuit.
Allez faire un tour sur le site LOCODUINO:http://www.locoduino.org/ c'est une mine de renseignement.
Pour ma part, j'utilise des LMD18200 et un max471 pour la detection .
N’hésitez pas à poser des questions, si je peux y répondre...

[UrsaBlack]

Bonjour,

Je viens de faire des tests de liaisons entre 2 nano avec le bus PJON. Cela marche plutôt bien. J'ai réussi à transmettre une variable char de l'arduino 1 au 2 et inversement. Voici les codes :

Arduino 1 :

Code : Tout sélectionner

#include <PJON.h>
PJON<SoftwareBitBang> bus(1);

const char* nom="A";

void setup() {
  bus.begin();
  bus.strategy.set_pin(12);
  bus.set_receiver(receiver_function);
  Serial.begin(9600);
}

void receiver_function(uint8_t *payload, uint16_t length, const PJON_Packet_Info &packet_info) {
  if(payload[0] == 'A') {
    Serial.println("Bien reçu de 2!");
  }
}

void loop() {
  bus.receive(10);  
  bus.send_packet(2,nom,1);
}

Arduino 2 :

Code : Tout sélectionner

#include <PJON.h>
PJON<SoftwareBitBang> bus(2);

const char* nom="A";

void setup() {
  bus.begin();
  bus.strategy.set_pin(12);
  bus.set_receiver(receiver_function);
  Serial.begin(9600);
}

void receiver_function(uint8_t *payload, uint16_t length, const PJON_Packet_Info &packet_info) {
  if(payload[0] == 'A') {
    Serial.println("Bien reçu de 1!");
  }
}

void loop() {
  bus.receive(10);
  bus.send_packet(1,nom,1);
}

Voyez-vous des erreurs dans ces codes?
Je souhaitais mettre un delay dans le loop des 2 codes mais je ne recevais plus rien. Je n'arrive pas bien à voir quand l'arduino 1 envoie au 2 / reçoit du 2 et inversement.

Savez-vous quelle est la taille maximale de variable char que l'on peut envoyer?

Encore merci pour vos réponses !

Cordialement

[notix]

La taille des données est codée sur 2 octets. On peut donc en déduire qu'un paquet peut transmettre jusqu’à 65535 octets de données.
Pour n'envoyer des données que toutes les secondes par exemple tu peux utiliser un timer (attention à ne pas interférer avec ceux utilisés par PJON).
Voir ici

[Petitrain]

Bonjour,
Le code me parait tout à fait correct, et si ça marche!!!!
Essayer aussi l'exemple de la bibliothèque : BlinkWithReponse. c'est un exemple de discussion entre 2 arduinos, un envoie, le deuxieme reçoit et renvoie un accusé de reception. Grace à ce shémas,par exemple, un T.C.O. distant peut demander à tel ou tel noeud d'actionner des aiguillages, d'allumer des lumières, etc , et quand c'est fait, il renvoie au T.C.O. son accusé de reception ,ce qui permet au T.C.O. de mettre à jour son interface: leds de direction, etc... (tout un univers de dialogue.)
Effectivement, vous pouvez transmetre largement assez de "byte" pour gérer tout un réseau.
Pour ma part, je vous conseille d'organiser vos données à envoyer dans un tableau:
byte paquet [3] = {pointeurMenu,servo,pwm};
ou paquet est le nom du tableau, pointeur menu, servo et pwm sont des varaibles byte déclarés .
Votre fonction pour envoyer le paquet sera:
bus.send(PJON_BROADCAST,paquet,3);
ou bus est le nom du réseau, PJON_BROADCAST permet d'envoyer à tous les noeuds, paquet c'est vos données et 3 le nombres de variables.
dans loop() la fonction bus.update(); suffit.
Pour les recevoir : votre fonction devient
void receiver_function(uint8_t *payload, uint16_t length, const PJON_Packet_Info &packet_info) {

pointeurMenu = payload[0];
servo = payload[1];
pwm = payload[2];
}
N'oubliez pas de déclarer vos variables.
Et proscrivez la fonction delay() cette fonction bloque le micro-controleur pendant le temps spécifié, c'est normal que vous n'envoyez ni ne recevez plus de données.
Bon courage pour la suite.

[UrsaBlack]

Bonjour,

Merci de votre réponse.

J'ai testé avec un tableau de byte, aucun soucis. Par contre, si j'ai un grand tableau (par exemple de longueur 20) la réception est plus longue. J’imagine que c'est normal mais peut-on améliorer ça?
En fait, j'ai pas mal d'info à faire circuler entre mes arduino mais ce sont globalement des booléens (par ex: soit le feu est au vert soit au rouge). Peut-on aussi envoyer des booléens plutôt que des bytes pour "alléger" la quantité de données?

J'ai essayé bus.update sans succès par contre. Avez-vous un exemple complet d'utilisation de cette fonction?
Où est-ce que la fonction bus.send doit être? dans le setup ou dans le loop?
Sachant que je défini mon tableau de byte au début de mon code, le fait de faire bus.update ne réinitialise pas ce tableau à chaque fois?

Merci d'avance,
Cordialement

[Petitrain]

Bonjour,

J'ai essayé bus.update sans succès

Attention bus.update n'est utilisé que pour envoyer des données, si vous attendez aussi une réponse il faut utiliser bus.receive(1000);
Les exemples de la bibliothèque BlinkTest et BlinkWithReponse sont explicites.
Pour le tableau, je pense que la bibliothèque est construite autour de byte mais ce n'est pas un soucis : les variables byte peuvent prendre des valeurs de 0 à 255.
C'est une question d'organisation: par exemple :
le premier feu prend les valeurs : eteint=0; allumé=1;
le deuxième feu : eteint= 2; allumé = 3;
etc....
le tout dans une variable byte feu1 = ...;
si 256 valeurs ne sont pas suffisantes vous pouvez créer une deuxième variable
feu2 = ...;
De plus le noeud qui reçoit le message ne peut pas gérer un nombre important de feu , si vous n'avez que rouge et vert par feu, donc 2 leds, vous ne gérerez au mieux que 8 feus. Gardez libre les broches de communication TX et RX et la broche de raccordement du bus. Je n'est pas l'architecture de votre réseau, mais tout l'intéret de la communication entre arduinos, c'est d'avoir des micros au plus prés des appareils à gérer (éclairage, servos, signalisation...)
Il me semble qu'un tableau avec 3 ou 4 variables est suffisant .
je vous transmets un petit programme dans ce sens. Il gère facilement les 17 broches de chaque noeud. Gardez aussi à l'esprit que chaque noeud à une adresse unique et que l'on peut parler qu'a une adresse.

Code : Tout sélectionner

/*******Noeud 01********
 * Un tableau de byte est créé (attention PJON ne travaille qu'avec des bytes ou des chars)
 * on y met 3 variables (plus si necessaire), la première gère un menu, la deuxième la position 
 * d'un servo et la troisième la PWM d'une led.
 * Une fonction lireBouton() est appelée à chaque tour de loop() et lie l'état des boutons. Si 
 * les boutons ont changé d'état, leur nouvelles valeur est mise a jour dans le tableau qui est 
 * envoyé aux autres noeuds.
 */


#define PJON_INCLUDE_SWBB           // permet de n'inclure que la partie qu'on a besoin.
#include <PJON.h>
PJON<SoftwareBitBang> bus(01);

#include <RBD_Timer.h>                      // Bibliothèque pour gérer les boutons
#include <RBD_Button.h>
RBD::Button boutonPlus(2);          //Déclaration des boutons
RBD::Button boutonMoins(3);
RBD::Button boutonServo(4);
RBD::Button boutonPwm(5);



byte pointeurMenu=0;
const byte valeurMin=0;                       // Valeur minimum du pointeurMenu
const byte valeurMax=10;                 // Valeur maximum du pointeurMenu
unsigned long dernierClic = 0;

byte servo=0;

byte pwm = 0;
/************************FONCTION POUR LIRE L'ETAT DES BOUTONS******************************/
void lireBouton() {

  if (millis()-dernierClic>=200) {
    if(boutonPlus.onPressed()) {
      if(pointeurMenu<valeurMax){pointeurMenu++;}
      dernierClic = millis();
    }
    else if(boutonMoins.onPressed()) {
      if(pointeurMenu>valeurMin){pointeurMenu--;}
      dernierClic = millis();   
    }
    else if(boutonServo.onPressed()){
      servo = !servo;    
    }
    else if(boutonPwm.onPressed()){
      pwm = pwm + 5;    
    }
  }
}
/*************************FONCTION POUR ENVOYER LES DONNEES AUX AUTRES NOEUDS************/
void valeurEnvoyee(){
  byte paquet [3] = {pointeurMenu,servo,pwm};
  bus.send(PJON_BROADCAST,paquet,3);
}

void setup() {
  bus.strategy.set_pin(8);
  bus.begin();
}
void loop() {
  bus.update();
  valeurEnvoyee();
  lireBouton();
}

Code : Tout sélectionner

/******NOEUD 02****************
 * Ce noeud reçoit les données et gère le servo, la PWM et les leds du Menu.
 */
#define PJON_INCLUDE_SWBB  // permet de n'inclure que la partie qu'on a besoin.
#include <PJON.h>

PJON<SoftwareBitBang> bus(02);

#include <VarSpeedServo.h>
VarSpeedServo aiguille;
#define MIN_PULSE_WIDTH 700
#define MAX_PULSE_WIDTH 1100
const byte servoPin = 5;

byte pointeurMenu;
byte servo;
byte pwm;
const byte verte = 2;
const byte rouge = 4;
const byte jaune = 3;
/*********FONCTION QUI RECOIT LES DONNEES ET LES METS DANS LES VARIABLES CORRESPONDANTES**************/
void receiver_function(uint8_t *payload, uint16_t length, const PJON_Packet_Info &packet_info) {

  pointeurMenu = payload[0];
  servo = payload[1];
  pwm = payload[2];
}

void setup() {
  bus.strategy.set_pin(8);
  bus.set_receiver(receiver_function);
  bus.begin();
  Serial.begin(9600);
  pinMode (rouge,OUTPUT);
  pinMode (verte,OUTPUT);
  pinMode (jaune,OUTPUT);
  aiguille.attach(servoPin);

}

void loop() {
  bus.receive(1000);
  Serial.println(servo);
  switch(pointeurMenu){
    case 0:digitalWrite(rouge,HIGH);digitalWrite(verte,LOW);break;
    case 1:digitalWrite(rouge,LOW);digitalWrite(verte,HIGH);break;
    case 2:digitalWrite(rouge,HIGH);digitalWrite(verte,HIGH);break;
    case 3:digitalWrite(rouge,(millis()/200)%2);digitalWrite(verte,LOW);break;
    case 4:digitalWrite(verte,(millis()/200)%2);digitalWrite(rouge,LOW);break;
    case 7:digitalWrite(rouge,LOW);digitalWrite(verte,LOW);break;
  }
  if(servo == 0){
//    aiguille.attach(servoPin);
    aiguille.write(70,30,false);
//    aiguille.detach();
  }
  if(servo == 1){
//    aiguille.attach(servoPin);
    aiguille.write(110,30,false);
//        aiguille.detach();
  }
  analogWrite(jaune,pwm);

}

J'utilise trois bibliothèques qu'il vous faut charger/
<RBD_Timer.h> // Bibliothèques pour gérer les boutons
<RBD_Button.h>
<VarSpeedServo.h> // Bibliothèque pour gérer les servos
voilà, bon courage,