71 réponses à ce sujet

[Vinchator]

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

Image(s) jointe(s)

• 

[Vinchator]

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

Image(s) jointe(s)

• 

[Vinchator]

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

Image(s) jointe(s)

• 

[Vinchator]

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

Le parchoc arrière en production

Image(s) jointe(s)

• 
• 

[Mike118]

tu pourrais lui mettre balais avec ramasse miette x) quand les gens se baladeront ils feront le ménage =)

[Vinchator]

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

Image(s) jointe(s)

• 

[Mike118]

On va concurrencer henry !

[Vinchator]

Le parchoc arrière installé

Image(s) jointe(s)

• 

[Vinchator]

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

[Mike118]

Oui c'est faisable. 

Pour référence : https://www.robot-ma...cation-example/ 

Par contre attention => On a un système temps réel => Faire du code arduino "temps réel " = interdit d'utiliser des fonctions bloquantes et des delay etc ... 
 

[Vinchator]

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 ?

[Mike118]

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 ?

 

alors il faut savoir qu'actuellement tu as deux  type de case mémoire possible pour envoyer tes valeurs personnalisées => Les val8 ou les val16 . 

Les val8 sont codés sur 8 bits. 
Les val16 sont codés sur 16 bits. 

Donc si tu veux de la précision tu peux le stocker sur un val 16 sinon tu peux le stocker sur un val 8. 

Ensuite au niveau du stockage tu pourra définir manuellement tes plages min et max sur le site, il faudra juste que tu sois cohérent entre le site et ton code arduino. 


Exemple si tu choisis un val8 ( de 0 à 255) 

Tu peux choisir min 0 = 0V      255 = 12.6V il faudra juste que ton code arduino fasse cette conversion...

Mais pour avoir plus de résolution tu peux aussi choisir : min 0 = 8.7V  et 255 = 12.6V 
Ainsi ta barre en haut du site sera vraiment " vide " quand tu aura 8.7V au lieu de 0V que tu ne verra jamais de toute façon ... 

 

[Vinchator]

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

[Vinchator]

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

}

[Vinchator]

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

}

[Mike118]

après avoir mis un 5ème val 8 sur la conf RX du site et dans la structure structure du code arduino et mis à jour la taille de la trame : 
 

#define TXFRAMESIZE (NBPOSITIONS * 4 + 18)   // NBPOSITIONS * 4 + 17 by default + 1 for the val8 added

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];               // 4 by default => Now set to 5 = 4 + 1
  };

  uint8_t bytes[TXFRAMESIZE];
 };
} TrameTx;

Tu peux mettre ton code sous forme de fonction , 

 

uint8_t getVoltage255 () {
   return constrain(map(analogRead(A0), 685, 790, 0, 255), 0, 255);
}

il te suffira alors de modifier la fonction " writePiSerial() " avec 

 

trameTx.val8[4] = getVoltage255();   

[Vinchator]

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

[Vinchator]

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

[Vinchator]

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

Image(s) jointe(s)

• 
• 

[Vinchator]

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