Potentiomètre PWM à deux canaux

Bonjour à tous,

Je cherche à simuler via une carte Uno les deux canaux d'un potentiomètre PWM simultanément de la manière suivante :

Position zéro % du potentiomètre donne : Canal_A : 0 et Canal_B : 255
Position 100 % du potentiomètre donne : Canal_A : 255 et Canal_B : 0

Voici le bout de programme de test que j'ai mis en place :

const int Canal_A = 2;
const int Canal_B = 6;

void setup() {

  Serial.begin(115200);
  pinMode(Canal_A, OUTPUT);
  pinMode(Canal_B, OUTPUT);

}

void loop() {

  analogWrite(Canal_A, 0);
  analogWrite(Canal_B, 255);

  for ( int i = 0; i <= 255; i++ ) {
    analogWrite(Canal_A, i);
    delay(25);
  }

  for ( int x = 255; x >= 0; x-- ) {
    analogWrite(Canal_B, x);
    delay(25);
  }
}

J'ai branché les deux canaux à mon oscilloscope et je vois deux problèmes :

  • le Canal_A de la première boucle for fonctionne pour atteindre sa valeur de 255.
  • le Canal_B de la deuxième boucle for fonctionne pour atteindre sa valeur de 0.

Comment puis-je faire pour que les deux canaux fonctionnent de manière simultané ?

Bonne soirée à tous

Bonjour udina

les 2 potentiomètres fonctionnent mécaniquement ensemble?

A+
Cordialement
jpbbricole

Voici le schéma de principe du composant :

C'est bien en un seul compsant

Essaies ca:

const int Canal_A = 2;
const int Canal_B = 6;
void setup() {
  // put your setup code here, to run once:
}

void loop() {
  // put your main code here, to run repeatedly:
  int pwmValue = map(analogRead(A0), 0, 1023, 0, 255);
  analogWrite(Canal_A, pwmValue);
  analogWrite(Canal_B, 255 - pwmValue);
}

Il faut que je puisse monter et descendre à souhait les valeurs des deux canaux simultanément, c'est à dire que j'ai deux boutons qui doivent gérer à l'impulsion la montée ou la descente d’où mes boucles for que j'avais mis en place.

Et bien tu mets ça dans une boucle

Bonjour,

Desolé si je ne fais pas avancer le projet avec ma question.

Je vois que cela a était rajouté en français sur le schéma à côté de "FOOT THROTTLE", je ne comprends pas ce que définit "Potentiométre PWM 2 canaux"?

Tu as écris

On voit bien qu'il y a 2 canaux sur le schema, que tu traduis par 2 boutons, mais c'est 2 "boutons" sont'ils activés en même temps?

Tu parle de "potentiométre", mais est-ce un potentiométre ou un bouton?

En fait, personnellement, je n'ai pas compris grand chose aux "entrées" et "sorties" de ton probléme.

Si quelqu'un pouvait m'éclairer ça m'intéresse, par pure curiosité.

J'ai tout de même pigé que se si tu veut faire "simultanément" et non l'un aprés l'autre, @jpbbricole et @fdufnews te proposent une solution qui fait simultanément évoluer les PWM de 2 canaux différents.

Bonjour udina

Si je reprends ton programme du post#1, ça donne ça:

const int Canal_A = 2;
const int Canal_B = 6;

void setup() {

	Serial.begin(115200);
	pinMode(Canal_A, OUTPUT);
	pinMode(Canal_B, OUTPUT);

}

void loop() {

	for ( int i = 0; i <= 255; i++ ) {
		analogWrite(Canal_A, i);
		analogWrite(Canal_B, 255 -i);
		delay(25);
		Serial.println("A " + String(i) + "\t" + "B " + String(255-i));
	}
}

PS: Quel Arduino as tu, parce que pour un UNO, ceci:
const int Canal_A = 2;
ne fonctionne pas, cette pin n'est pas PWM, mais la 3 oui.

Cordialement
jpbbricole

Bonjour,
C'est sur une carte Uno, j'ai modifié les sorties sur la 5 et la 6.
Ca fonctionne bien pour la montée et descente simultané des deux canaux avec les modifications suivantes :


const int Canal_A = 6;
const int Canal_B = 5;

void setup() {

  Serial.begin(115200);
  pinMode(Canal_A, OUTPUT);
  pinMode(Canal_B, OUTPUT);

}

void loop() {

  analogWrite(Canal_A, 0);
  analogWrite(Canal_B, 255);
  
  for ( int i = 0; i <= 10; i++ ) {
    analogWrite(Canal_A, 205 - i);
    analogWrite(Canal_B, 50 + i);
    delay(100);
    Serial.println("A " + String(205-i) + "\t" + "B " + String(50+i));
  }
}

Par contre, il va falloir que je puisse créer une variable qui mémorise la valeur PWM à intégrer car sur le moniteur série ci dessus, on voit qu'à chaque pression de mon bouton, je redémarre à zéro dans ma boucle for.

J'ai procédé comme sui mais les valeurs de map ne sont pas de 0, 1023 car les lectures sont sur un pin 5 et 6


const int Canal_A = 6;
const int Canal_B = 5;

void setup() {

  Serial.begin(115200);
  pinMode(Canal_A, OUTPUT);
  pinMode(Canal_B, OUTPUT);
  
  int pwmValue_A = map(analogRead(Canal_A), 0, 1023, 0, 255);
  int pwmValue_B = map(analogRead(Canal_B), 0, 1023, 0, 255);

  analogWrite(Canal_A, 0);
  analogWrite(Canal_B, 255);
  
}

void loop() {
  
  for ( int i = 0; i <= 10; i++ ) {
    analogWrite(Canal_A, pwmValue_A - i);
    pwmValue_A --;
    analogWrite(Canal_B, pwmValue_B + i);
    pwmValue_B ++;
    
    delay(100);
    Serial.println("A " + String(pwmValue_A-i) + "\t" + "B " + String(pwmValue_B+i));
  }
}

Bonjour,

Mes remarque/question:

1/ Faire les choses dans l'ordre je pense:

2/ Que se passe t'il quand

pwmValue_A --;

= 0

Ou quand

pwmValue_B++;

= 255

Bonjour udina

Je crois qu'il y a une grosse confusion :wink:
Tu as 2 potentiomètres qui sont lus sur des ports analogiques (A0 à A5) par des analogRead(A0);, par exemple. Tu as des sorties PWM ("analogiques") que tu commandes par des analogWrite(Canal_A, pwmValue_A - i);

Tu ne peut pas faire:
int pwmValue_A = map(analogRead(Canal_A), 0, 1023, 0, 255);
int pwmValue_B = map(analogRead(Canal_B), 0, 1023, 0, 255);
Un port PWN ne se lit pas.

Je pense qu'arrivé à ce point, il te faut expliquer ce que tu veux faire, plus en détail.
Tu as 2 potentiomètres, sont il indépendants mécaniquement?
Que veux tu faire avec ces signaux PWM?

Maintenant il y a un bouton.
Et ton programme ci-dessous ne compile pas :woozy_face:

A+
Cordialement
jpbbricole

@udina
Pour la bonne compréhension il faut que tu expliques quelles sont les entrées et quelles sont les sorties attendues dans ta réalisation.

Une entrée peut-être une tension lue sur un potentiomètre.
Et/Ou autre chose .

Une sortie peut-être un signal PWM avec un rapport cyclique.
Et/Ou autre chose.

Pour être efficaces les aidants ont besoin de tout connaitre du projet, et dès le début de l’aide.

Bien vu!

C'est le fameux abus de language du
analogWrite pour une sortie PWM.

@udina revois peut-être la définition de PWM, et peut-être que tu comprendra pourquoi on se pose des questions sur "potentiométre PWM 2 canaux"

Un des nombreux sites qui explique cela

Merci déjà à tous pour votre aide,

Voici le projet complet qui gère un véhicule à très faible vitesse.
Le potentiomètre double que je souhaite simuler est installé sur une pédale d'accélération.
J'ai rajouté deux fils pour la lecture des tensions sur A0 et A5.
Je vous est mis les endroits qui me posent problème en commentaire sur le code.



#include "OneButton.h"


OneButton boutonAppuiPedale;
OneButton boutonRelanchementPedale;
OneButton boutonArretVehicule;
OneButton boutonRelanceVehicule;

const int relaisInverseur = 2;
const int relaisCanal_A_B_PedaleAccelerateur = 12;
const int relaisParking = 13;

const int valeurFilVertInverseur = 8;
const int valeurFilBlancInverseur = 3;
const int valeurFilBleuInverseur = 4;

const int Canal_A = 6;
int pwmValue_A;
const int Canal_B = 5;
int pwmValue_B;

const int ValeurCanal_A = A0;
const int ValeurCanal_B = A5;

// _______________________________________________________  SETUP  ___________________________________________________________

void setup() {

  Serial.begin(115200);

  // ------------------  Initialisation des boutons  ---------------------

  boutonAppuiPedale.setup(9, INPUT);
  boutonRelanchementPedale.setup(10, INPUT);
  boutonArretVehicule.setup(11, INPUT);
  boutonRelanceVehicule.setup(15, INPUT);

  boutonAppuiPedale.attachClick(simpleClickAppuiPedale);
  boutonRelanchementPedale.attachClick(simpleClickRelachementPedale);
  boutonArretVehicule.attachClick(simpleClickArretVehicule);
  boutonRelanceVehicule.attachClick(simpleClickRelanceVehicule);

  pinMode(relaisInverseur, OUTPUT);

  pinMode(valeurFilVertInverseur, OUTPUT);
  pinMode(valeurFilBlancInverseur, OUTPUT);
  pinMode(valeurFilBleuInverseur, OUTPUT);

  pinMode(relaisCanal_A_B_PedaleAccelerateur, OUTPUT);

  pinMode(relaisParking, OUTPUT);

  pinMode(Canal_A, OUTPUT);
  pinMode(Canal_B, OUTPUT);
  pinMode(ValeurCanal_A, INPUT);
  pinMode(ValeurCanal_B, INPUT);



  arretDuVehiculeAuDemarrageDuProgramme();

}

// ___________________________________________________________  LOOP  _______________________________________________________________________


void loop() {


  boutonAppuiPedale.tick();
  boutonRelanchementPedale.tick();
  boutonArretVehicule.tick();
  boutonRelanceVehicule.tick();

}

// _________________________________________________________________  FONCTION(S) _____________________________________________________________

void simpleClickAppuiPedale() {

  /* j'aimerais pouvoir à chaque appui sur le bouton diminuer de 10 la valeur Canal_A et augmenter la valeur Canal_B
     de 10 également et que les valeurs soient mémorisées pour une deuxième impulsion sur le bouton*/

  pwmValue_A = map(analogRead(ValeurCanal_A), 0, 1023, 0, 255);
  pwmValue_B = map(analogRead(ValeurCanal_B), 0, 1023, 0, 255);

  for ( int i = 0; i <= 10; i++ ) {
    analogWrite(Canal_A, 205 - i);
    analogWrite(Canal_B, 50 + i);
    delay(50);
    Serial.println("A " + String(pwmValue_A) + "\t" + "B " + String(pwmValue_B));
  }

}


void simpleClickRelachementPedale() {

  /* j'aimerais pouvoir à chaque appui sur le bouton augmenter de 10 la valeur Canal_A et diminuer la valeur Canal_B
      de 10 également et que les valeurs soient mémorisées pour une deuxième impulsion sur le bouton*/

  pwmValue_A = map(analogRead(ValeurCanal_A), 0, 1023, 0, 255);
  pwmValue_B = map(analogRead(ValeurCanal_B), 0, 1023, 0, 255);

  for ( int i = 0; i <= 10; i++ ) {
    analogWrite(Canal_A,  + i);
    analogWrite(Canal_B,  - i);
    delay(50);
    Serial.println("A " + String(pwmValue_A) + "\t" + "B " + String(pwmValue_B));
  }
}
}

void simpleClickArretVehicule() {


  analogWrite(Canal_A, 205);
  analogWrite(Canal_B, 50);

  delay(2000);

  digitalWrite(relaisParking, HIGH);
  delay(500);
  digitalWrite(relaisParking, LOW);

}

void simpleClickRelanceVehicule() {

  digitalWrite(relaisInverseur, HIGH);

  digitalWrite(valeurFilVertInverseur, LOW);
  digitalWrite(valeurFilBlancInverseur, LOW);
  digitalWrite(valeurFilBleuInverseur, HIGH);

  delay(1000);

  digitalWrite(relaisInverseur, LOW);

}

void arretDuVehiculeAuDemarrageDuProgramme() {

  digitalWrite(relaisInverseur, LOW);

  analogWrite(Canal_A, 205);  // valeur des deux canaux à l'entrée de la LOOP
  analogWrite(Canal_B, 50);

  delay(1000);

  digitalWrite(relaisCanal_A_B_PedaleAccelerateur, HIGH);

  delay(1000);

  digitalWrite(relaisParking, HIGH);
  delay(2000);
  digitalWrite(relaisParking, LOW);
}


/* OIC canal un de la pédale : 53  ==> pédale relevée : 17.8 -- 1,79V  /  pédale enfoncée : 81.4 -- 8V
   OIC canal deux de la pédale : 54  ==> pédale relevée : 81.8 -- 8,18V  / pédale enfoncée : 18.7 -- 2V
*/

Bonjouz udina

En fait, seuls les boutons font augmente/diminuer tes PWM?

Tes boutons "simulent" tes potentiomètres?

J'ai juste?

Oui, c'est ça, un bouton pour simuler un appui de pédale et un autre pour relacher la pédale.

Donc on travaille sans potentiomètre?

Un potentiomètre PWM cela n’existe pas.
En quoi as tu besoin de la PWM ?

Est ce pour commander des moteurs ?
Est ce que ”ta pédale” n’est pas en fait un potentiomètre ?
Est ce que le volant n’est pas en fait un potentiomètre ?
Est ce que pour tourner tu as besoin de faire tourner les moteurs droite et gauche a des vitesses différentes ?

Bonjour udina
Question, comment sont câblés tes boutons, d'un côté à GND et de l'autre sur la pin du UNO?

Essaies ça, ce n'est pas testé. L'essentiel est dans:
void simpleClickAppuiPedale()
et
void simpleClickRelachementPedale()

Le programme:

#include "OneButton.h"


OneButton boutonAppuiPedale;
OneButton boutonRelanchementPedale;
OneButton boutonArretVehicule;
OneButton boutonRelanceVehicule;

const int relaisInverseur = 2;
const int relaisCanal_A_B_PedaleAccelerateur = 12;
const int relaisParking = 13;

const int valeurFilVertInverseur = 8;
const int valeurFilBlancInverseur = 3;
const int valeurFilBleuInverseur = 4;

const int Canal_A = 6;
int pwmValue_A;
const int Canal_B = 5;
int pwmValue_B;

const int ValeurCanal_A = A0;
const int ValeurCanal_B = A5;

// _______________________________________________________  SETUP  ___________________________________________________________

void setup() {

  Serial.begin(115200);

  // ------------------  Initialisation des boutons  ---------------------

  boutonAppuiPedale.setup(9, INPUT);
  boutonRelanchementPedale.setup(10, INPUT);
  boutonArretVehicule.setup(11, INPUT);
  boutonRelanceVehicule.setup(15, INPUT);

  boutonAppuiPedale.attachClick(simpleClickAppuiPedale);
  boutonRelanchementPedale.attachClick(simpleClickRelachementPedale);
  boutonArretVehicule.attachClick(simpleClickArretVehicule);
  boutonRelanceVehicule.attachClick(simpleClickRelanceVehicule);

  pinMode(relaisInverseur, OUTPUT);

  pinMode(valeurFilVertInverseur, OUTPUT);
  pinMode(valeurFilBlancInverseur, OUTPUT);
  pinMode(valeurFilBleuInverseur, OUTPUT);

  pinMode(relaisCanal_A_B_PedaleAccelerateur, OUTPUT);

  pinMode(relaisParking, OUTPUT);

  pinMode(Canal_A, OUTPUT);
  pinMode(Canal_B, OUTPUT);
  pinMode(ValeurCanal_A, INPUT);
  pinMode(ValeurCanal_B, INPUT);



  arretDuVehiculeAuDemarrageDuProgramme();

}

// ___________________________________________________________  LOOP  _______________________________________________________________________


void loop() {


  boutonAppuiPedale.tick();
  boutonRelanchementPedale.tick();
  boutonArretVehicule.tick();
  boutonRelanceVehicule.tick();

}

// _________________________________________________________________  FONCTION(S) _____________________________________________________________

void simpleClickAppuiPedale() {

  /* j'aimerais pouvoir à chaque appui sur le bouton diminuer de 10 la valeur Canal_A et augmenter la valeur Canal_B
     de 10 également et que les valeurs soient mémorisées pour une deuxième impulsion sur le bouton*/

  //pwmValue_A = map(analogRead(ValeurCanal_A), 0, 1023, 0, 255);
  //pwmValue_B = map(analogRead(ValeurCanal_B), 0, 1023, 0, 255);
//
  //for ( int i = 0; i <= 10; i++ ) {
    //analogWrite(Canal_A, 205 - i);
    //analogWrite(Canal_B, 50 + i);
    //delay(50);
    //Serial.println("A " + String(pwmValue_A) + "\t" + "B " + String(pwmValue_B));
  //}
	pwmValue_A -=10; // Diminuer A
	pwmValue_B +=10; // Augmenter B
	constrain(pwmValue_A, 0, 255); // Pour limiter les valeurs
	constrain(pwmValue_B, 0, 255); // https://docs.arduino.cc/language-reference/en/functions/math/constrain/
    Serial.println("A " + String(pwmValue_A) + "\t" + "B " + String(pwmValue_B));
}


void simpleClickRelachementPedale() {

  /* j'aimerais pouvoir à chaque appui sur le bouton augmenter de 10 la valeur Canal_A et diminuer la valeur Canal_B
      de 10 également et que les valeurs soient mémorisées pour une deuxième impulsion sur le bouton*/

  //pwmValue_A = map(analogRead(ValeurCanal_A), 0, 1023, 0, 255);
  //pwmValue_B = map(analogRead(ValeurCanal_B), 0, 1023, 0, 255);
//
  //for ( int i = 0; i <= 10; i++ ) {
    //analogWrite(Canal_A,  + i);
    //analogWrite(Canal_B,  - i);
    //delay(50);
    //Serial.println("A " + String(pwmValue_A) + "\t" + "B " + String(pwmValue_B));
  //}
	pwmValue_A +=10; // Augmenter A
	pwmValue_B -=10; // Diminuer B
	constrain(pwmValue_A, 0, 255); // Pour limiter les valeurs
	constrain(pwmValue_B, 0, 255); // https://docs.arduino.cc/language-reference/en/functions/math/constrain/
	Serial.println("A " + String(pwmValue_A) + "\t" + "B " + String(pwmValue_B));
}
//}

void simpleClickArretVehicule() {


  analogWrite(Canal_A, 205);
  analogWrite(Canal_B, 50);

  delay(2000);

  digitalWrite(relaisParking, HIGH);
  delay(500);
  digitalWrite(relaisParking, LOW);

}

void simpleClickRelanceVehicule() {

  digitalWrite(relaisInverseur, HIGH);

  digitalWrite(valeurFilVertInverseur, LOW);
  digitalWrite(valeurFilBlancInverseur, LOW);
  digitalWrite(valeurFilBleuInverseur, HIGH);

  delay(1000);

  digitalWrite(relaisInverseur, LOW);

}

void arretDuVehiculeAuDemarrageDuProgramme() {

  digitalWrite(relaisInverseur, LOW);

  analogWrite(Canal_A, 205);  // valeur des deux canaux à l'entrée de la LOOP
  analogWrite(Canal_B, 50);

  delay(1000);

  digitalWrite(relaisCanal_A_B_PedaleAccelerateur, HIGH);

  delay(1000);

  digitalWrite(relaisParking, HIGH);
  delay(2000);
  digitalWrite(relaisParking, LOW);
}


/* OIC canal un de la pédale : 53  ==> pédale relevée : 17.8 -- 1,79V  /  pédale enfoncée : 81.4 -- 8V
   OIC canal deux de la pédale : 54  ==> pédale relevée : 81.8 -- 8,18V  / pédale enfoncée : 18.7 -- 2V
*/

Cordialement
jpbbricole

Je pense que c'est important, pour que tout le monde parle de la même chose, que soit présenté un schéma de cablage avec dessus indiqué les entrées/sorties Arduino du systéme...