Ajout d'un petit ventilateur pour WallV car depuis l'ajout de la fonction de surveillance de la température du CPU sur Vigibot je me suis rendu compte que le Pi avait un peu chaud dans sa case en impression 3D : 63 degrés

Avancée de la station de charge du robot avec un chargeur exprès pour le lithium-ion 3S.
J'ai rajouté un voltmètre ampermètre pour savoir ou en est le chargeur dans son processus de charge

Non non c'est à titre préventif

Note a moi-même : isoler les resistances avec de la colle chaude ou une gaine thermo

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

Il me reste encore quelques petites choses à finir pour profiter pleinement de ce robot comme
- Terminer la station de charge avec le câble magnétique
- Finir le montage de l'arduino avec le convertisseur logique pour recevoir la tension de l'accu sur Vigibot
- Monter la nouvelle case pour le Pi avec le ventilateur piloté par une GPIO pour qu'il se coupe quand le robot est en veille
- Faire un accu 3S avec un BMS et des cellules de qualité avec une capacité de 3400mAh
-Remplacer les moteurs 370rpm par des 200rpm pour plus de couple et de précision

Voila le système de ventilation est terminé.
Un transistor 2N2222 est monté pour piloter le ventilateur avec une gpio.
Avant ventilation : 63 degrés
Après ventilation : 40 degrés

J'ai posé un laser 1mw piloté par le pi via un mosefet pour jouer avec les chats je posterai une photo prochainement

En passant la led du câble de charge à finalement rendu l'âme ( 12v à la place de 5v prévu) mais cela n'affecte pas 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

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

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

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

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

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

Le parchoc arrière installé

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

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

}

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

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

}

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 souhaite construire un robot explorateur sur un chassis à chenille TS100 avec une caméra FPV Foxeer Mini sur servos avec son émetteur, une petite pince à l'avant genre mandibules et un phare.
Je compte piloter le robot à distance avec une télécommande basée sur un hc12, arduino, ecran lcd et récepteur pour la vidéo et écran tactile nextion pour les commandes

Je n'est pas encore commencé le projet ni commandé le matériel. Je me demande, par rapport à la télécommande si c'est possible d'utiliser un écran nextion qui utilise tx et rx de l'arduino pour ensuite envoyer les ordres sur le hc12 émetteur. Est ce qu'il risque d'y avoir conflit sur le port série ?
Serait il plus judicieux d'utiliser des joysticks et des slicers hard plutôt que de les faire en soft sur le nextion ?

Cela serait chouette via Vigibot