- Arduino commandé par Joystick -

[invite2f313dba]

Salut à tous !
Bon, bon, ça se précise tout ça ! 153 pas, c'est largement suffisant ! Merci à vous pour vos calculs
Je vais commencer à rédiger le début du code, à mon niveau biensure !

Cordialement,

Vincent A.
-----

[invite2f313dba]

Je suis partie de bonne volonté, mais je suis bloqué aux premières lignes
Je m'en remet (encore) à votre aide si vous le souhaitez !
Bonne soirée,
Vincent A.

[Antoane]

J'ai regardé rapidement, ce diviseur a effectivement l'air de diviser l'horloge principale du µC, celle qui est envoyée à tous les périphériques (CPU y compris).
Je parlais plus haut du prescaler divisant la fréquence d'horloge avant envoi au compteur réalisant le timer/PWM (et à lui seulement).

Ca à l'air possible en langage arduino : http://playground.arduino.cc/Code/PwmFrequency mais là, c'est plus de mondomaine

[Yvan_Delaserge]

Restons simples pour un début et voyons déjà ce que ça donne à 490 Hz. ça fera des sons rigolos à la Robocop, on se rendra bien compte que ça marche!

Sinon, il y aurait toujours la possibilité de générer la PWM avec une boucle en soft, à partir de n'importe quelle sortie.

Je vous laisse, j'ai 320 pages de tuto à me farcir!

[invite2f313dba]

Salut, salut !

Est-ce que l'on dispose de tout les éléments pour commencer à programmer ?

[Yvan_Delaserge]

oui, y'a plus qu'à!

[Yvan_Delaserge]

Alors voilà mon premier programme pour Arduino: Il sert à étalonner le joystick.

/*
  Calibration du joystick
 
  La led s'allume pendant 5 secondes. 
  Pendanzt ce temps, on tourne le joystick nord-sud est-ouest en butée.
  Les lectures du joystick pendant les cinq premières secondes de 
  l' exécution définissent le minimum et le maximum des valeurs fournies
  par le joystick.
 
 The sensor minimum and maximum initial values may seem backwards.
 Initially, you set the minimum high and listen for anything 
 lower, saving it as the new minimum. Likewise, you set the
 maximum low and listen for anything higher as the new maximum.
 
 The circuit:
 les curseurs du joystick sont connectés à
  analog pin0 pour le pot x gauche-droite
  et analog pin1 pour le pot avant-arrière
 * LED attached from digital pin 9 to ground
 
  http://arduino.cc/en/Tutorial/Calibration
 
 This example code is in the public domain.
 
 */

// These constants won't change:
const int sensorPinx = A0;    // pin du pot x
const int sensorPiny = A1;    // pin du pot y
const int ledPin = 9;        // pin that the LED is attached to

// variables:
int xValue = 0;         // the x value
int xMin = 1023;        // minimum x value
int xMax = 0;           // maximum x value
int yValue = 0;         // the y value
int yMin = 1023;        // minimum y value
int yMax = 0;           // maximum y value


void setup() {
  // turn on LED to signal the start of the calibration period:
  pinMode(13, OUTPUT);
  digitalWrite(13, HIGH);

  // calibrate during the first five seconds 
  while (millis() < 5000) {
    xValue = analogRead(sensorPinx);
    yValue = analogRead(sensorPiny);

    // record the maximum sensor value for x
    if (xValue > xMax) {
      xMax = xValue;
    }
    // record the maximum sensor value for y
    if (yValue > yMax) {
      yMax = yValue;
    }

    // record the minimum sensor value for x
    if (xValue < xMin) {
      xMin = xValue;
    }
    // record the minimum sensor value for y
    if (yValue < yMin) {
      yMin = yValue;
    }
  }

  // signal the end of the calibration period
  digitalWrite(13, LOW);
}

void loop() {
  // read the sensor x:
  xValue = analogRead(sensorPinx);

  // apply the calibration to the sensor reading
  xValue = map(xValue, xMin, xMax, 0, 255);

  // in case the sensor value is outside the range seen during calibration
  xValue = constrain(xValue, 0, 255);
  
  // read the sensor y:
  yValue = analogRead(sensorPiny);

  // apply the calibration to the sensor reading
  yValue = map(yValue, yMin, yMax, 0, 255);

  // in case the sensor value is outside the range seen during calibration
  yValue = constrain(yValue, 0, 255);

  
}

Les commentaires sont moité en français moitié en anglais parce que je suis parti d'un des exemples donnés et que je l'ai modifié pour l'adapter au cas d'un joystick.

Commentaires?

Pour la suite, je vais reprendre le code d'Antoane et tâcher de l'adapter à l'Arduino. J'ai déjà commencé, mais y'a encore du boulot!

[Yvan_Delaserge]

Quelques petites modifications:

J'ai utilisé la fonction map pour que les deux valeurs x et y, qui représentent la position des deux curseurs des potentiomètres puissent aller de -128 à + 128.
Xmed et ymed, qui sont les valeurs de x et y lorsque le joystick est en position centrale, est définie comme = 0 et il y a une zone morte de 8 de part et d'autre du neutre.
J'ai viré les fonctions constrain parce que de toutes façons x et y ne seront jamais >128 ni < -128.
Par contre, cette fonction sera utilisée lorsqu'il s'agira de saturer les résultats de la somme x+y, selon les équations d'Antoane.
A demain.
J'adore l'Arduino!

/*
  Calibration du joystick
 
  La led s'allume pendant 5 secondes. 
  Pendanzt ce temps, on tourne le joystick nord-sud est-ouest en butée.
  Les lectures du joystick pendant les cinq premières secondes de 
  l' exécution définissent le minimum et le maximum des valeurs fournies
  par le joystick.
 
 The sensor minimum and maximum initial values may seem backwards.
 Initially, you set the minimum high and listen for anything 
 lower, saving it as the new minimum. Likewise, you set the
 maximum low and listen for anything higher as the new maximum.
 
 The circuit:
 les curseurs du joystick sont connectés à
  analog pin0 pour le pot x gauche-droite
  et analog pin1 pour le pot avant-arrière
 * LED attached from digital pin 9 to ground
 
  http://arduino.cc/en/Tutorial/Calibration
 
 This example code is in the public domain.
 
 */

// These constants won't change:
const int sensorPinx = A0;    // pin du pot x
const int sensorPiny = A1;    // pin du pot y
const int ledPin = 9;        // pin that the LED is attached to
const int xmed = 0;          // valeur de x au neutre
const int ymed = 0;          // valeur de y au neutre
const int blanc = 8;         // zone morte de part et d'autre du neutre

// variables:
int x = 0;         // the x value
int xMin = 1023;        // minimum x value
int xMax = 0;           // maximum x value
int y = 0;         // the y value
int yMin = 1023;        // minimum y value
int yMax = 0;           // maximum y value


void setup() {
  // turn on LED to signal the start of the calibration period:
  pinMode(13, OUTPUT);
  digitalWrite(13, HIGH);

  // calibrate during the first five seconds 
  while (millis() < 5000) {
    x = analogRead(sensorPinx);
    y = analogRead(sensorPiny);

    // record the maximum sensor value for x
    if (x > xMax) {
      xMax = x;
    }
    // record the maximum sensor value for y
    if (y > yMax) {
      yMax = y;
    }

    // record the minimum sensor value for x
    if (x < xMin) {
      xMin = x;
    }
    // record the minimum sensor value for y
    if (y < yMin) {
      yMin = y;
    }
  }

  // signal the end of the calibration period
  digitalWrite(13, LOW);
}

void loop() {
  // read the sensor x:
  x = analogRead(sensorPinx);

  // apply the calibration to the sensor reading
  x = map(x, xMin, xMax, -128, 128);

  
  
  // read the sensor y:
  y = analogRead(sensorPiny);

  // apply the calibration to the sensor reading
  y = map(y, yMin, yMax, -128, 128);

  

  
}

[Antoane]

Bonsoir,

J'ai utilisé la fonction map pour que les deux valeurs x et y, qui représentent la position des deux curseurs des potentiomètres puissent aller de -128 à + 128.

Pourquoi ne pas rester en "unités naturelles" ?
Tu perds en précision et payes du calcul.

C'est pas incompatible mais étrange :

const int ledPin = 9;        // pin that the LED is attached to
[...]
digitalWrite(13, HIGH);

[Yvan_Delaserge]

Bonsoir,

Pourquoi ne pas rester en "unités naturelles" ?
Tu perds en précision et payes du calcul.

C'est pas incompatible mais étrange :

const int ledPin = 9;        // pin that the LED is attached to
[...]
digitalWrite(13, HIGH);

Hello Antoane, et merci pour ton feedback.

C'est surtout pour passer en une seule opération de l'intervalle fourni par le joystick, disons 18 à par exemple 80 vers un intervalle comprenant des valeurs négatives (-128 à + 128) et donc centré sur zéro, ce qui du même coup nous donne la valeur centrale. Espérons que les potentiomètres seront suffisamment linéaires. Sinon, il faudra ajouter un bouton pour la calibration du point central. Ou trouver une autre solution (exemple: La LED clignote pendant 5 secondes. Laisser le joystick au point de repos.)

Je ne suis pas matheux. Est-ce que ton code fonctionnerait avec uniquement des valeurs fournies par le joystick > 0?

Oui, j'ai vu le coup de la LED. C'est comme ça dans les exemples donnés par les concepteurs de l'Arduino. Comme quoi... c'est difficile d'exterminer les bugs jusqu'au dernier!

En fait c'est parce que l'Arduino a déjà d'origine sur le PCB une LED SMD reliée à la pin 13. On peut en relier une autre à la pin 9 si on veut la fixer au boîtier dans lequel se trouvera l'Arduino.

Amicalement,

Yvan

[invite2f313dba]

Salut, salut ! Désolé pour cette période d'inactivité.
C'est parti pour les codes !
Merci Yvan. Donc, ça, c'est "juste" pour lire les joystick ? Ca ne comprend pas la partie de la sortie ?

[Yvan_Delaserge]

Salut, salut ! Désolé pour cette période d'inactivité.
C'est parti pour les codes !
Merci Yvan. Donc, ça, c'est "juste" pour lire les joystick ? Ca ne comprend pas la partie de la sortie ?

Oui, l'Arduino doit commencer par savoir à quelles valeurs de tension venant du joysick il doit s'attendre.
Ensuite, on va passer à la mesure proprement dite, puis on va touiller ces valeurs selon l'algorithme d'Antoane et finalement on va générer les signaux PWM et ceux servant à contrôler les deux relais.

[Yvan_Delaserge]

Je viens d'ajouter un bout de programme pour étalonner le point central du joystick.
Si la linéarité des potentiomètres était parfaite, il suffirait de prendre comme point central le milieu entre Xmax et Xmin, repectivement Ymax et Ymin.
Mais la linéarité des potentiomètres n'est peut-être pas parfaite....

Donc:

Au démarrage, tout d'abord, on étalonne la plage de valeurs couverte par les pot. du joystick:
La led s'allume 5 secondes sans clignoter. Pendant ces 5 secondes, l'opérateur doit déplacer le manche de joystick de gauche à droite et d'avant en arrière jusqu'en butée, plusieurs fois.
Ensuite, la LED s'éteint pendant 1 seconde, puis clignote pendant 5 secondes. Pendant ces 5 secondes, l'opérateur laisse le manche du joystick au point central. L'ordi fait 5 lectures et calcule la moyenne.

Commentaires?

Voici le code:

/*
  Calibration du joystick
 
  La led s'allume pendant 5 secondes, sans clignoter. 
  Pendanzt ce temps, on tourne le joystick nord-sud est-ouest en butée.
  Les lectures du joystick pendant les cinq premières secondes de 
  l' exécution définissent le minimum et le maximum des valeurs fournies
  par le joystick.
 
 The sensor minimum and maximum initial values may seem backwards.
 Initially, you set the minimum high and listen for anything 
 lower, saving it as the new minimum. Likewise, you set the
 maximum low and listen for anything higher as the new maximum.
 
 The circuit:
 les curseurs du joystick sont connectés à
  analog pin0 pour le pot x gauche-droite
  et analog pin1 pour le pot avant-arrière
 * LED attached from digital pin 9 to ground
 
  http://arduino.cc/en/Tutorial/Calibration
 
 This example code is in the public domain.
 
 */

// These constants won't change:
const int sensorPinx = A0;    // pin du pot x
const int sensorPiny = A1;    // pin du pot y
const int ledPin = 9;        // pin that the LED is attached to
const int blanc = 8;         // zone morte de part et d'autre du neutre

// variables:
int x = 0;         // the x value
int xmed = 0;          // valeur de x au neutre
int xMin = 1023;        // minimum x value
int xMax = 0;           // maximum x value
int y = 0;         // the y value
int ymed = 0;          // valeur de y au neutre
int yMin = 1023;        // minimum y value
int yMax = 0;           // maximum y value


void setup() {
  // turn on LED to signal the start of the calibration period:
  pinMode(13, OUTPUT);
  digitalWrite(13, HIGH);

  // calibrate during the first five seconds 
  while (millis() < 5000) {
    x = analogRead(sensorPinx);
    y = analogRead(sensorPiny);

    // record the maximum sensor value for x
    if (x > xMax) {
      xMax = x;
    }
    // record the maximum sensor value for y
    if (y > yMax) {
      yMax = y;
    }

    // record the minimum sensor value for x
    if (x < xMin) {
      xMin = x;
    }
    // record the minimum sensor value for y
    if (y < yMin) {
      yMin = y;
    }
  }

  // signal the end of the calibration period
  digitalWrite(13, LOW);
}
delay(1000);  // wait for a second
// calibration du point central
// la LED clignote pendant 5 secondes, laisser le joystick au point central
while (millis() < 5000) {
void loop() {
  
  digitalWrite(13, LOW);   // turn the LED off (low is the voltage level)
  delay(500);              // wait for a half second
  xmed = xmed + analogRead(sensorPinx);
  ymed = ymed + analogRead(sensorPiny);
  digitalWrite(13, HIGH);    // turn the LED on by making the voltage high
  delay(500);              // wait for a half second
}
digitalWrite(13, LOW);  // turn the LED off by making the voltage LOW
xmed = xmed/5;
ymed = ymed/5;
xmed = map(xmed, xMin, xMax, -128, 128);
ymed = map(ymed, yMin, yMax, -128, 128);
}
// fin de la calibration du point central
// normalement, xmed et ymed doivent être voisins de 0

void loop() {
  // read the sensor x:
  x = analogRead(sensorPinx);

  // apply the calibration to the sensor reading
  x = map(x, xMin, xMax, -128, 128);

  
  
  // read the sensor y:
  y = analogRead(sensorPiny);

  // apply the calibration to the sensor reading
  y = map(y, yMin, yMax, -128, 128);

  

  
}

[Yvan_Delaserge]

Bon, ben on n'y est pas encore le compilateur retourne des erreurs. Je cite:

sketch_oct31d:76: error: expected constructor, destructor, or type conversion before '(' token
sketch_oct31d:79: error: expected unqualified-id before 'while'

Je vais tâcher de savoir ce qu'il entend par là.

[Yvan_Delaserge]

Voilà, j'ai repris la partie servant à étalonner le point central du joystick.

Maintenant, ça compile. Le microcode fait 2'028 octets.

L'Arduino lit les valeurs du joystick et les convertit à 'intérieur d'un intervalle allant de -128 à + 128.

// These constants won't change:
const int sensorPinx = A0;    // pin du pot x
const int sensorPiny = A1;    // pin du pot y
const int ledPin = 9;        // pin that the LED is attached to
const int blanc = 8;         // zone morte de part et d'autre du neutre

// variables:
int x = 0;         // the x value
int xmed = 0;          // valeur de x au neutre
int xmin = 1023;        // minimum x value
int xmax = 0;           // maximum x value
int y = 0;         // the y value
int ymed = 0;          // valeur de y au neutre
int ymin = 1023;        // minimum y value
int ymax = 0;           // maximum y value
void setup() {
  // turn on LED to signal the start of the calibration period:
  pinMode(13, OUTPUT);
  digitalWrite(13, HIGH);

  // calibrate during the first five seconds 
  while (millis() < 5000) {
    x = analogRead(sensorPinx);
    y = analogRead(sensorPiny);

    // record the maximum sensor value
    if (x > xmax) {
      xmax = x;
    }
    if (y > ymax) {
      ymax = y;
    }

    // record the minimum sensor value
    if (x < xmin) {
      xmin = x;
    }
    if (y < ymin) {
      ymin = y;
    }
  }
  // signal the end of the calibration period
  digitalWrite(13, LOW);
  
  // on attend une seconde
  delay(1000);
  
 // calibration du point central
 // la LED clignote pendant 5 secondes, laisser le joystick au point central  
  while (millis() < 5000) {
    digitalWrite(13, HIGH);
    delay(200);
    digitalWrite(13, LOW);
    x = analogRead(sensorPinx);
    y = analogRead(sensorPiny);

    // record the midpoint sensor value
    if (x > xmin) {
      xmed = x;
    }
    if (y > xmin) {
      ymed = y;
    }
    
  }
  // signal the end of the midpoint calibration period
  digitalWrite(13, LOW);

  
}

void loop() {
  // read the sensor:
  x = analogRead(sensorPinx);
  y = analogRead(sensorPiny);

  // apply the calibration to the sensor reading
  x = map(x, xmin, xmax, -128, 128);
  y = map(y, ymin, ymax, -128, 128);

  
}

On va voir maintenant comment touiller ces valeurs selon l'algorithme d'Antoane et finalement on va générer les signaux PWM et ceux servant à contrôler les deux relais.

Retour au tuto et aux exemples donnés dans le soft Arduino. Tout ça est remarquable de convivialité.

A plus,

Yvan

[invite2f313dba]

Merci beaucoup Yvan ! Vous m'aidez vraiment beaucoup !
Super pour le code. Je n'y serrai jamais arrivé !
Aller ! On continue ?!
Merci beaucoup !

Vincent A.

[Yvan_Delaserge]

Alors voilà les branchements:

sensorPinx = A0; // pin du pot x
sensorPiny = A1; // pin du pot y
ledPin = 13; // pin où est branchée la LED
relaisDPin = 2; // pin qui contrôle le relais droit
relaisGPin = 4; // pin qui contrôle le relais gauche
moteurDPin = 3; // pin qui contrôle le moteur droit
moteurGPin = 5; // pin qui contrôle le moteur gauche


Et voilà le code complet. Il compile bien. Pas d'erreurs.

Le microcode compilé fait 2'346 octets. (d'un max de 32'256 octets)

// These constants won't change:
const int sensorPinx = A0;    // pin du pot x
const int sensorPiny = A1;    // pin du pot y
const int ledPin = 13;        // pin that the LED is attached to
const int relaisDPin = 2;    // pin that controls the right relay
const int relaisGPin = 4;    // pin that controls the left relay
const int moteurDPin = 3;    // pin that controls the right motor
const int moteurGPin = 5;    // pin that controls the left motor
const int blanc = 8;         // zone morte de part et d'autre du neutre

// variables:
int x = 0;         // the x value
int xmed = 0;          // valeur de x au neutre
int xmin = 1023;        // minimum x value
int xmax = 0;           // maximum x value
int y = 0;         // the y value
int ymed = 0;          // valeur de y au neutre
int ymin = 1023;        // minimum y value
int ymax = 0;           // maximum y value

void setup() {
  // turn on LED to signal the start of the calibration period:
  pinMode(13, OUTPUT);
  digitalWrite(13, HIGH);

  // calibrate during the first five seconds 
  while (millis() < 5000) {
    x = analogRead(sensorPinx);
    y = analogRead(sensorPiny);

    // record the maximum sensor value
    if (x > xmax) {
      xmax = x;
    }
    if (y > ymax) {
      ymax = y;
    }

    // record the minimum sensor value
    if (x < xmin) {
      xmin = x;
    }
    if (y < ymin) {
      ymin = y;
    }
  }
  // signal the end of the calibration period
  digitalWrite(13, LOW);

  // on attend une seconde
  delay(1000);

  // calibration du point central
  // la LED clignote pendant 5 secondes, laisser le joystick au point central  
  while (millis() < 5000) {
    digitalWrite(13, HIGH);
    delay(200);
    digitalWrite(13, LOW);
    x = analogRead(sensorPinx);
    y = analogRead(sensorPiny);

    // record the midpoint sensor value
    if (x > xmin) {
      xmed = x;
    }
    if (y > xmin) {
      ymed = y;
    }

  }
  // signal the end of the midpoint calibration period
  digitalWrite(13, LOW);

  // initialize the relay pin as an output:
  pinMode(relaisDPin, OUTPUT);

}

void loop() {
  // read the sensor:
  x = analogRead(sensorPinx);
  y = analogRead(sensorPiny);

  // apply the calibration to the sensor reading
  x = map(x, xmin, xmax, -128, 128);
  y = map(y, ymin, ymax, -128, 128);

  // if x+y is >0, turn right motor relay on :
  if (x+y > 0) {
    digitalWrite(relaisDPin, HIGH);
  } 
  else {
    digitalWrite(relaisDPin,LOW); 
  }

  delay(1);        // delay in between reads for stability

  // if y-x is >0, turn left motor relay on :
  if (y-x > 0) {
    digitalWrite(relaisGPin, HIGH);
  } 
  else {
    digitalWrite(relaisGPin,LOW); 
  }

  delay(1);        // delay in between reads for stability 

  // calculer le signal PWM pour les moteurs
  int moteurdroit = y - x ;
  int moteurgauche = y + x ; 
  
  // in case moteurdroit or moteurgauche are outside the range
  moteurdroit = constrain(-128, 0, 128);
  moteurgauche = constrain(-128, 0, 128);
  
  // send PWM to the motors
  analogWrite(moteurDPin, moteurdroit);
  analogWrite(moteurGPin, moteurgauche);

}

Il manque encore la gestion de la zone morte autour du point central de repos du joystick.

La suite au prochain numéro...A moins que je sois grillé par quelqu'un d'autre?

Amicalement,

Yvan

[invite2f313dba]

Oh la la ! Merci beaucoup ! Encore une fois
Juste, à un moment, tu initialise "relaisDpin" comme une output, mais pas "relaisGpin" ?
En tout cas, c'est une très bonne idée le truc de la led qui clignote pour aider à l'étalonnage. Juste à bien s'en souvenir !
Je vais acheter le maths cette après-midi. Concernant les relais et les transistors ? Auriez-vous une référence précise ? Je fais mes recherches de mon coté, et je reviens dès que j'ai quelque chose de convainquant.
Encore mmeeerrrciiii !
Vincent A.

[invite2f313dba]

Matos* !

Donc, j'ai pu me procurer un joystick. Comme prévus, c'est deux potars. J'ai à ma disposition une alim de 5v (5,22 volts en réel). J'ai fait des tests, on a bien : joystick à fond à gauche (ou à droite) on a 0v ; au neutre, on a ~2,5v ; et à fond à droite (ou a gauche) on a 5v.

Cordialement

Vincent A

[Yvan_Delaserge]

Matos* !

Donc, j'ai pu me procurer un joystick. Comme prévus, c'est deux potars. J'ai à ma disposition une alim de 5v (5,22 volts en réel). J'ai fait des tests, on a bien : joystick à fond à gauche (ou à droite) on a 0v ; au neutre, on a ~2,5v ; et à fond à droite (ou a gauche) on a 5v.

Cordialement

Vincent A

Ah bon?

Mais il pivote de combien de degrés de chaque coté le manche du joystick?
Tu peux nous montrer une photo?

[invite5c0d525e]

Ah bon?

Mais il pivote de combien de degrés de chaque coté le manche du joystick?
Tu peux nous montrer une photo?

Je vois pas ce que l'excursion du manche en degrés vient faire là dedans, un joystick qui te sort de 0 à 5V il n'y a rien de plus normal.

[Yvan_Delaserge]

Oh la la ! Merci beaucoup ! Encore une fois
Juste, à un moment, tu initialise "relaisDpin" comme une output, mais pas "relaisGpin" ?
En tout cas, c'est une très bonne idée le truc de la led qui clignote pour aider à l'étalonnage. Juste à bien s'en souvenir !
Je vais acheter le maths cette après-midi. Concernant les relais et les transistors ? Auriez-vous une référence précise ? Je fais mes recherches de mon coté, et je reviens dès que j'ai quelque chose de convainquant.
Encore mmeeerrrciiii !
Vincent A.

Bien vu vinvin. J'avais en effet oublié cette ligne.
On aura donc:

// initialize the relay pin as an output:
pinMode(relaisDPin, OUTPUT);
pinMode(relaisGPin, OUTPUT);


D'autre part, comme Antoane l'avait indiqué dès le départ, il y a deux possibilités de traitement pour le résultat de la somme x+ y, respectivement y-x:

1) soit on sature à la valeur maximale, au cas où celle-ci est dépassée,

Et on a peu de progressivité, mais on dispose de la puissance complète des deux moteurs lorsque l'on positionne le joystick en "avant toute" ou "arrière toute". C'est bien si on recherche la vitesse.

// apply the calibration to the sensor reading
x = map(x, xmin, xmax, -128,128);
y = map(y, ymin, ymax, -128,128);

2) soit on s'arrange pour rester dans les limites autorisées, mais dans ce cas, avec le manche en avant toute ou en arrière toute, les deux moteurs sont à demi-puissance. Mais on a une excellente progressivité dans tout le champ de valeurs x et y. C'est mieux pour manoeuvrer.

Pour cela, il suffit de faire aller les valeurs de x et de y de -64 à + 64

// apply the calibration to the sensor reading
x = map(x, xmin, xmax, -64, 64);
y = map(y, ymin, ymax, -64, 64);

et ensuite, comme on additionne x et y,
on va avoir des valeurs qui pourront aller de -128 à + 128.

Mais pour calculer le signal PWM, selon la doc page 273:
PWM2.jpg

Il faut que l'argument de analogwrite soit compris entre 0 et 255. Pas entre -128 et + 128.

Il faut donc modifier les deux lignes concernées comme suit:

// in case moteurdroit or moteurgauche are outside the range
moteurdroit = constrain(moteurdroit, 0, 255);
moteurgauche = constrain(moteurgauche, 0, 255);

Voilà encore quelques bugs d'éliminés.

// These constants won't change:
const int sensorPinx = A0;    // pin du pot x
const int sensorPiny = A1;    // pin du pot y
const int ledPin = 13;        // pin that the LED is attached to
const int relaisDPin = 2;    // pin that controls the right relay
const int relaisGPin = 4;    // pin that controls the left relay
const int moteurDPin = 3;    // pin that controls the right motor
const int moteurGPin = 5;    // pin that controls the left motor
const int blanc = 8;         // zone morte de part et d'autre du neutre

// variables:
int x = 0;         // the x value
int xmed = 0;          // valeur de x au neutre
int xmin = 1023;        // minimum x value
int xmax = 0;           // maximum x value
int y = 0;         // the y value
int ymed = 0;          // valeur de y au neutre
int ymin = 1023;        // minimum y value
int ymax = 0;           // maximum y value

void setup() {
  // turn on LED to signal the start of the calibration period:
  pinMode(13, OUTPUT);
  digitalWrite(13, HIGH);

  // calibrate during the first five seconds 
  while (millis() < 5000) {
    x = analogRead(sensorPinx);
    y = analogRead(sensorPiny);

    // record the maximum sensor value
    if (x > xmax) {
      xmax = x;
    }
    if (y > ymax) {
      ymax = y;
    }

    // record the minimum sensor value
    if (x < xmin) {
      xmin = x;
    }
    if (y < ymin) {
      ymin = y;
    }
  }
  // signal the end of the calibration period
  digitalWrite(13, LOW);

  // on attend une seconde
  delay(1000);

  // calibration du point central
  // la LED clignote pendant 5 secondes, laisser le joystick au point central  
  while (millis() < 5000) {
    digitalWrite(13, HIGH);
    delay(200);
    digitalWrite(13, LOW);
    x = analogRead(sensorPinx);
    y = analogRead(sensorPiny);

    // record the midpoint sensor value
    if (x > xmin) {
      xmed = x;
    }
    if (y > xmin) {
      ymed = y;
    }

  }
  // signal the end of the midpoint calibration period
  digitalWrite(13, LOW);

  // initialize the relay pin as an output:
  pinMode(relaisDPin, OUTPUT);
  pinMode(relaisGPin, OUTPUT);

}

void loop() {
  // read the sensor:
  x = analogRead(sensorPinx);
  y = analogRead(sensorPiny);

  // apply the calibration to the sensor reading
  x = map(x, xmin, xmax, -64, 64);
  y = map(y, ymin, ymax, -64, 64);

  // if x+y is >0, turn right motor relay on :
  if (x+y > 0) {
    digitalWrite(relaisDPin, HIGH);
  } 
  else {
    digitalWrite(relaisDPin,LOW); 
  }

  delay(1);        // delay in between reads for stability

  // if y-x is >0, turn left motor relay on :
  if (y-x > 0) {
    digitalWrite(relaisGPin, HIGH);
  } 
  else {
    digitalWrite(relaisGPin,LOW); 
  }

  delay(1);        // delay in between reads for stability 

  // calculer le signal PWM pour les moteurs
  int moteurdroit = y - x; 
  int moteurgauche = y + x ; 
  
  // in case moteurdroit or moteurgauche are outside the range
  moteurdroit = constrain(moteurdroit, -128, 128);
  moteurgauche = constrain(moteurgauche, -128, 128);
  
  // on transpose les valeurs, car les agrs de analogwrite doivent être >=0
  moteurdroit = map(moteurdroit,-128,128,0,255);
  moteurgauche = map(moteurgauche,-128,128,0,255);
  
  // in case moteurdroit or moteurgauche are outside the range
  moteurdroit = constrain(moteurdroit, 0, 255);
  moteurgauche = constrain(moteurgauche, 0, 255);
 
  // send PWM to the motors
  analogWrite(moteurDPin, moteurdroit);
  analogWrite(moteurGPin, moteurgauche);

}

On a encore quelques semaines pour trouver s'il y en a d'autres. Je devrais recevoir mon Arduino pas avant un mois.

Dommage qu'il n'existe pas de simulateur (à ma connaissance) pour voir comment le programme tourne. La vérification ne concerne que la syntaxe.

Et le debugger n'est pas toujours explicite.

Tel quel, le programme compile bien. Il retourne le message:
Taille binaire du croquis*: 2'418 octets (d'un max de 32'256 octets)

Mais si pour voir, je supprime un point-virgule, voici la réponse du compilateur:
DEBUG.jpg
D'une part, il met en surbrillance la ligne APRES celle où se situe l'erreur.
Il me dit bien qu'il manque une virgule ou un point-virgule avant INT
Mais il me dit aussi que moteurgauche n'a pas été déclaré, ce qui est faux.

[Yvan_Delaserge]

Pour le matos, on en a parlé au message#39:

Pour les sorties PWM et pour commuter les relais, des logic FET IRLZ 44N

Pour les relais eux-mêmes, on peut prendre ceci:


disponible ici:

http://www.ebay.com/itm/OMROM-LY2NJ-...item5667c8f5f6

Amicalement,

Yvan

[invite2f313dba]

Le joystick que j'ai récupéré (sur un joystick de pc) pivote de 30° de chaque coté du neutre.
Ensuite concernant les calculs. Peut-on pas utiliser un compromis ? Cela serra intéressant d'avoir de la puissance sous la main tout en gardant un peu de précision. Dans ce cas, peut être utiliser la 2eme solution, mais je risque de manquer de puissance, et, donc, de pèche.
Ok, pour les relais, il faut juste utiliser un simple relais qui puisse être commander par 5v de toute façon ? Ok, pour les transistors. Juste une question au passage, je sais que ça n'a pas de rapport avec ce que l'on est entrain de faire, mais un transistor, c'est aussi en tout-ou-rien ?
Aller ! On ne se démotive pas. On continue ! Dès que j'aurai mon arduino, je commencerai a faire les teste !
Merci bien à tous !
Vincent A.

[Yvan_Delaserge]

Le joystick que j'ai récupéré (sur un joystick de pc) pivote de 30° de chaque coté du neutre.

C'est pour ça que ça me surprend. Dans un joystick, on n'utilise pas la totalité de la piste du potentiomètre (rotation max. de 270 degrés environ). Donc le curseur ne peut pas balayer de 0 à 5 V. Dans ton joystick, le curseur ne peut parcourir que 60/270 = 22 % de la piste résistive. On n'aura donc pas 100 % de 5 V, mais 22 % seulement.

Ensuite concernant les calculs. Peut-on pas utiliser un compromis ? Cela serra intéressant d'avoir de la puissance sous la main tout en gardant un peu de précision. Dans ce cas, peut être utiliser la 2eme solution, mais je risque de manquer de puissance, et, donc, de pèche.

On peut trouver une solution intermédiaire, il suffira d'agir sur le mapping et attibuer une valeur intermédiaire entre 64 et 128.

Ok, pour les relais, il faut juste utiliser un simple relais qui puisse être commander par 5v de toute façon ?

Je dirais plutôt sous 12 V comme les moteurs, comme ça on ne charge pas trop le régulateur 5 V

Ok, pour les transistors. Juste une question au passage, je sais que ça n'a pas de rapport avec ce que l'on est entrain de faire, mais un transistor, c'est aussi en tout-ou-rien ?

On peut faire tout ou rien mais on peut aussi faire progressif. ça dépend du reste du circuit, qui entoure le transistor.

Aller ! On ne se démotive pas. On continue ! Dès que j'aurai mon arduino, je commencerai a faire les teste !
Merci bien à tous !
Vincent A.

[Antoane]

Bonsoir,

Après lecture (rapide) des derniers post et du code post 82 :

Post 77 : il n'y a pas de résistance en série avec la led, je ne sais pas si c'est un oubli ou si elle est intégrée à la carte.

Inutile de trop sur-dimensionner les relais (surtout au niveau du nombre de contacts), c'est gros et consomme pour rien.
Il vaut effectivement mieux les câbler sur le 12V pour limiter la consommation et les problèmes de compatibilité (bruit de commutation qui remonterait jusqu'au µC via l'alim).

La fonction millis() n'est, si je ne m'abuse pas initialisée. Il faut donc écrire un truc du genre :
variablerouge = millis();
variablerouge += 5000;
while(millis() < variablerouge) { } ;

J'ai du mal avec cette fonction :

 // calibration du point central 
// la LED clignote pendant 5 secondes, laisser le joystick au point central 
while (millis() < 5000) { 
    digitalWrite(13, HIGH); 
    delay(200);    
    digitalWrite(13, LOW); 
//ici il faut un delay() sans quoi la led paraitra tjs allumée.
    x = analogRead(sensorPinx); 
    y = analogRead(sensorPiny); 

    // record the midpoint sensor value 
    if (x > xmin) {  // c'est tjs le cas puisqu'on vient de calibrer x
        xmed = x; 
    } 
    if (y > xmin) { // idem ci-dessous + erreur de copier-coller : y>ymin.
        ymed = y; 
    }
}

Tu parcours la boucle 25 en mettant à jour xmed à chaque fois... Autant ne la parcourir qu'une fois.
Mon algorithme utilisait une boucle pour faire un moyennage sur ces n valeurs échantillonnées.


Concernant le 'débat' : que faire lorsque x+y>1 (je reste en valeurs normalisées ) :
- tronquer |x+y| à 1 fait que le rayon de braquage minimal (virage serré) en haute vitesse sera plus grand que celui en basse vitesse (plus grand rayon de bracage) -- c'est pas nécessairement un mal ;
- prendre PWMmoteur = (x+y)/2 permet d'assurer que la vitesse du milieu de l'axe des roues du robot aura une vitesse fonction uniquement de x. C'est propre, mais faut bien avouer que ça n'apporte pas grand chose tandis que ça coute énormément : la vitesse max du centre du robot est divisée par deux.

[Yvan_Delaserge]

Bonsoir,

Après lecture (rapide) des derniers post et du code post 82 :

Post 77 : il n'y a pas de résistance en série avec la led, je ne sais pas si c'est un oubli ou si elle est intégrée à la carte.

Bien vu Antoane!
J'en profite pour publier le schéma complet.

Inutile de trop sur-dimensionner les relais (surtout au niveau du nombre de contacts), c'est gros et consomme pour rien.

J'ai pris les DPDT 12 V les moins chers que j'ai trouvé sur E**y!

Il vaut effectivement mieux les câbler sur le 12V pour limiter la consommation et les problèmes de compatibilité (bruit de commutation qui remonterait jusqu'au µC via l'alim).


Concernant le 'débat' : que faire lorsque x+y>1 (je reste en valeurs normalisées ) :
- tronquer |x+y| à 1 fait que le rayon de braquage minimal (virage serré) en haute vitesse sera plus grand que celui en basse vitesse (plus grand rayon de bracage) -- c'est pas nécessairement un mal ;
- prendre PWMmoteur = (x+y)/2 permet d'assurer que la vitesse du milieu de l'axe des roues du robot aura une vitesse fonction uniquement de x. C'est propre, mais faut bien avouer que ça n'apporte pas grand chose tandis que ça coute énormément : la vitesse max du centre du robot est divisée par deux.

Il suffirait de choisir une valeur = 64 si on ne veut pas tronquer, 128 si on veut tronquer ou intermédiaire sur ces deux lignes:

// apply the calibration to the sensor reading
x = map(x, xmin, xmax, -64, 64);
y = map(y, ymin, ymax, -64, 64);

Je pensais essayer une valeur intermédiaire entre 64 et 128 au début, puis voir ce qui convient le mieux.

OK pour les autres remarques sur le soft. A tout-à-l'heure après un bon dîner!

[Yvan_Delaserge]

Concernant le 'débat' : que faire lorsque x+y>1 (je reste en valeurs normalisées ) :
- tronquer |x+y| à 1 fait que le rayon de braquage minimal (virage serré) en haute vitesse sera plus grand que celui en basse vitesse (plus grand rayon de bracage) -- c'est pas nécessairement un mal ;

Illustration de la fonction y+x et y-x par le tableau siivant:ALGOANTO.jpg

Comme certaines valeurs sont supérieures à 1, on les plafonne à 1, ce qui donne ceci:

ALGOANT2.jpg

- prendre PWMmoteur = (x+y)/2 permet d'assurer que la vitesse du milieu de l'axe des roues du robot aura une vitesse fonction uniquement de x. C'est propre, mais faut bien avouer que ça n'apporte pas grand chose tandis que ça coute énormément : la vitesse max du centre du robot est divisée par deux.

Illustration par le tableau suivant:ALGANTOMOITIE.jpg

[Yvan_Delaserge]

La fonction millis() n'est, si je ne m'abuse pas initialisée. Il faut donc écrire un truc du genre :
variablerouge = millis();
variablerouge += 5000;
while(millis() < variablerouge) { } ;

Apparemment, ce n'est pas nécessaire. J'ai pompé le code (eh oui!)directement de l'exemple "calibration" qui est inclus dans le soft de programmation de l'Arduino. Et puis s'il y avait un problème d'initialisation, le compilateur ne l'accepterait pas.

J'ai du mal avec cette fonction :

 // calibration du point central 
// la LED clignote pendant 5 secondes, laisser le joystick au point central 
while (millis() < 5000) { 
    digitalWrite(13, HIGH); 
    delay(200);    
    digitalWrite(13, LOW); 
//ici il faut un delay() sans quoi la led paraitra tjs allumée.
    x = analogRead(sensorPinx); 
    y = analogRead(sensorPiny); 

    // record the midpoint sensor value 
    if (x > xmin) {  // c'est tjs le cas puisqu'on vient de calibrer x
        xmed = x; 
    } 
    if (y > xmin) { // idem ci-dessous + erreur de copier-coller : y>ymin.
        ymed = y; 
    }
}

Tu as raison. Je rajoute le second delay et je corrige l'erreur de copier-coller.

Tu parcours la boucle 25 en mettant à jour xmed à chaque fois... Autant ne la parcourir qu'une fois.
Mon algorithme utilisait une boucle pour faire un moyennage sur ces n valeurs échantillonnées.

Tu as raison. Je voulais faire une moyenne, mais j'ai oublié!

Voici le code corrigé:

// calibration du point central
// la LED clignote pendant 5 secondes, laisser le joystick au point central
while (millis() < 5000) {
digitalWrite(13, HIGH);
delay(250);

x = analogRead(sensorPinx);
y = analogRead(sensorPiny);

// record the midpoint sensor value
xmed = xmed + x;
ymed = ymed + y;
digitalWrite(13, LOW);
delay(250);
}
// signal the end of the midpoint calibration period
digitalWrite(13, LOW);
xmed = xmed / 10;
ymed = ymed / 10;

On parcourt 10 fois la boucle en incrémentant xmed et ymed. Puis on sort de la boucle après 5000 millisecondes et on divise xmed et ymed par 10.

Je ne suis pas sûr que le second digitalWrite(13, LOW); soit indispensable, mais je le laisse.

Eh bien voilà encore une brassée de bugs corrigés. Merci Antoane!

Bonne soirée

Yvan

[invite2f313dba]

Salut, salut !
Donc si on fait la liste des courses :
- Deux relais DPDT
- Deux transistor (?) IRLZ44N
- Une diode 1N 5822
- Une diode (?) 4148

La LED et les résistance, j'ai. Qui n'a pas ça dans son garage ?
Concernant le matos, tout est ok. Parlons du code !
Ensuite, selon vous, vers quelle alimentation 12v devrais-je me tourner pour alimenter ces deux petits moteurs ? Sans cramer les transistors ni rien.
Merci encore à vous !

Vincent A.