Une des possibilité serait une camera CSI et une USB ... Une autre serait de boudouiller pour 2 CSI je suppose ?

Si le but c'est de remplacer ta petite manette avec deux joysticks par ton smartphone avec le robot piloté par internet tu pourra virer la mega et juste la remplacer par une raspberry pi avec une caméra. 
La pi peut sans problème piloter  L298 et les servo =) et même de quoi piloter des relais pour allumer tes leds et autre =) 
 
En plus vu que tout est sécurisé c'est top! =)

D'accord ca m'a l'air d'être la meilleure solution ca serait moins pratique d'utiliser la communication série entre le Pi et le Mega

Je me demande ou la camera serait la mieux placée
En POV ou à la 3ème personne ?
On ne peut pas en mettre 2 pour un seul robot ?

Pour finir le code présent dans l'arduino mega
 

//Moteur_Base ( DC, 12v, Shield l298n(1a), rotation de la base )
const int Pin_Vitesse_Moteur_Base =10;
const int Pin_Horaire_Moteur_Base =22;
const int Pin_AntiHoraire_Moteur_Base =23;
const int Pin_Joystick_1_X =A0;

//Moteur_Bras_1 ( DC, 12v, Shield l298n(1b), mouvement 1er bras )
const int Pin_Vitesse_Moteur_Bras_1 =5;
const int Pin_Horaire_Moteur_Bras_1 =24;
const int Pin_AntiHoraire_Moteur_Bras_1 =25;
const int Pin_Joystick_1_Y =A1;

//Moteur_Bras_2 ( DC, 12v, Shield l298n(2a), mouvement 2eme bras )
const int Pin_Vitesse_Moteur_Bras_2 =11;
const int Pin_Horaire_Moteur_Bras_2 =28;
const int Pin_AntiHoraire_Moteur_Bras_2 =29;
const int Pin_Joystick_2_X =A4;

//Moteur_Pince ( DC, 12v, Shield l298n(2b), inclinaison pince )
const int Pin_Vitesse_Moteur_Pince =9;
const int Pin_Horaire_Moteur_Pince =30;
const int Pin_AntiHoraire_Moteur_Pince =31;
const int Pin_Joystick_2_Y =A3;

//Servo_Rotation_Pince ( Hitec, 10-190, 6v )
#include <Servo.h>
Servo Servo_Rotation_Pince;
const in Pin_Pot_Rotation_Pince = A6;
int Val_Pot_Rotation_Pince;
int Angle_Rotation_Pince;

//Servo_Serrage_Pince ( Hitec, 10-190, 6v )
Servo Servo_Serrage_Pince;
const in Pin_Pot_Serrage_Pince = A7;
int Val_Pot_Serrage_Pince;
int Angle_Serrage_Pince;

void setup() {

//Liaison serie
Serial.begin(9600);

//Moteur_Base
pinMode(Pin_Vitesse_Moteur_Base, OUTPUT);
pinMode(Pin_Horaire_Moteur_Base, OUTPUT);
pinMode(Pin_AntiHoraire_Moteur_Base, OUTPUT);

//Moteur_Bras_1
pinMode(Pin_Vitesse_Moteur_Bras_1, OUTPUT);
pinMode(Pin_Horaire_Moteur_Bras_1, OUTPUT);
pinMode(Pin_AntiHoraire_Moteur_Bras_1, OUTPUT);

//Moteur_Bras_2
pinMode(Pin_Vitesse_Moteur_Bras_2, OUTPUT);
pinMode(Pin_Horaire_Moteur_Bras_2, OUTPUT);
pinMode(Pin_AntiHoraire_Moteur_Bras_2, OUTPUT);

//moteur_Pince
pinMode(Pin_Vitesse_Moteur_Pince, OUTPUT);
pinMode(Pin_Horaire_Moteur_Pince, OUTPUT);
pinMode(Pin_AntiHoraire_Moteur_Pince, OUTPUT);

//Servo_Pince
Servo_Rotation_Pince.attach(12);
Servo_Serrage_Pince.attach(13);

}


void loop() {

//Moteur_Base
int Valeur_1_X = analogRead(Pin_Joystick_1_X);
int Vitesse_Moteur_Base = Valeur_1_X;
if(Vitesse_Moteur_Base > 510)
{
Vitesse_Moteur_Base -= 510;
digitalWrite(Pin_Horaire_Moteur_Base, HIGH);
digitalWrite(Pin_AntiHoraire_Moteur_Base, LOW);
}
else if(Vitesse_Moteur_Base < 490)
{
Vitesse_Moteur_Base = 490-Vitesse_Moteur_Base;
digitalWrite(Pin_Horaire_Moteur_Base, LOW);
digitalWrite(Pin_AntiHoraire_Moteur_Base, HIGH);
}
else
{
Vitesse_Moteur_Base = 0;
digitalWrite(Pin_Horaire_Moteur_Base, LOW);
digitalWrite(Pin_AntiHoraire_Moteur_Base, LOW);
}
Vitesse_Moteur_Base /= 2.5;
analogWrite(Pin_Vitesse_Moteur_Base, Vitesse_Moteur_Base);

//Moteur_Bras_1
int Valeur_1_Y = analogRead(Pin_Joystick_1_Y);
int Vitesse_Moteur_Bras_1 = Valeur_1_Y;
if(Vitesse_Moteur_Bras_1 > 510)
{
Vitesse_Moteur_Bras_1 -= 510;
digitalWrite(Pin_Horaire_Moteur_Bras_1, HIGH);
digitalWrite(Pin_AntiHoraire_Moteur_Bras_1, LOW);
}
else if(Vitesse_Moteur_Bras_1 < 490)
{
Vitesse_Moteur_Bras_1 = 490-Vitesse_Moteur_Bras_1;
digitalWrite(Pin_Horaire_Moteur_Bras_1, LOW);
digitalWrite(Pin_AntiHoraire_Moteur_Bras_1, HIGH);
}
else
{
Vitesse_Moteur_Bras_1 = 0;
digitalWrite(Pin_Horaire_Moteur_Bras_1, LOW);
digitalWrite(Pin_AntiHoraire_Moteur_Bras_1, LOW);
}
Vitesse_Moteur_Bras_1 /= 2.5;
analogWrite(Pin_Vitesse_Moteur_Bras_1, Vitesse_Moteur_Bras_1);


//Moteur_Bras_2
int Valeur_2_X = analogRead(Pin_Joystick_2_X);
int Vitesse_Moteur_Bras_2 = Valeur_2_X;
if(Vitesse_Moteur_Bras_2 > 510)
{
Vitesse_Moteur_Bras_2 -= 510;
digitalWrite(Pin_Horaire_Moteur_Bras_2, HIGH);
digitalWrite(Pin_AntiHoraire_Moteur_Bras_2, LOW);
}
else if(Vitesse_Moteur_Bras_2 < 490)
{
Vitesse_Moteur_Bras_2 = 490-Vitesse_Moteur_Bras_2;
digitalWrite(Pin_Horaire_Moteur_Bras_2, LOW);
digitalWrite(Pin_AntiHoraire_Moteur_Bras_2, HIGH);


else
{
Vitesse_Moteur_Bras_2 = 0;
digitalWrite(Pin_Horaire_Moteur_Bras_2, LOW);
digitalWrite(Pin_AntiHoraire_Moteur_Bras_2, LOW);
}
Vitesse_Moteur_Bras_2 /= 2.5;
analogWrite(Pin_Vitesse_Moteur_Bras_2, Vitesse_Moteur_Bras_2);

//Moteur Pince
int Valeur_2_Y = analogRead(Pin_Joystick_2_Y);
int Vitesse_Moteur_Pince = Valeur_2_Y;
if(Vitesse_Moteur_Pince > 510)
{
Vitesse_Moteur_Pince -= 510;
digitalWrite(Pin_Horaire_Moteur_Pince, HIGH);
digitalWrite(Pin_AntiHoraire_Moteur_Pince, LOW);
}
else if(Vitesse_Moteur_Pince < 490)
{
Vitesse_Moteur_Pince = 490-Vitesse_Moteur_Pince;
digitalWrite(Pin_Horaire_Moteur_Pince, LOW);
digitalWrite(Pin_AntiHoraire_Moteur_Pince, HIGH);
}
else
{
Vitesse_Moteur_Pince = 0;
digitalWrite(Pin_Horaire_Moteur_Pince, LOW);
digitalWrite(Pin_AntiHoraire_Moteur_Pince, LOW);
}
Vitesse_Moteur_Pince /= 2.5;
analogWrite(Pin_Vitesse_Moteur_Pince, Vitesse_Moteur_Pince);

// Servo_Rotation_Pince
Val_Pot_Rotation_Pince = analogRead(Pin_Pot_Rotation_Pince);
Angle_Rotation_Pince = map(Val_Pot_Rotation_Pince, 0, 1023, 10, 180);
Servo_Rotation_Pince.write(Angle_Rotation_Pince);

//Servo_Serrage_Pince
Val_Pot_Serrage_Pince = analogRead(Pin_Pot_Serrage_Pince);
Angle_Serrage_Pince = map(Val_Pot_Serrage_Pince, 0, 1023, 60, 120);
Servo_Serrage_Pince.write(Angle_Serrage_Pince);


//Infos sur moniteur serie
Serial.print("Base IN :");
Serial.print(Valeur_1_X);
Serial.print(" OUT :");
Serial.print(Vitesse_Moteur_Base);
Serial.print(" - Bras1 IN :");
Serial.print(Valeur_1_Y);
Serial.print(" OUT :");
Serial.print(Vitesse_Moteur_Bras_1);
Serial.print(" - Bras2 IN :");
Serial.print(Valeur_2_X);
Serial.print(" OUT :");
Serial.print(Vitesse_Moteur_Bras_2);
Serial.print(" - Pince IN :");
Serial.print(Valeur_2_Y);
Serial.print(" OUT :");
Serial.println(Vitesse_Moteur_Pince);

}

Télécommande sur microcontrôleur

52 : Push_G 53 : Push_D A3 : Axe_X_D
A4 : Axe_Y_D A0 : Axe_X_G
A1 : Axe_Y_G A6 : Pot_G A7 : Pot_D

Sorties contrôle moteur

PWM 10 : EnA(1) Base Vert PWM 5 : EnB(1) - Axe 1 Vert
PWM 11 : EnA(2) Axe 2 Orange PWM 9 : EnB(2) - Pince Noir
PWM 12 : Rotation Blanc PWM 13 : Serrage Noir

Sorties sur microswitch

Base : Num 22 In = Brun Out = Gris In1(1)
Num 23 In = Rouge Out = Violet In2(1)
Axe 1 : Num 24 In = Orange Out = Bleu In3(1)
Num 25 In = Jaune Out = Vert In4(1)
Axe 2 : Num 28 In = Brun Out = Gris In1(2)
Num 29 In = Rouge Out = Violet In2(2)
Pince : Num 30 In = Orange Out = Bleu In3(2)
Num 31 In = Jaune Out = Vert In4(2)

Connecteur moteur

Pin 1 : + Mot2 Pin2 : -Mot2 Pin10 : +Mot1 Pin11 : -Mot1
Pin24 : -Mot3 Pin25 : +Mot3 Pin21 : -Mot4 Pin22 : +Mot4
Pin4 : +Light Pin5 : -Light
Pin7 : PWM Rotation Pin8 : PWM Serrage
Pin19 : + Rotation Pin16 : + Serrage
Pin18 : - Rotation Pin15 : - Serrage

Connecteur microswitch

Pin24 : Secu Anti In1 Pin23 : Secu Anti Out1
Pin22 : Secu Hor In 1 Pin21 : Secu Hor Out 1
Pin17 : Secu Anti In 2 Pin18 : Secu Anti Out 2
Pin19 : Secu Hor In 2 Pin20 : Secu Hor Out 2
Pin1 : Secu Hor In 3 Pin2 : Secu Hor Out 3
Pin3 : Secu Anti In 3 Pin4 : Secu Anti Out 3
Pin5 : Secu Hor In 4 Pin6 : Secu Hor Out 4
Pin7 : Secu Anti In 4 Pin8 : Secu Anti Out 4

*/

Tout les axes pilotés par des moteurs ( les 4 premiers ) sont équipés de fin de course. Les fin de course sont cablés directement en série entre l'arduino et sa pin digitale appropriée sur le driver moteur. Quand un axe arrive en fin de course le signal est coupé directement sur le driver il est dès lors uniquement possible de repartir dans l'autre sens

Pour le piloter j'ai construit une petite télécommande filiaire avec 2 joysticks pour les 4 moteurs et 2 potentiometre pour les 2 servos. Il y également 2 switchs, 1 pour le projecteur + l'éclairage de l'armoire électrique et l'autre pour allumer l'ampermetre - voltmètre de l'armoire. La serrure centrale c'est pour démarrer et arrêter l'alimentation

J'ai fait un système de connectique avec deux paires de DB25. C'était surtout pour le côté pratique si y fallait le transporter

La pince se compose de 2 servos type MG996R.
Un en axe de rotation et un autre pour serrer la pince. Ils sont alimentés par un convertisseur 12-6 18w.
Il y a aussi un petit projecteur 😁

Le microcontroleur est un arduino mega chinois avec lequel il faut le driver CH340. Malgré cela il fonctionne aussi bien qu'un original

J'ai utilisé des moteurs de stores 12V DC avec un système de vis sans fin. Même lorsqu'ils ne sont pas alimentés il ont un verouillage mécanique et garde leur position. Ces 4 moteurs pilotent la base et les 3 bras suivants. Ils sont drivés par des l298n
Sur la base, le bras 2 et le bras 3 il y a un système de poulie courroie avec rapport qui augmente le couple
Sur le bras 1 c'est en direct sur un plus gros moteur avec 2 arbres de sortie

À l'époque je n'avais pas d'imprimante 3D donc le bras est entièrement en acier, en alu et la base en bois

Pour alimenter le bras j'avais opté pour une alimentation d'ordinateur type ATX ... J'avais fait une ou deux bidouilles dessus si je me rappel bien comme mettre un certain fil à la masse avec une resistance de puissance 5 ohm 10w car ce type d'alimentation à besoin d'une charge pour démarrer et en connecter deux autres avec une serrure de contact pour démarrer ainsi qu'une led pour bien décharger les condos lors de l'extinction.
Je n'ai utilisé que le 12V

Je vais commencer par présenter la bête tel qu'elle est actuellement

Il y a bien longtemps, dans une galaxie lointaine, très lointaine 😉 j'ai fabriqué un bras robot que j'aimerais à présent piloter via Vigibot

J'ai fait un pont diviseur de tension avec des résistance de 9K et 18K pour etre au plus proche des 5V admissible sur les broches du nano quand mon accu est à 12.8V qui est la tension maximum que j'ai observée lors de la charge.

J'ai finalement choisi une tension de 12V à 100% et 10.5 à 0% cela devrait me laisser une autonomie de 2 bonnes heures avec utilisation modérée sans passer par la station de charge et faire durer mon accu un bon bout de temps 

Au niveau du code j'ai juste ceci au final

const int pinVoltage = A0;
int value = 0;
int valuePi = 0;

void setup() {

pinMode(pinVoltage,INPUT);

}

void loop() {

value = analogRead(pinVoltage);
value = constrain(value, 685, 790);
valuePi = map(value, 685, 790, 0, 255); 

}

const int pinVoltage = A0;
float voltageNano = 0.0;
float voltageAccu = 0.0;
float R1 = 22000.0;
float R2 = 5600.0;
int value = 0;
int Pi = 0;


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

}

void loop() {

value = analogRead(pinVoltage);
voltageNano = (value * 5.0) / 1024;
voltageAccu = (voltageNano / (R2/(R1+R2)))+0.5;
value = constrain(value, 410, 494);
Pi = map(value, 410, 494, 0, 255); 
Serial.print(value);
Serial.print("     ");
Serial.print(voltageAccu);
Serial.print("     ");
Serial.println(Pi);
delay(1000);

}

Voilà j'ai fait un petit code qui va de 10.4v jusqu'à 12.4 en donnant respectivement de 0 à 255 et si ca descend plus bas que 10.4 ca reste à 0 et si plus haut que 12.4 ca reste à 255...
ya un delay c'est pour voir plus clair dans le moniteur série après on le gicle.
Maintenant comment intégrer mon petit code dans ton code exemple serial arduino je suis pas sur du tout

Okay je me tâte à utiliser un mini pro pour éviter le convertisseur logique mais du coup pour televerser du code obliger de switcher tx rx du Pi au câble à chaque fois je vais opter pour le nano + convertisseur et des petits switch en serie sur rx tx pour pas qui est de conflit avec le Pi pendantle televersement du programme...
J'ai déjà récupéré des tensions dans un arduino avec un pont resistif et une petite transformation de valeures avec un bout de code mais je me demande au final pour vigibot il faut quoi ? Un pourcentage ? Une valeure de tension en volt directement ? Une valeure entre 0 et 1024 ?

Je pense rajouter un arduino nano pour avoir plus de possibilités...
J'ai vu passer sur le discord Vigibot une possibilité d'avoir un retour de la tension de la batterie directement sur l'interphase même avec un accu 12v ...

Le parchoc arrière installé

J'ai déjà Henry qui s'occupe de ca 😁

J'ai mis du feutre sur le parchoc pour une meilleure absorption des chocs

Le parchoc arrière en production

Le dessous du chassis n'est pas en reste niveau protection

Un bon parchoc 100% infill en PETG pour les fous du volant

Voila " WallV " est en ligne sur Vigibot
Voici mon système de charge magnétique avec Voltmètre pour surveiller la tension de l'accu directement avec la camera
J'attend une ventouse que j'ai commandé pour faire la station de charge du robot

Salut! on est en train de faire une migration donc on a bloqué l'édition. Je te préviens dès que c'est de nouveau en place. cela ne devrait plus trop tarder.

Super je me rejouis !! A bientôt alors