Controle interrupteur multifil

Bonjour à tous,

Au travail, on utilise des interrupteurs avec 6 fils, ce sont des inter à levier, et en fonction du sens du levier, le courant passe entre 2 de ces 6 fils.

Débutant en arduino, pour le moment je suis juste arriver à controler le passage entre un fil et les 5 autres, en branchant le 1er fil sur GND et les 5 autres fils sur les entrée numériques.

Mais il faut que je puisse controler toutes les solutions, style fil 1&2, 1&3, 2&4.....

Et la je sèche, je ne sais pas comment faire le branchement.

Pour le moment, j'ai ce code :

#include "Wire.h"
#include "LiquidCrystal_I2C.h"

LiquidCrystal_I2C LCD(0x27,16,2); // définit le type d'écran lcd 16 x 2

int bouton2 = 2; // création de la variable "bouton" connectée à la broche 2 de la carte.
int etatbouton2 = 0; // variable qui servira à mémoriser la position du bouton.
int bouton3 = 3; // création de la variable "bouton" connectée à la broche 3 de la carte.
int etatbouton3 = 0; // variable qui servira à mémoriser la position du bouton.
int bouton4 = 4; // création de la variable "bouton" connectée à la broche 4 de la carte.
int etatbouton4 = 0; // variable qui servira à mémoriser la position du bouton.
int bouton5 = 5; // création de la variable "bouton" connectée à la broche 5 de la carte.
int etatbouton5 = 0; // variable qui servira à mémoriser la position du bouton.
int bouton6 = 6; // création de la variable "bouton" connectée à la broche 6 de la carte.
int etatbouton6 = 0; // variable qui servira à mémoriser la position du bouton.
int bouton7 = 7; // création de la variable "bouton" connectée à la broche 7 de la carte.
int etatbouton7 = 0; // variable qui servira à mémoriser la position du bouton.

void setup() {
    Serial.begin (9600);
    pinMode (bouton2, INPUT_PULLUP);
    pinMode (bouton3, INPUT_PULLUP);
    pinMode (bouton4, INPUT_PULLUP);
    pinMode (bouton5, INPUT_PULLUP);
    pinMode (bouton6, INPUT_PULLUP);
    pinMode (bouton7, INPUT_PULLUP);
    LCD.init(); // initialisation de l'afficheur
    LCD.backlight();
}

void loop() {
    etatbouton2 = digitalRead(bouton2);//la variable etatbouton mémorise la position du bouton
    etatbouton3 = digitalRead(bouton3);//la variable etatbouton mémorise la position du bouton
    etatbouton4 = digitalRead(bouton4);//la variable etatbouton mémorise la position du bouton
    etatbouton5 = digitalRead(bouton5);//la variable etatbouton mémorise la position du bouton
    etatbouton6 = digitalRead(bouton6);//la variable etatbouton mémorise la position du bouton
    etatbouton7 = digitalRead(bouton7);//la variable etatbouton mémorise la position du bouton


if (etatbouton2 == LOW) {// si la variable etatbouton est à LOW /Attention l'état est inversé lorsque l'on utilise une résistance de PULLUP.

    LCD.setCursor(1, 0);
    LCD.print("OK2");
    LCD.display();
    delay(1000);
    LCD.clear();
}
else 
    if (etatbouton3 == LOW) {
    LCD.setCursor(1, 0);
    LCD.print("OK3");
    LCD.display();
    delay(1000);
    LCD.clear();
}
else 
    if (etatbouton4 == LOW) {
    LCD.setCursor(1, 0);
    LCD.print("OK4");
    LCD.display();
    delay(1000);
    LCD.clear();
}
else 
    if (etatbouton5 == LOW) {
    LCD.setCursor(1, 0);
    LCD.print("OK5");
    LCD.display();
    delay(1000);
    LCD.clear();
}
else 
    if (etatbouton6 == LOW) {
    LCD.setCursor(1, 0);
    LCD.print("OK6");
    LCD.display();
    delay(1000);
    LCD.clear();
}
else 
    if (etatbouton7 == LOW) {
    LCD.setCursor(1, 0);
    LCD.print("OK7");
    LCD.display();
    delay(1000);
    LCD.clear();
}
else {
    LCD.setCursor(1, 0);
    LCD.print("NOT OK");
    LCD.display();
    delay(1000);
    LCD.clear();
}
}

Bonjour wolfen38

Tu démarres "fort" :wink:

Pour pouvoir contrôler efficacement 6 boutons, il faut les mettre en tableau pour les lire et déduire lesquels sont pressés simultanément, une des possibilité est de stocker leur état dans [les bits d'une variable]bitSet() - Arduino Reference).
Je peut te faire un exemple si tu le désires
Quelle est la relation entre les boutons et les commandes du courant dans les fils? Cette commande se fait par des relais?

Cordialement
jpbbricole

Salut, meri de ton aide.

Moi, j'ai branché comme celà :

Mais ca me permet juste de vérifier si les fils en contact sont le 1 avec un des 5 autres, mais ca ne me permets pas de comparer 2-3, 3-4....

Mon but, c'est "juste" de savoir parmi ces 6 fils, les 2 qui sont en contact.

Bonjour wolfen38

Oui, ça c'est les entrées, mais tu va commander tes courants, en sortie, c'est ça qui m'intéresse.

A+
jpbbricole

Moi aussi c'est ca qui m'intéresse.... je sais pas comment faire la sortie.

Si je mets les 6 fils sur les antrées, ca peut pas fonctionner, alors je sais pas comment faire.

Bonjour wolfen38

Donc tu as aussi 6 fils en sortie pour commander les courants?

A+
jpbbricole

Voici mon installation, j'ai une prise reliée à l'arduino, sur cette prise je viens en brancher une autre qui est elle meme connecté à un inter à levier :

Dans cet inter à levier, seulement 4 fils sont branchés (mais en fonction du client , ces 4 fils peuvent prendre les 6 positions).
En fonction du coté ou va le levier, le courant passe par 2 de ces 4 fils.

Mon but, c'est de savoir sur l'arduino, quels sont les 2 fils qui sont utilisés quand on bascule le levier d'un coté ou de l'autre.

Bonjour,

Tu mets toutes tes entrées en INPUT_PULLUP, ensuite tu bascules une entrée en sortie et tu la mets à LOW. Tu regardes quelle entrée (s'il y en a une) est passée à LOW.
Tu refais l'opération pour tous les fils.
Ca donne ceci par exemple


const byte tabFils[] = {A0, 2, 3, 4, 5, 6};
const byte NBFILS = sizeof tabFils;

void setup()
{
  Serial.begin(115200);

  for (byte i = 0; i < NBFILS; i++)
    pinMode(tabFils[i], INPUT_PULLUP);
}

void loop()
{
  for (byte i = 0; i < NBFILS-1; i++)
  {
    pinMode(tabFils[i], OUTPUT);
    digitalWrite(tabFils[i], LOW);
    for (byte j = i + 1; j < NBFILS; j++)
    {
      if (digitalRead(tabFils[j]) == LOW)
      {
        Serial.print(i + 1);
        Serial.print(" - ");
        Serial.print(j + 1);
        Serial.println("  connecté");
      }
    }
    pinMode(tabFils[i], INPUT_PULLUP);
  }
  delay(2000);
}

Salut,

J'ai donc branché mes 6 fils sur les entrées digital 2 à 7.
J'ai mis ton programme, et quand je fais touché 2 fils, dans le moniteur, j'ai souvent � ou parfois des lettres, Z, ou R, ou P....

J'ai pas du te comprendre....

Vérifie que ton moniteur est bien configuré à 115200 bauds (en bas à droite du moniteur).

Si tes fils sont connectés comme ça il faut changer la table
const byte tabFils[] = {2, 3, 4, 5, 6, 7};

Bravo, t'as juste et juste, mon moniteur est sur 9600, donc problème réglé, et changement pin effectué, ca marche aussi.

Merci beaucoup, je continue mes recherches avec ces infos.

Merci à vous 2.

Je me permets encore une question.

Maintenant, mon but, c'est pas qu'il m'affiche les fils connectés, c'est de vérifier que les fils connecté soit les bon, donc en gros en français, si fil connecté sont les 2 et 3, alors écrire OK.

Comment je fais pour récupérer les fils connecté et les comparer ?

Merci.

La meilleure méthode pour terminer avec succès un projet est de ne faire qu'une chose à la fois.

Tu commences par coucher sur le papier les conditions à respecter : en français et en faisant des phrases.
Une fois ce travail terminé tu verra que le codage viendra naturellement.

C'est quand on veut commencer à coder avant d'avoir défini toutes les conditions que c'est difficile.

La j'ai pu faire ma comparaison.

Maintenant, il me reste 2 étapes.
1 : Stocker des données dans un tableau, les récupérer, et faire la comparaison.
2 : Passer par un écran tactile.

Je vais donc essayer de comprendre le mode de fonctionnement des tabeaux....