projet pocket quad radio commandé

Navré mes connaissances son vraiment basique pour moi tout les potentiomètres fonctionne de la même façon: branchement 3 fils et le fait de jouer avec la rotation du bouton fait que le courant passe plus ou moins.
Ici il ressemble exterieurement a une poignée d’accélérateur type moto.
Une version "logicielle" c'est a dire?
En fouinant sur gogol j'ai vu une histoire de pont en H C'est ça?

Sur vos 3 fils, deux sont fixés, généralement GND et une tension max et le troisième fil sort une tension entre les deux en fonction de la position de la poignée.

Si c’est cette tension variable qui contrôle la vitesse, l’idée c’est d’être capable de générer par logiciel l’équivalent de cette tension de contrôle. Ça se fait par un potentiomètre numérique ou un convertisseur numérique analogique (DAC).

L’autre option est mécanique, mettre un dispositif qui fait tourner la poignée (servo par exemple) et vous pilotez ce moteur

Merci de votre éclairage.
Je viens de regarder ce potentiomètre numérique je pense que vue l’état de mes connaissances, le coup du servo moteur pour actionner le potar est plus simple et peux directement se gérer par l'arduino.
Ça ferait un servo pour la direction un pour l'accéleration ralentissement et un pour gerer les freins.
Pour ce qui est de l’inversion de sens du moteur afin d'avoir la marche arriere.
La solution de relais serait elle pour vous une bonne option?
Je m'explique en actionnant le joystick en avant le circuit du relais de marche avant se ferme et actionne plus ou moins le servo gérant l'accelerateur. position neutre le 2relais sont ouvert et position marche arriere le deuxieme relais se ferme les polaritées sont inversées le servo gére toujours plus ou moins l'accélération.
cela vous semble t'il correct, ou c'est rop simple pour l'etre ?
Sinon existe'til des potentiometres qui peuvent inversé le courant? c'est le cas non dans les télécommandes RC sous le joystick?

si vous réussissez à inverser la polarité, c'est jouable oui.

on utilise un Pont en H

Bonjour Messieurs Dames,
Je reviens pour l’état d’avancement de ce projet.
J’ai donc fais acquisition d’un starter kit Elegoo mega 2560 et j’ai pu débuter la gestion de moteur avec le L293D.
J’arrive donc maintenant a gérer grasse a ce composant le sens de rotation du moteur ainsi que la marche moteur grâce a un bouton poussoir.
j’ai reçu aujourd’hui une manette de playstation avec son shield récepteur 2.4Ghz.
il faut donc que j’apprenne a gerer mon moteur ainsi qu’un servo avec cette manette.
le shield dispose de 4 pin: Vcc, Tx, RX, GND.

j’ai fait ce tuto sur les contrôleurs pS2, si c’est ça que vous avez

Merci oui c’est a peu de chose pres cela j’ai en plus un shield ou je peux brancher le module reception avec juste 4 pin en sortie


J’avais aperçu votre tuto.
J’ai bien noté qu’il me faut la bibliothèque, qu’il faut que j’adapte le branchement. Si j’ai bien compris je dois raccorder mon TXD du shield sur la pin 1, RXD sur la pin 0 gnd au gnd bien sure et vcc sur 5v ?

Celle de mon tuto utilisait un protocole similaire à du SPI et j’avais 6 fils, je en sais pas ce que propose la votre. Vous avez un lien sur le produit que vous que vous avez acheté ? Ça m’étonnerait que ce soit juste un port série UART mais comme il semble y avoir une puce intelligente sur votre shield… on ne sait jamais… peut être du USB HID…

c’est la même manette je pense , comme j’ai vu ce shield je me suis dis que ça serait plus facile plus simple niveau cablage.
C’est bien UART 9600-115200Bauds.

Ok

Créez un port software serial pour brancher la manette et affichez dans la console série ce que vous recevez quand vous bougez les manettes ou appuyez les boutons…

Bonjour, j’ai suivi vos conseil et ai donc cherché comment fonctionne serialprint software.
Le problème est que l’exemple trouvé ne m’aide pas j’ai essayé quand même de me débrouiller et d’inclure un bout de votre code du tuto manette ps2, mais tout se que j’ai pu obtenir du moniteur serie c’est:
Controller_type: 0
Manette Absente - code Controller_type: 0
0

aucune reaction lorsque j’appuie sur les boutons.
voici le code que j’ai testé:

Blockquote
#include <SoftwareSerial.h>
#include <PS2X_lib.h>
PS2X ps2x;
const byte dataPin = 10;
const byte commandPin = 11;
int PS2 = 0;
SoftwareSerial mySerial(10, 11); // RX, TX
void setup() {
Serial.begin(115200);
if (ps2x.readType() == 1) Serial.println(F(“DualShock”));
else {
Serial.print(F("Manette Absente - code "));
Serial.println(ps2x.readType());
while (true); // on meurt ici, éventuellement enlever si vous avez un autre code manette
}
ps2x.read_gamepad(); // initialisation des valeurs
delay(50);
ps2x.read_gamepad(); /* initialise les états /
}
void loop() {
static uint32_t chrono = 0;
const uint32_t periode = 20ul; // la manette est assez sensible, il ne faut pas lui demander les infos trop souvent. 15ms ou 20ms ça fonctionne pour moi
if (millis() - chrono >= periode) {
int RX = 0, RY = 0, LX = 0, LY = 0;
static int PRX = 127, PRY = 128, PLX = 127, PLY = 128;
chrono += periode;
ps2x.read_gamepad(); /
on lit l’état de la manette /
LX = ps2x.Analog(PSS_LX); /
joystick de gauche X*/
LY = ps2x.Analog(PSS_LY); /* joystick de gauche Y /
RX = ps2x.Analog(PSS_RX); /
joystick de droite X /
RY = ps2x.Analog(PSS_RY); /
joystick de droite Y /
// si une des coordonnées des joystick a changé alors on imprime les nouvelles coordonnées
if ((LX != PLX) || (LY != PLY) || (RX != PRX) || (RY != PRY)) {
PLX = LX;
PLY = LY;
PRX = RX;
PRY = RY;
Serial.print(LX); Serial.print(F(" ,"));
Serial.print(LY); Serial.print(F(" ,"));
Serial.print(RX); Serial.print(F(" ,"));
Serial.println(RY);
}
// if (ps2x.NewButtonState()) {} /
vrai s’il y a un changement d’état, si on ne veut pas lire l’état à la main */
// ButtonPressed(unsigned int) vrai si le bouton VIENT d’être appuyé (depuis la dernière lecture de config)
if (ps2x.ButtonPressed(PSB_START)) Serial.println(F(“START APPUI”));
if (ps2x.ButtonPressed(PSB_SELECT)) Serial.println(F(“SELECT APPUI”));
if (ps2x.ButtonPressed(PSB_PAD_UP)) Serial.println(F(“HAUT APPUI”));
if (ps2x.ButtonPressed(PSB_PAD_RIGHT)) Serial.println(F(“DROIT APPUI”));
if (ps2x.ButtonPressed(PSB_PAD_LEFT)) Serial.println(F(“GAUCHE APPUI”));
if (ps2x.ButtonPressed(PSB_PAD_DOWN)) Serial.println(F(“BAS APPUI”));
if (ps2x.ButtonPressed(PSB_L1)) Serial.println(F(“GAUCHE 1 APPUI”));
if (ps2x.ButtonPressed(PSB_R1)) Serial.println(F(“DROITE 1 APPUI”));
if (ps2x.ButtonPressed(PSB_L2)) Serial.println(F(“GAUCHE 2 APPUI”));
if (ps2x.ButtonPressed(PSB_R2)) Serial.println(F(“DROITE 2 APPUI”));
if (ps2x.ButtonPressed(PSB_GREEN)) Serial.println(F(“Triangle APPUI”));
if (ps2x.ButtonPressed(PSB_BLUE)) Serial.println(F(“X APPUI”));
if (ps2x.ButtonPressed(PSB_RED)) Serial.println(F(“Cercle APPUI”));
if (ps2x.ButtonPressed(PSB_PINK)) Serial.println(F(“Carre APPUI”));
// Button(uint16_t); vrai si le bouton est tenu enfoncé
if (ps2x.Button(PSB_START)) Serial.println(F(“START”));
if (ps2x.Button(PSB_SELECT)) Serial.println(F(“SELECT”));
if (ps2x.Button(PSB_PAD_UP)) Serial.println(F(“HAUT”));
if (ps2x.Button(PSB_PAD_RIGHT)) Serial.println(F(“DROITE”));
if (ps2x.Button(PSB_PAD_LEFT)) Serial.println(F(“GAUCHE”));
if (ps2x.Button(PSB_PAD_DOWN)) Serial.println(F(“BAS”));
if (ps2x.Button(PSB_L1)) Serial.println(F(“GAUCHE 1”));
if (ps2x.Button(PSB_R1))Serial.println(F(“DROITE 1”));
if (ps2x.Button(PSB_L2))Serial.println(F(“GAUCHE 2”));
if (ps2x.Button(PSB_R2))Serial.println(F(“DROITE 2”));
if (ps2x.Button(PSB_GREEN)) Serial.println(F(“Triangle”));
if (ps2x.Button(PSB_BLUE)) Serial.println(F(“X”));
if (ps2x.Button(PSB_RED)) Serial.println(F(“Cercle”));
if (ps2x.Button(PSB_PINK)) Serial.println(F(“Carre”));
// ButtonReleased(unsigned int) vrai si le bouton VIENT d’être relâché (depuis la dernière lecture de config)
if (ps2x.ButtonReleased(PSB_START)) Serial.println(F(“START RELACHE”));
if (ps2x.ButtonReleased(PSB_SELECT)) Serial.println(F(“SELECT RELACHE”));
if (ps2x.ButtonReleased(PSB_PAD_UP)) Serial.println(F(“HAUT RELACHE”));
if (ps2x.ButtonReleased(PSB_PAD_RIGHT)) Serial.println(F(“DROITE RELACHE”));
if (ps2x.ButtonReleased(PSB_PAD_LEFT)) Serial.println(F(“GAUCHE RELACHE”));
if (ps2x.ButtonReleased(PSB_PAD_DOWN)) Serial.println(F(“BAS RELACHE”));
if (ps2x.ButtonReleased(PSB_L1)) Serial.println(F(“GAUCHE 1 RELACHE”));
if (ps2x.ButtonReleased(PSB_R1)) Serial.println(F(“DROITE 1 RELACHE”));
if (ps2x.ButtonReleased(PSB_L2)) Serial.println(F(“GAUCHE 2 RELACHE”));
if (ps2x.ButtonReleased(PSB_R2)) Serial.println(F(“DROITE 2 RELACHE”));
if (ps2x.ButtonReleased(PSB_GREEN)) Serial.println(F(“Triangle RELACHE”));
if (ps2x.ButtonReleased(PSB_BLUE)) Serial.println(F(“X RELACHE”));
if (ps2x.ButtonReleased(PSB_RED)) Serial.println(F(“Cercle RELACHE”));
if (ps2x.ButtonReleased(PSB_PINK)) Serial.println(F(“Carre RELACHE”));
}
}

(J’ai du supprimer les espaces pour utiliser le blockquote mais n’est pas modifier cela dans le code seul la premiere partie du code a été modifier pour ajouter serialsofware.

Le L293D c’est 1,2A! c’est un peu juste pour un moteur 250W/24V = 10A!

essayez de voir ce que balance la manette avec ce code

#include <SoftwareSerial.h>
SoftwareSerial mySerial(10, 11); // pin 10 connectée à Tx, pin 11 connectée à Rx

void setup() {
  Serial.begin(115200);     // pour le moniteur Série, régler à 115200 bauds
  mySerial.begin(115200);   // il faudra trouver la bonne valeur, essayez les valeurs classiques de 1200 à 115200
}

void loop() {
  int c = mySerial.read();
  if (c != -1) {
    Serial.print((byte) c, HEX);
    if (isalnum(c)) {
      Serial.write('\t');
      Serial.write((char) c);
    }
    Serial.println();
  }
}

Bonjour vileroi,
oui j’avais bien vue ca c’est un attendant étant debutant dans la programmation. Je me suis dis que le code et le principe reste le même.
J’ai commandé le pont H qui va bien avec le moteur je crois meme que j’ai commandé pour du 15A

voici donc ce que me sort le moniteur série dans l’ordre des touche suivant haut,bas,gauche,droite, triangle, rond croix carré, r1 l1, r2, l2
41 A41 A41 A42 B42 B42 B42 B43 C43 C43 C44 D44 D44 D4B K49 I4C L4A J45 E45 E45 E45 E4D M4D M4D M4D M4E N4E N4E N4E N46 F46 F46 F46 F

seul les joystick ne réponde pas enfin le poussoir oui.

zut j’ai oublié un Serial.println(); dans le code pour que ce soit plus lisible

ça aurait dû s’imprimer comme cela:

41 A
41 A
41 A
42 B
42 B
42 B
42 B
43 C
43 C
43 C
44 D
44 D
44 D
4B K
49 I
4C L
4A J
45 E
45 E
45 E
45 E
4D M
4D M
4D M
4D M
4E N
4E N
4E N
4E N
46 F
46 F
46 F
46 F

donc on gros pour ce que vous avez touché ça envoie les caractères ASCII A, B, C, D ou I, J, K, L ou E,M,N,F. Il y a deux croix de 4 boutons, qu’est-ce qui a émis la dernière trame ?

Si ça n’émet rien pour les joysticks, c’est pas terrible… il n’y a pas des points de sorties ailleurs sur la carte ?

46F c’est L2 sur la manette.
Non rien de plus je crois que je n’utiliserais pas ce petit module du coup vue le projet ce n’est pas si grave d’utiliser plus de pin sur l’arduino meme si j’ai plein d’idées plus débile les unes que les autres comme une tourelle avec une réplique d’airsoft mais la madame me vire et la police pourrait m’en vouloir Haha.
Dans ce projet j’ai juste besoin d’un marche/arret moteur via bouton poussoir (je pense que ce sera start), de marche avant, marche arriere( de preference en pouvant regler la vitesse) joystick gauche et droite-gauche joystick droit , si je pouvais commander les freins a disque du quad ça serait un plus mais pas necessaire.

OK donc le code pour gérer votre manette est super simple:

#include <SoftwareSerial.h>
SoftwareSerial mySerial(10, 11); // pin 10 connectée à Tx, pin 11 connectée à Rx

void gererJoyStick() {
  int c = mySerial.read();
  if (c != -1) {
    switch (c) {
      case 'A':
        break;

      case 'B':
        break;

      case 'C':
        break;

      case 'D'
          break;

      // ----------

      case 'I':
        break;

      case 'J':
        break;

      case 'K':
        break;

      case 'L':
        break;

      // ----------

      case 'E':
        break;

      case 'M':
        break;

      case 'N':
        break;

      case 'F':
        break;
    }
  }
}

void setup() {
  Serial.begin(115200);     // pour le moniteur Série, régler à 115200 bauds
  mySerial.begin(115200);   // il faudra trouver la bonne valeur, essayez les valeurs classiques de 1200 à 115200
}

void loop() {
  gererJoyStick();
}

et vous n’avez plus qu’à mettre ce qu’il faut faire dans le switch/case pour chacune des touches

1 Like

Vous avez commandé quoi exactement
dans votre cas le + simple est de vous procurer une unité de puissance dans ce genre

ce que j’ai commandé
ceci étant j’ai le régulateur d’origine du moteur qui ressemble a celui de votre lien.
Je ne pensais pas que je pourrais le piloter avec l’arduino sachant qu’en plus il ne fais pas la marche arriere