{
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 même moi j'ai du mal a me comprendre!!
Si quelqu'un a une idée, merci d'avance
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
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 :
vw_send((uint8_t *)AI_0, strlen(AI_0));
tetete
vw_send((uint8_t *)AI_0, strlen(AI_0) + 1);
(ne pas oublier le \0 en fin de chaine de caractére)
cutprod:
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 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 ? ... ?
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 = [Arduino] Transmission valeur analogique par nRF24L01+ | Skyduino - Le DIY à la française
Mais bon! on fait avec ce qu'on a...
1 envoi par valeur analogique ça risque d’être un peu lourd
T'as une autre idée? ou je tente comme ça
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 = [Arduino] Transmission valeur analogique par nRF24L01+ | Skyduino - Le DIY à la française
Mais bon! on fait avec ce qu'on a...
1 envoi par valeur analogique ça risque d’être un peu lourd
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
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
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...
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
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 !?
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...
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)
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 =
#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 =
#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
}
//##########################################################################################
//##########################################################################################
Si j'ai fais cette mini usine a gaz c'est pas parce que je suis fou des String...quoi-que
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....
cutprod:
Si j'ai fais cette mini usine a gaz c'est pas parce que je suis fou des String...quoi-que
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 ...)
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
cutprod:
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
Bon déja : byte report[3]; -> erreur !
c'est : byte report[4]; puisque un int est stocké sur 2 octets
cutprod:
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
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 : Bitwise operation - Wikipedia