Structure algorithmique d'un programme avec une led RGB

Bonjour, je me tourne vers vous pour discuter de structure algorithmique. En effet, je suis équipé d’une carte arduino Uno, un Deuligne (écran lcd) et une led RGB. Il faut savoir qu’il y a un joystick sur le Deuligne et mon but est qu’avec ce joystick, j’incrément une variable RC de +/-10 à partir de 60. Quand RC>120, m’a lampe s’allume en rouge, de même quand RC<50 sinon en vert. Sachant que la led continue de clignoter à intervalle de demi-seconde.
Mon problème est que je n’arrive pas à changer ma variable RC avec fluidité. Effectivement, je dois attendre que la led clignote avant de changer de variable. Il faut que je réarrange mon code pour cela, mais c’est ici que je bloque…
Voici mon code :

#include <Wire.h> // I2C library include
#include <Deuligne.h> // LCD library include

static Deuligne lcd; // lcd object declaration

const int R=1;
const int V=1;
const int B=1;

// — Déclaration des constantes des broches E/S numériques —

const int ledRouge=3; // Constante pour la broche 3
const int ledVert=5; // Constante pour la broche 5
const int ledBleu=4; // Constante pour la broche 6
//Key message
static const char msgs[5][15] = {
"Right Key OK ",
"Up Key OK ",
"Down Key OK ",
"Left Key OK ",
“Select Key OK” };

void setup()
{
Wire.begin(); // join i2c
pinMode (ledVert,OUTPUT); // Broche ledVert configurée en sortie
pinMode (ledRouge,OUTPUT); // Broche ledRouge configurée en sortie
pinMode (ledBleu,OUTPUT); // Broche ledBleu configurée en sortie
pinMode (13,OUTPUT);
lcd.init(); // LCD init

lcd.clear();
lcd.print("Rythme : ");
lcd.setCursor(13,0);
lcd.print(“bpm”);
int RC=60;

}

void loop()
{
int (RC) =60;
while (RC!=-4)
{
RC = coeur(RC);
lcd.setCursor(9,0);
lcd.print(RC);

if (RC>120)
{
digitalWrite(ledVert,HIGH);
digitalWrite(ledBleu,HIGH);
//ledRVB(0,V,0); // allume Rouge Vert et Bleu => blanc
digitalWrite(ledRouge,LOW); // allume la couleur voulue
delay(500); // pause
digitalWrite(ledRouge,HIGH); // éteint la couleur voulue
delay(500); // pause
}
if (RC<50)
{
digitalWrite(ledVert,HIGH);
digitalWrite(ledBleu,HIGH);
digitalWrite(ledRouge,LOW); // allume la couleur voulue
delay(500); // pause
digitalWrite(ledRouge,HIGH); // éteint la couleur voulue
delay(500);
}
if (RC<=120 and RC>=50)
{
digitalWrite(ledRouge,HIGH);
digitalWrite(ledBleu,HIGH);
digitalWrite(ledVert,LOW); // allume la couleur voulue
delay(500); // pause
digitalWrite(ledVert,HIGH); // éteint la couleur voulue
delay(500); // pause

}

}
}

int coeur(int RC)
{

static int8_t oldkey = -1;
int8_t key = lcd.get_key(); // read the value from the sensor & convert into key press

if (key != oldkey) // if keypress is detected
{

key = lcd.get_key(); // read the value from the sensor & convert into key press
if (key != oldkey)
{
oldkey = key;
if (key >=0)
{
if (key==0)
{
RC=RC+5;
}

if (key==3)
{
if (RC>0)
{
RC=RC-5;
if (RC<100)
{
lcd.setCursor(11,0);
lcd.print(" “);
}
if (RC<10)
{
lcd.setCursor(10,0);
lcd.print(” ");
}
}
}
}
}
}

return(RC);

}

void ledRVB(int Rouge, int Vert, int Bleu)

{

//— attention - avec une LED RGB anode commune : la LED s’allume sur niveau BAS !

if (Rouge==1) digitalWrite(ledRouge,LOW); // allume couleur
if (Rouge==0) digitalWrite(ledRouge,HIGH); // éteint couleur

if (Vert==1) digitalWrite(ledVert,LOW); // allume couleur
if (Vert==0) digitalWrite(ledVert,HIGH); // éteint couleur

if (Bleu==1) digitalWrite(ledBleu,LOW); // allume couleur
if (Bleu==0) digitalWrite(ledBleu,HIGH); // éteint couleur

}

//---- fonction pour variation progressive des couleurs ----

void ledRVBpwm(int pwmRouge, int pwmVert, int pwmBleu)

{ // reçoit valeur 0-255 par couleur

//— attention - avec une LED RGB anode commune : la LED s’allume sur niveau BAS !

analogWrite(ledRouge, 255-pwmRouge); // impulsion largeur voulue sur la broche 0 = 0% et 255 = 100% haut
analogWrite(ledVert, 255-pwmVert); // impulsion largeur voulue sur la broche 0 = 0% et 255 = 100% haut
analogWrite(ledBleu, 255-pwmBleu); // impulsion largeur voulue sur la broche 0 = 0% et 255 = 100% haut

}

Je vous remercie d’avance,

Jean M.

Ard3x:
Bonjour, je me tourne vers vous pour discuter de structure algorithmique. En effet, je suis équipé d’une carte arduino Uno, un Deuligne (écran lcd) et une led RGB. Il faut savoir qu’il y a un joystick sur le Deuligne et mon but est qu’avec ce joystick, j’incrément une variable RC de +/-10 à partir de 60. Quand RC>120, m’a lampe s’allume en rouge, de même quand RC<50 sinon en vert. Sachant que la led continue de clignoter à intervalle de demi-seconde.
Mon problème est que je n’arrive pas à changer ma variable RC avec fluidité.

bonsoir
C’est parce que tu utilise des delay qui est un processus bloquant, il faut utiliser un processus non bloquant
voir l’exemple 02-digital—>blinkwithoutdelay

Je ne comprends pas très bien ce programme, pourrais-tu m'éclairer ?

Mais est-ce que je peux changer le temps d’intervalle pendant que le programme se déroule ? Mon but est que le temps d’intervalle change en fonction de RC.
Pouvez-vous m’indiquer comment je dois modifier mon code ?

Merci à vous, j'ai pu réussir ou presque ! Effectivement, j'aimerai savoir si il est possible d'avoir un intervalle que je peux régler pour la led LOW et une constante qui reste la même pour la led HIGH. Pour m'illustrer, j'aimerai que led LOW=x et led HIGH=200 ms, avec x un paramètre que je peux régler.

Une idée ?

Pas d'idée ?

Bonjour, Et ta réflexion sur le sujet, donne quoi ?

Apparemment cela ne m'a pas l'air possible puisque on fait ça que sur un intervalle de temps

L'exemple est présenté avec un intervalle de temps mais rien ne t'empêche de modifier ledit intervalle de temps en même temps que tu changes l'état de la LED.

Comment ça ? je ne suis pas du tout famille avec ce genre de système... Vous n'aurez pas un exemple de code basic ?

Re, Mets nous ton programme actuel pour voir comment on peut adapter ton soft. @+

Si on part du code exemple de BlinkWithoutDelay cela donne quelque chose comme ça.

// the follow variables is a long because the time, measured in miliseconds,
// will quickly become a bigger number than can be stored in an int.
long interval;           // interval at which to blink (milliseconds)

long interval_1=500L;
long interval_2=3000L;

void setup() {
  // set the digital pin as output:
  pinMode(ledPin, OUTPUT);
  interval=  interval_1;
}

void loop()
{
  // here is where you'd put code that needs to be running all the time.

  // check to see if it's time to blink the LED; that is, if the 
  // difference between the current time and last time you blinked 
  // the LED is bigger than the interval at which you want to 
  // blink the LED.
  unsigned long currentMillis = millis();

  if(currentMillis - previousMillis > interval) {
    // save the last time you blinked the LED 
    previousMillis = currentMillis;   

    // if the LED is off turn it on and vice-versa:
    if (ledState == LOW){
      ledState = HIGH;
      interval=  interval_1;
    }
    else{
      ledState = LOW;
      interval=  interval_2;
    }

    // set the LED with the ledState of the variable:
    digitalWrite(ledPin, ledState);
  }
}

Maintenant dans loop rien ne t'empêche d'avoir un morceau de code qui modifie interval_1 et/ou interval_2.

Je veux juste que vous me montrez un exemple basic à partir de ce code pour que je puisse mieux comprendre et ensuite l'adapter à mon code.

/* Blink without Delay

Turns on and off a light emitting diode(LED) connected to a digital pin, without using the delay() function. This means that other code can run at the same time without being interrupted by the LED code.

The circuit: * LED attached from pin 13 to ground. * Note: on most Arduinos, there is already an LED on the board that's attached to pin 13, so no hardware is needed for this example.

created 2005 by David A. Mellis modified 8 Feb 2010 by Paul Stoffregen modified 11 Nov 2013 by Scott Fitzgerald

This example code is in the public domain.

http://www.arduino.cc/en/Tutorial/BlinkWithoutDelay */

// constants won't change. Used here to set a pin number : const int ledPin = 13; // the number of the LED pin

// Variables will change : int ledState = LOW; // ledState used to set the LED

// Generally, you shuould use "unsigned long" for variables that hold time // The value will quickly become too large for an int to store unsigned long previousMillis = 0; // will store last time LED was updated

// constants won't change : const long interval = 1000; // interval at which to blink (milliseconds)

void setup() { // set the digital pin as output: pinMode(ledPin, OUTPUT); }

void loop() { // here is where you'd put code that needs to be running all the time.

// check to see if it's time to blink the LED; that is, if the // difference between the current time and last time you blinked // the LED is bigger than the interval at which you want to // blink the LED. unsigned long currentMillis = millis();

if(currentMillis - previousMillis >= interval) { // save the last time you blinked the LED previousMillis = currentMillis;

// if the LED is off turn it on and vice-versa: if (ledState == LOW) ledState = HIGH; else ledState = LOW;

// set the LED with the ledState of the variable: digitalWrite(ledPin, ledState); } }

Re, Si tu déclares interval en long au lieu de const long, rien ne t'empêche de le modifier dans ton programme. @+