Fabriquer sa propre console pour jeux de lumières [CONSEIL]

International Français
1

Bonjour à tous,
Je souhaite fabriquer ma propre "console DMX". C'est une console qui me permet de commander des projecteurs mais je n'utilise pas le DMX 512. Mes projecteurs sont allumés par un alimentation externe et j'utilise un MOSFET pour le signal PWM.

Pour basculer entre mes projecteurs, j'utilise 2 boutons, ex :
x = 1; projecteur rouge
x = 2; projecteur vert
x = 3; projecteur bleu
x = 4; projecteur blanc

1 bouton augmente x, 1 autre diminue x, cela me permet de définir le clignotement et le PWM de chaque projecteurs. Mon problème c'est que je ne sais pas s'il faut une boucle ou non pour modifier x, je l'ai mis dans une boucle while. Merci de votre aide

Voici le code:

#include <LiquidCrystal.h>

//pins du lcd
LiquidCrystal lcd(13, 12, 11, 10, 9, 8);

//logo PWM
byte PWM[8] = {
  0b00000,
  0b01000,
  0b10100,
  0b10100,
  0b00101,
  0b00101,
  0b00010,
  0b00000
};

byte UN[8] = {
  0b00000,
  0b00000,
  0b00000,
  0b00100,
  0b01100,
  0b00100,
  0b00100,
  0b01110
};

byte DEUX[8] = {
  0b00000,
  0b00000,
  0b00000,
  0b01100,
  0b10010,
  0b00100,
  0b01000,
  0b11110
};

byte TROIS[8] = {
  0b00000,
  0b00000,
  0b00000,
  0b01100,
  0b00010,
  0b00100,
  0b00010,
  0b01100
};

// état de l'interrupteur d'activation ON/OFF
int switchValeur;
// état de la lumière
int rState = 0;
// temps soustrait
unsigned long rMillis = 0;
// temps
unsigned long recurrentMillis;
// valeur PWM
int rLight;
// délai de clignotement
int rSpeed, x;


void setup(){
  lcd.begin(16,4);
  lcd.clear();
  
  lcd.createChar(1, UN);
  lcd.createChar(2, DEUX);
  lcd.createChar(3, TROIS);
  lcd.createChar(4, PWM);
  
  lcd.setCursor(0,0);
  lcd.print("Speed");
  
  lcd.setCursor(0,1);
  lcd.write(4);
  lcd.setCursor(1,1);
  lcd.write(1);
  
  lcd.setCursor(0,2);
  lcd.write(4);
  lcd.setCursor(1,2);
  lcd.write(2);
  
  lcd.setCursor(0,3);
  lcd.write(4);
  lcd.setCursor(1,3);
  lcd.write(3);
  
  // lampe rouge
  pinMode(2, OUTPUT);
  //interrupteur x++
  pinMode(8, INPUT);
  //interrupteur x--
  pinMode(9, INPUT);
  //interrupteur activation ON/OFF
  pinMode(10, INPUT);

}

void loop(){  
 
  // lecture interrupteur x++
  int xPositive = digitalRead(8);
  //lecture interrupteur x--
  int xNegative = digitalRead(9);


  while(x >= 0){
  // valeur de x
  x = 0;
  
  if(xPositive == HIGH) {
    // si l'interrupteur est activé ALORS x = x+1
    x++;
  }
  
  else if(xNegative == HIGH){
    // si l'interrupteur est activé ALORS x = x-1
    x--;
 }
}
    
  // exécution de différents traitements en fonction de x
  switch (x) {   
  
    // lecture des variables pour la lampe rouge
    case 0: 
 // permet d'éviter que des valeurs ne se mélangent et se changent en choisissant la bonne couleur
    switchValeur = digitalRead(10);
    if (switchValeur == HIGH) {
      rLight = (analogRead(A0)/4);
      rSpeed = analogRead(A1);
    }
      break;

    default:
      // On ne fait rien dans les autres cas
      break;
  }
      
  // lecture du délai
  recurrentMillis = millis();

  // différence et exécution en fonction de la lecture analogique
  if ( (recurrentMillis - rMillis) >= rSpeed) {
    // remise à "zéro"
    rMillis = recurrentMillis;
    // si la lampe est à l'état bas alors l'allumer en fonction du PWM
    if (rState == 0) {
      rState = rLight;
    } else {
      //si la lampe est à l'état haut alors l'éteindre
      rState = 0;
    }
  }
  // exécution du PWM
  analogWrite(2, rState);*/
}
2

Au final tu veux faire une console DMX ou juste piloter tes projecteurs avec un arduino et des boutons ?

3

Je veux piloter mes projecteurs avec des boutons et des potentiomètres et aussi rajouter des effets des consoles DMX. J'ai juste un problème avec la boucle pour x dasn mon programme

4

bonjour,
tu pourrais déjà faire un retour console avec des serial.print de ton x pour voir ce qu'il en retourne.

while(x >= 1){
  // valeur de x
  x = 0;
  
  if(xPositive == HIGH) {
    // si l'interrupteur est activé ALORS x = x+1
    x++;
  }
  
  else if(xNegative == HIGH){
    // si l'interrupteur est activé ALORS x = x-1
    x--;
 }
}

ce que je comprends est que x sera toujours égal à zéro ou alors négatif

EDIT :
pas d'antirebond sur les boutons ou alors c'est via une R.
donc debuggage via serial.print

5

Tout d'abord, excusé moi j'ai remarqué que après l'erreur dans le programme.
En réalité x est supérieur ou égal à 0.

while(x >= 0){
  // valeur de x
  x = 0;
  
  if(xPositive == HIGH) {
    // si l'interrupteur est activé ALORS x = x+1
    x++;
  }
  
  else if(xNegative == HIGH){
    // si l'interrupteur est activé ALORS x = x-1
    x--;
 }
}

Je suis ne comprend pas

c'est via une R

Merci de me l'expliquer

Je vais tester le while avec la liaison série et vous tient au courant

6

Je ne suis pas convaincu de l'utilité d'une boucle while dans ton code.
Pourquoi ne pas vérifier l'état du bouton à chaque tour de boucle et incrémenter ou décrémenter en fonction de son état ?
Merci d'avoir modifié le titre.

7

Je croit que c'est bon, j'ai trouvé la solution. J'ai regardé si Eskimon n'avait pas un truc similaire et bien oui.

/*Tiré de Eskimon*/
/* déclaration des constantes pour les nom des broches; ceci selon le schéma*/
const int btn_minus = 8;
const int btn_plus = 9;
const int led_0 = 10;
const int led_1 = 11;
const int led_2 = 12;
const int led_3 = 13;

/*déclaration des variables utilisées pour le comptage et le décomptage*/

int x = 0; //le nombre qui sera incrémenté et décrémenté
int etat_bouton; //lecture de l'état des boutons (un seul à la fois mais une variable suffit)
int memoire_plus = LOW; //état relâché par défaut
int memoire_minus = LOW;

void setup(){
    pinMode(btn_plus, INPUT);
    pinMode(btn_minus, INPUT);
    
    pinMode(led_0, OUTPUT);
    pinMode(led_1, OUTPUT);
    pinMode(led_2, OUTPUT);
    pinMode(led_3, OUTPUT);
}

void loop(){    
    etat_bouton = digitalRead(btn_plus); //lecture de l'état du bouton d'incrémentation
    
    //Si le bouton a un état différent que celui enregistré ET que cet état est "appuyé"
    if((etat_bouton != memoire_plus) && (etat_bouton == HIGH)){
        x++; //on incrémente la variable qui indique combien de LED devrons s'allumer
    }
       
    memoire_plus = etat_bouton; //on enregistre l'état du bouton pour le tour suivant

    
    etat_bouton = digitalRead(btn_minus); //lecture de l'état du bouton de décrémentation
    
    //Si le bouton a un état différent que celui enregistré ET que cet état est "appuyé"
    if((etat_bouton != memoire_minus) && (etat_bouton == HIGH)){
        x--; //on décrémente la valeur de nombre_led
    }
    memoire_minus = etat_bouton; //on enregistre l'état du bouton pour le tour suivant

    
    //on applique des limites au nombre pour ne pas dépasser 4 ou 0
    if(x > 4){
      x = 4;}
      
    if(x < 0){
      x = 0;}
    
    //appel de la fonction affiche() que l'on aura créée
    //on lui passe en paramètre la valeur du nombre de LED à éclairer
    affiche(x); 
}


void affiche(int valeur_recue){
    //on éteint toutes les leds
    digitalWrite(led_0, LOW);
    digitalWrite(led_1, LOW);
    digitalWrite(led_2, LOW);
    digitalWrite(led_3, LOW);
    
    //Puis on les allume une à une
    if(valeur_recue >= 1){
        digitalWrite(led_0, HIGH);}
    
    if(valeur_recue >= 2){
        digitalWrite(led_1, HIGH);}
    
    if(valeur_recue >= 3){
        digitalWrite(led_2, HIGH);}
    
    if(valeur_recue >= 4){
        digitalWrite(led_3, HIGH);}
}

Est ce qu'on peut m'expliquer à quoi sert:

memoire_plus = etat_bouton;
memoire_minus = etat_bouton;

Je ne comprend pas à quoi ils servent puisque "etat_boutton" est lut une première fois puis est remis à "zéro" avec la seconde lecture. Ne pourrait-on pas les supprimer pour donner ceci.

etat_bouton = digitalRead(btn_plus); //lecture de l'état du bouton d'incrémentation
    
  
    if(etat_bouton == HIGH){
        x++; //on incrémente la variable qui indique combien de LED devrons s'allumer
    }
    
    etat_bouton = digitalRead(btn_minus); //lecture de l'état du bouton de décrémentation
    
    if(etat_bouton == HIGH){
        x--; //on décrémente la valeur de nombre_led
    }
8

Bonjour,

Pourquoi etat_bouton serait remis à zéro à la seconde lecture? Il reste à HIGH tant qu'il est appuyé.
memoire_plus et memoire_minus servent justement à mémoriser l'état précédent pour incrémenter quand on appuie et non continuellement tant que le bouton est appuyé.

9

En effet, je ne l'avait pas remarquer. Merci de ton aide ainsi qu'aux autres.