Hello.

Euh ce ne sont pas les "for" et les "while" qui sont problématiques bien au contraire c'est obligatoire.

Ce qui compte c'est le temps d'exécution et donc le code que tu mets dedans et le nombre d'itérations VERSUS les performances que t'as besoin.

delay est ok au boot (fonction setup) mais des tout petits delais pour initialiser du hardware ça passe.

Après dans un contexte d'exécution normal devoir utiliser delay signifie code caca. A recoder avec utilisation du timer (millis...) et des machines d'états = switch case case case...

ça, c'est la base :

http://playground.arduino.cc/Code/SimpleTimer

Tu mets le run dans la boucle principal et tu peux exécuter des fonctions à intervalle précis.

@Pascal, j'ai retrouvé le compromis qu'il faut faire avec un PIC32 et un rplidar. C'est les 2K. Pour avoir les 4K, il faut du CPU comme celui d'un raspberry.

Je viens de finir mon avancement du cloud pour aujourd'hui ! premier fonctionnement avec succès maintenant plus que des détails...

Pourquoi un compromis avec le PIC32 ? On fais tout fonctionner dessus et en 4K SVP d'ou le fameux thread de dev C d'un driver optimisé RPLIDAR spécial 4K lol

Mais le Due doit être aussi bien j'ai pris le PIC32 car plus de périphériques il me semble puis surtout a l'époque je codais dessus direct en MPLAB sans framework Arduino du coup j'ai continué dessus lol

Pourquoi tu étudies pas notre code C avec jojo ? D'ailleurs ça doit se porter sur n'importe puce sans trop forcer sous réserve de port série avec de gros FIFO

car j'en ai chier avec le datasheet PIC32 pour coder le driver UART interrupt avec FIFO custom.

Après les compromis sont obligatoires t'en a partout, la nature même de l'électronique force à un agrégat de compromis.

Après ce que tu n'aime pas c'est la bouïne. Effectivement un protocole ASCII entre 2 machines qui peuvent parler le binaire couramment c'est de la bouïne:)

T'as des compromis bouïneux et des compromis classe. lol

En dehors de devoir prévoir l'espace des données... le binaire c'est peu de complexité de dev supplémentaire pour beaucoup d'optimisation

EDIT : au final c'est le même boulot car il faut forcément maîtriser les type des données reçues pour pouvoir les utiliser dans les algos donc zéro pointé le protocole ASCII... Quitte à faire une couche d'abstraction autant faire des trames binaires de longeur variable avec séparation du modèle de données

Tu peux voir que j'ai fait la même chose sous une forme différente pour la récupération directe du signe du deltaAnglesQ3 :

On fait un benchmark ? lol

void readLidar() {
 static bool init = false;
 uint8_t current;
 static uint8_t n = 0;
 static uint8_t checksum;
 static uint8_t sum = 0;
 static uint16_t startAngleQ6;
 bool start;
 static uint16_t diffAngleQ6;
 static uint16_t oldStartAngleQ6 = 0;
 int32_t diffAngleTotalQ6;
 int32_t angleBrutQ6;
 static int32_t oldAngleBrutQ6;
 int32_t angle;
 static uint8_t deltaAnglesQ3[NBMESURESCABINES];
 static uint16_t distances[NBMESURESCABINES];
 static uint8_t m = 0;
 static uint8_t s = 0;

 if(!up) {
  init = false;
  return;
 }

 while(RXLIDAR.available()) {
  current = RXLIDAR.read();

  switch(n) {

   case 0:                                                                             // Début de réception de l'en-tête
    if(current >> 4 == 0xA) {
     checksum = current & 0xF;
     n = 1;
    }
    break;

   case 1:
    if(current >> 4 == 0x5) {
     checksum |= current << 4;
     n = 2;
    } else
     n = 0;
    break;

   case 2:
    sum ^= current;
    startAngleQ6 = current;
    n = 3;
    break;

   case 3:
    sum ^= current;
    startAngleQ6 |= (current & 0x7F) << 8;
    start = current >> 7;                                                              // Fin de réception de l'en-tête
    if(start)
     TXDEBUG.println("start");

    if(!init) {                                                                        // Ne pas calculer sans cabines
     init = true;
     n = 4;
     break;
    }

    diffAngleQ6 = startAngleQ6 - oldStartAngleQ6;                                      // Calculer l'angle entre deux mesures de référence
    if(oldStartAngleQ6 > startAngleQ6)
     diffAngleQ6 += UNTOURQ6;

    diffAngleTotalQ6 = 0;
    for(uint8_t i = 0; i < NBMESURESCABINES; i++) {

     angleBrutQ6 = (oldStartAngleQ6 + diffAngleTotalQ6 / NBMESURESCABINES) % UNTOURQ6; // Calculer l'angle non compensé
     diffAngleTotalQ6 += diffAngleQ6;

     if(oldAngleBrutQ6 > angleBrutQ6) {                                                // Détection du passage par zéro de l'angle non compensé
      lidarReady = true;

      // Ici détection du passage par l'angle zéro
      // Ici remise à zéro de l'index du tableau de stockage final

     }
     oldAngleBrutQ6 = angleBrutQ6;

     if(distances[i]) {                                                                // Si la lecture est valide
      angle = angleBrutQ6 - (deltaAnglesQ3[i] << 3);                                   // Calculer l'angle compensé
      angle = angle * 65536 / UNTOURQ6;                                                // Remise à l'échelle de l'angle

      //
      // Ici distances[i] et angle sont OK !
      // Ici arithmétique entière et stockage des résultats dans un tableau global
      //

     }

    }
    oldStartAngleQ6 = startAngleQ6;

    n = 4;
    break;

   default:                                                                            // Début de réception des cabines
    sum ^= current;
    switch(m) {
     case 0:
      deltaAnglesQ3[s] = (current & 0b11) << 4;
      distances[s] = current >> 2;
      m = 1;
      break;
     case 1:
      distances[s] |= current << 6;
      m = 2;
      break;
     case 2:
      deltaAnglesQ3[s + 1] = (current & 0b11) << 4;
      distances[s + 1] = current >> 2;
      m = 3;
      break;
     case 3:
      distances[s + 1] |= current << 6;
      m = 4;
      break;
     case 4:
      deltaAnglesQ3[s] |= current & 0b1111;
      deltaAnglesQ3[s + 1] |= current >> 4;
      m = 0;
      s += 2;
      if(s == NBMESURESCABINES) {
       if(sum != checksum) {
        TXDEBUG.println("checksum");
        init = false;                                                                  // Ne pas faire les calculs pour ces cabines
       }
       n = 0;
       s = 0;
       sum = 0;
      }
      break;
    }
    break;

  }
 }

}

Puis sur un Arduino faut tant que possible bosser en 8-bits types uint8_t ou int8_t et utiliser le wrap:)

Euh c'est grâce aux interruptions levées par rapport à l'état du FIFO hardware que tu peux ajouter un plus gros buffer software derrière ! et c'est ce que j'ai fait:)

Après il est possible de le faire full hardware en configurant le module DMA qui permet des écritures directement en RAM sans passer par le CPU.

Versus comme je fais avec mon processus logiciel de bête copie de variables qui se trouve dans une interruption et qui est exécuté par le CPU.

Vu que tu parles de conversion du polaire en cartésien je te colle la totalité de du driver qui la comprend ainsi que le calage des array[0] au Theta zéro du lidar. Tu parles aussi de pb d’ordonnancement de mon côté j'ai au pire une seule "méta"cabine à traiter en integermaths ce qui ne foire pas l'ordonnancement. Je suis curieux de voir ton avancement.

cos16() et sin16() fonctions qui exploitent une lookup de 16 bits de taille sur 16 bits d'amplitude directement en mémoire flash pour les maths integer.

#define PI16 0x8000
#define PISURDEUX16 0x4000
#define UN16 0x8000

const uint16_t sinTable16[] {
 0x8000, 0x8003, 0x8006, 0x8009, 0x800C, 0x800F, 0x8012, 0x8015, 0x8019, 0x801C, 0x801F, 0x8022, 0x8025, 0x8028, 0x802B, 0x802F,
 0x8032, 0x8035, 0x8038, 0x803B, 0x803E, 0x8041, 0x8045, 0x8048, 0x804B, 0x804E, 0x8051, 0x8054, 0x8057, 0x805B, 0x805E, 0x8061,
... sinus ...
 0x7F9E, 0x7FA1, 0x7FA4, 0x7FA8, 0x7FAB, 0x7FAE, 0x7FB1, 0x7FB4, 0x7FB7, 0x7FBA, 0x7FBE, 0x7FC1, 0x7FC4, 0x7FC7, 0x7FCA, 0x7FCD,
 0x7FD0, 0x7FD4, 0x7FD7, 0x7FDA, 0x7FDD, 0x7FE0, 0x7FE3, 0x7FE6, 0x7FEA, 0x7FED, 0x7FF0, 0x7FF3, 0x7FF6, 0x7FF9, 0x7FFC, 0x8000
};

int16_t sin16(uint16_t angle) {
 return sinTable16[angle] - UN16;
}

int16_t cos16(uint16_t angle) {
 return sin16(PISURDEUX16 - angle);
}

lidarsx[j] et y[i] // Cartésiennes dans le plan du ROBOT

lidarsCartex[j] et y[i] // Cartésiennes dans le plan de la CARTE après filtrage des points qui sont DANS le robot !!!

pointOdometrie.x et .y // Odométrie absolue et corrigée du robot (sortie de boucle de correcteur d'estimation).

void readLidar() {
 static bool init = false;
 uint8_t current;
 static uint8_t n = 0;
 static uint8_t checksum;
 static uint8_t sum = 0;
 static uint16_t startAngleQ6;
 bool start;
 static uint16_t diffAngleQ6;
 static uint16_t oldStartAngleQ6 = 0;
 int32_t diffAngleTotalQ6;
 int32_t angleBrutQ6;
 static int32_t oldAngleBrutQ6;
 int32_t angle;
 static uint8_t deltaAnglesQ3[NBMESURESCABINES];
 static uint16_t distances[NBMESURESCABINES];
 static uint8_t m = 0;
 static uint8_t s = 0;
 static uint16_t j = 0;

 if(!up) {
  init = false;
  return;
 }

 while(RXLIDAR.available()) {
  current = RXLIDAR.read();

  switch(n) {

   case 0:                                                                             // Début de réception de l'en-tête
    if(current >> 4 == 0xA) {
     checksum = current & 0xF;
     n = 1;
    }
    break;

   case 1:
    if(current >> 4 == 0x5) {
     checksum |= current << 4;
     n = 2;
    } else
     n = 0;
    break;

   case 2:
    sum ^= current;
    startAngleQ6 = current;
    n = 3;
    break;

   case 3:
    sum ^= current;
    startAngleQ6 |= (current & 0x7F) << 8;
    start = current >> 7;                                                              // Fin de réception de l'en-tête
    if(start)
     TXDEBUG.println("start");

    if(!init) {                                                                        // Ne pas calculer sans cabines
     init = true;
     n = 4;
     break;
    }

    diffAngleQ6 = startAngleQ6 - oldStartAngleQ6;                                      // Calculer l'angle entre deux mesures de référence
    if(oldStartAngleQ6 > startAngleQ6)
     diffAngleQ6 += UNTOURQ6;

    diffAngleTotalQ6 = 0;
    for(uint8_t i = 0; i < NBMESURESCABINES; i++) {

     angleBrutQ6 = (oldStartAngleQ6 + diffAngleTotalQ6 / NBMESURESCABINES) % UNTOURQ6; // Calculer l'angle non compensé
     diffAngleTotalQ6 += diffAngleQ6;

     if(oldAngleBrutQ6 > angleBrutQ6) {                                                // Détection du passage par zéro de l'angle non compensé
      lidarReady = true;
      lidarsx[j] = MESURENULLE;
      lidarsy[j] = MESURENULLE;
      lidarsCartex[j] = MESURENULLE;
      lidarsCartey[j] = MESURENULLE;
      j = 0;
     }
     oldAngleBrutQ6 = angleBrutQ6;

     if(distances[i]) {                                                                // Si la lecture est valide
      angle = angleBrutQ6 - (deltaAnglesQ3[i] << 3);                                   // Calculer l'angle compensé
      angle = angle * 65536 / UNTOURQ6;                                                // Remise à l'échelle de l'angle

      // Passage du plan du lidar au plan du robot
      lidarsx[j] = POSITIONLIDARX + distances[i] * sin16(angle) / UN16;                // Enregistrement cartésien
      lidarsy[j] = POSITIONLIDARY + distances[i] * cos16(angle) / UN16;

      if(lidarsx[j] > POSITIONSROBOTXMAX || lidarsx[j] < POSITIONSROBOTXMIN ||
         lidarsy[j] > POSITIONSROBOTYMAX || lidarsy[j] < POSITIONSROBOTYMIN) {         // Si la lecture est hors du robot

       // Passage du plan du robot au plan de la carte
       lidarsCartex[j] = pointOdometrie.x + (lidarsx[j] * cos16(theta16) - lidarsy[j] * sin16(theta16)) / UN16;
       lidarsCartey[j] = pointOdometrie.y + (lidarsx[j] * sin16(theta16) + lidarsy[j] * cos16(theta16)) / UN16;

       if(j < NBMESURESMAX - 1)                                                        // Si il reste de la place dans les tableaux
        j++;
       else
        lidarReady = false;
      }
     }

    }
    oldStartAngleQ6 = startAngleQ6;

    n = 4;
    break;

   default:                                                                            // Début de réception des cabines
    sum ^= current;
    switch(m) {
     case 0:
      deltaAnglesQ3[s] = (current & 0b11) << 4;
      distances[s] = current >> 2;
      m = 1;
      break;
     case 1:
      distances[s] |= current << 6;
      m = 2;
      break;
     case 2:
      deltaAnglesQ3[s + 1] = (current & 0b11) << 4;
      distances[s + 1] = current >> 2;
      m = 3;
      break;
     case 3:
      distances[s + 1] |= current << 6;
      m = 4;
      break;
     case 4:
      deltaAnglesQ3[s] |= current & 0b1111;
      deltaAnglesQ3[s + 1] |= current >> 4;
      m = 0;
      s += 2;
      if(s == NBMESURESCABINES) {
       if(sum != checksum) {
        TXDEBUG.println("checksum");
        init = false;                                                                  // Ne pas faire les calculs pour ces cabines
       }
       n = 0;
       s = 0;
       sum = 0;
      }
      break;
    }
    break;

  }
 }

}

la vache mais quelle idée de commencer en ASCII avec un système haut niveau or qu'il est plus simple et logique de comprendre des octets 8 bits et des mots 16 bits pour les types bas niveau.

Je voulais un driver qui se suffit a lui même car d'origine j'ai un FIFO UART hardware de 8 octets de profondeur.

Le portage de l'API Arduino pour PIC32 s'appelle ChipKit et la dedans ils ont mis une salopperie de while(1) bloquant le temps que ça se vide, pendant la transmission !!!! j'ai crié au scandale chez les développeurs, et après une quantité astronomique d'échanges avec Matt (je pense le meilleur dev du projet ChipKit) voir https://github.com/c...core/issues/326on a fini par réussir à fiabiliser le truc (j'en ai chié) ça fait pas très longtemps que j'avais des corruptions d'un octet de temps en temps.

Maintenant j'ai un FIFO "illimité" via interruptions qui exploite correctement le FIFO hardware de 8 octets,en TX et en RX sur les 6 UARTs. Je pourrais gratter 1% de CPU en passant en DMA mais a quoi bon... C'est du code non portable je préfère maximiser le générique

65% du FIFO de 128k aucun problème si le code temps réel est bien fait et ne le laisse pas atteindre 100%

lol. Mais 16MHz pour faire de l'odométrie mecanum c'est très très très très très très large.

Et des trames binaires c'est largement plus K.I.S.S que de l'ASCII caca !

Le contrôleur qui se prononce comme le fruit acide est une tuerie atomique je dirais ce qui se fait de mieux sur le marché si on veux du PWM de cette taille.

ton moteur est 2* plus réduit que celui de mon robot actuel.

j'avais fait un compromis vitesse max précision pas trop dégueu...

mais pour de l'autopilote optimal à vitesse max comme je fais ton moteur est encore plus adapté que le mien car plus de précision et le supplément de vitesse que j'ai je ne m'en sert que rarement (et pilotage manuel).

Top !

Moi j'suis arrivé sur un grave problème de moteurs inutilisable pour mon type de projet sur le petit robot (ou la précision et la vitesse doivent aller de paire), j'ai du fedexer aux US pour ne pas être bloqué et dégouté pendant mes 2 semaines de congé.

J'ai mis un post plus complet ici http://www.robot-maker.com/forum/topic/11316-robot-pilotable-a-distance-via-internet-de-maniere-securise/page-3#entry91032

en résumé il faut un moteur qui tourne très vite avec une boite de réduction qui démultiplie fort - je suis passé de 34 à 100 mais je garde 150RPM sur l'arbre de sortie sans survolter le moteur!.

Hop stared merci:D

Ou alors tu balades le lidar à la main et tu mets une IMU pour connaître son attitude:)

Surtout si l'angle est prononcé tu vas mesurer le sol lol comme le petit robot quand il monte sur un gros tapis ben fouac ça stop l'autopilote (obstacle)

Mais c'est quoi cette bouïne moi j'arrive à tout caser sur un arduino 8 bits 16MHz : la lecture des 4 encodeurs, la génération des 4 PWM, l'asservissement PID de tout ça, et l'odométrie + le protocole de trame radio temps réel à faible latence. et ça fonctionne absolument aussi bien que sur un PIC32 que j'ai mis uniquement pour traiter des milliers de points lidars et faire l'autopilote avec jojo.

Niveau charge CPU un seul arduino peux virtuellement gérer une dizaine de robots en pilotage manuel avec odométrie et asservissement et protocole faible latence.

EDIT : il suffit de quelques pages de code C pour un robot MECANUM complet asservi, odométriesé et pilotable via télécommande...

L'arduino peux aussi gérer une centrale inertielle complète en plus de tout ça... la preuve mes drones volent très bien:)

Le PIC32 80MHz c'est uniquement pour le défi de l'autopilote au lidar !

EDIT2 : avant que je connaisse jojo j'avais tout ça sur l'Arduino + la lecture de 8 capteurs ultrasons PWM et 12 télémètres infrarouges linéarisés + lecture courant + tension batterie. C'était le premier robot mecanum en ligne.

Pb d'ICC mdr !!!

Ah oui nickel j'avais pas vu la vidéo !

On vois souvent des lidars 2D montés en double axe, pour moi c'est idéal car permet de faire un mouvement circulaire, même de toute petite amplitude et/ou stabiliser l'horizon.

Du coup ou lieu d'avoir une ligne 2D t'as nuage de point en forme de cylindre, quelques degrés suffisent pour augmenter la perception du robot et fiabiliser l'anticolision, même si on fonctionne toujours avec des maths 2D !

Génial j'ai hâte de voir les premiers tests : suivre une autre implémentation surtout full NodeJS me passionne aussi:)

J'utilise aussi le module SerialPort de Node, (quasi) obligatoire pour ce qu'on fait:)

J'avais envoyé ma logique de décodage du 2K et du 4K en C, mais ma 4K comporte un dernier bug d'angle courant/futur à corriger - bug qui fait deux "marches d'escalier" à un endroit dans la lecture qui semble fonctionner correctement hormis ça, faudra que je m'y re penche donc curieux de suivre ton avancement.