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);
      
}

Je trouve ça beau

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

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...

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); } }

dernière astuce, si jamais ton neutre sur ton joystick et pas bien centré ou autre au lieu de faire un simple map tu peux découper en 3 morceaux du genre :
si ta valeur est entre 0 et neutreMin  => map( valeur , 0, neutreMin, -255, 0 ); 
si ta valeur est entre netureMin et neutreMax => 0 
si ta valeur est entre neutreMax et 1023 => map( valeur , neutreMax, 1023, 0, 255);

 
 
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 =)

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()
{
}

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

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

En effet il vaut mieux éviter d'avoir deux périphériques UART sur les même pins RX et TX, par contre si tu utilises une arduino mega qui a plusieurs module UART, tu peux contrôler sans problème 4 périphérique UART en même temps chacun sur un des 4 UART différents présents sur l'arduino mega ! =)

Bon, du coup, probablement pas de conflit.
 
Si la télécommande sert juste de télécomande et rien d'autres (pas de retour d'information, pas de gros calculs), alors je pense que le softwareSerial ne devrait pas ralentir de manière perceptible la commande.
 
En revanche, je réinterroge sur un aspect : tu as une caméra sur ton robot, et vue la portée de tes radios, je suppose que tu ne compte pas toujours avoir ton robot juste à coté de toi (donc j'imagine que tu vas utiliser la caméra pour voir le terrain pour le piloter). Du coup, se pose la question suivante : comment compte tu récupérer et afficher la vidéo? Car là, pour le coup, je ne suis pas sur que l'arduino arrive à suivre (pour de la bonne résolution d'image, je suis même sur que non, vue qu'un Arduino Uno n'a que 2ko de Ram, ce qui est insuffisant pour stocker une image de plus de 40*50 pixels)

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

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/

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