Voila WallV est en ligne la camera fonctionne super bien
J'ai essayé de régler la config des moteurs mais quand je fait verifier et enregistrer j'ai AJAX POST error qui s'affiche ...
Comment régler la course des servos ?

Content pour toi !

Mais alors, pourquoi un char ?

J'aime les chars 😂

Merci Mike
Apparemment la led encaisse elle ne chauffe pas à voir à la longue je préviens si il lui arrive malheur

Chacun fait comme il veut ! =) 

Dès que tu commences à câbler le robot, note bien sur quel pin de la raspberry pi tu branches quoi pour que je puisse t'aider pour la config sur le site web. On a pas encore la tonne de documentation mais on compense avec de l'assistance ++ =) 

Super merci du tuyau je le ferais

Je vais changer mon système de charge et mon accu actuel car mon chargeur de basse qualité parasite les servos quand le robot est en veille et l'accu 12v 3s à une capacité bien inférieure à la valeure annoncée. Le nouveau système sera un module avec tension et courant constant, un bms externe et 3 cellules li-ion que je vais récupérer dans un vieux portable

Chacun fait comme il veut ! =) 

Dès que tu commences à câbler le robot, note bien sur quel pin de la raspberry pi tu branches quoi pour que je puisse t'aider pour la config sur le site web. On a pas encore la tonne de documentation mais on compense avec de l'assistance ++ =) 

Je ne suis pas très habitué au raspberry mais vu le nombre de sorties pwm je suppose avoir besoin d'une carte de ce type ? Pour les signaux pwm des drivers de moteurs dc on peut utilisé la même carte ?
Et en fait est ce que les commandes de pilotage sur Vigibot permettent de piloter les moteurs des roues ou chenilles en controlant la vitesse ou seulement en " tout ou rien " ?

Pour la charge vu que tu utilises du matériel adapté c'est bon =) 
Par contre pour la décharge, est ce que tu as quelque chose qui protège te batterie de la décharge profonde ?

Je n'ai rien prévu contre cela je pensais prendre l'habitude de ramener le robot à la station de charge après utilisation mais je pourrai chercher une petite carte avec un relai pour l'éteindre si cela arrive

Une carte de ce type

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

}

J'ai eu une petite idée qui est la suivante...
Je vais utiliser un axe et deux paliers pour la rotation de la tourelle et modeliser deux pignons.
Un pour l'axe de rotation et un pour aller directement sur le servo avec un rapport 2:1 comme ca j'aurais un grand angle de rotation

Ci-dessus le code televersé dans l'arduino

Avec l'aide de Mike j'ai intégré la fonction qui récupère une valeur sur 8 bits ( 0 à 255) proportionnel à la tension de l'accu dans le code exemple pour communiquer avec Vigibot via le Pi en liaison série. Du coté de Vigibot le barre graphe voltage à été adapté à ma plage de tension. Il y a également une moyenne qui est faite sur 100 mesures pour avoir un affichage moins oscillant dans le barre graphe



Ci dessous des photos du nano et de la case ou il sera monté. Il me manque encore un convertisseur de logique 3.3-5 pour les pins RX/TX pour finaliser et faire le test final

Voilà mon système pour avoir un meilleur angle de rotation...
Lol c'est du costaud... un peu trop peu être

Y a t-il des escaliers dans ta maison ?

Bonjour

😁 non tout est à plat

Rapport 1,7 ... la tourelle peut faire 180 degrés et -180 degrés

Et voila ! Plus que le système de charge j'attend encore 1 ou 2 pièces... Demain je m'occupe de la micro SD et il sera en ligne

Finalement je vais faire une tourelle simple je tournerais les chenilles pour l'angle de vision
J'ai modélisé un chassis un peu plus large je vais mettre l'accu 12v , le 12-5 pour le pi et le 12-6 pour les servos dessous comme ca dessus y aura que la cam, le pi et le driver moteur

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

Joli ! =) c'est quoi ce que tu utilises comme servomoteur ?

Merci
J'ai mis ca sur le premier post du sujet

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

}

Joli ! =) c'est quoi ce que tu utilises comme servomoteur ?

En parlant de servo il me vient une question..
Est ce que je pourrais régler la course maximale des servos ou est ce qu'il faut que je prevoit le débattement maximum sans obstacles ?

/*
 * Vigibot Pi to Arduino Uart default remote configuration example by Mike118                     
 * Exemple pour récupérer la tension de la batterie réalisé par vinchator
 */




// Meta Type : 

typedef struct {
 union {
  struct {
   uint16_t x;
   uint16_t y;
  };
  uint16_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;


// CONFIG 

#define PISERIAL Serial
#define NBPOSITIONS 2
#define FAILSAFE 250 // ms


// TTS 

#define TTSBUFFERSIZE 255  
uint8_t ttsBuffer[TTSBUFFERSIZE];
uint8_t ttsCurseur = 0;


// TX

#define TXFRAMESIZE (NBPOSITIONS * 4 + 18)

typedef struct {
 union {
  struct {
   uint8_t sync[4];               // 4
   Point positions[NBPOSITIONS];  // NBPOSITIONS * 4
   uint16_t val16[2];             // 2 * 2
   uint8_t choixCameras;          // 1
   Vitesses vitesses;             // 3
   uint8_t interrupteurs;         // 1
   uint8_t val8[5];               // 5
  };

  uint8_t bytes[TXFRAMESIZE];
 };
} TrameTx;


// RX

#define RXFRAMESIZE (NBPOSITIONS * 4 + 9)

typedef struct {
 union {
  struct {                       // Sizes
   uint8_t sync[4];              // 4
   Point positions[NBPOSITIONS]; // NBPOSITIONS * 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();

const int nEchantillons = 100;      //nombre d'échantillons
int moyenne = 0;                    //moyenne des échantillons
int total = 0;                      //somme des échantillons
int indice = 0;                     //indice de l'échantillon courant
int echantillon[nEchantillons];     //tableau de stockage des échantillons


void setup() {
  PISERIAL.begin(115200);
  
  pinMode(A0, INPUT);
  for (int i =0; i< nEchantillons; i++)  //remplissage du tableau avec des 0
  {echantillon[i] = 0;}
}


void loop() {

  total = total - echantillon[indice];  // soustraction de l'échantillon précédent
  echantillon[indice] = constrain(map(analogRead(A0), 680, 820, 0, 255), 0, 255); //lecture de A0
  total = total + echantillon[indice];  //ajout du dernier échantillon
  indice++;  // incrémentation de l'indice
  if (indice >= nEchantillons) {
   indice = 0;                        // retour au début si on est à la fin du tableau
  }
  moyenne = total / nEchantillons;

  
  
  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.positions[i].x trameRx.positions[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 = 4; i < RXFRAMESIZE; i++)  // Do not send the 4 sync data in the tts buffer
       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';  
 trameTx.sync[2] = ' ';
 trameTx.sync[3] = ' '; 

 // modify the feedback according your need. By default we copy the trameRx content ... 
 for(uint8_t i = 0; i < NBPOSITIONS; i++) {
  trameTx.positions[i].x = trameRx.positions[i].x;
  trameTx.positions[i].y = trameRx.positions[i].y;
 }
 trameTx.val16[0] = 0;   // Voltage 
 trameTx.val16[1] = 0;   // Percent 
 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] = 0;  // CPU load
 trameTx.val8[1] = 0;  // Soc temp
 trameTx.val8[2] = 0;  // Link
 trameTx.val8[3] = 0;  // RSSI
 trameTx.val8[4] = getVoltage255();

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

uint8_t getVoltage255 () {
        return moyenne; 
}

Quelques photos du robot presque terminé

Voilà WallV qui reprend des forces sur sa station de charge

Pour mon système de charge j'ai déjà un chargeur dédié qui se coupe quand l'accu est chargé je compte juste placer le connecteur magnétique et le petit adaptateur micro usb entre deux. Je compte mettre un petit voltmètre que je pourrais observer directement avec la camera. D'un point de vue sécurité cela devrait être suffisant ou il faudrait quand même une carte supplémentaire pour la gestion de la charge ??

J'ai eu quelques court circuit lors de la mise en charge du robot... En fait j utilise un système frontal avec un câble très rigide pour qu'il reste droit. Quand le robot avance un peu trop contre le câble lors de la connexion la partie extérieur du connecteur coté base fait un pont entre le 12 et 0 du connecteur coté robot. Pour palier à ca j'ai rendu mon câble mobile dans le presse étoupe. A l'aller c'est le parchoc du robot qui fait butée contre la base et au décrochage c'est la butée blanche installée sur le câble... Depuis plus de problème