Castel'Lab le Fablab MJC de Château-Renault

Outils pour utilisateurs

Outils du site

Piste :
start:arduino:joystick

Différences

Ci-dessous, les différences entre deux révisions de la page.

Lien vers cette vue comparative

Les deux révisions précédentesRévision précédente
Prochaine révision		Révision précédente
start:arduino:joystick [2024/04/02 10:53] – [Comment fonctionne un joystick ?] gerardadminstart:arduino:joystick [2024/04/02 12:55] (Version actuelle) – [Utilisation de la manette Joystick avec Arduino] gerardadmin
Ligne 55: Ligne 55:
 Cela n'a pas d'importance puisque ce que nous lisons comme tension analogique n'est que la différence relative de tension.  Cela n'a pas d'importance puisque ce que nous lisons comme tension analogique n'est que la différence relative de tension. 
  
-Voyons le brochage d'un joystick couramment disponible.+=====Voyons le brochage d'un joystick couramment disponible.=====
  
  
Ligne 84: Ligne 84:
  
 Je recommande de prendre au moins 100 valeurs. Cela permet de supprimer le bruit et de choisir une meilleure valeur de correction de décalage. Je recommande de prendre au moins 100 valeurs. Cela permet de supprimer le bruit et de choisir une meilleure valeur de correction de décalage.
 +
 +=====Voyons l'étalonnage du potentiomètre de l'axe X. =====
 +
 +      * Gardez le joystick au ralenti (position centrale)
 +  *     Lisez la valeur analogique de l'ADC.
 +  *     Assurez-vous que la lecture est comprise entre 500 et 520. Ceci permet de garantir que la position de l'arbre est dans la position/l'état attendu.
 +  *     Continuez à ajouter les lectures à une variable.
 +  *     Répétez les étapes de 2 à 4 100 fois
 +  *     Calculer la moyenne (Somme totale / 100)
 +  *     Stockez la nouvelle valeur « moyenne ». 
 +
 +De même, vous pouvez calibrer le potentiomètre de l'axe X pour les positions finales. Suivez également les mêmes étapes pour le potentiomètre de l’axe Y.
 +
 +===== Comment connecter le module joystick avec Arduino UNO =====
 +
 +{{ :start:arduino:connect-the-analog-pin-a0-768x519.jpg?direct&600 |}}
 +
 +-1- Connectez l'une des broches GND de l'Arduino à la broche étiquetée « GND » sur le module joystick.
 +
 +J'insiste toujours pour démarrer les connexions en connectant d'abord les connexions GND.
 +
 +-2- La broche SEL peut également être étiquetée SW. Il s'agit de l'interrupteur momentané présent dans le module.
 +
 +N'oubliez pas d'activer le pullup interne sur cette broche. Connectez la broche SEL à la broche 6 de l'Arduino UNO.
 +
 +-3- Connectez la broche d'entrée analogique A1 de l'Arduino UNO à la broche marquée « HOR » du module. L'étiquette HOR est également connue sous le nom d'axe X/VRx, 
 +
 +-4- Connectez la broche analogique A0
 +
 +Connectez la broche d'entrée analogique A0 de l'Arduino UNO à la broche étiquetée « VER » du module. L'étiquette HOR est également connue sous le nom d'axe Y/VRy,
 +
 +-5- Connectez la broche du capteur étiquetée VCC à la broche Arduino 5 V. 
 +
 +
 +=====Programme Arduino contrôle servo avec joystick=====
 +
 +
 +<code c joystick001.ino>
 +#define pinX A1
 +
 +#include "Servo.h"
 +Servo servo1;
 +
 +void setup() {
 +   pinMode(pinX, INPUT);
 + 
 +   servo1.attach(12);
 +}
 + 
 +void loop() {
 +   int X = analogRead(pinX);
 +
 +   X = map(X, 0, 1023, 0, 180);
 +  
 +   servo1.write(X);
 +}
 +</code>
 +
 +=====Utilisation de la manette Joystick avec Arduino=====
 +
 +<code c joystick002.ino>
 +#include <LiquidCrystal_I2C.h>
 +//—– Adressage matériel —–
 +// En cas de non fonctionnement, mettez la ligne 8 en
 +// commentaire et retirez le commentaire à la ligne 9.
 +LiquidCrystal_I2C lcd(0x27, 20, 4);
 +
 +int VRx = A0;
 +int VRy = A1;
 +int SW = 2;
 +
 +int xPosition = 0;
 +int yPosition = 0;
 +int SW_state = 0;
 +int mapX = 0;
 +int mapY = 0;
 +
 +void setup() {
 +lcd.init(); // initialisation de l’afficheur
 +pinMode(VRx, INPUT);
 +pinMode(VRy, INPUT);
 +pinMode(SW, INPUT_PULLUP);
 +
 +}
 +
 +void loop() {
 +lcd.backlight();
 +lcd.clear(); // effacer le contenu de l’Afficheur LCD
 +xPosition = analogRead(VRx);
 +yPosition = analogRead(VRy);
 +SW_state = digitalRead(SW);
 +mapX = map(xPosition, 0, 1023, -512, 512);
 +mapY = map(yPosition, 0, 1023, -512, 512);
 +
 +if ((mapX>=-515)&& (mapX<=-510)&&(mapY>=-175)&& (mapY<=-168))
 +lcd.print("Avant");
 +if ((mapX>=168)&& (mapX<=175)&&(mapY>=-175)&& (mapY<=-168))
 +lcd.print("Arriere");
 +if ((mapX<=-166)&& (mapX>=-175)&&(mapY>=-515)&& (mapY<=-510))
 +lcd.print("Droite");
 +if ((mapX>=-175)&& (mapX<=-170)&&(mapY>=165)&& (mapY<=175))
 +lcd.print("Gauche");
 +if (SW_state==0)
 +lcd.print("Bouton appuye");
 +delay(1000);
 +}
 +</code>
 +
 +===== Contrôleur de joystick pour robot MeArm =====
 +
 +<code c joystick003.ino>
 +/* meArm analog joysticks version 1.3.1 - UtilStudio.com Dec 2018
 +   Uses two analogue joysticks and four servos.
 +
 +   In version 1.3 was improved  recording of coordinates.
 +   Some bugs was removed.
 +
 +   First joystick  moves gripper forwards, backwards, left and right,
 +   button start/stop recording  positions.
 +
 +   Second joystick moves gripper up, down, and closes and opens,
 +   button start/stop playing recorded positions.
 +   Press button for 2 seconds  to autoplay.
 +
 +   Pins:
 +   Arduino    Stick1    Stick2    Base   Shoulder  Elbow    Gripper   Record/
 +      GND       GND       GND    Brown     Brown   Brown     Brown    Auto play
 +       5V       VCC       VCC      Red       Red     Red       Red    LED
 +       A0       HOR
 +       A1       VER
 +       PD2      BUTT
 +       A2                 HOR
 +       A3                 VER
 +       PD3                BUTT
 +       11                       Yellow
 +       10                                 Yellow
 +        9                                         Yellow
 +        6                                                   Yellow
 +       PD4                                                            X
 +*/
 +#include  <Servo.h>
 +
 +bool repeatePlaying = false; /* Repeatedly is running recorded  cycle */
 +int delayBetweenCycles = 2000; /* Delay between cycles */
 +
 +int  basePin = 11;       /* Base servo */
 +int shoulderPin = 10;   /* Shoulder servo  */
 +int elbowPin = 9;       /* Elbow servo */
 +int gripperPin = 6;     /* Gripper  servo */
 +
 +int xdirPin = 0;        /* Base - joystick1*/
 +int ydirPin = 1;        /* Shoulder - joystick1 */
 +int zdirPin = 3;        /* Elbow - joystick2  */
 +int gdirPin = 2;        /* Gripper - joystick2 */
 +
 +//int pinRecord =  A4;     /* Button record - backward compatibility */
 +//int pinPlay = A5;       /*  Button play  - backward compatibility */
 +int pinRecord = PD2;     /* Button record  - recommended (A4 is deprecated, will by used for additional joystick) */
 +int  pinPlay = PD3;       /* Button play  - recommended (A5 is deprecated, will by used  for additional joystick) */
 +int pinLedRecord = PD4;  /* LED - indicates recording  (light) or auto play mode (blink one) */
 +
 +bool useInternalPullUpResistors  = false;
 +
 +const int buffSize = 512; /* Size of recording buffer */
 +
 +int  startBase = 90;
 +int startShoulder = 90;
 +int startElbow = 90;
 +int startGripper  = 0;
 +
 +int posBase = 90;
 +int posShoulder = 90;
 +int posElbow = 90;
 +int  posGripper = 0;
 +
 +int lastBase = 90;
 +int lastShoulder = 90;
 +int lastElbow  = 90;
 +int lastGripper = 90;
 +
 +int minBase = 0;
 +int maxBase = 150;
 +int  minShoulder = 0;
 +int maxShoulder = 150;
 +int minElbow = 0;
 +int maxElbow  = 150;
 +int minGripper = 0;
 +int maxGripper = 150;
 +
 +const int countServo  = 4;
 +int buff[buffSize];
 +int buffAdd[countServo];
 +int recPos = 0;
 +int  playPos = 0;
 +
 +int buttonRecord = HIGH;
 +int buttonPlay = HIGH;
 +
 +int  buttonRecordLast = LOW;
 +int buttonPlayLast = LOW;
 +
 +bool record = false;
 +bool  play = false;
 +bool debug = false;
 +
 +String command = "Manual";
 +int  printPos = 0;
 +
 +int buttonPlayDelay = 20;
 +int buttonPlayCount = 0;
 +
 +bool  ledLight = false;
 +
 +Servo servoBase;
 +Servo servoShoulder;
 +Servo servoElbow;
 +Servo  servoGripper;
 +
 +void setup() {
 +  Serial.begin(9600);
 +
 +  if (useInternalPullUpResistors)  {
 +    pinMode(pinRecord, INPUT_PULLUP);
 +    pinMode(pinPlay, INPUT_PULLUP);
 +  }
 +  else
 +  {
 +    pinMode(pinRecord, INPUT);
 +    pinMode(pinPlay, INPUT);
 +  }
 +
 +  pinMode(xdirPin, INPUT);
 +  pinMode(ydirPin, INPUT);
 +  pinMode(zdirPin,  INPUT);
 +  pinMode(gdirPin, INPUT);
 +
 +  pinMode(pinLedRecord, OUTPUT);
 +
 +  servoBase.attach(basePin);
 +  servoShoulder.attach(shoulderPin);
 +  servoElbow.attach(elbowPin);
 +  servoGripper.attach(gripperPin);
 +
 +  StartPosition();
 +
 +  digitalWrite(pinLedRecord,  HIGH);
 +  delay(1000);
 +  digitalWrite(pinLedRecord, LOW);
 +}
 +
 +void  loop() {
 +
 +  buttonRecord = digitalRead(pinRecord);
 +  buttonPlay = digitalRead(pinPlay);
 +
 +  //  Serial.print(buttonRecord);
 +  //  Serial.print("\ ");
 +  //  Serial.println(buttonPlay);
 +  //  for testing purposes
 +
 +  if (buttonPlay == LOW)
 +  {
 +    buttonPlayCount++;
 +
 +    if (buttonPlayCount >= buttonPlayDelay)
 +    {
 +      repeatePlaying = true;
 +    }
 +  }
 +  else buttonPlayCount = 0;
 +
 +  if (buttonPlay != buttonPlayLast)
 +  {
 +    if (record)
 +    {
 +      record = false;
 +    }
 +
 +    if  (buttonPlay == LOW)
 +    {
 +      play = !play;
 +      repeatePlaying = false;
 +
 +      if (play)
 +      {
 +        StartPosition();
 +      }
 +    }
 +  }
 +
 +  if (buttonRecord != buttonRecordLast)
 +  {
 +    if (buttonRecord == LOW)
 +    {
 +      record = !record;
 +
 +      if (record)
 +      {
 +        play  = false;
 +        repeatePlaying = false;
 +        recPos = 0;
 +      }
 +      else
 +      {
 +        if (debug) PrintBuffer();
 +      }
 +    }
 +  }
 +
 +  buttonPlayLast = buttonPlay;
 +  buttonRecordLast = buttonRecord;
 +
 +  float dx = map(analogRead(xdirPin), 0, 1023, -5.0, 5.0);
 +  float dy = map(analogRead(ydirPin),  0, 1023, 5.0, -5.0);
 +  float dz = map(analogRead(zdirPin), 0, 1023, 5.0, -5.0);
 +  float dg = map(analogRead(gdirPin), 0, 1023, 5.0, -5.0);
 +
 +  if (abs(dx)  < 1.5) dx = 0;
 +  if (abs(dy) < 1.5) dy = 0;
 +  if (abs(dz) < 1.5) dz = 0;
 +  if (abs(dg) < 1.5) dg = 0;
 +
 +  posBase += dx;
 +  posShoulder += dy;
 +  posElbow += dz;
 +  posGripper += dg;
 +
 +  if (play)
 +  {
 +    if (playPos  >= recPos) {
 +      playPos = 0;
 +
 +      if (repeatePlaying)
 +      {
 +        delay(delayBetweenCycles);
 +        StartPosition();
 +      }
 +      else
 +      {
 +        play = false;
 +      }
 +    }
 +
 +    bool endOfData =  false;
 +
 +    while (!endOfData)
 +    {
 +      if (playPos >= buffSize -  1) break;
 +      if (playPos >= recPos) break;
 +
 +      int data = buff[playPos];
 +      int angle = data & 0xFFF;
 +      int servoNumber = data & 0x3000;
 +      endOfData  = data & 0x4000;
 +
 +      switch (servoNumber)
 +      {
 +        case 0x0000:
 +          posBase = angle;
 +          break;
 +
 +        case 0x1000:
 +          posShoulder  = angle;
 +          break;
 +
 +        case 0x2000:
 +          posElbow =  angle;
 +          break;
 +
 +        case 0x3000:
 +          posGripper =  angle;
 +          dg = posGripper - lastGripper;
 +          break;
 +      }
 +
 +      playPos++;
 +    }
 +  }
 +
 +  if (posBase > maxBase) posBase = maxBase;
 +  if (posShoulder > maxShoulder) posShoulder = maxShoulder;
 +  if (posElbow >  maxElbow) posElbow = maxElbow;
 +  if (posGripper > maxGripper) posGripper = maxGripper;
 +
 +  if (posBase < minBase) posBase = minBase;
 +  if (posShoulder < minShoulder)  posShoulder = minShoulder;
 +  if (posElbow < minElbow) posElbow = minElbow;
 +  if (posGripper < minGripper) posGripper = minGripper;
 +
 +  servoBase.write(posBase);
 +  servoShoulder.write(posShoulder);
 +  servoElbow.write(posElbow);
 +
 +  bool  waitGripper = false;
 +  if (dg < 0) {
 +    posGripper = minGripper;
 +    waitGripper  = true;
 +  }
 +  else if (dg > 0) {
 +    posGripper = maxGripper;
 +    waitGripper  = true;
 +  }
 +
 +  servoGripper.write(posGripper);
 +  if (play && waitGripper)
 +  {
 +    delay(1000);
 +  }
 +
 +  if ((lastBase != posBase) | (lastShoulder  != posShoulder) | (lastElbow != posElbow) | (lastGripper != posGripper))
 +  {
 +    if (record)
 +    {
 +      if (recPos < buffSize - countServo)
 +      {
 +        int buffPos = 0;
 +
 +        if (lastBase != posBase)
 +        {
 +          buffAdd[buffPos] = posBase;
 +          buffPos++;
 +        }
 +
 +        if (lastShoulder != posShoulder)
 +        {
 +          buffAdd[buffPos]  = posShoulder | 0x1000;
 +          buffPos++;
 +        }
 +
 +        if (lastElbow  != posElbow)
 +        {
 +          buffAdd[buffPos] = posElbow | 0x2000;
 +          buffPos++;
 +        }
 +
 +        if (lastGripper != posGripper)
 +        {
 +          buffAdd[buffPos] = posGripper | 0x3000;
 +          buffPos++;
 +        }
 +
 +        buffAdd[buffPos - 1] = buffAdd[buffPos - 1] | 0x4000;
 +
 +        for (int i = 0; i < buffPos; i++)
 +        {
 +          buff[recPos  + i] = buffAdd[i];
 +        }
 +
 +        recPos += buffPos;
 +      }
 +    }
 +
 +    command = "Manual";
 +    printPos = 0;
 +
 +    if (play)
 +    {
 +      command = "Play";
 +      printPos = playPos;
 +    }
 +    else  if (record)
 +    {
 +      command = "Record";
 +      printPos = recPos;
 +    }
 +
 +    Serial.print(command);
 +    Serial.print("\ ");
 +    Serial.print(printPos);
 +    Serial.print("\ ");
 +    Serial.print(posBase);
 +    Serial.print("\ ");
 +    Serial.print(posShoulder);
 +    Serial.print("\ ");
 +    Serial.print(posElbow);
 +    Serial.print("\ ");
 +    Serial.print(posGripper);
 +    Serial.print("\ ");
 +    Serial.print(record);
 +    Serial.print("\ ");
 +    Serial.print(play);
 +    Serial.println();
 +  }
 +
 +  lastBase = posBase;
 +  lastShoulder = posShoulder;
 +  lastElbow = posElbow;
 +  lastGripper = posGripper;
 +
 +  if ( repeatePlaying)
 +  {
 +    ledLight = !ledLight;
 +  }
 +  else
 +  {
 +    if (ledLight)
 +    {
 +      ledLight = false;
 +    }
 +
 +    if (record)
 +    {
 +      ledLight  = true;
 +    }
 +  };
 +
 +  digitalWrite(pinLedRecord, ledLight);
 +  delay(50);
 +}
 +
 +void  PrintBuffer()
 +{
 +  for (int i = 0; i < recPos; i++)
 +  {
 +    int data  = buff[i];
 +    int angle = data & 0xFFF;
 +    int servoNumber = data & 0x3000;
 +    bool endOfData = data & 0x4000;
 +
 +    Serial.print("Servo=");
 +    Serial.print(servoNumber);
 +    Serial.print("\ Angle=");
 +    Serial.print(angle);
 +    Serial.print("\ End=");
 +    Serial.print(endOfData);
 +    Serial.print("\ Data=");
 +    Serial.print(data,  BIN);
 +    Serial.println();
 +  }
 +}
 +
 +void StartPosition()
 +{
 +  int angleBase = servoBase.read();
 +  int angleShoulder = servoShoulder.read();
 +  int angleElbow = servoElbow.read();
 +  int angleGripper = servoGripper.read();
 +
 +  Serial.print(angleBase);
 +  Serial.print("\ ");
 +  Serial.print(angleShoulder);
 +  Serial.print("\ ");
 +  Serial.print(angleElbow);
 +  Serial.print("\ ");
 +  Serial.print(angleGripper);
 +  Serial.println("\ ");
 +
 +  posBase = startBase;
 +  posShoulder = startShoulder;
 +  posElbow = startElbow;
 +  posGripper = startGripper;
 +
 +  servoBase.write(posBase);
 +  servoShoulder.write(posShoulder);
 +  servoElbow.write(posElbow);
 +  servoGripper.write(posGripper);
 +}
 +</code>
/home/chanteri/www/fablab37110/data/attic/start/arduino/joystick.1712048029.txt.gz · Dernière modification : 2024/04/02 10:53 de gerardadmin