43 réponses à ce sujet

[Vinchator]

Tu peux indiquer ce que tu as utilisé comme matériel pour la vidéo ?

Je ne suis pas chez moi je vous donne les infos demain soir

[Vinchator]

Mince j'ai fais ma proposition un peu tard ... 

Oui pour ma proposition le plus simple et le plus économique est d'utiliser une pi + pi cam. 
Pas besoin d'avoir une IP fixe , ni d'ouvrir un port c'est la pi sur le robot qui se connecte à vigibot ...
Après c'est une proposition comme une autre si tu as déjà une solution qui fonctionne c'est bon =)
 
 
 
Je sais pas si tu as vu mais si tu veux nous soutenir on est en ce moment sur kickstarter : https://www.kickstar...or-live-robots/

C'est quand même trop attirant...
J'ai un chassis à chenille en plus et je suis intéressé pour le monter en raspberry avec picam.
Je voudrais faire un robot de surveillance pour la maison avec un laser et un distributeur de friandise pour le chat...
C'est possible de piloter des servos supplémentaires, des relais, des moteurs pas a pas ou a courant continu sur vigibot ?
C'est uniquement en communauté ou il y aurait moyen de privatiser le robot pour ma femme et moi uniquement ?

[Vinchator]

Je suis également curieux d'en savoir plus. En te remerciant d'avance.

J'avais une photo sur mon téléphone
La camera est pas dessus c'est une foxer mini
Je peux te donner les références demain soir si ca interesse
Le matériel fonctionne bien

Image(s) jointe(s)

• 

[Vinchator]

J'ai modélisé et imprimé des boitiers pour l'arduino mega et le driver l298

Image(s) jointe(s)

• 

[Mike118]

C'est quand même trop attirant...
J'ai un chassis à chenille en plus et je suis intéressé pour le monter en raspberry avec picam.
Je voudrais faire un robot de surveillance pour la maison avec un laser et un distributeur de friandise pour le chat...
C'est possible de piloter des servos supplémentaires, des relais, des moteurs pas a pas ou a courant continu sur vigibot ?
C'est uniquement en communauté ou il y aurait moyen de privatiser le robot pour ma femme et moi uniquement ?

 

Oui tu peux sans problème faire un robot de surveillance avec un laser et un distributeur de friandise => Tu peux piloter autant de servo , de relais et de moteur à courant continu supplémentaire que tu veux  directement depuis la pi ( en passant par un driver cc pour les moteurs cc ) . 

Par contre c'est vrai qu'on ne gère pas encore les moteurs pas à pas ... Mais on vient de publier le code pour communiquer avec une arduino... Donc après avec l'arduino tu peux piloter tout ce que tu veux =) dont le moteur pas à pas. 

Tu peux privatiser le robot sans soucis, c'est prévu pour. En gros tu peux décider de le rendre dispo que pour toi et la "white liste" : donc si tu mets ta femme dans la white liste vous serez les seuls à pouvoir accéder au robot =)  En plus ce qui est drôle c'est que vous pourrez piloter le robot en même temps ... Genre un qui pilote le lazer pendant que l'autre bouge le robot et envoit les friandises  


 

[Vinchator]

Oui tu peux sans problème faire un robot de surveillance avec un laser et un distributeur de friandise => Tu peux piloter autant de servo , de relais et de moteur à courant continu supplémentaire que tu veux  directement depuis la pi ( en passant par un driver cc pour les moteurs cc ) . 
Par contre c'est vrai qu'on ne gère pas encore les moteurs pas à pas ... Mais on vient de publier le code pour communiquer avec une arduino... Donc après avec l'arduino tu peux piloter tout ce que tu veux =) dont le moteur pas à pas. 
Tu peux privatiser le robot sans soucis, c'est prévu pour. En gros tu peux décider de le rendre dispo que pour toi et la "white liste" : donc si tu mets ta femme dans la white liste vous serez les seuls à pouvoir accéder au robot =)  En plus ce qui est drôle c'est que vous pourrez piloter le robot en même temps ... Genre un qui pilote le lazer pendant que l'autre bouge le robot et envoit les friandises

C'est génial !
Je vais donc participer aux donnations, commander le matériel dont j'ai besoin et ouvrir un nouveau sujet sur robotmaker pour ce nouveau robot...
Merci

[Vinchator]

Oui tu peux sans problème faire un robot de surveillance avec un laser et un distributeur de friandise => Tu peux piloter autant de servo , de relais et de moteur à courant continu supplémentaire que tu veux  directement depuis la pi ( en passant par un driver cc pour les moteurs cc ) . 
Par contre c'est vrai qu'on ne gère pas encore les moteurs pas à pas ... Mais on vient de publier le code pour communiquer avec une arduino... Donc après avec l'arduino tu peux piloter tout ce que tu veux =) dont le moteur pas à pas. 
Tu peux privatiser le robot sans soucis, c'est prévu pour. En gros tu peux décider de le rendre dispo que pour toi et la "white liste" : donc si tu mets ta femme dans la white liste vous serez les seuls à pouvoir accéder au robot =)  En plus ce qui est drôle c'est que vous pourrez piloter le robot en même temps ... Genre un qui pilote le lazer pendant que l'autre bouge le robot et envoit les friandises

J'ai juste encore quelques questions...
Il faut juste un pi et une picam pour interphaser avec vigibot ou j'ai besoin d'autre chose de "spécifique " ?
Quel modèle de Pi est optimal ?
Je peux utiliser un accu 12v ou il y a une surveillance de tension qui impose du 5v ?

[Mike118]

Un excellent rapport qualité prix c'est le raspberry pi A+. 

N'importe quel Pi camera conviendra, mais on recommande d'utiliser une camera grand angle pour le confort de pilotage. 
De plus une camera qui peut voir dans le noir c'est top ... et pour avoir une belle qualitée d'image de jour comme de nuit il faut un filtre IR cut amovible ... 
Bref du coup on recommande cette camera : https://www.robot-ma...spberry-pi.html 
mais tu n'es pas du tout obligé d'avoir celle là. Il n'y a rien besoin de " spécifique ". 
Bien qu'on fournisse une config par défaut,  vigibot c'est fait pour que n'importe qui puisse faire son propre robot complètement custom =) Il faudra juste adapter un peu la config à ton besoin. Cela se fait directement sur la page web =)

Tu peux utiliser une batterie 12V mais il te faudra un convertisseur 5V pour alimenter la pi. 

 

[Vinchator]

Avancée du robot
Le dessous du char est terminé

Image(s) jointe(s)

• 
• 

[Path]

Je trouve ça beau

[Vinchator]

Je trouve ça beau

Merci ca fait plaisir

[Vinchator]

Avancée de la pince avec une couverture de câbles ainsi que la mise en place d'un boitier pour le relai des phares

Image(s) jointe(s)

• 

[Vinchator]

Je n'ai pas du tout fini la partie hardware du robot mais je souhaite commencer le soft vu que c'est mon point faible...

Soyez indulgents 

 

J'utilise des HC12  et j'ai regardé à gauche à droite sur le web comment les utilisés...

Ce n'est pas encore très clair pour moi sur la manière d'envoyer des données et de les recevoir sur le récepteur et surtout de les mettre dans " dans l'ordre" car j'ai 5 servos à piloter en pwm, 2 moteurs dc avec un driver l298d donc un pwm et deux digitales sur chaque moteur et un relai.

Alors j'ai essayé d'écrire un code avec une sorte d'ID avant les valeurs.

Pouvez vous me donner votre avis et des tuyaux parce que c'est surement pas la bonne manière de faire je pense...

 

//Code de l'émetteur ( Arduino UNO + HC12 + 1x Joystick + 5x Potentiometre + 1x Bouton on/off )

#include <SoftwareSerial.h>           
#define SW_SERIAL_TX     2           //Branchement HC12
#define SW_SERIAL_RX     3           //Branchement HC12
SoftwareSerial BTSerial(SW_SERIAL_RX, SW_SERIAL_TX);

const int Pin_Direction =A0;             //Joystick gauche-droite
const int Pin_Gaz =A1;                   //Joystick haut-bas
const int Pin_Rotation_Camera =A2;       //Potentiometre camera 1
const int Pin_Inclinaison_Camera =A3;    //Potentiometre camera 2
const int Pin_Bras1_Pince =A4;           //Potentiometre pince 1
const int Pin_Bras2_Pince =A5;           //Potentiometre pince 2
const int Pin_Serrage_Pince =A6;         //Potentiometre pince 3
const int Pin_Phare = 6;                 //Interrupteur

void setup() {
  
Serial.begin(9600);
BTSerial.begin(9600);

pinMode(Pin_Direction, INPUT);
pinMode(Pin_Gaz, INPUT);
pinMode(Pin_Rotation_Camera, INPUT);
pinMode(Pin_Inclinaison_Camera, INPUT);
pinMode(Pin_Bras1_Pince, INPUT);
pinMode(Pin_Bras2_Pince, INPUT);
pinMode(Pin_Serrage_Pince, INPUT);
  

void loop() {

    Valeur_A0  = analogRead(Pin_Direction[1]);
    angle = byte(map(Valeur_A0, 0, 1023, 0, 1023));
    BTSerial.write(id);
    BTSerial.write(angle);

    Valeur_A1  = analogRead(Pin_Gaz[2]);
    vitesse = byte(map(Valeur_A2, 0, 1023, 0, 255));
    BTSerial.write(id);
    BTSerial.write(vitesse);

    Valeur_A2  = analogRead(Pin_Rotation_Camera[3]);
    angle = byte(map(Valeur_A2, 0, 1023, 0, 180));
    BTSerial.write(id);
    BTSerial.write(angle);

    Valeur_A3  = analogRead(Pin_Inclinaison_Camera[4]);
    angle = byte(map(Valeur_A3, 0, 1023, 0, 180));
    BTSerial.write(id);
    BTSerial.write(angle);

    Valeur_A4  = analogRead(Pin_Bras1_Pince[5]);
    angle = byte(map(Valeur_A4, 0, 1023, 0, 180));
    BTSerial.write(id);
    BTSerial.write(angle);

    Valeur_A5  = analogRead(Pin_Bras2_Pince[6]);
    angle = byte(map(Valeur_A5, 0, 1023, 0, 180));
    BTSerial.write(id);
    BTSerial.write(angle);

    Valeur_A6  = analogRead(Pin_Serrage_Pince[7]);
    angle = byte(map(Valeur_A6, 0, 1023, 0, 180));
    BTSerial.write(id);
    BTSerial.write(angle);
      
}

 

[Vinchator]

Je me concentre deja sur l'émetteur car si c'est incorrect le recepteur le sera aussi

Avec ce code je ne sais deja pas comment envoyé l'etat de mon interrupteur sur la telecommande pour piloter le relai sur le robot

 

En fait A0 devrait donner une indication de direction pour tourner le robot donc agir sur les entrées digitales du driver et A1 servirait d'indication de vitesses pour les moteurs...

[Vinchator]

J'ai trouvé un exemple tout bête que je comprend bien pour allumer une led via un potar mais comme tout ce que j'ai trouvé on ne commande qu'une seule chose

 

Mais maintenant comment envoyer plusieurs informations et comment les récupérer et les exploiter ??

Emetteur



 #include <SoftwareSerial.h>

SoftwareSerial HC12(10, 11); // HC-12 TX Pin, HC-12 RX Pin

int pot = A2;

void setup() {

Serial.begin(9600); // Serial port to computer

HC12.begin(9600); // Serial port to HC12

pinMode(pot,INPUT); }



void loop() {

int val = map(analogRead(pot),0,1024,0,255);

HC12.write(val); // Send that data to HC-12 }



Recepteur



#include <SoftwareSerial.h>

SoftwareSerial HC12(10, 11); // HC-12 TX Pin, HC-12 RX Pin

int LED = 3;

void setup() {

Serial.begin(9600); // Serial port to computer

HC12.begin(9600); // Serial port to HC12

pinMode(LED,OUTPUT); }

void loop() {

while (HC12.available()) { // If HC-12 has data

int val = HC12.read();

Serial.println(HC12.read()); // Send the data to Serial monitor

analogWrite(LED,val); } }

[Mike118]

alors, quand tu poste du codes, pour plus de lisibilité je te recommande d'utiliser la balise code, icone <> dans les outils d'édition des message comme ça ton code apparaît comme ça : 

 

Valeur_A0  = analogRead(Pin_Direction[1]);
    angle = byte(map(Valeur_A0, 0, 1023, 0, 1023));
    BTSerial.write(id);
    BTSerial.write(angle);

Ensuite dans le code ci dessus, j'ai noté un petit problème : 
BTSerial.write => doit écrire une valeur sur 8 bits et donc comprise entre 0 et 255 ... or angle tu as fait un map avec une limite à 1023...

 

Pour ce qui est du bouton tu peux faire exactement la même chose que pour les vitesse en mettant 255 si tu appuis sur le bouton et 0 si tu appuis pas par exemple ... 

 

Ensuite pour ton id, ça peut être une méthode, si tu envois toujours des trucs un peu disparate jamais les même genre pour allumer ou éteindre quelque chose ça se fait, mais pour piloter un robot en général on va préférer envoyer une trame toujours la même avec toujours les même info dedans tout le temps, kit à répéter les info qui n'ont pas changé. Comme ça si jamais on perd une trame c'est pas grave les info sont dans la trame suivante ... Dans ce cas là tu as plus besoin des id dans ta trame et tu as juste besoin de faire une trame de taille fixe et la décoder. 

D'ailleurs si tu veux tu peux prendre modèle sur la trame vigibot. L'avantage c'est que le code est déjà fait et que si un jour tu décide de piloter ton robot depuis vigibot il sera compatible il pourra même être piloté par les deux en même temps ^^

 

Exemple pour le récepteur reprenant le code de la trame vigibot et en mappant " Pi Serial " sur le bluetooth serial 

// Meta Type :

typedef struct {
 union {
  struct {
   int16_t x;
   int16_t y;
  };
  int16_t coordonnees[2];
  uint8_t bytes[4];
 };
} Point;

typedef struct {
 union {
  struct {
   int8_t x;
   int8_t y;
   int8_t z;
  };
  uint8_t bytes[3];
 };
} Vitesses;

#include <SoftwareSerial.h>           
#define SW_SERIAL_TX     2           //Branchement HC12
#define SW_SERIAL_RX     3           //Branchement HC12
SoftwareSerial BTSerial(SW_SERIAL_RX, SW_SERIAL_TX);
#define PISERIAL BTSerial 
#define NBOUTILS 3 
#define FAILSAFE 100 // ms // TTS 
#define TTSBUFFERSIZE 255 
uint8_t ttsBuffer[TTSBUFFERSIZE]; 
uint8_t ttsCurseur = 0; // TX 
#define TXFRAMESIZE (NBOUTILS * 4 + 13) 

typedef struct { 
 union { 
  struct { 
   uint8_t sync[2]; // 2 Point outils[NBOUTILS]; // NBOUTILS * 4 
   uint16_t val16[2]; // 2 * 2 uint8_t choixCameras; // 1 
   Vitesses vitesses; // 3 uint8_t interrupteurs; // 1 
   uint8_t val8[2]; // 2 
  }; uint8_t bytes[TXFRAMESIZE]; 
 }; 
} TrameTx; 

// RX 
#define RXFRAMESIZE (NBOUTILS * 4 + 7) 

typedef struct { 
 union { 
  struct { // Sizes 
   uint8_t sync[2]; // 2 
   Point outils[NBOUTILS]; // NBOUTILS * 4 
   uint8_t choixCameras; // 1 
   Vitesses vitesses; // 3 
   uint8_t interrupteurs; // 1 
  }; 
  uint8_t bytes[RXFRAMESIZE]; 
 }; 
} TrameRx; 

TrameTx trameTx; 
TrameRx trameRx; 

uint32_t lastTrameTimestamp = millis(); 

void setup() { 
 PISERIAL.begin(115200); // add all your init here 
} 

void loop() { 
 if(readPiSerial()) { 
  // each time we receive a full trame run repeatedly: 
  // use values inside TrameRx to tell your robot how to move ... 
  // TrameRx.vitesses.x , TrameRx.vitesses.y, TrameRx.vitesses.z // TrameRx.outils[i].x TrameRx.outils[i].y etc.... 
  writePiSerial(); 
  lastTrameTimestamp = millis(); 
 } 
 if( millis() - lastTrameTimestamp > FAILSAFE ) { 
  // Stop the robot in case the robot lost connection with the Pi 
 } else { 
 // put your main code here, to run repeatedly: 
 // avoid abstacle, run speed ... 
 } 
} 

bool readPiSerial() { 
 uint8_t current; 
 static uint8_t lastType = 0; 
 static uint8_t n = 0; 
 static uint8_t frame[RXFRAMESIZE]; 
 while(PISERIAL.available()) { 
  current = PISERIAL.read(); 
  switch(n) { 
   case 0: 
    if(current == '$') 
    n = 1; 
    break; 
   case 1: 
    if(current != 'T' && lastType == 'T') 
     writeTtsBuffer('\0'); 
    if(current == 'S' || current == 'T') { 
     lastType = current; 
     n = 2; 
    } else n = 0; 
    break; 
   default: 
    frame[n++] = current; 
    if(n == RXFRAMESIZE) { 
     if(lastType == 'T') { 
      for(uint8_t i = 2; i < RXFRAMESIZE; i++) 
       writeTtsBuffer(frame[i]); 
     } else if(lastType == 'S') { 
      for(uint8_t p = 0; p < RXFRAMESIZE; p++) 
       trameRx.bytes[p] = frame[p]; 
     } 
     n = 0; 
     return true; 
    } 
   } 
 } return false; 
} 

void writePiSerial() { 
 // Header, do not modify 
 trameTx.sync[0] = '$'; 
 trameTx.sync[1] = 'R'; 
 // modify the feedback according your need. By default we copy the trameRx content ... 
 for(uint8_t i = 0; i < NBOUTILS; i++) { 
  trameTx.outils[i].x = trameRx.outils[i].x; 
  trameTx.outils[i].y = trameRx.outils[i].y; 
 } 
 trameTx.val16[0] = analogRead(A0); // Voltage change according your need 
 trameTx.val16[1] = analogRead(A1); // Percent change according your need 
 trameTx.choixCameras = trameRx.choixCameras; 
 trameTx.vitesses.x = trameRx.vitesses.x; 
 trameTx.vitesses.y = trameRx.vitesses.y; 
 trameTx.vitesses.z = trameRx.vitesses.z; 
 trameTx.interrupteurs = trameRx.interrupteurs; 
 trameTx.val8[0] = 127; // link change according your need 
 trameTx.val8[1] = 255; // RSSI change according your need 
 
 for( uint8_t i = 0; i < TXFRAMESIZE; i++) 
  PISERIAL.write(trameTx.bytes[i]); 
} 


void displayTtsBuffer (uint8_t * ttsBuffer, uint8_t bufferSize) { 
 // you can modify this function to display text on a screen depending on your hardware... 
 for( uint8_t i = 0; i < bufferSize; i++) 
  Serial.write(ttsBuffer[i]); 
 Serial.println(""); 
} 

void writeTtsBuffer( uint8_t ttsChar) { 
 static uint8_t ttsCurseur = 0; 
 if( ttsCurseur < TTSBUFFERSIZE && ttsChar != '\0') { 
  ttsBuffer[ttsCurseur] = ttsChar; ttsCurseur ++; 
 } 
 if( ttsCurseur == TTSBUFFERSIZE || ttsChar == '\0') { 
  displayTtsBuffer (ttsBuffer, ttsCurseur); 
  ttsCurseur = 0; 
 } 
}

pour l'émetteur tu peux avoir un truc du genre : 

 

// Meta Type :

typedef struct {
 union {
  struct {
   int16_t x;
   int16_t y;
  };
  int16_t coordonnees[2];
  uint8_t bytes[4];
 };
} Point;

typedef struct {
 union {
  struct {
   int8_t x;
   int8_t y;
   int8_t z;
  };
  uint8_t bytes[3];
 };
} Vitesses;

#define NBOUTILS 3
#define TXFRAMESIZE (NBOUTILS * 4 + 7)

typedef struct {
union {
struct { // Sizes
uint8_t sync[2]; // 2
Point outils[NBOUTILS]; // NBOUTILS * 4
uint8_t choixCameras; // 1
Vitesses vitesses; // 3
uint8_t interrupteurs; // 1
};

uint8_t bytes[TXFRAMESIZE];
};
} TrameTx;


TrameTx trameTx;

#include <SoftwareSerial.h>           
#define SW_SERIAL_TX     2           //Branchement HC12
#define SW_SERIAL_RX     3           //Branchement HC12
SoftwareSerial BTSerial(SW_SERIAL_RX, SW_SERIAL_TX);

#define PISERIAL BTSerial
 
const int Pin_Direction =A0;             //Joystick gauche-droite
const int Pin_Gaz =A1;                   //Joystick haut-bas
const int Pin_Rotation_Camera =A2;       //Potentiometre camera 1
const int Pin_Inclinaison_Camera =A3;    //Potentiometre camera 2
const int Pin_Bras1_Pince =A4;           //Potentiometre pince 1
const int Pin_Bras2_Pince =A5;           //Potentiometre pince 2
const int Pin_Serrage_Pince =A6;         //Potentiometre pince 3
const int Pin_Phare = 6;                 //Interrupteur
uint16_t angle;
 
void setup() {
  
 Serial.begin(9600);
 BTSerial.begin(9600);
 
 pinMode(Pin_Direction, INPUT);
 pinMode(Pin_Gaz, INPUT);
 pinMode(Pin_Rotation_Camera, INPUT);
 pinMode(Pin_Inclinaison_Camera, INPUT);
 pinMode(Pin_Bras1_Pince, INPUT);
 pinMode(Pin_Bras2_Pince, INPUT);
 pinMode(Pin_Serrage_Pince, INPUT);
 pinMode(Pin_Phare, INPUT);

 // header de trame à ne pas modifier
 trameTx.sync[0] = '$';
 trameTx.sync[1] = 'R'; 
}
 
void loop() {
    
    int8_t Valeur_A0  = analogRead(Pin_Direction);
    trameTx.vitesse[2] = byte(map(Valeur_A0, 0, 1023, -127, 127));
    
 
    int8_t Valeur_A1  = analogRead(Pin_Gaz);
    vitesse = byte(map(Valeur_A2, 0, 1023, -127, 127));
    trameTx.vitesse[1] = vitesse;

 
    int Valeur_A2  = analogRead(Pin_Rotation_Camera);
    angle = byte(map(Valeur_A2, 0, 1023, 0, 65535));
    trameTx.outils[0].x = angle;
 
    int Valeur_A3  = analogRead(Pin_Inclinaison_Camera);
    angle = byte(map(Valeur_A3, 0, 1023, 0, 65535));
    trameTx.outils[0].y = angle;
 
    int Valeur_A4  = analogRead(Pin_Bras1_Pince);
    angle = byte(map(Valeur_A4, 0, 1023, 0, 65535));
    trameTx.outils[1].x = angle;

 
    int Valeur_A5  = analogRead(Pin_Bras2_Pince);
    angle = byte(map(Valeur_A5, 0, 1023, 0, 65535));
    trameTx.outils[1].y = angle;
   
 
    int Valeur_A6  = analogRead(Pin_Serrage_Pince);
    angle = byte(map(Valeur_A6, 0, 1023, 0, 65535));
    trameTx.outils[2].x = angle;
    
    if(digitalRead(Pin_Phare) == 1) 
     trameTx.interrupteurs = 255; 
    else 
     trameTx.interrupteurs = 0;
     
    for( uint8_t i = 0; i < TXFRAMESIZE; i++)
     PISERIAL.write(trameTx.bytes[i]); 
      
}

[Vinchator]

Merci pour l'astuce des balises et merci de ton aide je vais bien regarder cela demain

[Vinchator]

J'ai trouvé une méthode plus adaptée à mon niveau...

J'espère qu'elle fonctionne

Apparemment l'émetteur envoie les infos sur une ligne en les séparant par une virgule et le récepteur récupère ces données et les rend à nouveau indépendantes 

Qu'en pensez vous ??

 

J'aurais également besoin d'astuces pour le pilotage des moteurs

Je n'ai pas de problème avec les entrées digitales du driver c'est simplement pour l'activation et donc le sens de rotation des moteurs par contre pour la vitesse c'est une autre affaire

Par exemple, pour reculer le robot... Quand mon joystick est au centre il renvoie environ 512 si je tire en arriere disons vers la valeur 100 j'aimerais que le robot recule quasi à fond mais du coup la valeure est faible et il reculera tout doucement... Il y a aussi une histoire de mappage je dois passer de 0-1024 à 0-255...

 

Voici mon code temporaire

//Code de l'émetteur ( Arduino UNO + HC12 + 1x Joystick + 5x Potentiometre + 1x Bouton on/off )

#include <SoftwareSerial.h>
#include <Wire.h>
SoftwareSerial HC12(10, 11);

int Gaz = A0;
int Direction = A1;
int Cam1 = A2;
int Cam2 = A3;
int Pince1 = A4;
int Pince2 = A5;
int Pince3 = A6;
int Phare = 2;

void setup()
{ 
  
HC12.begin(9600);
Serial.begin(9600);

pinMode(A0, INPUT);
pinMode(A1, INPUT);
pinMode(A2, INPUT);
pinMode(A3, INPUT);
pinMode(A4, INPUT);
pinMode(A5, INPUT);
pinMode(A6, INPUT);
pinMode(2, INPUT);

}

void loop()

{
  
Gaz = analogRead(A0);
Direction = analogRead(A1);
Cam1 = analogRead(A2);
Cam2 = analogRead(A3);
Pince1 = analogRead(A4);
Pince2 = analogRead(A5);
Pince3 = analogRead(A6);
Phare = digitalRead(2);

HC12.print(Gaz);
HC12.print(",");
HC12.print(Direction);
HC12.print(",");
HC12.print(Cam1);
HC12.print(",");
HC12.print(Cam2);
HC12.print(",");
HC12.print(Pince1);
HC12.println("");
HC12.print(Pince2);
HC12.print(",");
HC12.print(Pince3);
HC12.print(",");
HC12.print(Phare);
HC12.print(",");


delay(100);

}

//Code du récepteur  ( Arduino Mega + HC12 + 5x Servo + 1x L298D avec 2 moteurs 12V DC + 1 relai )

#include <SoftwareSerial.h>
#include <Wire.h>
#include <Servo.h>

const int Pwm_Mot1 = 1;
const int Dig1_Mot1 = 2;
const int Dig2_Mot1 = 3;
const int Pwm_Mot2 = 4 ;
const int Dig1_Mot2 = 5;
const int Dig2_Mot2 = 6;
const int Relai = 7;

Servo Rotation_Cam;
Servo Inclinaison_Cam;
Servo Bras1_Pince;
Servo Bras2_Pince;
Servo Serrage_Pince;
              
SoftwareSerial HC12(10, 11);

int Gaz;
int Direction;
int Cam1;
int Cam2;
int Pince1;
int Pince2;
int Pince3;
int Phare;
String input;
int boundLow;
int boundHigh;
const char delimiter = ',';

void setup() {

pinMode(Pwm_Mot1, OUTPUT);
pinMode(Dig1_Mot1, OUTPUT);
pinMode(Dig2_Mot1, OUTPUT);
pinMode(Pwm_Mot2, OUTPUT);
pinMode(Dig1_Mot2, OUTPUT);
pinMode(Dig2_Mot2, OUTPUT);

Rotation_Cam.attach(8);
Inclinaison_Cam.attach(9);
Bras1_Pince.attach(10);
Bras2_Pince.attach(11);
Serrage_Pince.attach(12);
    
Serial.begin(9600);
HC12.begin(9600);

}

void loop() {

  if(HC12.available())
  {
  input = HC12.readStringUntil('\n');
  if (input.length() > 0)
      {
        Serial.println(input);
       
       boundLow = input.indexOf(delimiter);
        Gaz = input.substring(0, boundLow).toInt();
    
        boundHigh = input.indexOf(delimiter, boundLow+1);
        Direction = input.substring(boundLow+1, boundHigh).toInt();
    
        boundLow = input.indexOf(delimiter, boundHigh+1);
        Cam1 = input.substring(boundHigh+1, boundLow).toInt();

        boundHigh = input.indexOf(delimiter, boundLow+1);
        Cam2 = input.substring(boundLow+1, boundHigh).toInt();

        boundLow = input.indexOf(delimiter, boundHigh+1);
        Cam2 = input.substring(boundHigh+1, boundLow).toInt();

        boundHigh = input.indexOf(delimiter, boundLow+1);
        Pince1 = input.substring(boundLow+1, boundHigh).toInt();

        boundLow = input.indexOf(delimiter, boundHigh+1);
        Pince2 = input.substring(boundHigh+1, boundLow).toInt();

        boundHigh = input.indexOf(delimiter, boundLow+1);
        Pince3 = input.substring(boundLow+1, boundHigh).toInt();
    
        Phare = input.substring(boundHigh+1).toInt();
  
        delay(10); 
  
        }

Mouvement();
Eclairage();
Bras();
Vision();
 
}}


void Mouvement()
{
 
if ((Gaz > 700) && (Direction > 300) && (Direction < 700))    //avancer  
{
digitalWrite(Dig1_Mot1, HIGH); 
digitalWrite(Dig2_Mot1, LOW);
digitalWrite(Dig1_Mot2, HIGH); 
digitalWrite(Dig2_Mot2, LOW);
analogWrite(Pwm_Mot1, Gaz);
analogWrite(Pwm_Mot2, Gaz);
}
 
else if ((Gaz < 700) && (Direction > 300) && (Direction < 700))   //reculer
{
digitalWrite(Dig1_Mot1, LOW); 
digitalWrite(Dig2_Mot1, HIGH);
digitalWrite(Dig1_Mot2, LOW); 
digitalWrite(Dig2_Mot2, HIGH);
}

else if () // gauche
{
}

else if ()   // droite
{
}

else if ()    // avant gauche
{
}

else if ()   // avant droite
{
}

else if ()    // arriere gauche
{
}

else if ()   // arriere droite
{
}

else //stop
{
digitalWrite(Dig1_Mot1, LOW); 
digitalWrite(Dig2_Mot1, LOW);
digitalWrite(Dig1_Mot2, LOW); 
digitalWrite(Dig2_Mot2, LOW);
}
}

void Eclairage()
{
}

void Bras()
{
}

void Vision()
{
}

[Mike118]

 

J'ai trouvé une méthode plus adaptée à mon niveau...

 

 

 

Justement le but c'est de progresser. 
Je suis prêt à passer le temps qu'il faudra pour t'aider à comprendre chaque ligne du code que je t'ai proposé si ça t'intéresse =) 
On peut discuter ici et à l'oral genre discord si tu connais =)

Par contre pour ce qui est de t'aider pour la vitesse j'ai pas bien compris ton problème. 
Tu utilises quoi comme driver ? tu utilises bien des drivers avec deux pins de directon et un pin pwm en plus ? 

dans tous les cas je te propose de faire des petites fonction du genre : 

 

void driveRightMotor( int speed ) {  // speed compris entre -255 et 255
  if(speed > 0 ) {
    // je fais ce qu'il faut pour que mon moteur droit cherche à faire avancer le robot 
    // exemple : 
    digitalWrite(Dig1_Mot1, LOW);
    digitalWrite(Dig2_Mot1, HIGH);
    analogWrite(Pwm_Mot1, speed);  
  } else if(speed < 0 ) {
  // je fais ce qu'il faut pour que mon moteur droit cherche à faire reculer le robot
  // exemple :
  digitalWrite(Dig1_Mot1, HIGH);
  digitalWrite(Dig2_Mot1, LOW);
  analogWrite(Pwm_Mot1, -speed);
 } else {
  // je stop
  digitalWrite(Dig1_Mot1, LOW);
  digitalWrite(Dig2_Mot1, LOW);
  analogWrite(Pwm_Mot1, 0);
 }   
}

faudra ajuster en fonction de ton driver et de ton câblage mais quand ça marche pour le moteur droit tu fais pareil la fonction avec le moteur gauche  puis comme ça on peut faire une fonction du genre : 

 

void drive2WDrobot(int linearspeed, int angularspeed) { // avec linearspeed et angularspeed compris entre -255 et 255
  int rightspeed = constrain(linearspeed - angularspeed, -255, 255); 
  int leftspeed = constrain(linearspeed + angularspeed, -255, 255); 
  driveRightMotor( rightspeed );
  driveLeftMotor( leftspeed );
}

et pour obtenir tes vitesse de consigne linéaire et angulaire tu fais ton map entre de ton entré qui va de 0 et 1023 pour que ça sorte en -255 255 =)

[Vinchator]

 
 
Justement le but c'est de progresser. 
Je suis prêt à passer le temps qu'il faudra pour t'aider à comprendre chaque ligne du code que je t'ai proposé si ça t'intéresse =) 
On peut discuter ici et à l'oral genre discord si tu connais =)

Par contre pour ce qui est de t'aider pour la vitesse j'ai pas bien compris ton problème. 
Tu utilises quoi comme driver ? tu utilises bien des drivers avec deux pins de directon et un pin pwm en plus ? 

dans tous les cas je te propose de faire des petites fonction du genre : 

 

void driveRightMotor( int speed ) {  // speed compris entre -255 et 255  if(speed > 0 ) {    // je fais ce qu'il faut pour que mon moteur droit cherche à faire avancer le robot     // exemple :     digitalWrite(Dig1_Mot1, LOW);    digitalWrite(Dig2_Mot1, HIGH);    analogWrite(Pwm_Mot1, speed);    } else if(speed < 0 ) {  // je fais ce qu'il faut pour que mon moteur droit cherche à faire reculer le robot  // exemple :  digitalWrite(Dig1_Mot1, HIGH);  digitalWrite(Dig2_Mot1, LOW);  analogWrite(Pwm_Mot1, -speed); } else {  // je stop  digitalWrite(Dig1_Mot1, LOW);  digitalWrite(Dig2_Mot1, LOW);  analogWrite(Pwm_Mot1, 0); }   }

faudra ajuster en fonction de ton driver et de ton câblage mais quand ça marche pour le moteur droit tu fais pareil la fonction avec le moteur gauche  puis comme ça on peut faire une fonction du genre : 

 

void drive2WDrobot(int linearspeed, int angularspeed) { // avec linearspeed et angularspeed compris entre -255 et 255  int rightspeed = constrain(linearspeed - angularspeed, -255, 255);   int leftspeed = constrain(linearspeed + angularspeed, -255, 255);   driveRightMotor( rightspeed );  driveLeftMotor( leftspeed );}

et pour obtenir tes vitesse de consigne linéaire et angulaire tu fais ton map entre de ton entré qui va de 0 et 1023 pour que ça sorte en -255 255 =)

Cool j'avais pas pensé à faire un mapping avec du négatif ca résout bien mon problème...

Oui je veux bien comprendre le code que tu m'a partagé je vais déjà bosser dessus de mon coté et après je viendrai vers toi pour approfondir merci

Oui j'utilise bien ce genre de driver avec 1x pwm et 2x digital

Image(s) jointe(s)

•