Spectre RVB sur un potentiomètre (type HUE)

[Doucho]

Bonjour,

Je souhaite faire changer la couleur de LED RVB à l'aide d'un seul potentiomètre (ou encodeur rotatif) où sur une rotation complète et 0 à 360, la couleur passe par tout le spectre.
Comme illustré sur cette image :

Je pense faire face à un problème de codage. J'ai utiliser la fonction if dans la section COLOR MAPPING mais ce n'est peut-être pas la bonne.
Qu'en pensez-vous ?
Merci

Le code :

#include <Wire.h>
int x = 0;

//PWM CONTROL outputs to LED --------------------------------------------

#define drivePin1 3    //RED ground color drive PWM
#define drivePin2 5    //GREEN ground color drive PWM
#define drivePin3 6    //BLUE ground color drive PWM

//READINGS knobs  --------------------------------------------

#define readPin1 A0   //dimmer drive knob
#define readPin2 A1   //color drive knob + switch


//variable de lecture pwm ------------------------------------------
unsigned int colorValue = 0;
unsigned int dimmerValue = 0;

unsigned int redRead = 0;
unsigned int greenRead = 0;
unsigned int blueRead = 0;

byte redPrint = 0;
byte greenPrint = 0;
byte bluePrint = 0;


//variable de stockage pwm
//GROUND
unsigned int redPrintGROUND = 0;     // RED
unsigned int greenPrintGROUND = 0;   // GREEN
unsigned int bluePrintGROUND = 0;    // BLUE


//facteur multiplicateur de dimmer ------------------------------------------
float dimmerFactor = 0.00;  //0 to 1

//variable de sortie ------------------------------------------
//GROUND
byte outputValue1 = 0;  // RED
byte outputValue2 = 0;  // GREEN
byte outputValue3 = 0;  // BLUE


void setup() {

  //PWM CONTROL --------------------------------------------
  // set the drive pin as outputs
  //GROUND
  pinMode(drivePin1, OUTPUT);
  pinMode(drivePin2, OUTPUT);
  pinMode(drivePin3, OUTPUT);


  //KNOB INPUT ------------------------------------------
  pinMode(readPin1, INPUT);
  pinMode(readPin2, INPUT);


  delay(200);
}



void loop() {

  //DIMMER CONTROL --------------------------------------------

  constrain(dimmerValue, 0, 1000);

  dimmerValue = analogRead(readPin1) / 4;  // read the input pin in 0-1023 soit 1024 valeurs

  dimmerFactor = dimmerValue / 250.00;




  //COLOR MAPPING ------------------------------------------


  /* VALEUR    RVB           OUTPUT
     0-170     100_50_0       rouge
     171-340   50_100_0     jaune
     341-510   0_100_50       vert
     511-680   0_50_100     cyan
     681-850   50_0_100       bleu
     851-1023   100_0_50     magenta
  */



  colorValue = analogRead(readPin2);

  redRead = colorValue;
  greenRead = colorValue;
  blueRead = colorValue;


  //red mapping
  if ( (redRead <= 170) || (redRead >= 851) )
  {
    redPrint = 255;
  }
  else if ( (redRead >= 171) && (redRead <= 340) )
  {
    redPrint = map(colorValue, 171, 340, 255, 0);
  }
  else if ( (redRead >= 681) && (redRead <= 850) )
  {
    redPrint = map(colorValue, 681, 850, 0, 255);
  }
  else ( (redRead >= 341) && (redRead <= 680) )
  {
    redPrint = 0;
  }

  //green maping
  if ( (greenRead >= 171) || (greenRead >= 510) )
  {
    greenPrint = 255;
  }
  else if (greenRead <= 170)
  {
    greenPrint = map(colorValue, 0, 170, 0, 255);
  }
  else if ( (greenRead >= 511) && (greenRead <= 680) )
  {
    greenPrint = map(colorValue, 511, 680, 255, 0);
  }
  else (greenRead >= 681)
  {
    greenPrint = 0;
  }


  //blue maping
  if (blueRead <= 340)
  {
    bluePrint = 0;
  }
  else if ( (blueRead >= 341) && (blueRead <= 510) )
  {
    bluePrint = map(colorValue, 341, 510, 0, 255);
  }
  else if ( (blueRead >= 511) || (blueRead >= 850) )
  {
    bluePrint = 255;
  }
  else (blueRead >= 851)
  {
    bluePrint = map(colorValue, 851, 1023, 255, 0);
  }



  //OUTPUT ------------------------------------------
  //final OUT calc
  outputValue1 = redPrint * dimmerFactor;
  outputValue2 = greenPrint * dimmerFactor;
  outputValue3 = bluePrint * dimmerFactor;


  //usa data to controle drive
  analogWrite(drivePin1, outputValue1);    //RED ground 0 à 255
  analogWrite(drivePin2, outputValue2);    //GREEN ground 0 à 255
  analogWrite(drivePin3, outputValue3);    //BLUE ground 0 à 255


  delay(200);
}

[J-M-L]

@Doucho

  dimmerValue = analogRead(readPin1) / 4;  // read the input pin in 0-1023 soit 1024 valeurs

le commentaire est faux. Comme vous divisez par 4 vous n'avez qu'une valeur entre 0 et 255

ensuite vous faites

  dimmerFactor = dimmerValue / 250.00;

mais vous avez dit

float dimmerFactor = 0.00;  //0 to 1

➜ comme la valeur peut être au de la de 250, vous pourrez être au dessus de 1

Sinon on dirait que vous lisez depuis 2 potentiomètres

analogRead(readPin1) 
analogRead(readPin2);

un pour la brightness et un pour la couleur ?

généralement on travaille en HSB : on utilise la valeur du potentiomètre pour définir H (Hue, la teinte) et on fixe la saturation et la brightness. Ensuite il y a une formule pour passer de HSB en RGB (un exemple pris au hasard)

[fdufnews]

Tu trouveras toutes les transformation d'un espace de couleur vers un autre ici

Math | EasyRGB

L'espace des couleurs est généralement représenté comme un cône

Avec un seul potentiomètre, on ne peut pas avoir toutes les couleurs mais seulement une partie.
Pour les avoir toutes il faut en plus jouer sur la luminance et la saturation.