- Arduino commandé par Joystick -

[Antoane]

Bonjour,
Le L298 est effectivement protégé contre les sur-chauffes. http://www.st.com/st-web-ui/static/a...CD00000240.pdf

Le TB6560 de Toshiba, qui utilise des MOSFET. Mais c'est un hybride. Je me demande s'il existe l'équivalent du L298 avec des MOSFET. Je vais faire quelques recherches.

https://www.toshiba.com/taec/compone...E_EN_27885.pdf
C'est un hybride, et alors ? C'est plutôt signe de qualité (ou en tout cas de truc cher), le process alliant MOS et Bipolaire coûtant plus cher que le tout CMOS ou tout bipolaires.

Il faudra un driver comme sur ce schéma
http://letsmakerobots.com/files/userpics/u152/FET_3.jpg

Sans condensateur de bootstrap, ça risque de pas très bien fonctionner.

-----

[freepicbasic]

Sans condensateur de bootstrap, ça risque de pas très bien fonctionner.

+1

Je ne pouvais pas mettre de lien sur l'intérieur du pdf LOL
Il y est sur le datasheet.
Et il y a des IRFZ44 dans l'exemple du datasheet.

[vinvin69]

Non, il veux dire qu'il ne comprend pas comment tu fonctionnes...

Le monsieur attend la fin du code que tu lui promets pour faire fonctionner les deux relais et les quatre transistors que tu lui as fait acheter. Tes élucubrations sur le L298 il s'en tape comme de l'an 40.

Bonjour à tous !

Bon... Je vous ai définitivement perdu je crois là. Quelqu'un pour m'aider à finir mon tout petit montage "tout simple" ?
Merci bien !

Vincent A.

[Antoane]

Hej,
pas d'inquiétude, on discute entre nous de pont en H intégrés, mais tu n'as pas absolument besoin de suivre -- puisque tu es partis sur des relais, restes-y

Yvan devrait s'occuper de la suite du programme à un moment ou à un autre, mais il part de zéro, ca risque de demander encore un peu de temps et de bugs

[Yvan_Delaserge]

http://letsmakerobots.com/files/userpics/u152/FET_3.jpg

Je me demande ce qu'ils ont utilisé pour dessiner ce schéma? C'est fait à main levée, ou bien c'est généré par un soft "organique"?
ça existe, c'est un algorithme darwinien. ça génère un circuit avec une fonction random, puis ça simule, on élimine si c'est pas bon, on garde si c'est bon et petit à petit ça converge vers quelque chose qui fonctionne.

En tout cas, je sais que ça existe pour le design d'antennes. Peut-être aussi pour les circuits électroniques?

[vinvin69]

Salut salut !
Ouai, je compte rester sur les relais. Mais le code qu'Yvan élabore est pour vos ponts en H integrés, et pas pour mes petits relais et simples transistors.
Aussi. Quand je téléverse mon code sur l'Arduino et que je le lance. La led s'allume 3 secondes puis elle s'arrête. Alors que d'après le code, elle devrait s'allumer 2 fois. Une idée ?
Je finis mon projet, et après je vous laisse tranquille !
Merci !

Vincent A.

[Yvan_Delaserge]

Salut salut !
Ouai, je compte rester sur les relais. Mais le code qu'Yvan élabore est pour vos ponts en H integrés, et pas pour mes petits relais et simples transistors.
Aussi. Quand je téléverse mon code sur l'Arduino et que je le lance. La led s'allume 3 secondes puis elle s'arrête. Alors que d'après le code, elle devrait s'allumer 2 fois. Une idée ?
Je finis mon projet, et après je vous laisse tranquille !
Merci !

Vincent A.

Négatif. La dernière mouture était pour un système à relais (-Davidson). Tel quel ça devrait fonctionner, il manque juste la production de la zone morte au voisinage du point de repos du joystick.
J'ai pas eu trop le temps de m'en occuper dernièrement, à cause d'obligations de toutes sortes.

Amicalement,

Yvan

[vinvin69]

Salut Yvan !
Tu peux juste m'aider pour faire cette dernière action pour finaliser le projet ? Merci bien à toi !
Par contre, concernant la led, tu as une idée ?
Cordialement,

Vincent A.

[Yvan_Delaserge]

Salut Yvan !
Tu peux juste m'aider pour faire cette dernière action pour finaliser le projet ? Merci bien à toi !
Par contre, concernant la led, tu as une idée ?
Cordialement,

Vincent A.

Tu n'as pas publié ton code.

[vinvin69]

Bonsoir,

Cela correspond à ça :


// 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(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;
// 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 ;

// on sature à 128 le cas échéant
moteurdroit = constrain(moteurdroit, -128, 128);
moteurgauche = constrain(moteurgauche, -128, 128);

// on calcule la valeur absolue
moteurdroit = abs(moteurdroit);
moteurgauche = abs(moteurgauche);

// on transpose les valeurs, car les agrs de analogwrite doivent être entre 0 et 255
moteurdroit = map(moteurdroit,0,128,0,255);
moteurgauche = map(moteurgauche,0,128,0,255);

// send PWM to the motors
analogWrite(moteurDPin, moteurdroit);
analogWrite(moteurGPin, moteurgauche);

}

Merci bien !

[Yvan_Delaserge]

La led s'allume 3 secondes puis elle s'arrête. Alors que d'après le code, elle devrait s'allumer 2 fois. Une idée ?

Ah, tu voulais dire MON code! Je croyais que tu parlais d'essais de code que tu avais faits toi-même.

Les lignes qui allument et éteignent la LED sont les suivantes:
// 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(250);

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

// record the midpoint sensor value
xmed = xmed + x;
ymed = ymed + y;
digitalWrite(13, LOW);
delay(250);
}

La LED devrait donc s'allumer pendant 5 secondes, puis s'éteindre pendant une seconde et ensuite clignoter pendant 5 secondes à une fréquence de 2 Hz.

Si ça ne fait pas ça, je ne comprends pas pourquoi! A moins que les instructions digitalwrite, analogread, etc, ne prennent un temps disproportionné. Il faudrait essayer de les virer et voir ce que ça donne.

Il faudra que je fasse des essais dès que j'aurai reçu mes Arduinos.

De ton côté, puisque tu as déjà le tien, essaie de faire tourner les programmes d'exemple simples et regarde ce que ça donne. Il y a aussi des manips intéressantes sur le tutorial signalé en début de ce fil.

[freepicbasic]

Pourquoi y a t il 2 fois ;

while (millis() < 5000) {

l'un derrière l'autre le second ne s'effectuera jamais!

ou Alors on met;

while (millis() <10000) {

Pour le second


http://arduino.cc/en/reference/millis

[vinvin69]

Bonjour, bonjour !
Ouai, effectivement, j'ai utilisé ton code. J'espère que ça te derange pas !?
J'ai essayé de mettre le second "digitalWrite(13, HIGH);" avant le "while (millis() < 5000) {". Dans ce cas, la led s'allume 5 secondes puis elle s'allume +/- 10msecs. Et elle s'éteint. J'ai fait des test en remplacent les relais par des leds, tout fonctionne comme prévus. J'ai un petit problème avec le joystick, mais je vais régler ça !
Merci

[Yvan_Delaserge]

Champion freepicbasic! Selon la doc, millis Returns the number of milliseconds since the Arduino board began running the current program.

autrement dit, il compte le nombre de millisecondes depuis le début de l'exécution du programme! Moi je pensais que c'était depuis le moment où il rencontre la fonction millis. Tout s'explique. J'avais simplement copié-collé deux millis l'une après l'autre.

Comme quoi, on devrait toujours lire toute la doc! Shame on me!

Donc pour le 2e millis, je vais mettre while (millis() < 11000) {

Parce qu'il y a encore l'attente d'une seconde entre la calibration des max-min et celle du point milieu.

En fait, il y aurait peut-être moyen de simplifier tout ça en prenant un point de repos du joystick à mi-chemin entre max et min. ça dépend de la linéarité du potentiomètre.

L'angle maximum de rotation d'un potentiomètre est de 265 degrés.
POT.gif

Mais le joystick ne peut pivoter que de + ou - 20 degrés. 40 degrés au total.
POTROT.gif
Donc une rotation de seulement 15 % du total.
Si le potentiomètre est alimenté en 5 V, on aura entre la rotation max. et min. du potentiomètre 15% de 5 V = 750 mV.
Le pas de l'ADC de l'Arduino est d'un peu plus de 8 mV. On aura donc environ 90 pas. Un pas = environ 1 %.

La linéarité d'un potentiomètre bon marché comme ceux utilisés dans les potentiomètres est de + ou - 5 %.
LINEARIT.gif

Ce qui veut dire que le point milieu de la course du potentiomètre au lieu de se trouver à mi-chemin entre V min et V max, C'est à-dire à V min +375 mV, il peut se trouver n'importe où entre V min + 337,5 mV et V min + 412,5 mV.

Si on compte en pas de l'ADC, 75 mV/ 8 mV = un peu plus de 9 pas.

Comme de toutes manières, une zone morte au voisinage du point de repos du joystick est nécessaire, on pourrait la fixer comme étant égale à + ou - 5 pas de l'ADC. De cette manière, l'incertitude découlant de la non-linéarité du potentiomètre serait couverte.

En réalité, les + ou - 35 mV sont une situation pessimiste, car on n'utilise que 15 % de la piste du potentiomètre. Statistiquement, la non-linéarité devrait pouvoir être aussi basse que 15 % de + ou - 5 %, c'est-à-dire qu'on pourrait atteindre moins de + ou - 1 %. On pourrait après les premiers essais, revoir à la baisse la largeur de la zone morte.

Dans un premier temps, juste pour la beauté du geste, je fais la modif de millis, mais par la suite, on va simplifier.

Alors voici la modif que m'a soufflée freepicbasic. Merci à lui!

// 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() < 11000) {
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;

  // 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 ; 

  // on sature à 128 le cas échéant
  moteurdroit = constrain(moteurdroit, -128, 128);
  moteurgauche = constrain(moteurgauche, -128, 128);
  
  // on calcule la valeur absolue
  moteurdroit = abs(moteurdroit);
  moteurgauche = abs(moteurgauche);

  // on transpose les valeurs, car les agrs de analogwrite doivent être entre 0 et 255
  moteurdroit = map(moteurdroit,0,128,0,255);
  moteurgauche = map(moteurgauche,0,128,0,255);

    // send PWM to the motors
  analogWrite(moteurDPin, moteurdroit);
  analogWrite(moteurGPin, moteurgauche);

}

[vinvin69]

Oulala !
Ca marche mieux comme ça !
J'a fait des tests en remplacant les relais/moteurs par des leds, et tout marche. La led pour la calibration marche comme il faut. Il reste plus qu'a définir une zone morte de chaque coté du neutre. Si l'on regarde bien, le neutre n'est pas vraiment au milieu.
Merci bien encore à vous tous !
Vincent A.

[Yvan_Delaserge]

Que constates-tu au voisinage du point milieu?

[vinvin69]

Bah le neutre n'est pas au centre du joystick (à quelques degrés près). Aux alentours du neutre, le système réagit correctement. Les relais s'actionnent bien. Les moteurs s'actionnent bien. Donc plus qu'a définir la "marge" autour du neutre.

Vincent A.

[Yvan_Delaserge]

OK, alors j'ai ajouté la génération de la zone morte centrale au moyen de ces deux lignes:

//définition de la zone morte centrale
if (moteurdroit < 5) {
moteurdroit = 0;
}
if (moteurgauche < 5) {
moteurgauche = 0;
}

Le code complet devient:

// 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() < 11000) {
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;

  // 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 ; 

  // on sature à 128 le cas échéant
  moteurdroit = constrain(moteurdroit, -128, 128);
  moteurgauche = constrain(moteurgauche, -128, 128);
  
  // on calcule la valeur absolue
  moteurdroit = abs(moteurdroit);
  moteurgauche = abs(moteurgauche);
    
  //définition de la zone morte centrale  
    if (moteurdroit < 5) {
      moteurdroit = 0;
    }
    if (moteurgauche < 5) {
      moteurgauche = 0;
    }

  // on transpose les valeurs, car les agrs de analogwrite doivent être entre 0 et 255
  moteurdroit = map(moteurdroit,0,128,0,255);
  moteurgauche = map(moteurgauche,0,128,0,255);

    // send PWM to the motors
  analogWrite(moteurDPin, moteurdroit);
  analogWrite(moteurGPin, moteurgauche);

}

ça se compile bien. Essaie et dis-moi ce que ça donne. Si c'est satisfaisant, on pourra supprimer la phase de calibration du point de repos du joystick.

[vinvin69]

Merci Yvan.
Le code n'est pas concluant. Je remarque, qu'avec ce code, lorsque le joystick est au neutre, les leds représentant les moteur sont à 50%. Et lorsque je bouge le joystick de part et d'autre, la led s'éteind petit à petit puis elle s'allume de plus en plus lorsqu'on s'approche de la fin de course. Je pense que la zone morte est, avec ce code à 50% du PWM. Et lorsqu'on sort de cette zone, la led réagit correctement.
Where's the problem ?
Vincent A.

[Yvan_Delaserge]

Je pense que le problème doit venir du fait que j'interviens sur le signal destiné aux moteurs plutôt que sur le signal prélevé sur les potentiomètres. C'était plus facile à faire comme ça parce qu'en intervenant après le calcul de la valeur absolue, on n'avait besoin de tester que sur des valeurs positives.

Retour à la doc. Les trucs simples en apparence ne le sont jamais.

Je te tiens au courant.

En attendant, le code précédent semblait aller pas trop mal.

[vinvin69]

Okay ! Je vais ESSAYER de regarder de mon coté aussi.
Globalement on est pas très loin du but ! Samedi j'ai mes transistors, je commencerai à faire des tests "grandeur nature".
Allez ! Merci encore
Vincent A.

[Yvan_Delaserge]

Voilà, j'ai viré le test sur moteurdroit et moteurgauche.

j'interviens sur les lectures des 2 potentiomètres, x et y,
juste après avoir généré les commandes des relais et juste avant d'additionner (resp. de soustraire) y et x.

//définition de la zone morte centrale
if (x < blanc && x > - blanc) {
x = 0;
}
if (y < blanc && y > - blanc) {
y = 0;
}

blanc est définie tout en début de programme comme la largeur de la zone morte dans une direction donnée. Comme ça on n'a pas à intervenir à l'intérieur du programme.

Le code se compile sans problème, le voici:

// 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 = 5;         // 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() < 11000) {
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;

  // 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 
  
  //définition de la zone morte centrale
      if (x < blanc && x > - blanc) {
      x = 0;
    }
    if (y < blanc && y > - blanc) {
      y = 0;
    }

  // calculer le signal PWM pour les moteurs
  int moteurdroit = y - x; 
  int moteurgauche = y + x ; 

  // on sature à 128 le cas échéant
  moteurdroit = constrain(moteurdroit, -128, 128);
  moteurgauche = constrain(moteurgauche, -128, 128);
  
  // on calcule la valeur absolue
  moteurdroit = abs(moteurdroit);
  moteurgauche = abs(moteurgauche);
    
    // on transpose les valeurs, car les agrs de analogwrite doivent être entre 0 et 255
  moteurdroit = map(moteurdroit,0,128,0,255);
  moteurgauche = map(moteurgauche,0,128,0,255);

    // send PWM to the motors
  analogWrite(moteurDPin, moteurdroit);
  analogWrite(moteurGPin, moteurgauche);

}

Voilà, il n'y a plus qu'à essayer. Tiens-moi au courant.

[vinvin69]

Je viens d'essayer. C'est déjà plus concluant !
La zone morte n'est pas assez grande car au neutre, la led est légèrement allumé. Mais globalement, tout marche comme prévus !
Continuons !

[Yvan_Delaserge]

Ok, je double la largeur de la zone morte

// 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 = 10;         // 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() < 11000) {
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;

  // 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 
  
  //définition de la zone morte centrale
      if (x < blanc && x > - blanc) {
      x = 0;
    }
    if (y < blanc && y > - blanc) {
      y = 0;
    }

  // calculer le signal PWM pour les moteurs
  int moteurdroit = y - x; 
  int moteurgauche = y + x ; 

  // on sature à 128 le cas échéant
  moteurdroit = constrain(moteurdroit, -128, 128);
  moteurgauche = constrain(moteurgauche, -128, 128);
  
  // on calcule la valeur absolue
  moteurdroit = abs(moteurdroit);
  moteurgauche = abs(moteurgauche);
    
    // on transpose les valeurs, car les agrs de analogwrite doivent être entre 0 et 255
  moteurdroit = map(moteurdroit,0,128,0,255);
  moteurgauche = map(moteurgauche,0,128,0,255);

    // send PWM to the motors
  analogWrite(moteurDPin, moteurdroit);
  analogWrite(moteurGPin, moteurgauche);

}

Qu'est-ce que ça donne?

[vinvin69]

C'est tout bon ! Tout marche correctement !
Reste plus qu'a faire les "vrais" tests et c'est tout bon ! Merci !

[Yvan_Delaserge]

Yesssss!

[vinvin69]

Juste une petite question. Sur les transistors.
Comment je les cable ? Le pin de gauche sur l'arduino et les deux autres pour couper le 12v ?
Ou je pin du milieu pour l'arduino ? Ou le pin de droite pour l'arduino ?
Merci

[Yvan_Delaserge]

tu n'as pas la datasheet?

[vinvin69]

Heu... J'ai ça
Je vois pas où c'est marqué...
http://www.irf.com/product-info/data...ta/irlz44n.pdf

[Yvan_Delaserge]

dernière page