Exosquelette pour piloter les bras de HumaOne

 Ce que tu as trouvé c'est pas mal =) Et oui tu t'approches d'une vérité =) 

Si tu veux du moins lourd, je peux te proposer une alternative : 
=> En partant du principe que ta trame est formaté et de taille connu tu peux te servir de ces données pour simplifier le traitement. 

 

if(Serial.available())                   // si un commande est disponible sur le port série trame de forme : <requete;pramètre;valeur>
  {
    char requete[10]="";                     // variable tableau stockant la requète 
    char param[6]="";                       // variable tableau stockant le paramètre
    char value[6]="";                       // variable tableau stockant la valeur
    String request;                          // variable String stockant la requete
    String parameter;                        // variable String stockant le paramètre
    String valeur;                           // variable String stockant la valeur
    int val;                                 // variable int stockant la valeur
    int para;                                // variable int stockant la valeur
    serialdata= Serial.read();               // lecture du premier charactère
    if(serialdata=='<')                      // test si début de trame
    {
      Serial.readBytesUntil(';',requete,10); // stockage des données requetes paramètre et valeur dans les tableaux correspondants
      Serial.readBytesUntil(';',param,6);
      Serial.readBytesUntil('>',value,6);    // test de trame de fin après la 3 ème valeur
      request=requete;                       // conversion des données requete paramètre et valeur en string
      valeur=value;
      parameter=param;
      val = valeur.toInt();                  // conversion de paramètre et valeur en int et pars requete car ici requète est un texte comme " avancer"
      para = parameter.toInt();
   }
}

un truc du genre te permet de " parser " en lisant ta trame, et donc pas besoin de lire toute ta trame puis de parser en utilisant des pointeur ... 

Après pour des trames de longueur variable il est préférable de soit changer les caractère de départ de trame, soit lire toute la trame et parser après coup comme proposé précédement... 

Et une fois que tu as la base qui marche tu peux ensuite ajouter des petit bout de code pour faire de la gestion d'erreur ...

De même tu peux largement améliorer le bout de code que je te propose en faisant un tableau de tableau de char et en utilisant une structure ... 

Si tu veux faire le protocole toi même me mieux est toujours de partir sur un truc simple et de le complexifier par la suite  

 

Merci pour les informations et vos retours.

sinon, concernant le code suivant : cela fonctionne très bien. J'ai placé pas mal de serial.print à l'intérieur pour comprendre plus exactement sont fonctionnement.

voici le code en question :
 

/*************************************************************
PROGRAMME DE DECODAGE D'UNE TRAME DU TYPE : /N°broche*consigne : exemple /9*126 = sur broche 9 consigne 126°
**************************************************************/

// --- Déclaration des variables globales ---
/*
      la trame sera formaté ainsi : <1;-3;16;2294;531>
      '<' = le debut de la trame
      '>' = la fin de la trame
      ';' = délimiteur des donnees
*/

//----------
String Trame;              // Chaine pour contenir la Trame entrante
boolean TrameRecu = false; // si la Trame a été reçue dans son intégralité : Tramereçu sera = true
int NbrData = 4;           // NbrData = nombre de données reçues   exemple: 5 valeurs : 1;-3;16;2294;531 de 0 à 4 = 5 valeurs


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

}




//========================
void loop() 
{
  handleCommand();//appel de la fonction
} //FIN LOOP
//=======================


//************************* routines sur événement sérial
void serialEvent()
{
  while (Serial.available()) // tant que je reçois une donnée
  {
     char incomingByte = (char)Serial.read();//le byte entrant sera chargé dans la variable incomingByte
     if (incomingByte == '>') // si valeur d'arrivée = '>' = fin de la Trame
       { 
         TrameRecu = true;  // alors TrameRecu = true
         return;
       }
     else if (incomingByte == '<')// si valeur d'arrivée = '<' = début de Trame
       { 
         Trame = "";  // Trame = vide
         TrameRecu = false; // TrameRecu = false
         return;
       }
     else //si valeur d'arrivée != '<' ET valeur d'arrivée != '>'
       {
         Trame += incomingByte; // concaténation de trame avec les valeurs reçues soit ici : 1;-3;16;2294;531
         return;
       }
  }//fin de while (Serial.available())
} // fin de void serialEvent()

void handleCommand() 
{
  if (!TrameRecu) return; // Si Tramereçu = false, alors aucune Trame a parser je quitte
  int data[NbrData];     // tableau d'entier de la taille NbrData = 4. de 0 à 4 -> 5 nombres.
  char cmd[Trame.length()+1]; // tableau de char de la taille du string Trame +1 (caractère de fin de ligne). Ce +1 OBLIGATOIRE ?
  
  Serial.print("Trame = "); Serial.println(Trame); 
  Serial.print("Trame.length() "); Serial.println(Trame.length()); 
  Serial.print("Trame.length()+1 "); Serial.println(Trame.length()+1); 

  
  Trame.toCharArray(cmd, Trame.length()+1);// récupère chaque valeur de Trame dans un tableau cmd de tailleTrame.length()+1)  
  char *token = strtok(cmd, ";"); // *token, c'est un pointeur, strtok(cmd, ";")->split le tableau cmd en fonction de cmd !!! COMPRENDS PAS ???
  
  
  Serial.print("*token = "); Serial.println(*token); 
  for (int b = 0; b < Trame.length()+1; b++)
  {
  Serial.print("cmd[b]"); Serial.println(cmd[b]); 
  }
  

  for (int i = 0; i < NbrData+1; i++) // place de toute les valeurs dans les valeurs dans le tableau data[i]
   { 
      if (token) //COMPRENDS PAS ???
        {
         Serial.print("token = "); Serial.println(token); 
      data[i] = atoi(token); //converti valeur en variable int pour pouvoir l'utiliser
      token = strtok(NULL, ";");//COMPRENDS PAS ???
      Serial.print("*token-next = "); Serial.println(*token); 
        }
       else
       {
        Serial.print("!token = "); Serial.println(token); 
        
       }
   }

//---Pour verif sur monitor de ce qui a été reçu
  Serial.print("data[0] = "); Serial.println(data[0]);
  Serial.print("data[1] = "); Serial.println(data[1]);
  Serial.print("data[2] = ");Serial.println(data[2]);
  Serial.print("data[3] = ");Serial.println(data[3]);
  Serial.print("data[4] = ");Serial.println(data[4]);
  

  TrameRecu = false;// Drapeau pour dire que nous avons traite la commande
 }
//************************Fin routines

*****************************************

la trame envoyée : <12;34;56;78;99>

Le résultat :

Trame = 12;34;56;78;99
Trame.length() = 14
Trame.length()+1 = 15

*token = 1 //position du première pointeur

cmd[b]1
cmd[b]2
cmd[b] //il manque tjrs le ; ici ???
cmd[b]3
cmd[b]4
cmd[b];
cmd[b]5
cmd[b]6
cmd[b];
cmd[b]7
cmd[b]8
cmd[b];
cmd[b]9
cmd[b]9
cmd[b] //forcément puisque cmd[Trame.length()+1], Trame.length() = 14



token = 12 //première valeur

*token-next = 3 //pointeur
token = 34 //deuxième valeur

*token-next = 5 //pointeur
token = 56 //troisième jvaleur

*token-next = 7 //pointeur
token = 78 //quatrième valeur

*token-next = 9 //pointeur
token = 99 //cinquième valeur


*token-next =

****************Les valeurs dans le tableau data
data[0] = 12
data[1] = 34
data[2] = 56
data[3] = 78
data[4] = 99


OK alors !!!!

Bon le code ci dessus proposé par telson marche bien cependant juste pour faire suite à mon message #6 dans ce même sujet voilà ici plus de détails concernant l'autre approche qui consiste à passer facilement par des bytes au lieu de passer par des string. 

Bonjour tout le monde,

 

Me revoici avec une nouvelle question : Pour mon exosquelette je pense mettre en place deux modules wifi un en émission sur l'exo et l'autre en réception sur le robot. Je pense mettre en place des modules ESP8266......Seulement voilà il existe énormément de site sur lequel il est possible d'acheter ces modules.

 

Est ce quelqu'un aurait déjà acheter un modèle ESP12E et où. que pourriez vous me dire sur ces modules. Est ce un bon choix? Est t'il préférable de choisir un autre modèle. Et surtout où acheter le bouzin !!!

 

Sur ebay on trouve de tout, sur Ali aussi......Mais ......est ce bien raisonnable....D'autant que mes derniers achats sur Ali ne m'ont absolument pas donnés satisfactions.........

 

Merci

 

++

Salut ,

 

Je prévois d'utiliser un module wifi ESP8266 ( marque Olimex  ) qui faisait partie du starter kit Arduio , pour faire communiquer mon robot à un smartphone via router wifi .

 

Ton cas ne nécéssite pas de passer par un réseau wifi aussi tu pourrais te contenter d'une radio 2.4Ghz  type NF240I01 pour faire communiquer directemement entre eux les Humaone et Exosquelette ( alternative à bluetooth)

 

Vois si cela peut convenir au lieu du ESP8266  , un exemple parmi tant d'autres sur le net :

 

-->>  https://itechnofranc...-avec-larduino/

Merci pour ces premières informations,

 

ESP8266 et NF240I01 utilisent tous les deux la bande de fréquences 2,4 Ghz.......Quel est pour toi l'intérêt de prendre un NF plutôt qu'un ESP.....

 

++

Je ne suis pas très bien placé pour te donner des conseils car je n'ai pas encore utilisé ces 2 produits mais je vais utiliser un ESP8266 pour piloter mon robot à partir d'un smartphone via wifi de mon Lan ou d'internet

 

Néanmoins comme tes 2 robots , pour dialoguer entre eux , n'ont pas besoin de se connecter  à routeur wifi , un smartphone ou internet  , la radio de type wifi n'est pas obligatoire. (ESP8266)

 

L'avantage de la radio NRF24L01  est sa basse consommation ( au moins pour le model avec antenne intégrée ) et sa possible alimentation par la carte Arduino directement alors  qu'il faut une alimentation séparée pour le ESP8266 ( car > 50mA)

 

En outre le ESP8266 a besoin d'un port USB  ce qui pose problème pour certaines cartes Arduino comme la UNO qui ne possède qu'un port UART/USB meme si un port software peut etre utilisé ( software serial , ne valant pas un port hardware )

 

Le module NRF24L01 se connecte sur le bus SPI

 

 

EDIT  : lien vers page site arduino sur l'interface avec NRF24 ... http://playground.arduino.cc/InterfacingWithHardware/Nrf24L01

 

et un exemple concret ...  http://forum.arduino.cc/index.php?topic=421081

Modifié par gerardosamara, 30 août 2016 - 01:26 .

Merci pour ces informations......Je regardes tout cela .....