Go Down

Topic: [Résolu] Télémétrie sur module 433mhz (Read 1 time) previous topic - next topic

cutprod

Feb 19, 2012, 01:20 am Last Edit: Feb 22, 2012, 06:05 pm by cutprod Reason: 1
Bonjour,grâce au tuto de skywodd = http://skyduino.wordpress.com/2011/12/29/tutoriel-arduino-et-emetteurrecepteur-433mhz-virtualwire/
je suis sur un projet de véhicule radio commander mais je bloque sur la  télémétrie!
j' envoi la valeur de A0 =
Code: [Select]
{
delay(100);
 
 a0 = analogRead(A0);
 char str[5] ;// max 1023 = 4 char + char null \0
 String ana_0_val = itoa(a0,str,10);// transformation décimal -> chaine de char

 String ana_0 = ("AI_0 = "+ ana_0_val);//ajoute a la chaine "AI_1" pour connaitre l'analog input
 char AI_0[15];//déclare un buffer
 ana_0.toCharArray(AI_0, 15);//convertion de la chaine en array de char max 14 char
   Serial.println(AI_0);
 
 
 if  (analogRead(A0)!=a0)
{
 
 
  char str2[5] ;// max 1023 = 4 char + char null \0
 String ana_0_val = itoa(analogRead(A0),str2,10);// transformation décimal -> chaine de char

 String ana_0 = ("AI_0 = "+ ana_0_val);//ajoute a la chaine "AI_1" pour connaitre l'analog input
 char AI_0[15];//déclare un buffer
 ana_0.toCharArray(AI_0, 15);//convertion de la chaine en array de char max 14 char
  Serial.println(AI_0);
}
 
   vw_send((uint8_t *)AI_0, strlen(AI_0));
   vw_wait_tx();
   

}

Tout va bien mais c'est a la réception que je bug: je reçois un array que je peut afficher dans la console, mais je n'arrive pas a le transformer en String "pure et dur"!
afin de le manipuler avec "startsWith()" ou autre pour savoir de quel entrée ana il sagit.
Mon but et d'attribuer une valeur précise a un moteur précis en fonction du nom et de la valeur de l"entée ana reçut par radio  :smiley-eek-blue: même moi j'ai du mal a me comprendre!!
Si quelqu'un a une idée, merci d'avance ;)

skywodd

Salut,

Bon déja :
Code: [Select]
char str2[5] ;// max 1023 = 4 char + char null \0
String ana_0_val = itoa(analogRead(A0),str2,10);// transformation décimal -> chaine de char

String ana_0 = ("AI_0 = "+ ana_0_val);//ajoute a la chaine "AI_1" pour connaitre l'analog input
char AI_0[15];//déclare un buffer
ana_0.toCharArray(AI_0, 15);//convertion de la chaine en array de char max 14 char
Serial.println(AI_0);

ça -> poubelle ;)
Code: [Select]
String ana_0 = "AI_0 = "; // les deux espaces c'est un peu du gachi de mémoire ram, m'enfin je dis ça je dis rien, hein ;)
ana_0 += analogRead(A0);

char AI_0[15];//déclare un buffer
ana_0.toCharArray(AI_0, 15);
Serial.println(AI_0);


Ensuite :
Code: [Select]
vw_send((uint8_t *)AI_0, strlen(AI_0));
tetete ;)
Code: [Select]
vw_send((uint8_t *)AI_0, strlen(AI_0) + 1);
(ne pas oublier le \0 en fin de chaine de caractére)


Tout va bien mais c'est a la réception que je bug: je reçois un array que je peut afficher dans la console, mais je n'arrive pas a le transformer en String "pure et dur"!
afin de le manipuler avec "startsWith()" ou autre pour savoir de quel entrée ana il sagit.
Mon but et d'attribuer une valeur précise a un moteur précis en fonction du nom et de la valeur de l"entée ana reçut par radio  :smiley-eek-blue: même moi j'ai du mal a me comprendre!!

Bon déja, je te vois parler de startsWith() tu compte utiliser les données recu sur un autre arduino ? processing ?  ... ?

Si tu veut utiliser avec un autre arduino :
Code: [Select]
String maChaine;
// ...
if (vw_get_message(buf, &buflen))
{
  maChaine = (char*)buf;
}
Des news, des tutos et plein de bonnes choses sur http://skyduino.wordpress.com !

cutprod

Bonjour skywodd, merci du coup de main.
récupère les infos sur une Uno.
Le top aurait été d'envoyer un array avec des int et a la réception de trier tout ça comme ton exemple = http://skyduino.wordpress.com/2012/02/01/arduino-transmission-valeur-analogique-par-nrf24l01/
Mais bon! on fait avec ce qu'on a...
1 envoi par valeur analogique ça risque d'être un peu lourd :smiley-fat:
T'as une autre idée? ou je tente comme ça

skywodd


Bonjour skywodd, merci du coup de main.
récupère les infos sur une Uno.
Le top aurait été d'envoyer un array avec des int et a la réception de trier tout ça comme ton exemple = http://skyduino.wordpress.com/2012/02/01/arduino-transmission-valeur-analogique-par-nrf24l01/
Mais bon! on fait avec ce qu'on a...
1 envoi par valeur analogique ça risque d'être un peu lourd :smiley-fat:
T'as une autre idée? ou je tente comme ça

Pourquoi tu te casse la tête ?
Tu n'as qu'as envoyer un tableau de deux int, un premier int avec le numéro de l'entrée analogique, et un second avec la valeur ;)
Des news, des tutos et plein de bonnes choses sur http://skyduino.wordpress.com !

cutprod

Oui, c'est plus ou moins ce que je fais sauf que j'ai des char dans le nom de l'entrée ana...qui peuvent être replacer par un int.
Mais ce qui me dérange c'est que je ne peux pas envoyer 2 valeurs de 2 entrées ana dans le même array?
Genre:
            array[0] = n° de l' entrée ana
            array[1] = valeur de l'entrée ana
            array[2] = n° de l' entrée ana
            array[3] = valeur de l'entrée ana

cutprod

Ha si j'ai une idée, la lib me limite a un array a une dimension de max [30], j'ai qu'a me débrouiller pour y mettre les entrée ana qui m'intéresse et leur valeurs.
Le probleme suivant est a la réception...

skywodd


Oui, c'est plus ou moins ce que je fais sauf que j'ai des char dans le nom de l'entrée ana...qui peuvent être replacer par un int.
Mais ce qui me dérange c'est que je ne peux pas envoyer 2 valeurs de 2 entrées ana dans le même array?
Genre:
            array[0] = n° de l' entrée ana
            array[1] = valeur de l'entrée ana
            array[2] = n° de l' entrée ana
            array[3] = valeur de l'entrée ana

Bien sur que si !? Il suffit que tu fasse deux analogRead() et que tu place le n° qui va bien au bonne endroit ...
Je vois pas ce qui t'empêche de faire une array de 4 int !?


Ha si j'ai une idée, la lib me limite a un array a une dimension de max [30], j'ai qu'a me débrouiller pour y mettre les entrée ana qui m'intéresse et leur valeurs.
Le probleme suivant est a la réception...

Le max c'est 32 octets, pour la réception c'est la même chose que pour l'émission mais en sens inverse.
(il te suffit de regarder mon code d'exemple qui envoyé 6 valeurs et l'ajusté pour ton application)
Des news, des tutos et plein de bonnes choses sur http://skyduino.wordpress.com !

cutprod

J'ai fais deux sketchs qui fonctionnent bien,je traite mon String reçut a base de "substring"et autre "indexOf" peux tu me dire ce que tu en pense ?
Et si c'était pas du tout a cela que tu pensais , peux tu me donner un exemple.

TX =
Code: [Select]
#include <VirtualWire.h>
//pin tx = 12 par default

int a0;
int a1;
char ARRAY[30];//déclare un buffer qui contient le msg

//##########################################################################################
//########################################################################################## 

void setup()
{
    Serial.begin(9600); // Initialisation du port série pour avoir un retour sur le serial monitor
    Serial.println("test VirtualWire");

    vw_setup(2000);
    //envoi une premiere fois les valeurs
    transfo();
    envoi_val();
}

//##########################################################################################
//########################################################################################## 

void loop()
{
delay(20);

  a0 = analogRead(A0);
  a1 = analogRead(A1);
   
  if  (analogRead(A0)!=a0 || analogRead(A1)!=a1)
   {
      transfo();
      envoi_val();
   }
 
}//fin loop

//##########################################################################################
//########################################################################################## 

void transfo()
{
char val_1[5] ;// max 1023 = 4 char + char null \0
String ana_0_val = itoa(analogRead(A0),val_1,10);// transformation décimal -> chaine de char
String ana_0 = ("A0="+ ana_0_val);//ajoute a la chaine "A0" pour connaitre l'analog input
   
char val_2[5] ;// max 1023 = 4 char + char null \0
String ana_1_val = itoa(analogRead(A1),val_2,10);// transformation décimal -> chaine de char
String ana_1 = ("A1="+ ana_1_val);//ajoute a la chaine "A1" pour connaitre l'analog input
   
(">" +ana_0 + ">" + ana_1 + ">").toCharArray(ARRAY, 30);//convertion de la chaine en array de char max 30 char + ajout de balise pour le traitement de la chaine a la reception
Serial.println(ARRAY);
   
}

//##########################################################################################
//########################################################################################## 

void envoi_val()
{
 
//Serial.print("TX ... "); // On signale le début de l'envoi
vw_send((uint8_t *)ARRAY, strlen(ARRAY)); // On envoi le message
vw_wait_tx(); // On attend la fin de l'envoi
//Serial.println("Done !"); // On signal la fin de l'envoi
   
}


RX =
Code: [Select]
#include <VirtualWire.h> // inclusion de la librairie VirtualWire
//pin de rx = 11 par default
uint8_t buf[VW_MAX_MESSAGE_LEN]; // Tableau qui va contenir le message recu (de taille maximum VW_MAX_MESSAGE_LEN)
uint8_t buflen = VW_MAX_MESSAGE_LEN; // Taille maximum de notre tableau

String val_rx;

//##########################################################################################
//########################################################################################## 

void setup()   
{
  Serial.begin(9600);
  vw_setup(2000); // initialisation de la librairie VirtualWire à 2000 bauds
  vw_rx_start();  // Activation de la partie réception de la librairie VirtualWire
}

//##########################################################################################
//########################################################################################## 

void loop()
{
  uint8_t buf[VW_MAX_MESSAGE_LEN];
  uint8_t buflen = VW_MAX_MESSAGE_LEN;

if (vw_get_message(buf, &buflen))
             {
       int i;
               val_rx = "";   
                 
                  for (i = 0; i < buflen; i++)
                    {
                       val_rx += buf[i];// on construit la variable string de reception en assemblent les char du tableau
                    }
                 
                 Serial.println (val_rx);
                 traite_val_rx();
                 
}

}//fin loop

//##########################################################################################
//##########################################################################################

void traite_val_rx()
{
 
//###################################
//découpe la chaine reçu
//###################################

   int premiere_balise = val_rx.indexOf(">");
   int seconde_balise = val_rx.indexOf(">",premiere_balise+1);
   int troisieme_balise = val_rx.indexOf(">",seconde_balise+1);

   String val_a0 = val_rx.substring(premiere_balise+4,seconde_balise);//+4 pour enlever le A0=(inclu dans la chaine tx)
   String val_a1 = val_rx.substring(seconde_balise+4,troisieme_balise);//+4 pour enlever le A1=(inclu dans la chaine tx)

//###################################
//convertion String en Int
//###################################

   int longueur_chaine_1 = val_a0.length()+1;//pour construire le tableau on prend la taille de la chaine et on rajoute un char null
   char a0 [longueur_chaine_1];//on construit le tableau
   val_a0.toCharArray(a0,longueur_chaine_1);//on y met la chaine
   int A0 = atoi(a0);//on transforme le tableau en int

   int longueur_chaine_2 = val_a1.length()+1;//pour construire le tableau on prend la taille de la chaine et on rajoute un char null
   char a1 [longueur_chaine_2];//on construit le tableau
   val_a1.toCharArray(a1,longueur_chaine_2);//on y met la chaine
   int A1 = atoi(a1);//on transforme le tableau en int


   Serial.println(A0);//=>affiche la valeur de A0 de la carte distante
   Serial.println(A1);//=>affiche la valeur de A1 de la carte distante
}

//##########################################################################################
//########################################################################################## 


cutprod

Si j'ai fais cette mini usine a gaz c'est pas parce que je suis fou des String...quoi-que :smiley-mr-green:
Mais parce que selon moi (et mes nombreux tests) la lib m'oblige a poster ce type de variable.
J'aimerai me tromper (chose qui arrive souvent) et pouvoir envoyer des int....

skywodd


Si j'ai fais cette mini usine a gaz c'est pas parce que je suis fou des String...quoi-que :smiley-mr-green:
Mais parce que selon moi (et mes nombreux tests) la lib m'oblige a poster ce type de variable.
J'aimerai me tromper (chose qui arrive souvent) et pouvoir envoyer des int....

La lib virtualWire marche beaucoup mieux avec des int qu'avec des String !
Je serait toi, je prendrai le code d'exemple de mon tuto avec 6 analogRead et j'en enlèverai 4, ça serait tellement plus simple, et tellement plus pratique à utiliser ;)
(Et niveau optimisation je t'en parle même pas ...)
Des news, des tutos et plein de bonnes choses sur http://skyduino.wordpress.com !

cutprod

#10
Feb 22, 2012, 12:01 am Last Edit: Feb 22, 2012, 05:53 am by cutprod Reason: 1
Il aura fallut que tu me le dise 3 fois pour que j' arrête avec mes string et que je copie ton code !!
Merci a toi ça fonctionne très bien.
TX =
Code: [Select]
#include <VirtualWire.h>

byte report[3];
int tmp1;
int tmp2;

void setup()
{
   Serial.begin(9600);
   Serial.println("setup");
 
   vw_setup(2000);
}

void loop()
{
   tmp1 = analogRead(A0);
   report[0] = tmp1& 0xFF;
   report[1] = (tmp1 & 0xFF00) >> 8;
   
   
   tmp2 = analogRead(A1);
   report[2] = tmp2& 0xFF;
   report[3] = (tmp2 & 0xFF00) >> 8;
   
   
   vw_send((uint8_t *)report,4);
   vw_wait_tx();
   
   delay(1000);
}

RX =
Code: [Select]
#include <VirtualWire.h>

void setup()
{
   Serial.begin(9600);
   Serial.println("setup");

   vw_setup(2000);
   vw_rx_start();      
}

void loop()
{
   uint8_t buf[3];
   uint8_t buflen = 4;

   if (vw_get_message(buf, &buflen))
   {
Serial.print("Got: ");
Serial.println("");
Serial.print(buf[0]+ (buf[1] << 8));
Serial.println("");
       Serial.print(buf[2]+ (buf[3] << 8));
       Serial.println("");
   }
}

Par contre j' ai de grosse lacune en prog et comme j'aime bien comprendre ce que je fais, peux-tu m'expliquer =
byte report[1]; et pas int report[1]; (j'ai essayer les valeur s'arrete a 255 et reparte a zero)
et aussi =
pour la stoker

tmp1 = analogRead(A0);
   report[0] = tmp1& 0xFF;
   report[1] = (tmp1 & 0xFF00) >> 8;

et pour la lire

Serial.print(buf[0]+ (buf[1] << 8 ));

Désoler, mais j'ai du louper un gros passage... je me suis encore jamais attarder sur les bytes et leur manip

skywodd


Il aura fallut que tu me le dise 3 fois pour que j' arrête avec mes string et que je copie ton code !!
Merci a toi ça fonctionne très bien.

Au moins tu as finit par le faire c'est le principal :smiley-mr-green:

Bon déja : byte report[3]; -> erreur !
c'est : byte report[4]; puisque un int est stocké sur 2 octets ;)


Par contre j' ai de grosse lacune en prog et comme j'aime bien comprendre ce que je fais, peux-tu m'expliquer =
byte report[1]; et pas int report[1]; (j'ai essayer les valeur s'arrete a 255 et reparte a zero

Pourquoi byte et non int ?
Tout simplement parce que je préfère manipuler des octets brute plutôt que des types prédéfini, c'est tout :smiley-mr-green:

Version avec un tableau de int :
Code: [Select]
#include <VirtualWire.h>

int report[2];

void setup()
{
    Serial.begin(9600);
    Serial.println("setup");
   
    vw_setup(2000);
}

void loop()
{
    report[0] = analogRead(A0);
    report[1] = analogRead(A1);
   
    vw_send((uint8_t *)report, sizeof(report));
    vw_wait_tx();
   
    delay(1000);
}


Code: [Select]
#include <VirtualWire.h>

void setup()
{
    Serial.begin(9600);
    Serial.println("setup");

    vw_setup(2000);
    vw_rx_start();     
}

void loop()
{
    int buf[2];
    uint8_t buflen = sizeof(buf);

    if (vw_get_message((uint8_t *)buf, &buflen))
    {
      Serial.print("Got: ");
      Serial.println();
      Serial.print(buf[0]);
      Serial.println();
      Serial.print(buf[1]);
      Serial.println();
    }
}


Au niveau du bitwise (xx << nn, xx & nn, etc etc) c'est une technique de transformation d'octet.
xx << nn, permet de "décaler" les bits de la valeur xx par nn rang vers la gauche,
xx >> nn, permet de édécaler" les bits de la valeur xx par nn rang vers la droite,
xx & nn, applique un masque nn de "et" logique sur chaque bits de xx
etc etc ...

Dans cette application j'utilise le bitwise pour transformer des int de 2 octets en deux octets séparé.
Si tu est curieux : http://en.wikipedia.org/wiki/Bitwise_operation
Des news, des tutos et plein de bonnes choses sur http://skyduino.wordpress.com !

cutprod

OK, merci de m'avoir expliquer et merci++ pour ton aide ;)

Go Up