Projet sur Arduino UNO

Bonjour à tous,

Débutant dans ce domaine, je tente de réaliser un projet.

Le but étant de récupérer les signaux de sortie (GPIOUT 1 à 4) pour créer une commutation de led de 1 à 10.
Suivant un tableau de logique.
GPIOUT1 = 1; Led 1 =1 toutes les autres sortie reste à 0
Quand
GPIOUT2 = 1; Led2 = 1 la Led1 =0 et toutes les autres led aussi.
GPIOUT1 =1 et GPIOUT2= 1 LED3 = 1 : Donc Led1 et Led2 = 0 ainsi que les autres.
GPIOUT3 = 1; Led4 = 1
Et ainsi de suite
Voila un début de code.
J'ai la commutation sur mes led a base de mes REL 1 à 4.
La ou je bloque c'est sur la combinaison de deux ou trois entrées actives qui pour le moment activent leurs sorties de départ et non pas celle que je voudrais.

/*
Interface : commande de commutation  Led 
*/

const int REL1=2;     //Déclaration des constantes pour les noms des Relais 1 à 4
const int REL2=3;
const int REL3=4;
const int REL4=5;
const int led_1 = 6;      // Led 1
const int led_2 = 7;      // Led 2
const int led_3 = 8;      // Led 3
const int led_4 = 9;      // Led 4
const int led_5 = 10;     // Led 5
const int led_6 = 11;     // Led 6
const int led_7 = 10;     // Led 7
const int led_8 = 12;     // Led 8
const int led_9 = 13;     // Led 9


int Etat_REL1;   // Variable utilisé pour la mémoire des etats
int Etat_REL2;
int Etat_REL3;
int Etat_REL4;
int Etat_REL12;
int Etat_REL13;
int Etat_REL14;
int Etat_REL23;
int Etat_REL24;
int Etat_REL34;

int Etat_Led1=0;
int Etat_Led2=0;
int Etat_Led3=0;
int Etat_Led4=0;
int Etat_led5=0;
int Etat_Led6=0;
int Etat_Led7=0;
int Etat_Led8=0;


void setup()
{
pinMode(2, INPUT);
pinMode(3, INPUT);
pinMode(4, INPUT);
pinMode(5, INPUT);
pinMode(6, OUTPUT);
pinMode(7, OUTPUT);
pinMode(8, OUTPUT);
pinMode(9, OUTPUT);
pinMode(10, OUTPUT);
pinMode(11, OUTPUT);
pinMode(12, OUTPUT);
pinMode(13, OUTPUT);

}

void loop()
{
digitalWrite(REL1, HIGH);                 // Etat du REL1 à 1
Etat_REL1 = digitalRead(REL1);            // mise en Memoire du relais 

digitalWrite(REL2, HIGH);
Etat_REL2 = digitalRead(REL2);

digitalWrite(REL3, HIGH);
Etat_REL3 = digitalRead(REL3);

digitalWrite(REL4, HIGH);
Etat_REL4 = digitalRead(REL4);

digitalWrite(Etat_REL12, HIGH);       //ecrit à 1 l'Etat memoire du REL12
Etat_REL12 == ((Etat_REL1, HIGH) && (Etat_REL2, HIGH));   //Etat_REL12 = 1 si REL1 et REL2 =1


if(!Etat_REL1)
  {
    Etat_Led1 = !Etat_Led1;     // Lecture de l'etat de la led
    digitalWrite(6, HIGH);      // Sortie incrementé à 1 pour la led1
    digitalWrite(7, LOW);       // Sortie à 0 pour les autres
    digitalWrite(8, LOW);
    digitalWrite(9, LOW);
    digitalWrite(10, LOW);
    digitalWrite(11, LOW);
    digitalWrite(12, LOW);
    digitalWrite(13, LOW);
    
  }

  if(!Etat_REL2)
  {
    Etat_Led2 = !Etat_Led2;
    digitalWrite(7, HIGH);
    digitalWrite(6, LOW);
    digitalWrite(8, LOW);
    digitalWrite(9, LOW);
    digitalWrite(10, LOW);
    digitalWrite(11, LOW);
    digitalWrite(12, LOW);
    digitalWrite(13, LOW);
  }

  if(!Etat_REL3)
  {
    Etat_Led4 = !Etat_Led4;
    digitalWrite(9, HIGH);
    digitalWrite(7, LOW);
    digitalWrite(6, LOW);
    digitalWrite(8, LOW);
    digitalWrite(10, LOW);
    digitalWrite(11, LOW);
    digitalWrite(12, LOW);
    digitalWrite(13, LOW);
  }
 
  if(!Etat_REL4)
  {
    Etat_Led4 = !Etat_Led4;
    digitalWrite(13, HIGH);
    digitalWrite(7, LOW);
    digitalWrite(6, LOW);
    digitalWrite(8, LOW);
    digitalWrite(9, LOW);
    digitalWrite(10, LOW);
    digitalWrite(11, LOW);
    digitalWrite(12, LOW);
  }

  if (Etat_REL12)          // Si Etat_REL12 = 1 alors Led3 = 1 Mais la c'est le bug j'ai led 1 et 2 qui s'allume.
  {
    Etat_Led3 = !Etat_Led3;
    digitalWrite(12, HIGH)
    digitalWrite(7, LOW);
    digitalWrite(6, LOW);
    digitalWrite(8, LOW);
    digitalWrite(9, LOW);
    digitalWrite(10, LOW);
    digitalWrite(11, LOW);
    digitalWrite(13, LOW);
  }
}

Si des personnes ont des idées pour m'aiguiller et comprendre pourquoi la relation faite sur REL12 ne fonctionne pas.
Merci à tous.
Gribouille76fr
Le Cablage en photo. Le dip switch pour simuler les GPiOUT

Débutant dans ce domaine, je tente de réaliser un projet.

on conseille aux débutants de lire les messages épinglés en haut du forum avant de poster...

corrigez votre post ci dessus et rajoutez les code tags autour du code:

[code]

[color=blue]// votre code ici[/color]

[/code]

.

ça doit ressembler à cela:

// votre code ici

(faites aussi ctrl-T (PC) or cmd-T (Mac) dans l'IDE avant de copier le code pour qu'il soit indenté correctement)

———

l'état de vos LEDs dépend de l'ensemble des 4 switch, donc agrégez les en une seule valeur (par exemple les 4 bits de poids faibles d'un octet) et ensuite faites un test (switch/case) sur cette valeur agrégée pour décider de l'état des LEDS

PS: donnez des noms à vos pins

  pinMode(2, INPUT);
  pinMode(3, INPUT);
  pinMode(4, INPUT);
  pinMode(5, INPUT);
  pinMode(6, OUTPUT);
  pinMode(7, OUTPUT);
  pinMode(8, OUTPUT);
  pinMode(9, OUTPUT);
  pinMode(10, OUTPUT);
  pinMode(11, OUTPUT);
  pinMode(12, OUTPUT);
  pinMode(13, OUTPUT);

ou utilisez ceux qui existent déjà

const int REL1 = 2;
const int REL2 = 3;
const int REL3 = 4;
const int REL4 = 5;

(un const byte est mieux pour un N° de pin)

Bonjour,

La calcul de l'etat de REL12 est incorrect (ou au moins ne fait pas ce que tu penses qu'il fait).
Je suppose que tu veux faire

Etat_REL12 = Etat_REL1==HIGH && Etat_REL2==HIGH;

Edit: oups j'ai corrigé le premier == qui devait être =

Merci pour ces débuts de réponse.
Désolé pour le post au début en effet j'ai oublié les tag c'est rectifié j'espère que c'est plus compréhensible.

l'état de vos LEDs dépend de l'ensemble des 4 switch, donc agrégez les en une seule valeur (par exemple les 4 bits de poids faibles d'un octet) et ensuite faites un test (switch/case) sur cette valeur agrégée pour décider de l'état des LEDS

Je ne suis pas encore accommoder a ce langage switch/case mais je vais y regarder de plus près.
Merci je continu mes recherches et test par la même occasion.

ce code est un peu louche

  digitalWrite(REL1, HIGH);
  Etat_REL1 = digitalRead(REL1);

  digitalWrite(REL2, HIGH);
  Etat_REL2 = digitalRead(REL2);

  digitalWrite(REL3, HIGH);
  Etat_REL3 = digitalRead(REL3);

  digitalWrite(REL4, HIGH);
  Etat_REL4 = digitalRead(REL4);

vos pins REL1...REL4 sont en INPUT, le fait de les forcer à HIGH active le PULLUP... est-ce ce que vous voulez ? si oui pourquoi le faire à chaque fois, autant mettre

  pinMode(REL1, INPUT_PULLUP);
  pinMode(REL2, INPUT_PULLUP);
  pinMode(REL3, INPUT_PULLUP);
  pinMode(REL4, INPUT_PULLUP);

dans le setup() et juste faire

  Etat_REL1 = digitalRead(REL1);
  Etat_REL2 = digitalRead(REL2);
  Etat_REL3 = digitalRead(REL3);
  Etat_REL4 = digitalRead(REL4);

dans la loop()

Déclarez Etat_REL1..4 en byte et pas en int. Pour combiner les 4 états en 4 bits vous pouvez faire

byte etatGlobal = (Etat_REL4 << 3) | (Etat_REL3 << 2) | (Etat_REL2 << 1) | Etat_REL1;

etatGlobal prendra alors une valeur entre 0b0000 et 0b1111 (de 0 à 15) en fonction des 4 bits (le bit de poids fort étant Etat_REL4 et celui de poids faible Etat_REL1)

donc ensuite on fait un

switch(etatGlobal) {
  case 0b0000: ... ; break;
  case 0b0001: ... ; break;
  case 0b0010: ... ; break;
  case 0b0011: ... ; break;
  case 0b0100: ... ; break;
  case 0b0101: ... ; break;
  case 0b0110: ... ; break;
  case 0b0111: ... ; break;
  case 0b1000: ... ; break;
  case 0b1001: ... ; break;
  case 0b1010: ... ; break;
  case 0b1011: ... ; break;
  case 0b1100: ... ; break;
  case 0b1101: ... ; break;
  case 0b1110: ... ; break;
  case 0b1111: ... ; break;
}

et vous remplacez bien sûr les .... par le code qui va bien en fonction de la configuration des 4 switches

WOuah,
La vous me scotchez.
Plus jeune j'avais une notion en assembleur, je me rappelle avoir écrit un prog sur PIC pour de la commutation de LED sur 8 bit que J'envoyais sur un émetteur HF pour contrôler des récepteurs monté sur des caméras.
Mais c'était il y a 20 ans environs et j'ai un peu tout oublié car ne pratiquant plus.

Sinon en effet on se retrouve dans le cas de figure ou je lis 4 données que l'on peut considérer sur 4 Bits.
J'ai commencer la doc arduino pour les nuls, je vais continuer.
En tout cas merci car en effet cela me donne une très bonne marche à suivre.

Bonjour,

Voila je reviens avec le programme réécrit suivant vos indications et ce que j'ai pu comprendre.
pour le moment cela ne fonctionne pas, mais j'ai des doute sur le fait de bien mettre en oeuvre l'ensemble des données.

/*
Declaration des constantes
*/

const int REL1 = 2;   // Entre Digital 2 à 5
const int REL2 = 3;
const int REL3 = 4;
const int REL4 = 5;

byte Etat_REL1=1;
byte Etat_REL2=1;
byte Etat_REL3=1;
byte Etat_REL4=1;

int Etat_Led6=0;       //Led en sorties Digital de 6 à 13
int Etat_Led7=0;
int Etat_Led8=0;
int Etat_Led9=0;
int Etat_Led10=0;
int Etat_Led11=0;
int Etat_Led12=0;
int Etat_Led13=0;


void setup()
	{
	pinMode(2, INPUT_PULLUP);
	pinMode(3, INPUT_PULLUP);
	pinMode(4, INPUT_PULLUP);
	pinMode(5, INPUT_PULLUP);
  
	pinMode(6, OUTPUT);
	pinMode(7, OUTPUT);
	pinMode(8, OUTPUT);
	pinMode(9, OUTPUT);
	pinMode(10, OUTPUT);
	pinMode(11, OUTPUT);
	pinMode(12, OUTPUT);
	pinMode(13, OUTPUT);
	}


void loop()
	{
	Etat_REL1 = digitalRead(REL1);
	Etat_REL2 = digitalRead(REL2);
	Etat_REL3 = digitalRead(REL3);
	Etat_REL4 = digitalRead(REL4);

/*
declaration de la variable Globale pour définir l'etat sur 4 bit
*/

byte etatGlobal = (Etat_REL4 << 3) | (Etat_REL3 << 2) | (Etat_REL2 << 1) | Etat_REL1;


switch(etatGlobal) 
 {
 
  case 0b0001: digitalWrite(Etat_Led6, HIGH);    //Lecture des 4 bit et on allume la led
  break;
  
  case 0b0010: digitalWrite(Etat_Led7, HIGH); 
  break;
  
  case 0b0011: digitalWrite(Etat_Led8, HIGH); 
  break;
  
  case 0b0100: digitalWrite(Etat_Led9, HIGH); 
  break;
  
  case 0b0101: digitalWrite(Etat_Led10, HIGH); 
  break;
  
  case 0b0110: digitalWrite(Etat_Led11, HIGH); 
  break;
  
  case 0b0111: digitalWrite(Etat_Led12, HIGH); 
  break;
  
  case 0b1000: digitalWrite(Etat_Led13, HIGH); 
  break;

 }
}

Essentiellement sur l’écriture des bits.
J'ai bien compris que je dois passer d'un etat HIGH ou LOW en état 1 ou 0 pour définir l’état comme un bit de valeur 0 ou 1
Ensuite de lire la suite de ces 4 bits pour me donner le résultat attendu.
c'est de ce coté ou je ne suis pas sur.
Je lis bien que la syntaxe est la suivante : byte 'nom variable' : 'valeur de la variable 0 ou 1'

Ou est-ce dans le switch que je donne pas les bonne données???
Voila ou j'en suis pour le moment.
Je continue mes recherche.
Merci de me corriger si je suis complètement a coté de la plaque.

dans vos case vous ne faites qu'allumer des LEDs vous ne les éteignez jamais ?

il faut toujours commencer simplement, avec le console série par exemple. Testez ce code en ouvrant la console série à 115200 bauds et en appuyant sur vos boutons qui sont sur les pin 2,3,4 et 5

// les entrées
const byte pinREL1 = 2;
const byte pinREL2 = 3;
const byte pinREL3 = 4;
const byte pinREL4 = 5;

byte etatGlobal ;

void setup()
{
  Serial.begin(115200);
  pinMode(pinREL1, INPUT_PULLUP);
  pinMode(pinREL2, INPUT_PULLUP);
  pinMode(pinREL3, INPUT_PULLUP);
  pinMode(pinREL4, INPUT_PULLUP);

}

void loop() {
  byte Etat_REL1 = digitalRead(pinREL1); // actif LOW puisque PULLUP
  byte Etat_REL2 = digitalRead(pinREL2);
  byte Etat_REL3 = digitalRead(pinREL3);
  byte Etat_REL4 = digitalRead(pinREL4);

  byte nouvelEtat = (Etat_REL4 << 3) | (Etat_REL3 << 2) | (Etat_REL2 << 1) | Etat_REL1;

  if (nouvelEtat != etatGlobal) {
    Serial.println(F("----------------------"));

    Serial.print(F("Etat_REL1: "));
    Serial.println(Etat_REL1 == HIGH ? "HIGH" : "LOW");

    Serial.print(F("Etat_REL2: "));
    Serial.println(Etat_REL2 == HIGH ? "HIGH" : "LOW");

    Serial.print(F("Etat_REL3: "));
    Serial.println(Etat_REL3 == HIGH ? "HIGH" : "LOW");

    Serial.print(F("Etat_REL4: "));
    Serial.println(Etat_REL4 == HIGH ? "HIGH" : "LOW");

    Serial.print(F("Etat: "));
    Serial.println(nouvelEtat, BIN);

    etatGlobal = nouvelEtat;
    delay(15); // anti rebond du pauvre
  }
}

par exemple en appuyant et relâchant les boutons sur les pins 2 et 3 vous verrez

[color=purple]
----------------------  [color=red]état initial tout HIGH car pullup[/color]
Etat_REL1: HIGH
Etat_REL2: HIGH
Etat_REL3: HIGH
Etat_REL4: HIGH
Etat: 1111
----------------------  [color=red]appui sur pin 2, elle passe LOW[/color]
Etat_REL1: [color=red]LOW[/color]
Etat_REL2: HIGH
Etat_REL3: HIGH
Etat_REL4: HIGH
Etat: 111[color=red]0[/color]   [color=red]on voit le bit correspondant à 0[/color]
----------------------  [color=red]on relâche la pin 2[/color]
Etat_REL1: [color=blue]HIGH[/color]
Etat_REL2: HIGH
Etat_REL3: HIGH
Etat_REL4: HIGH
Etat: 111[color=blue]1[/color]
----------------------  [color=red]appui sur pin 3, elle passe LOW[/color]
Etat_REL1: HIGH
Etat_REL2: [color=red]LOW[/color]
Etat_REL3: HIGH
Etat_REL4: HIGH
Etat: 11[color=red]0[/color]1  [color=red]on voit le bit correspondant à 0[/color]
----------------------    [color=red]on relâche la pin 3[/color]
Etat_REL1: HIGH
Etat_REL2: [color=blue]HIGH[/color]
Etat_REL3: HIGH
Etat_REL4: HIGH
Etat: 11[color=blue]1[/color]1
[/color]

vous pouvez "jouer" en appuyant plusieurs boutons simultanément et en les relâchant, vous verrez les 4 bits de l'état qui changent

:frowning: >:( je suis vraiment a coté de la plaque.
En fait les entrées (simulé par les Relais) seront des sorties d'octocoupleurs, donc ce sera a moi de câbler en fonction.
J'ai pas encore eu la certitude du fonctionnement si celui-ci fonctionne en actif ou passif. Sortie à 1 ou 0.
je dois récupérer la doc.
Pour les sorties cela correspond a ce que j'ai mis dans mon premier poste, et que vous avez bien compris. C'est a la lecture des bit que l'action se fait sur les led.

Je viens de copier le programme sur le simulateurs arduino et cela correspond très bien a ce que vous avez écrit.
A moi de chercher et comprendre.

Je reviendrai vers vous en espérant avoir réussi, cette fois ci.
Merci pour vos explication et votre temps, ça fait plaisirs de voir que vous avez une très bonne connaissance de l'arduino. et surement plus.
Merci.

Bonjour à tous et Joyeuses fêtes.
Me revoila, j'ai un programme qui fonctionne comme j'aimerai.
Mais aujourd’hui on m'a compliqué la tache, il faut que celui-ci puisse etre intégré sur un PC via l'USB pour piloter des fonctions assignées à des touche de clavier.
Aprés recherche le LEONARDO pourrai me satisfaire car il icnlue une bibliothèque Keyboard.
Voila le Prog.

//*
  Programme sur Arduino Uno leonardo.
    Interface entre RP120 et VMix.
    Commutation de sources Camera sur RP, Vsualisation sur écran par intermédiaire du VMix
*/
// 4 entrées binaires
const byte pinREL1 = 2;
const byte pinREL2 = 3;
const byte pinREL3 = 4;
const byte pinREL4 = 5;

// 8 Leds en sorties Digital de 6 Ã  13 avec envoie d'un caractere sur le clavier
int Etat_Led6=0;      
int Etat_Led7=0;
int Etat_Led8=0;
int Etat_Led9=0;
int Etat_Led10=0;
int Etat_Led11=0;
int Etat_Led12=0;
int Etat_Led13=0;

byte etatGlobal ;

// Allumage fonction clavier

#include <Keyboard.h>

void setup()
{
  Serial.begin(115200);
  pinMode(pinREL1, INPUT);
  pinMode(pinREL2, INPUT);
  pinMode(pinREL3, INPUT);
  pinMode(pinREL4, INPUT);
  pinMode(6, OUTPUT);
  pinMode(7, OUTPUT);
  pinMode(8, OUTPUT);
  pinMode(9, OUTPUT);
  pinMode(10, OUTPUT);
  pinMode(11, OUTPUT);
  pinMode(12, OUTPUT);
  pinMode(13, OUTPUT);
 
  Keyboard.begin();

}

void loop() {
  byte Etat_REL1 = digitalRead(pinREL1); 
  byte Etat_REL2 = digitalRead(pinREL2);
  byte Etat_REL3 = digitalRead(pinREL3);
  byte Etat_REL4 = digitalRead(pinREL4);

  byte nouvelEtat = (Etat_REL4 << 3) | (Etat_REL3 << 2) | (Etat_REL2 << 1) | Etat_REL1;

  if (nouvelEtat != etatGlobal) {
    Serial.println(F("----------------------"));
    Serial.print(F("Etat_REL1: "));

    Serial.println(Etat_REL1 == HIGH ? "HIGH" : "LOW");
    Serial.print(F("Etat_REL2: "));
    Serial.println(Etat_REL2 == HIGH ? "HIGH" : "LOW");
    Serial.print(F("Etat_REL3: "));
    Serial.println(Etat_REL3 == HIGH ? "HIGH" : "LOW");
    Serial.print(F("Etat_REL4: "));
    Serial.println(Etat_REL4 == HIGH ? "HIGH" : "LOW");
    Serial.print(F("Etat: "));
    Serial.println(nouvelEtat, BIN);
    etatGlobal = nouvelEtat;
    delay(15); // anti rebond du pauvre
  }

 /* Lecture de l'etat Global pour gérer les sorties.
 */  

 switch(etatGlobal)   // Variable contenant les états des relais
 {
  case 0b0001: 
    digitalWrite(6, HIGH);    //Lecture des 4 bit et on allume la led
    Etat_Led6 = 1;
   
    Keyboard.write(KEY_LEFT_SHIFT);
    Keyboard.write('1');
    delay(10);
    Keyboard.releaseAll(); 
   
    digitalWrite (7, 0);
    digitalWrite (8, 0);
    digitalWrite (9, 0);
    digitalWrite (10, 0);
    digitalWrite (11, 0);
    digitalWrite (12, 0);
    digitalWrite (13, 0);
    break;

  case 0b0010: 

    digitalWrite(7, HIGH); 
    Etat_Led7 = 1;

    Keyboard.write(KEY_LEFT_SHIFT);
    Keyboard.write('2');
    delay(10);
    Keyboard.releaseAll();
   
    digitalWrite (6, 0);
    digitalWrite (8, 0);
    digitalWrite (9, 0);
    digitalWrite (10, 0);
    digitalWrite (11, 0);
    digitalWrite (12, 0);
    digitalWrite (13, 0);
    break;

  case 0b0011: 

    digitalWrite(8, 1); 
    Etat_Led8 = 1;

   Keyboard.write(KEY_LEFT_SHIFT);
    Keyboard.write('3');
    delay(10);
    Keyboard.releaseAll(); 
   
    digitalWrite (7, 0);
    digitalWrite (6, 0);
    digitalWrite (9, 0);
    digitalWrite (10, 0);
    digitalWrite (11, 0);
    digitalWrite (12, 0);
    digitalWrite (13, 0);
  
    break;

  case 0b0100: 

    digitalWrite(9, 1);
    Etat_Led9 = 1;

    Keyboard.write(KEY_LEFT_SHIFT);
    Keyboard.write('4');
    delay(10);
    Keyboard.releaseAll();
   
    digitalWrite (7, 0);
    digitalWrite (8, 0);
    digitalWrite (6, 0);
    digitalWrite (10, 0);
    digitalWrite (11, 0);
    digitalWrite (12, 0);
    digitalWrite (13, 0);
    break;

  case 0b0101: 

    digitalWrite(10, 1); 
    Etat_Led10 = 1;

    Keyboard.write(KEY_LEFT_SHIFT);
    Keyboard.write('5');
    delay(10);
    Keyboard.releaseAll(); 
    
    digitalWrite (7, 0);
    digitalWrite (8, 0);
    digitalWrite (9, 0);
    digitalWrite (6, 0);
    digitalWrite (11, 0);
    digitalWrite (12, 0);
    digitalWrite (13, 0);
  
    break;

  case 0b0110: 

    digitalWrite(11, 1);
    Etat_Led11 = 1;

    Keyboard.write(KEY_LEFT_SHIFT);
    Keyboard.write('6');
    delay(10);
    Keyboard.releaseAll(); 
   
    digitalWrite (7, 0);
    digitalWrite (8, 0);
    digitalWrite (9, 0);
    digitalWrite (10, 0);
    digitalWrite (6, 0);
    digitalWrite (12, 0);
    digitalWrite (13, 0);
    break;

   case 0b0111: 

    digitalWrite(12, 1);
    Etat_Led12 = 1;

    Keyboard.write(KEY_LEFT_SHIFT);
    Keyboard.write('7');
    delay(10);
    Keyboard.releaseAll();

    digitalWrite (7, 0);
    digitalWrite (8, 0);
    digitalWrite (9, 0);
    digitalWrite (10, 0);
    digitalWrite (11, 0);
    digitalWrite (6, 0);
    digitalWrite (13, 0);
    break;

  case 0b1000: 

    digitalWrite(13, 1);
    Etat_Led13 = 1;

    Keyboard.write(KEY_LEFT_SHIFT);
    Keyboard.write('8');
    delay(10);
    Keyboard.releaseAll();    

   
    digitalWrite (7, 0);
    digitalWrite (8, 0);
    digitalWrite (9, 0);
    digitalWrite (10, 0);
    digitalWrite (11, 0);
    digitalWrite (12, 0);
    digitalWrite (6, 0);
    break;
 }
}

N'ayant pas le LEONARDO, pour le moment, donc j'ai testé de la manière suivante ; lecture sur le moniteur série de la sortie LED6

/*
    Interface entre RP120 et VMix.
    Commutation de sources Camera sur RP, Vsualisation sur écran par intermédiaire du VMix
*/

// les entrées
const byte pinREL1 = 2;
const byte pinREL2 = 3;
const byte pinREL3 = 4;
const byte pinREL4 = 5;

//Led en sorties Digital de 6 à 13
int Etat_Led6=0;      
int Etat_Led7=0;
int Etat_Led8=0;
int Etat_Led9=0;
int Etat_Led10=0;
int Etat_Led11=0;
int Etat_Led12=0;
int Etat_Led13=0;

byte etatGlobal ;

// Fonction utilitaire de remise à zero des etats et des leds
// Le paramètre de cette fonction pinLed sert à eviter un pin lors de la remise à zéro
// pinLed vaut 0 si la remise à zero est complète


void setup()
{
  Serial.begin(115200);
  pinMode(pinREL1, INPUT);
  pinMode(pinREL2, INPUT);
  pinMode(pinREL3, INPUT);
  pinMode(pinREL4, INPUT);
  pinMode(6, OUTPUT);
  pinMode(7, OUTPUT);
  pinMode(8, OUTPUT);
  pinMode(9, OUTPUT);
  pinMode(10, OUTPUT);
  pinMode(11, OUTPUT);
  pinMode(12, OUTPUT);
  pinMode(13, OUTPUT);

}

void loop() {
  byte Etat_REL1 = digitalRead(pinREL1); 
  byte Etat_REL2 = digitalRead(pinREL2);
  byte Etat_REL3 = digitalRead(pinREL3);
  byte Etat_REL4 = digitalRead(pinREL4);

  byte nouvelEtat = (Etat_REL4 << 3) | (Etat_REL3 << 2) | (Etat_REL2 << 1) | Etat_REL1;

  if (nouvelEtat != etatGlobal) {
    Serial.println(F("----------------------"));

    Serial.print(F("Etat_REL1: "));
    Serial.println(Etat_REL1 == HIGH ? "HIGH" : "LOW");

    Serial.print(F("Etat_REL2: "));
    Serial.println(Etat_REL2 == HIGH ? "HIGH" : "LOW");

    Serial.print(F("Etat_REL3: "));
    Serial.println(Etat_REL3 == HIGH ? "HIGH" : "LOW");

    Serial.print(F("Etat_REL4: "));
    Serial.println(Etat_REL4 == HIGH ? "HIGH" : "LOW");

    Serial.print(F("Etat: "));
    Serial.println(nouvelEtat, BIN);

    etatGlobal = nouvelEtat;
    delay(15); // anti rebond du pauvre
   
  }
 
 /* Lecture de l'etat Global pour gérer les sorties
 */  
  
 switch(etatGlobal)   // Variable contenant les états des relais
 {
 
  case 0b0001: 
    digitalWrite(6, HIGH);    //Lecture des 4 bit et on allume la led
    Etat_Led6 = 1
    Serial.print(F("Etat_Led6: "));
    Serial.println(Etat_Led6 == HIGH ? "HIGH" : "LOW");
    digitalWrite (7, 0);
    Serial.print(F("Etat_Led7: "));
    Serial.println(Etat_Led7 == HIGH ? "HIGH" : "LOW");
    digitalWrite (8, 0);
    digitalWrite (9, 0);
    digitalWrite (10, 0);
    digitalWrite (11, 0);
    digitalWrite (12, 0);
    digitalWrite (13, 0);
  	break;
   
  case 0b0010: 
    digitalWrite(7, HIGH); 
    Etat_Led7 = 1
 
    digitalWrite (6, 0);
    digitalWrite (8, 0);
    digitalWrite (9, 0);
    digitalWrite (10, 0);
    digitalWrite (11, 0);
    digitalWrite (12, 0);
    digitalWrite (13, 0);   
  	break;
    
  case 0b0011: 
    digitalWrite(8, 1); 
    Etat_Led8 = 1;
    
    digitalWrite (7, 0);
    digitalWrite (6, 0);
    digitalWrite (9, 0);
    digitalWrite (10, 0);
    digitalWrite (11, 0);
    digitalWrite (12, 0);
    digitalWrite (13, 0);
  	break;
  
  case 0b0100: 
    digitalWrite(9, 1);
    Etat_Led9 = 1;
    ;
    digitalWrite (7, 0);
    digitalWrite (8, 0);
    digitalWrite (6, 0);
    digitalWrite (10, 0);
    digitalWrite (11, 0);
    digitalWrite (12, 0);
    digitalWrite (13, 0);
  	break;
  
  case 0b0101: 
    digitalWrite(10, 1); 
    Etat_Led10 = 1;
    
    digitalWrite (7, 0);
    digitalWrite (8, 0);
    digitalWrite (9, 0);
    digitalWrite (6, 0);
    digitalWrite (11, 0);
    digitalWrite (12, 0);
    digitalWrite (13, 0);
  	break;
  
  case 0b0110: 
    digitalWrite(11, 1);
    Etat_Led11 = 1;
    
    digitalWrite (7, 0);
    digitalWrite (8, 0);
    digitalWrite (9, 0);
    digitalWrite (10, 0);
    digitalWrite (6, 0);
    digitalWrite (12, 0);
    digitalWrite (13, 0);
  	break;
  
  case 0b0111: 
    digitalWrite(12, 1);
    Etat_Led12 = 1;
    
    digitalWrite (7, 0);
    digitalWrite (8, 0);
    digitalWrite (9, 0);
    digitalWrite (10, 0);
    digitalWrite (11, 0);
    digitalWrite (6, 0);
    digitalWrite (13, 0);
  	break;
  
  case 0b1000: 
    digitalWrite(13, 1);
    Etat_Led13 = 1;
    
    digitalWrite (7, 0);
    digitalWrite (8, 0);
    digitalWrite (9, 0);
    digitalWrite (10, 0);
    digitalWrite (11, 0);
    digitalWrite (12, 0);
    digitalWrite (6, 0);
  	break;

 }
}

Et la je me rends compte que sur le moniteur serie que je lie en boucle ma sortie activé.
Ce qui je pense va créer un pb sur le report de la touche clavier, puisque à chaque lecture la touche affecté va etre considéré comme un appui. et donc si c'est le a , j'aurai une serie de aaaaaaaaaaaaa jusqu'au prochain changement d'état.
Comme je suis dans une boucle il faut que l’état soit lu mais pas relus a chaque fois mais seulement lors d'un nouveau changement de mon état global.
Si c’était que des led ou relais il y avait pas de souci mais la c'est une autre chose avec l’écriture pour un clavier.
J'essaie de trouver comment on peut lui dire de lire et rester sur ce même état sans créer une boucle.
Mais bon sans succès pour le moment.
Toujours preneur d'idée ou de solution plus adapté.
Merci.

Vous devez donc mémoriser ce qui a déjà été traité pour ne pas le refaire

C’est typiquement une définition de programme qui se prête bien à la programmation par machine à états (cf mon tuto éventuellement)

(Quand c’est simple on peut juste garder une variable booléenne qui dit si une action spécifique a été réalisée)

Merci de la réponse.
Ma question est : est-ce que ce que j'ai mis en loop je le sort pour le mettre dans un void etat_memoire et ensuite dans mon mode loop je lui ecrit : Ex: si mon "état_mémoire = etatglobal=Etatled6" qui se lit dans la partie switch/case j'écris ma sortie 6 et ainsi de suite?
ce serait l'idée.

Un void ca ne veut rien dire. Vous pouvez voir void comme un type (comme int, long, bool, char,...) mais c’est le type ‘vide, ‘sans valeur’ ou inconnu.

Donc ce que vous dites n’a pas beaucoup de sens...

Si vous voulez faire une machine à états, dessinez la. Quel est le système, quels sont les evenements, quelles sont les transitions possibles et décrivez les actions à réaliser lors de ces transitions.

Merci pour la réponse.
Je suis allé voir ton post sur la machine a état
Je ne suis pas programmeur j'essaie de comprendre.
Donc en effet je m'exprime surement très mal.
Ce que je voulais dire, si je crée une variable etatmemoire qui reprend l'état de mon étatGlobal .
Dans ma boucle je ne lirais plus que l'état de ma variable etatmémoire. Mais je reste quand meme septique.
Si j'arrive à me faire comprendre.

Merci J-M-L pour ton aide.
J'ai lu et relu ton post sur la machine a état.
Je ne peux pas faire le test sur l’émulateur tinkercad car pas possible d'y associer des bibliothèques.
Je tourne en rond, j'essaie d'autres façon, mais je ne m'en sort pas

Si je crée une variable qui correspond à l’état de mes relais choses que tu m'a montré (mais dans la fonction loop pour voir les états dans le moniteur série), Je pense donc que ce n'est pas la que je dois la mettre.
Donc si je crée une fonction etatRelais qui determine un état binaire. Qui servira pour la fonction CallBack
Est ce que je peux utiliser l’état binaire, c-a-d le résultat : 0000, 0001, 0010 etc.... reprendre tous ces états dans enum et leur donner comme variable "etatRelais" par ex.
Ensuite si j'ai compris il me faut créer une fonction callBack dans laquelle je prends ma variable etatRelais et faire un switch/case pour définir les états de mes sorties suite a chaque état defini par etatRelais.
Et c'est la que je bute.
Dis moi si je suis clair ou pas.

Ah oui j'oubliai au départ il falait juste allumé une led, donc le programme en boucle faisait le taf.
Comme on m'a demandé de voir si c’était possible d'avoir les led mais aussi la possibilité de l'associer a un clavier via L'USB c'est la que pour moi la donne a changé.

Je ne peux pas faire le test sur l'émulateur tinkercad car pas possible d'y associer des bibliothèques.

vous pouvez prendre le code de SimpleBouton.h et .cpp et l'injecter en début de votre code par exemple

je ne suis pas bien sûr de suivre ce que vous dites sinon...

Peut-on poster une image?
Cela vous permetrez de comprendre le projet.

oui - clickez sur preview en bas du cadre où vous tapez votre texte, ça fait apparaître le post tel qu'il sera mais en dessous du cadre maintenant vous avez un bouton "Attachments and other options". clickez dessus et vous verrez un moyen de choisir les fichiers à attacher.

Choisissez une image en format gif, jpg, mpg, pdf ou png qui est sur votre ordinateur et attachez là.

puis soumettez votre post en cliquant sur "Post". l'image devrait apparaître
(avant c'était encore plus compliqué :slight_smile: )

NB: vous l'avez fait dans votre premier post...

ok voila le synoptique.
c'est pour une micro régie de tele le tout en IP connecté. Un PC permet de recevoir via une interface RP120 plusieurs cameras celui-ci commute les différentes cameras pour envoyer ces images sur un camion de transmission par exemple.
Le PC est particulier puisque prévu avec un soft propriétaire et bien sur fait pour ce genre de chose.
il permet notamment de connecter plusieurs écrans depuis la dernières version.

Le but c'est d'affecte un écran a l'opérateur camera. cela qui lui permettrait de voir ces camera pour les régler.
Quand il commute sur sa télécommande RP120 pour regler la camera qu'il veut , je voudrais que dans son moniteur cette camera s'affiche. D'ou lidée de l'interface par le module arduino leonardo qui est prévu pour utiliser le keyboard.

Le dessin est pas top mais Je l'ai fait rapidement avec paint car c'est le seul outil que j'ai a disposition pour le moment.

NB oui en effet je ne sais même plus comment je l'avais fait sur le coup.