Bonjour tout le monde !
J’espère que les fêtes se sont bien passées pour vous aussi et que le réveil du lendemain n’a pas était trop dur ;)
Aujourd’hui je vous est préparé un tutoriel sur la librairie VirtualWire, qui permet (comme son nom l’identique) de créer un câble « virtuel » entre deux arduino.
Alors quand je dis « câble virtuel » je sous entends sans fil, et pas n’importe quel module sans fil.
La librairie VirtualWire a été créée pour fonctionner des modules émetteurs / récepteurs 433MHz, modules que je vais vous présenter dans ce billet.
Avant tout chose il vous faudra l’ide arduino et la librairie VirtualWire disponible ici : http://www.open.com.au/mikem/arduino/
(pour les curieux il y a d’autre librairies sympa sur ce site ;))
Mon tutoriel est en grande partie une version francisé du pdf d’utilisation de VirtualWire mais je vais quand même rajouter quelque petits choses qui ne sont pas expliquées dedans ;)
L’avantage de la librairie VirtualWire c’est quelle permet de mettre en communication plusieurs arduino en utilisant des modules sans-fil low-cost (~5€ pour les miens) tout en assurant une transmission parfaite de l’information (via un systéme de checksum).
La librairie VirtualWire permet d’envoyer des messages binaires (du texte ou des données brutes (structures, variables, …)) à la manière d’un paquet UDP sur un réseau ethernet, c’est à dire sans adressage (pas d’envoi vers l’arduino n spécifiquement, c’est du « broadcasting »), sans retransmission en cas d’erreur (si le message est corrompu, il est ignoré) et sans ACK (Acknowledge) (il serait donc intéressant de prévoir un mini système de question/réponse entre les deux arduino dans le cadre d’une application sérieuse).
Pour fonctionner la librairie VirtualWire implémente en software un algorithme de ASK (Amplitude Shift Keying).
(Si vous êtes curieux : http://en.wikipedia.org/wiki/Amplitude-shift_keying)
L’avantage d’une transmission ASK c’est que le signal d’horloge est synchronisé sur le signal reçu, ce n’est pas le cas avec Serial, au départ j’avais prévu de voir faire ce tutoriel en deux parties, une partie VirtualWire et une partie Serial, mais les problèmes de synchronisation avec Serial sont assez problématiques, par conséquent je vais juste faire la partie VirtualWire.
—
Trêve de bavardage techniques. Vous avez installé la librairie VirtualWire ? Votre ide arduino est ouvert ? Ok Let’s GO !
Tout d’abord la partie hardware, il va nous falloir :
– deux cartes arduino, une pour émettre et une pour recevoir,
– un émetteur 433MHz et un récepteur 433MHz (~5€ piéce exemple : émetteur & récepteur)
– des câbles, dont deux d’au moins ~20cm (ils vont nous servir d’antennes).
Le câblage :
Le Récepteur :
récepteur -> Arduino
GND -> GND
DATA -> D11
VCC -> 5V
(+ Antenne)
L’émetteur :
Arduino -> émetteur
GND -> GND
D12 -> DATA
5V -> VCC
(+ Antenne)
Avant de vous donner les deux sketch arduino émetteur / récepteur voici le descriptif des fonctions de la librairie virtualWire :
vw_set_tx_pin
extern void vw_set_tx_pin(uint8_t pin);
Définie la broche utilisée pour transmettre les données, par défaut D12.
vw_set_rx_pin
extern void vw_set_rx_pin(uint8_t pin);
Définie la broche utilisée pour recevoir les données, par défaut D11.
vw_set_ptt_pin
extern void vw_set_ptt_pin(uint8_t pin);
Définie la broche utilisée comme broche ENABLE (aka broche PTT ou « Press to talk », les émetteurs low-cost ont rarement cette fonctionnalité), par défaut D10.
vw_set_ptt_inverted
extern void vw_set_ptt_inverted(uint8_t inverted);
Définie l’état « actif » de la broche PTT, si inverted = false -> HIGH, si inverted = true -> LOW
vw_setup
extern void vw_setup(uint16_t speed);
Initialise la librairie et assigne la vitesse de transmission (dans mon cas mon couple Rx/Tx peut allez jusqu’à 2400 bauds).
Note: plus la vitesse de transmission est lente plus la porté est accentué, au contraire une vitesse de transmission élevée diminuera la porté du signal.
Note 2 : Après l’appel d’une fonction vw_set_****** vous devrez toujours rappeler la fonction vw_rx_start() sinon vous ne recevrez jamais de messages.
vw_rx_start
extern void vw_rx_start();
Déclenche l’interruption gérant le signal en réception, c’est cette fonction qui « démarre » la partie réception de la librairie VirtualWire.
vw_rx_stop
extern void vw_rx_stop();
Arrête l’interruption gérant le signal en réception, c’est cette fonction qui « arrête » la partie réception de la librairie VirtualWire.
vx_tx_active
extern uint8_t vx_tx_active();
Retourne true si la partie transmission de la librairie VirtualWire est active.
vw_wait_tx
extern void vw_wait_tx();
Fonction bloquante qui attend la fin de la transmission en cours avant de rendre la main à la suite du programme.
vw_wait_rx
extern void vw_wait_rx();
Fonction bloquante qui attend l’arrivée d’un nouveau message avant de rendre la main à la suite du programme.
vw_wait_rx_max
extern uint8_t vw_wait_rx_max(unsigned long milliseconds);
Fonction bloquante AVEC TIMEOUT (en millisecondes) qui attend l’arrivée d’un nouveau message ou le dépassement du timeout avant de rendre la main à la suite du programme.
vw_send
extern uint8_t vw_send(uint8_t* buf, uint8_t len);
Transmet un message de taille len à partir des données contenues dans le tableau buf (de type uint8_t, soit unsigned char).
Rend la main à la suite du programme immédiatement la plus part du temps (suivant la taille len).
Retourne true s’il n’y a pas d’incohérence entre len et VW_MAX_PAYLOAD (taille maximum par envoi).
vw_have_message
extern uint8_t vw_have_message();
Retourne true si un message à était reçu, que celui ci ait une bonne ou une mauvaise checksum !!
vw_get_message
extern uint8_t vw_get_message(uint8_t* buf, uint8_t* len);
Copie le message reçu dans buf avec comme limite à ne pas dépasser len, si le message dépasse len celui ci sera tronqué.
Le message est copié dans buf que celui ait une bonne ou une mauvaise checksum, cependant la fonction ne retournera true que si la checksum est valide (sinon false).
—
Voila j’en est fini avec les fonctions de la librairie, à présent vous devriez pouvoir comprendre sans trop de problèmes les deux sketch suivant :
Partie émetteur :
#include <VirtualWire.h> // inclusion de la librairie VirtualWire
const char *msg = "Arduino"; // Tableau qui contient notre message
void setup() // Fonction setup()
{
Serial.begin(9600); // Initialisation du port série pour avoir un retour sur le serial monitor
Serial.println("Tuto VirtualWire"); // Petit message de bienvenue
vw_setup(2000); // initialisation de la librairie VirtualWire à 2000 bauds (note: je n'utilise pas la broche PTT)
}
void loop() // Fonction loop()
{
Serial.print("TX ... "); // On signale le début de l'envoi
vw_send((uint8_t *)msg, strlen(msg)); // On envoie le message
vw_wait_tx(); // On attend la fin de l'envoi
Serial.println("Done !"); // On signal la fin de l'envoi
delay(1000); // Et on attend 1s pour pas flooder
}
Partie récepteur :
#include <VirtualWire.h> // inclusion de la librairie VirtualWire
void setup() // Fonction setup()
{
Serial.begin(9600); // Initialisation du port série pour avoir un retour sur le serial monitor
Serial.println("Tuto VirtualWire"); // Petit message de bienvenue
vw_setup(2000); // initialisation de la librairie VirtualWire à 2000 bauds (note: je n'utilise pas la broche PTT)
vw_rx_start(); // Activation de la partie réception de la librairie VirtualWire
}
void loop() // Fonction loop()
{
uint8_t buf[VW_MAX_MESSAGE_LEN]; // Tableau qui va contenir le message reçu (de taille maximum VW_MAX_MESSAGE_LEN)
uint8_t buflen = VW_MAX_MESSAGE_LEN; // Taille maximum de notre tableau
// REMARQUE ULTRA IMPORTANTE :
// Par le passé ces deux lignes se trouvaient en "haut de programme", c'était donc des variables globales.
// Elles ne doivent PAS être globales, c'est très important !
//
// Pourquoi ?
// C'est très simple. Posez vous la question suivante : que vaut "buflen" si la réception d'un message échoue,
// où qu'on reçoit un message de moins de VW_MAX_MESSAGE_LEN octets ?
// Au début "buflen" vaut VW_MAX_MESSAGE_LEN, mais après "buflen" vaudra une valeur < VW_MAX_MESSAGE_LEN.
// Et paf, la taille de votre buffer vient de diminuer pour la réception suivante, et ainsi de suite.
if (vw_wait_rx_max(200)) // Si un message est reçu dans les 200ms qui viennent
{
if (vw_get_message(buf, &buflen)) // On copie le message, qu'il soit corrompu ou non
{
Serial.print("RX : ");
for (byte i = 0; i < buflen; i++) // Si il n'est pas corrompu on l'affiche via Serial
Serial.print(buf[i]);
Serial.println("");
}
}
}
Petit précision par rapport aux émetteurs 433MHz, il sont très souvent employés pour les télécommandes sans fil (porte de garage, lampe domotique, etc …) si dans votre programme vous recevez des messages indésirable c’est surement que vous avez capté le signal d’une de ces télécommandes.
Par le passé par exemple j’ai (sans le vouloir) bloqué mon ouverture de portail en envoyant trop de choses à la fois et en continu.
(Pour les petits malins, il faut un NE555 générant un signal carré de 1KHz pour bloquer complétement toute télécommande sur 433MHz dans les 50 métres aux alentours. ;)).
Le principe de mon code est simple, le 1er arduino va envoyer « arduino » au second arduino qui va l’afficher sur le serial monitor, voici ce que ce la donne :
(Ps: il n’est pas possible de faire un test de réception + émission en simultané avec une seul carte arduino, il vous faut absolument deux cartes)
VirtualWire, simple, rapide, et efficace, que demander de plus ;)
Détails technique pour les Hackers :)
Les message peuvent faire au maximum 27 octets.
Chaque message est transmit de cette maniére :
• 36 bits de préambule (couple de 0 & 1),
• 12 bits formant le « symbole » de start (0xb38 en hexa),
• 1 octets définissant la longueur du message (de 4 à 30), checksum compris,
• n octets du message,
• 2 octets de checksum.
Par rapport à ma note sur l’importance du couple vitesse / porté (tiré du pdf de VirtualWire) :
At 7000bps, Range about 90m
At 5000bps, Range about 100m
At 2000bps, Range over 150m
At 1000bps, Range over 150m
Les distances sont relativement identiques avec mon émetteur, seulement je n’ai mesuré que sur la plage 1000 – 2400 bauds (plage de mon émetteurs) et non 1000 – 7000 bauds.
Super article ! exactement ce que je cherchais.
Publié par coliss | 1 janvier 2012, 19 h 14 minTrès intéressant. Merci.
J’ai une question : si on souhaite mettre en place un système de questions/réponses entre les 2 Arduinos, il faut donc qu’elles puissent émettre et recevoir toutes les 2.
Dans ce cas, existe-t-il des cartes qui font à la fois émetteur / récepteur et qui fonctionneraient avec la librairie VirtualWire ?
merci.
Publié par mcmf | 3 janvier 2012, 1 h 01 minLe DR3100 peut émettre / recevoir (mais pas en même temps bien sur) et fonctionne avec VirtuaWire, sinon n’importe quel transmetteur 433MHz devrait marcher.
Publié par skywodd | 3 janvier 2012, 9 h 12 minOk, merci Skywodd.
Publié par mcmf | 4 janvier 2012, 0 h 20 minSalut Skywodd
J’essayais de mettre en pratique ce montage
J’ai un souci de compilation avec vw_setup(2000); qui n’est pas déclaré
J’utilise arduino 1.0, y a t’il eu des changement dans la bibliothèque ???
Publié par Cyril | 7 janvier 2012, 13 h 20 minIl y eu énormément de changement dans l’api arduino lors du passage en 1.0.
La librairie VirtualWire comme beaucoup d’autre librairies ne compile plus à cause de ces changements, essaye de compiler en arduino 0023 pour moi ça marche.
PS: je continu à faire mes tutoriels sous arduino 0023 tant que les librairies compatible arduino 1.0 ne seront pas plus nombreuse, je te conseil donc de rester sous arduino 0023 sauf si tu veut absolument tester les différentes nouveauté introduite dans la 1.0 ;)
Publié par skywodd | 7 janvier 2012, 16 h 43 minJ’ai utilisé la dernière librairie dispo pour VirtualWire, la compil ce passe bien avec la V1, mais le résultat ne correspond pas, j’obtient une chaine de num au lieu de caractères
Avec la V023 pas de problème
Publié par Cyril | 7 janvier 2012, 18 h 42 min@CYRIL surement une incompatibilité causé par les changements dans l’api arduino 1.0, si tu peut reste sous 0023 pour le moment ya vraiment trop de problémes d’incompatibilités avec la version 1.0.
Publié par skywodd | 7 janvier 2012, 19 h 29 minMerci beaucoup pour ce tuto!!
Tu me donne de nouvelles possibilités d’utilisation des cartes arduino.
T’es au top continu :-)
Publié par cutprodcutprod | 20 janvier 2012, 16 h 24 minMerci pour ce tuto clair et détaillé !
La réalisation s’est passée sans problème et fonctionnement OK du 1er coup.
Pour aller plus loin en utilisant cette base, j’ai commencé à mettre en œuvre un système de détection du passage du facteur.
Etape 1 : Ir Led + PhotoTransistor, coté émetteur / Led coté récepteur => ça marche :-))
Etape 2 : Ir Led + PhotoTransistor coté émetteur / Led + Ethernet Shield coté récepteur pour connexion serveur et envoi d’un email « Le facteur est passé » => ça marche en utilisant les ports rx et tx standard mais pas avec la librairie VirtualWire.
Les ports Rx (11) et Tx (12) de la lib VirtualWire peuvent ils être modifiés (du fait que la carte Ethernet utilise déjà ses ports) ?
Merci pour vos conseils
Publié par Vince | 23 janvier 2012, 17 h 59 minTient tient, quelqu’un qui n’as pas lu les descriptions des fonctions ;)
extern void vw_set_tx_pin(uint8_t pin);
Définie la broche utilisé pour transmettre les données, par défaut D12.
extern void vw_set_rx_pin(uint8_t pin);
Définie la broche utilisé pour recevoir les données, par défaut D11.
Publié par skywodd | 23 janvier 2012, 21 h 47 minEn fait je me suis mal exprimé…Sorry.
Je me demandais si il y avait une incompatibilité de la lib VirtualWire avec la carte Ethernet car j’ai bien modifié les ports ptt, rx et tx dans VirtualWire.cpp (les 3 ports étant utilisés par la carte Ethernet).
Voici mes valeurs:
static uint8_t vw_ptt_pin = 5;
static uint8_t vw_rx_pin = 6;
static uint8_t vw_tx_pin = 7;
Peut être une erreur qui se cache ailleurs…je vais regarder ça de plus près.
Merci Skywood et encore bravo pour tes posts divers et variés.
Publié par Vince | 24 janvier 2012, 2 h 14 min@VINCE : Si tu as modifié les 3 broches il n’y a pas de raison que ça ne marche pas.
Tu as bien le vw_setup() (avec une vitesse acceptable par ton kit 433MHz) et vw_rx_start() ?
Ethernet + VirtualWire c’est faisable, la preuve : http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1289769139 donc ya surement un probléme autre pars ;)
Publié par skywodd | 24 janvier 2012, 9 h 18 minReprise des tests ce matin….et oui le problème venait bien d’ailleurs….petit fil de masse coté émetteur qui s’était discrètement fait la malle !
Y a plus qu’à ranger tout ça dans une petite boite et attendre que le facteur soit passé avant de mettre le nez dehors :-)
Merci Skywood
Publié par Vince | 24 janvier 2012, 10 h 09 minSalut !! Est-ce que ces petits modules sans fils seraient assez rapide pour effectuer la liaison entre une Super Famicom (Super Nintendo) et un controleur Super Famicom. J’ai 12bits (12 boutons ) de donnée a transferer 60 fois par seconde. Est-ce possible avec un couple émeteur recepteur 433 ?? Est ce quil va y avoir une grosse latence?
Merci
Publié par Patrice | 3 mars 2012, 23 h 34 minSi tu place l’état des boutons dans un uint16_t tu pourrait (au maximum) envoyé ~15 messages par seconde.
Pour avoir 60Hz de rafraichissement des modules de type nrf24L01 seraient beaucoup plus adapté.
Publié par skywodd | 3 mars 2012, 23 h 53 minbonjour,
merci pour ce tuto j’arrive biens a envoyer et recevoir et afficher le message mais ce que j’aimerais c’est pouvoir piloter une sortie en fonction du message recut
pouvez vous m’aider je n’arrive pas a trouver la solution( je debute sur arduino)
en resume si je recoit le message pin111 mettre la pin 11 au niveau haut
si je recoit pin131 mettre la pin 13 au niveau haut
merci
Publié par yanick | 21 juin 2012, 17 h 44 minIl suffit d’utiliser la fonction strcmp (en supposant que le message envoyé est au format texte) :
if(strcmp("pin111", buf) == 0) digitalWrite(11, HIGH); else if(strcmp("pin131", buf) == 0) digitalWrite(13, HIGH);http://www.cplusplus.com/reference/clibrary/cstring/strcmp/
Publié par skywodd | 21 juin 2012, 17 h 47 minSi a la place de « pin111″ on veut mettre une variable INT il sufit de mettre la variable comme ce si :
int val(buf) { for(int i=0; i <= 255; i++) { if(strcmp(i, buf) == 0) return i; } }Si je comprend bien le lien que tu as mis sa ne peut que comparer des textes :/ …
Publié par Adrien | 2 octobre 2012, 20 h 06 minRegarde du coté des fonctions « sscanf » et « sprintf » qui permettent de lire / écrire des variables dans une chaine de caractères suivant un format donné.
Publié par skywodd | 2 octobre 2012, 20 h 14 minUn grand merci pour ton aide, je vais essayer de me débrouiller avec sa :)
Publié par Adrien | 2 octobre 2012, 20 h 23 minmerci
je test cela au plus vite
Publié par yanick | 22 juin 2012, 13 h 36 min@skywood merci pour l’infos.
mais quand je test le code que tu m’a mis j’ai ce message d’erreur il doit me manquer quelque chose non ?
sketch_jun23b.cpp: In function ‘void loop()':
sketch_jun23b:28: error: invalid conversion from ‘uint8_t*’ to ‘const char*’
sketch_jun23b:28: error: initializing argument 2 of ‘int strcmp(const char*, const char*)’
merci
Publié par yanick | 23 juin 2012, 22 h 58 minHa oui, j’avais pas vu qu’il fallait un cast …
if(strcmp("pin111", (char*)buf) == 0) digitalWrite(11, HIGH); else if(strcmp("pin131", (char*)buf) == 0) digitalWrite(13, HIGH);Ça devrait le faire.
Publié par skywodd | 23 juin 2012, 23 h 04 minmerci
la compilation marche reste a tester sur le montage merci encore.
Publié par yanick | 24 juin 2012, 9 h 37 minbon c’est presque bon je viens bien piloter pa sorti mais j’ai seulement une reve impulsion ne n’arrive pas a la maintenir pendant le temps voulu.
un idee?
// commande pin 4 voie 4
if(strcmp(« v41″,(char*) buf) == 0)
{
digitalWrite(ledPin4, HIGH);
delay(1000);
digitalWrite(ledPin4, LOW);
}if(strcmp(« v51″,(char*) buf) == 0)
// commande pin 5 voie 5
{
digitalWrite(ledPin5, HIGH);
delay(1000);
digitalWrite(ledPin5, LOW);
}}
Publié par yanick | 25 juin 2012, 15 h 19 minprobleme resolu cela venait de mon alimentation qui etait defetueuse .
chgt de l’alim et tout est redevenu ok.
merci
Publié par yanick | 29 juin 2012, 17 h 40 minBonjour,
Merci pour ce tuto excellent! Je l’ai suivi à la lettre et il à parfaitement fonctionné!
J’aimerais maintenant pouvoir récupérer les infos d’une sonde Oregon THGN132N qui émet sur du 433Mhz.
Mon récepteur avec votre programme est en écoute mais aucun signal/message ne lui parvient , savez vous d’où cela peut il venir?
Merci d’avance pour votre aide
Cordialement,
Benjamin
Publié par Benny | 4 août 2012, 15 h 04 minAprès recherche, il semblerait que ma sonde utilise le protocole Oregon version 2.x basé sur un encodage appelé Manchester (http://en.wikipedia.org/wiki/Manchester_code) . J’ai trouvé un programme arduino permettant de décoder le protocole V3 : http://www.lostbyte.com/Arduino-OSV3/ . Pas mal de choses ne sont pas de mon niveau mais peut-être que cela te parle ;) Merci encore pour ton aide.
Publié par Benny | 4 août 2012, 15 h 27 minApparemment c’est très spécial comme protocole (l’encodage Manchester est trés répandu par contre).
Tu devrais utiliser cette librairie si tu veut utiliser ton capteur, sinon faire un décodeur Manchester + Oregon à la main demanderai beaucoup de temps.
Publié par skywodd | 4 août 2012, 19 h 52 minAprès encore quelques recherche je suis tombé sur ce site : http://jeelabs.net/projects/11/wiki/Decoding_the_Oregon_Scientific_V2_protocol#bfheader-ec6397c0822900144d198679449d287b qui parle du décodage du protocole V2 d’Oregon, il donne même un sketch : http://jeelabs.net/attachments/download/1018 . J’ai uploadé ce programme mais je n’ai pas de sortie dans le serial monitor après plusieurs minutes si ce n’est le println « [ookDecoder] » . Pourtant l’encoding Manchester semble bien être utilisé dans sa class : OregonDecoderV2 .
Merci encore pour ton aide.
Publié par Benny | 5 août 2012, 11 h 32 minJe viens de trouver les specs pour les différentes version de protocole : http://wmrx00.sourceforge.net/Arduino/OregonScientific-RF-Protocols.pdf, ca reste très complexe pour moi xD Si jamais tu as de bon tuto ou pages d’aide pour triturer du binaire je suis preneur!
Publié par Benny | 5 août 2012, 12 h 06 minJe te proposerai bien de suivre la même démarche que pour le hack des interrupteurs blyss, mais a mon avis tu va trouver ça encore plus compliqué ^^ »
http://arduino.cc/forum/index.php/topic,109892.0.html
Publié par skywodd | 5 août 2012, 12 h 38 minSalut Benny,
J’ai eu les memes problèmes que toi avec le décodeur sur Jeelabs et des sondes THN132N il y a quelque temps. J’ai écris un petit article la dessus la semaine dernière si ça peut t’aider : http://connectingstuff.net/blog/decodage-protocole-oregon-arduino-1/
Publié par Olivier | 16 septembre 2012, 21 h 43 minHello Olivier,
Je réponds également ici , je viens de le faire sur ton site, merci pour ton article qui éclair ma lanterne bien faiblarde!
Je vais tester tes changements ce soir et je répondrais en image je l’espère!
Super boulot !
++Benny
Publié par Benny | 17 septembre 2012, 14 h 04 minbonjour, 2 jours que je luttes pour faire fonctionner ce module ; à la place de ‘arduino’, j’obtiens 65114100117105110111
Est ce uniquement un pb de virtualwire ?
Merci d’avance
Ma
Publié par Max Patissier | 11 août 2012, 14 h 58 min-> Un petit lien pastebin vers le code émetteur / récepteur (si modifié) et le câblage utilisé ?
Si j’ai pas de quoi analyser la situation je peut pas deviner le probléme.
A mon avis c’est un probléme de code ou de câblage ;)
Publié par skywodd | 11 août 2012, 15 h 56 minSerial.print(char(buf[i])); au lieu de Serial.print(buf[i]);
Merci pour l’aide !
Publié par Max Patissier | 11 août 2012, 23 h 54 minSerial.write((char)buf[i]);
Publié par skywodd | 12 août 2012, 0 h 19 minj’ai un autre soucis de la meme veine….
J’essaye de passer un float venant d’une sonde de T°.
Tout fonctionne hormis que la T° réceptionnée montre 10° de plus que celle émise….
voici mon code d’émition :
#include // inclusion de la librairie VirtualWire
int sensorPinE = A1; //the analog pin the TMP36’s Vout (sense) pin is connected to
void setup()
{
Serial.begin(2400); //Start the serial connection with the computer
vw_setup(2000); //to view the result open the serial monitor
}
void loop() // run over and over again
{
//getting the voltage reading from the temperature sensor
int readingE = analogRead(sensorPinE);
// converting that reading to voltage, for 3.3v arduino use 3.3
float voltageE = readingE * 5.0;
voltageE /= 1024.0;
// now print out the temperature
float temperatureCE = (voltageE – 0.5) * 100 ; //converting from 10 mv per degree wit 500 mV offset
//to degrees ((volatge – 500mV) times 100)
Serial.println(temperatureCE,1);
char msg[19];
dtostrf(temperatureCE,10,2,msg);
Serial.println(msg);
vw_send((uint8_t *)msg, strlen(msg));
vw_wait_tx(); // On attend la fin de l’envoi
delay(3000); //waiting a second
}
et le code de réception est celui du tuto.
Sur le monitor de l’émetteur, les données sont les bonnes (msg)
Merci d’avance pour toute bonne idée et piste !
Max
Publié par Max Patissier | 12 août 2012, 3 h 23 minAffiche le buffer émis et le buffer reçu sous forme de valeurs hexa séparé par un espace.
Si ça ce trouve c’est un probléme de buffer.
Essaye aussi de déclarer char msg[19]; en tant que variable globale (hors de la fonction).
Publié par skywodd | 12 août 2012, 16 h 08 minune bonne nuit après :
si je mets :
char msg[19];
float tp = temperatureCE;
dtostrf(tp,10,5,msg); // au lieu de dtostrf(temperatureCE,10,2,msg)
vw_send((uint8_t *)msg, strlen(msg));
vw_wait_tx(); // On attend la fin de l’envoi
je réceptionne la bonne température…. ca fonctionne mais j’ai du mal à comprendre comment la var temperatureCE peut changer dans la fonction dtostrf ; j’ai dejà eu le cas sous delphi ou il fallait passer un ‘temp:=temp’ pour réceptionner la bonne valeur (sans doute un bug du compilateur) mais je n’aime pas me coucher sur ce genre d’incompréhension. Si quelqu’un a une idée ou une explication ! merci d’avance. Et bravo pour les tuto, bien faits et bien écrits !
Publié par Max Patissier | 12 août 2012, 16 h 12 minLe cast float -> double lors de l’appel à dtostrf() peut être qui n’est pas bien passé ?
Publié par skywodd | 12 août 2012, 16 h 14 minBonjours, y aurait-il moyen d’avoir d’autre example de code, car j’essaye de coder un arduino pour qu’il puisse recevoir des commande prédéfinie mais je bloc sur les variable char …., sa ne dois surement pas être la bonne méthode pour envoyer des commande a distance …
Merci d’avance
Publié par Adrien | 2 octobre 2012, 18 h 44 minIl y a un début d’exemple de système de commande à distance dans les commentaires ;)
La fonction à utiliser c’est « strcmp » avec des if.
Publié par skywodd | 2 octobre 2012, 18 h 52 minD’accord un grand merci, je vais lire et regarder tous sa :)
Publié par Adrien | 2 octobre 2012, 18 h 56 minEffectivement se serais un truc du genre mais … j’envois une commande que j’enregistre dans une variable puis j’envois une valleur de 0 à 255, le but serais de contrôler la vitesse et le sens du moteur a distance mais j’ais beau chercher je ne vois pas grand chose comme solution.
….
Quoi que maintenant que j’y panses avec la « strcmp » et des boolean sa pourrais aller
Merci pour ton aide
Publié par Adrien | 2 octobre 2012, 19 h 04 minMerci pour ce tuto très intéressant, justement je veux le suivre afin de commander un moteur a distance mais comme je suis au début je ne sais pas comment faire commander un moteur en utilisant ces modules
merci pour votre aide
Publié par Djad | 5 octobre 2012, 23 h 47 minTrès bon tuto.
En suivant ce que tu décris, j’arrive à obtenir le même résultat et allumer ou éteindre une diode.
Par contre, dès que je débranche les modules pour les rendre autonomes (un branché sur ma box et l’autre sur mon pc), ça ne marche plus
Une idée d’où peut provenir le souci?
Publié par Michel | 22 mars 2013, 2 h 37 minah ben c’est bon problème résolu, merci
Publié par Michel | 22 mars 2013, 2 h 59 minSalut Skywodd,
Merci pour ce tuto qui m’a vraiment aider malheureusement j’ai le même problème que cyril:
« J’ai utilisé la dernière librairie dispo pour VirtualWire, la compil ce passe bien avec la V1, mais le résultat ne correspond pas, j’obtient une chaine de num au lieu de caractères »
Le problème c’est que moi je ne peux pas prendre la version V023 étant en projet scolaire.
J’obtiens au lieu du message arduino le nombre: 7797105114105101
Pourrais-tu m’aider?
PS: je ne sais pas si cela à un rapport mais la commande strlen n’est pas en couleur dans mon programme.
Publié par Adri | 2 avril 2013, 12 h 01 minautre précision j’utilise une arduino nano pour recevoir les informations
Merci d’avance :)
Publié par Adri | 2 avril 2013, 12 h 02 minRemplace :
par :
Et le probléme devrait étre réglé.
Publié par skywodd | 2 avril 2013, 19 h 45 minmerci cela a fonctionner :)
Publié par adri | 7 avril 2013, 21 h 00 minBonjour j’ai un petit problème :
En fait j’envoie une chaîne de caractère contenant le pourcentage d’une batterie
char msg[64];
sprintf(msg, « %d », Pourcentagebattery);
Et le problème est que je reçoit donc une chaîne mais je ne sais pas comment retrouver la valeur du pourcentage de ma batterie ?
Publié par Marquis | 10 avril 2013, 18 h 41 minEnvois ta valeur sous forme binaire.
Même principe qu’ici :
https://skyduino.wordpress.com/2012/02/01/arduino-transmission-valeur-analogique-par-nrf24l01/
Publié par skywodd | 10 avril 2013, 19 h 52 minMerci mais sinon j’avais pensé à utiliser la fonction atoi mais je n’ai pas réussit ?
Publié par Marquis | 10 avril 2013, 20 h 01 minSalut Skywodd,
Merci pour ce tuto qui m’a vraiment aider mais malheureusement
j’ai une question est ce que la bibliothéque virtualWire est compatible avec des modules de transmissions et réceptions de 863MHz ( dans mon cas j’ai un emetteur AUREL tx8lavsa05 863 MHz et un récepteur AUREL AM8SF 863MHz)
Merci d’avance
Publié par IsaAd | 5 mai 2013, 18 h 40 minThéoriquement la librairie marche avec n’importe quels modules RF.
Publié par skywodd | 5 mai 2013, 18 h 42 minOK skywood merci :)
Publié par IsaAd | 6 mai 2013, 15 h 27 minbonjour, tout d’abord je debute totalement sur arduino, en electronic, et donc aussi en liaison rf433.
bien que ce tuto soit fort interressant, j’ai suivi scrupuleusement toutes les instructions (copié/collé du prog) mais ça ne fonctionne pas ! :'(
j’ai essayé avec la derniere version de l’ide aindi que la version recommandée ici (0023) sans succés.
j’ai donc plusieurs questions:
– ces codes sont-ils pret a l’emplois ou manque-t-il des lignes
– avez-vous un exemple de code complet et fonctionnel afin de faire des test
d’avance merci.
je precise qu’étant débutant je demande des prog complet pour essayé de comprendre leurs fonctionnement et non pour copier/coller betement..
Publié par nexen | 19 mai 2013, 16 h 18 min>> – ces codes sont-ils pret a l’emplois ou manque-t-il des lignes
Il sont prés à l’emploi.
>> – avez-vous un exemple de code complet et fonctionnel afin de faire des test
La librairie est fourni avec un exemple « Ping » de test ;)
Ps: la librairie est elle correctement installé ? Quelles sont les erreurs ?
Publié par skywodd | 20 mai 2013, 16 h 39 minbonjour,
J’aurais voulu savoir si la lib. virtualWire et la lib. LiquidCrystal peuvent fonctionner en même temps :
un LCD graphique :http://www.miniinthebox.com/fr/12864-128-x-64-points-graphique-retro-eclairage-bleu-couleur-lcd-module-d-affichage_p391035.html?litb_from=sysmail
et un module radio en récepteur
Quel sont les délai de réception/transition ?
sinon Merci beaucoup cet article m’aide vraiment !!!!
Publié par martinfactory | 20 mai 2013, 0 h 43 minLiquidCrystal ne gère pas les afficheurs graphiques !
Sinon avec la librairie u8glib tu n’auras pas de problème (mais il faudra vérifier que tu as assez de broches libres).
Pour les timings voir le pdf page 5 ;)
Publié par skywodd | 20 mai 2013, 16 h 45 minmerci :)
Et si je contrôle le LCD en SPI ça me fais 3 broches + une pour le récepteur ça devrais le faire nan ?
Publié par martinfactory | 20 mai 2013, 22 h 36 minOui ça devrait aller.
Publié par skywodd | 21 mai 2013, 9 h 51 minMerci beaucoup :D
Publié par martinfactory | 22 mai 2013, 15 h 23 minBonjour,
j’essaie de faire marcher un RR3-433 sur un arduino 2560, pendant que j’ai mis un RT5 sur un Uno
sur le 2560 j’ai le code suivant (complétement pompé sur ton site) :
#include // inclusion de la librairie VirtualWire
uint8_t buf[VW_MAX_MESSAGE_LEN];
uint8_t buflen = VW_MAX_MESSAGE_LEN; // Taille maximum de notre tableau
void setup() // Fonction setup()
{
Serial.begin(9600); // Initialisation du port série pour avoir un retour sur le serial monitor
Serial.println(« Tuto VirtualWire »); // Petit message de bienvenue
vw_setup(2000); // initialisation de la librairie VirtualWire à 2000 bauds (note: je n’utilise pas la broche PTT)
vw_rx_start(); // Activation de la partie réception de la librairie VirtualWire
}
void loop() // Fonction loop()
{
Serial.println(« debut RX « );
if (vw_wait_rx_max(2000)) // Si un message est reçu dans les 200ms qui viennent
{
if (vw_get_message(buf, &buflen)) // On copie le message, qu’il soit corrompu ou non
{
Serial.print(« RX : « );
for (byte i = 0; i < buflen; i++) // Si il n'est pas corrompu on l'affiche via Serial
Serial.print(buf[i]);
Serial.println("");
}
}
Serial.println("fin RX ");
}
qui se complie bien, j'ai branché l'antenne en 3, l'alim en 15 ou en 12), le signal en 14,, la masse en 11 comme prévu sur la doc trouvé en :
http://www.telecontrolli.com/en/resources/telecontrolli-download/products-datasheet-telecontrolli/radiofrequency-products/rf-receivers-datasheet.html?download=153:rr3
J'ai branché le port 14 du RTC sur le port 11 du Méga (2560) le TX buitbuit … mais je ne reçoit rien ….
Faut-il mettre sur un port de type RX comme le port 15 (noté RX3) du Arduino 2560 ?
et alors comment le déclarér ?
j'ai essayé :
#include // inclusion de la librairie VirtualWire
uint8_t buf[VW_MAX_MESSAGE_LEN];
uint8_t buflen = VW_MAX_MESSAGE_LEN; // Taille maximum de notre tableau
uint8_t pin = 15;
extern void vw_set_rx_pin(uint8_t pin);
void setup() // Fonction setup() ….
ça se compile mais je n’ai pas plus de résultat.
Comment et quoi vérifier quand ça fonctionne pas ?
Merci de votre aide toujours efficace.
Publié par Barrois | 24 mai 2013, 17 h 20 minpourquoi avoir branché l’antenne sur le arduino ?
Publié par martinfactory | 24 mai 2013, 17 h 52 min« j’ai branché l’antenne en 3″ sur le shield de réception RR3-433 (désolé pour se raccouci.
Je pense avoir trouvé en http://forum.freetronics.com/viewtopic.php?f=12&t=4750
la raison de mes problème: « On the MEGA2560 the ICP is on a different pin. »
/**
* http://www.practicalarduino.com/project … n-receiver
*/
The Mega328 only has one ICP which is on D8, the Mega2560 has a few ICPs as follows:
ICP1 – PD4 (Not connected in the Arduino)
ICP3 – PE7 (Not connected in the Arduino)
ICP4 – PL0 (D49 in the Arduino)
ICP5 – PL1 (D48 in the Arduino)
reste à traduire et à essayer.
Publié par Barrois | 27 mai 2013, 8 h 21 minj’ai trouvé ça aussi : http://forum.snootlab.com/viewtopic.php?t=805&p=3841
qui semble provenir de chez toi … :
vw_setup(2000); // initialisation de la librairie VirtualWire à 2000 bauds (note: je n’utilise pas la broche PTT)
vw_set_rx_pin(43);
donc le port receiver du 2560 serait le 43 ?
Publié par Barrois | 27 mai 2013, 10 h 46 minEst-il possible d’envoyer une variable plutôt qu’une char ?
Merci d’avance
Publié par Nathan | 27 mai 2013, 19 h 59 minOui il suffit de faire un cast de pointeur :
Publié par skywodd | 27 mai 2013, 20 h 07 minUn énorme merci !!! :)
Publié par Nathan | 27 mai 2013, 20 h 20 minbonjour skywood, ton tuto est très intéressant, je l ai testé dans le cadre scolaire, pour un projet, en rajoutant un buzzer pour faire sonner dès qu il reçoit le message, tout marche très bien mais je voudrais juste savoir ou et comment se branche les antennes.
merci de ta réponse
Publié par pitralph | 2 juin 2013, 17 h 12 minOu : sur la broche « antenne » (« ANT »)
Comment : avec un fer à souder et de la soudure …
Je vois pas quoi répondre d’autre …
Publié par skywodd | 3 juin 2013, 9 h 55 minlongueur de l’antenne : 1/4 d’onde
Pour du 433,92 Mhz ça fait : 17,2825 cm soit 17,3 cm
Publié par nb | 19 juillet 2013, 14 h 27 minBonjour Skywodd,
Merci pour ce tuto très instructif!
Je démarre un projet sous Arduino, je souhaite commander mes portails automatiques. Pour cela je dois imiter la télécommande du constructeur (elle émet sur une fréquence de 433.920 Mhz).
Dans un premier temps j’aimerai récupérer les signaux envoyés par cette télécommande.
D’après toi je peux utiliser ton code « récepteur » pour essayer ?
Le problème c’est que je n’ai aucune idée du protocole/encodage utilisés par cette télécommande, ni de la vitesse d’émission… Je risque de rencontrer les mêmes problèmes que Benny avec sa sonde Oregon (qui fonctionne sur un protocole différent).
Sinon, est-il possible de surveiller toutes les données émise en 433MHz grâce à VirtualWire (je veux dire les données « brutes », peu importe le protocole de l’émetteur) ?
Merci.
Geoffrey
Publié par ggeo | 14 juillet 2013, 11 h 06 minVirtualWire ne te sera d’aucune utilité, il te faut un analyseur logique câblé sur un récepteur 433MHz.
Regarde mes articles sur blyss, c’est le même principe.
Publié par skywodd | 14 juillet 2013, 21 h 38 minMerci pour ta réponse. Effectivement, ton reverse engineering de « blyss » est le même principe (au passage bravo pour ce travail).
J’ai bien peur que le protocole utilisé par mes télécommandes soit un peu plus difficile à comprendre…
Me reste donc à utiliser un sniffer pour analyser les trames :)
Publié par ggeo | 20 juillet 2013, 13 h 29 minBonjour,
J’apporte ma pierre…
Il me semble préférable de placer les deux lignes:
uint8_t buf[VW_MAX_MESSAGE_LEN]; // Tableau qui va contenir le message reçu (de taille maximum VW_MAX_MESSAGE_LEN)
uint8_t buflen = VW_MAX_MESSAGE_LEN; // Taille maximum de notre tableau
dans la loop.
Ca permet de gérer les messages envoyés par l’émetteur et qui sont de longueur variable. Actuellement la taille maxi est celle du premier message reçu.
Très bon tuto
Merci
Publié par nb | 19 juillet 2013, 19 h 57 minbonjour,
un tres bon tuto ,
svp je veux savoir quel est la distance maximal qui doit etre entre l’emetteur et le recepteur merci
Publié par arduino lover | 12 août 2013, 13 h 30 minÇa dépend fortement de l’alimentation et du module utilisaient, ya pas vraiment de distance type.
Publié par skywodd | 12 août 2013, 20 h 17 minah bon alors on dit que la distance que je veux est de 50m est-ce possible ?
Publié par arduino lover | 13 août 2013, 14 h 27 minles modules entrée de gamme sont entre 60 et 90m théoriquement dans les conditions types
Publié par iDjad | 13 août 2013, 17 h 26 minSalut , merci pour le tuto c’est tres utile,
est-ce qu’on peut utiliser ce module pour la transmission audio sans fil ?
Publié par Tech | 17 août 2013, 21 h 29 minNon les débits sont de l’ordre de 100 octets par seconde.
C’est fait pour transmettre des informations simple uniquement (appui sur un bouton, …).
Publié par skywodd | 18 août 2013, 19 h 30 minmerci
Publié par TECH | 3 septembre 2013, 20 h 41 minSalut,
Merci pour ce tuto qui est très claire et très utile.
As-tu déja essayé une communication entre un Arduino et un Raspberry .
Publié par Mike | 21 août 2013, 20 h 15 minSalut,
Je me permets de répondre.
Plusieurs formes de communications sont possibles, ta question n’est pas assez précise sur ce point.
Si tu veux parler de communication RF433 entre les deux en utilisant Virtualwire, ce n’est pas possible, la lib n’a pas été portée (et ne le sera probablement jamais) sur Raspberry.
Avec un autre protocole, RPI emetteur et ARDUINO récepteur, c’est possible. L’inverse non, à cause de la fréquence très élevée avec le RPI qui n’est pas temps réel, et qui fait beaucoup d’autres choses en même temps.
Publié par nb | 21 août 2013, 21 h 52 minBonjour NB et merci pour ta réponse,
En fait je suis novice et je me suis mis dans l’idée de développer un peu de domotique à la maison. Le premier projet est un détecteur de profondeur pour ma citerne d’eau de plus pour calculer le volume disponible.
Pour le moment, un capteur HR-SR4 couplé avec un arduino et un emetteur RF 433mhz a été réalisé et fonctionne pas mal sur un bureau :). La partie software se fait effectivement en RF433 en utilisant Virtualwire.
Le but maintenant est de collecter ces données sur un raspberry pour les rendre disponible (xively, web ou autre).
Si je suis bien ton raisonnement, ça ne sera pas possible. Il faudra donc que je récolte les informations sur un arduino qui serait linker avec un raspberry pour lui transférer les informations par cable ?
Bonne soirée
Mike
Publié par Mike | 21 août 2013, 23 h 18 minBonjour,
Oui, c’est exactement ça. Le RPI n’aurait pas d’activité temps réel, mais une activité ordinaire d’ordi.
Tu aurais donc un arduino émetteur (celui qui mesure l’eau), un arduino récepteur qui sera là juste pour décoder le flux RF433, et un RPI pour analyser/utiliser/publier les infos.
La liaison entre le récepteur et le RPI pourra se faire par câble (serial ou i2c), ou encore en wifi (plus cher et plus volumineux). Je n’ai pour ma part expérimenté que l’i2c.
Note également qu’avec le virtualwire, tu pourras avoir plusieurs récepteurs arduino. ex un pour communiquer avec le RPI, et un pour afficher le volume sur un écran lcd à l’entrée de ta maison.
Bon courage pour ta réalisation, ça fonctionnera snas problème.
Publié par nb | 22 août 2013, 9 h 01 minMerci pour tes éclaircissements. J’ai vu qu’il existait des shield pour le Rpi, je pense que je vais me tourner vers cela. (genre http://shop.openenergymonitor.com/rfm12pi-v2-pre-assembled-raspberry-pi-expansion-board-433-mhz/)
Publié par Mike | 22 août 2013, 12 h 05 minC’est pas mal du tout, je ne connaissais pas ce concept.
Ce n’est pas donné mais esthétique, compact et fonctionnel.
De plus le RPi suffit pour tout préparer, pas besoin d’un PC supplémentaire.
Je vais le faire connaitre sur le blog d’Idleman dédié au RPi, mais qui fait de fréquentes embardées dans le monde Arduino…
Merci pour l’info et bon courage pour la suite.
Ce serait bien une fois terminé de faire de publier une synthèse.
ps : Skyduino + Idleman, ça fait plaisir de voir des gens comme ça. C’est HS, mais c’est un cri du coeur.
Publié par nb | 22 août 2013, 13 h 54 minA la lecture des derniers commentaires je me posais la question, ne serait-il pas mieux d’utiliser la carte PCduino (linux+arduino http://www.pcduino.com) à la place de la Rpi pour communiquer avec une autre arduino.
On resterait ainsi dans le milieu arduino (plus simple à mon avis pour la compatibilité des prog).
Publié par Franck | 22 août 2013, 15 h 29 minBonjour a tous,
Qu’est ce que vous utilisez comme emetteur/recepteur 433mhz ?
Personnellement j’en ai acheté chez des vendeurs ebay chinois (http://www.befr.ebay.be/itm/370685120131?ssPageName=STRK:MEWNX:IT&_trksid=p3984.m1439.l2648) et j’ai vraiment de très mauvais résultat …
Mike
Publié par Mike | 22 août 2013, 15 h 49 minLa taille maxi des messages est passée à 80 caractères depuis la v1.17:
1.17 Increase default MAX_MESSAGE_LENGTH to 80. Added vw_get_rx_good() and vw_get_rx_bad() functions.
La dernière version de la lib est disponible ici:
http://www.airspayce.com/mikem/arduino/VirtualWire
Publié par nb | 27 août 2013, 19 h 30 minJe vais regarder tout ça merci ;)
Publié par skywodd | 28 août 2013, 13 h 44 minBonjour Skyduino, en testant ton tuto et avec des modules chinois, j’arrive péniblement à 4 mètres d éloignement. j’ai des d’antennes supérieure à 17cm,
Publié par laul | 6 octobre 2013, 13 h 03 min4m ça me semble un peu léger, mes modules atteignent les 25m sans trop de probléme.
Publié par skywodd | 9 octobre 2013, 16 h 07 minHey ! Je me suis mis dans le crâne de faire un truc tout con, j’appuie sur un bouton, ça envoie un message au récepteur qui lance l’allumage d’une Led. Le tout sur un seul arduino. Je galère même pour ça, c’est possible ou pas ? ;) je ne saisis pas très bien comment il fait pour rester en écoute et des que il y a plus d’informations il arrête la Led. J’ai beau tout faire la les reste allumée.
Publié par Nicolas | 23 octobre 2013, 1 h 44 minDeux solutions :
– soit tu fait deux commandes : une pour allumer, une pour éteindre
– soit tu fait une unique commande pour allumer et tu ajoutes un timer pour éteindre la led âpres un temps défini.
Dans la deuxième solution le fait d’envoyer la commande « allumer » plus rapidement que le délai gardera la led allumée.
Pour le timer regarde l’exemple « blink without delay » ;)
Publié par skywodd | 23 octobre 2013, 19 h 24 minBonjour et merci pour ce tutoriel qui m’a bien aidé pour établir une com dans mon projet actuel.
Le projet en question consiste à allumer ou éteindre une led « 1 » si on appuie sur le bouton « 1 », et ainsi de suite pour en tout (pour l’instant) 4 boutons et 4 leds.
Ma carte réceptrice reçoit bien les caractères ascii correspondants à ce que j’envoie, mon soucis à présent est de « décoder » ce que je reçois pour pouvoir allumer le bon voyant. J’ai tenté d’utiliser strcmp(), comme suggéré plus haut dans un autre exemple, mais ça ne fonctionne pas chez moi.
Voici le code de mon récepteur :
void loop()
{
uint8_t buf[VW_MAX_MESSAGE_LEN];
uint8_t buflen = VW_MAX_MESSAGE_LEN;
if (vw_get_message(buf, &buflen)) // On test afin de savoir si un message est reçu.
{
Serial.print(« RX : « );
digitalWrite(led_rx, LOW); // Un message est reçu.
int i;
for (i = 0; i < buflen; i++) // On affiche tous ce que l'on a
Serial.print(buf[i]);
Serial.println("");
if(strcmp("1",(char*) buf) == 0)
{
etat_led_1 = !etat_led_1;
digitalWrite(led_1, etat_led_1);
}
if(strcmp("2",(char*) buf) == 0)
{
etat_led_2 = !etat_led_2;
digitalWrite(led_2, etat_led_2);
}
if(strcmp("3",(char*) buf) == 0)
{
etat_led_3 = !etat_led_3;
digitalWrite(led_3, etat_led_3);
}
if(strcmp("4",(char*) buf) == 0)
{
etat_led_4 = !etat_led_4;
digitalWrite(led_4, etat_led_4);
}
delay(100);
digitalWrite(led_rx, HIGH);
}
}
Publié par Chris | 21 novembre 2013, 17 h 29 minA mon avis dans le code émetteur tu envois strlen(msg) et non strlen(msg) + 1 octets ;)
Publié par skywodd | 23 novembre 2013, 11 h 40 minBonjour et merci pour ta réponse.
Apparemment ça ne lui plaisait pas le fait que je compare directement le contenu du buffer à mon caractère.
En insérant une étape intermédiaire de recopiage du buffer dans une chaine de caractère, et en comparant ensuite les 2 chaînes de caractères ça passe mieux.
Voici un extrait de ce que ça donne :
int i;
for (i = 0; i < buflen; i++) // On affiche tous ce que l'on a
{
Serial.print(buf[i]);
string1[i] = buf[i];
}
Serial.println("");
if(strcmp(msg_1, string1) == 0)
{
etat_led_1 = !etat_led_1;
digitalWrite(led_1, etat_led_1);
}
Etc etc…
Merci encore pour ton tuto ! ;)
Publié par Chris | 25 novembre 2013, 16 h 16 minBonjour,
J’ai un petit souci à la réception des trames qui deviennent incomplètes au bout d’un certain temps.
J’ai décris mon problème sur le forum Arduino auquel vous participez régulièrement :
http://forum.arduino.cc/index.php?topic=204444.0
Si vous avez une piste pour la résolution de ce problème, n’hésitez pas
Merci pour votre implication.
Olivier
Publié par Olivier BERNARD | 14 décembre 2013, 9 h 51 minSalut skywodd, tu dis qu’un 555 sur 1kHz peut bloqué les transmissions en 433MHz. Comment c’est possible ?
Publié par eliobou | 2 février 2014, 14 h 10 minLe NE555 génère un signal carré, de 1KHz ou autre (en réalité la fréquence importe peu).
Ce signal est modulé puis transmit sur la porteuse de 433MHz par le module RF.
En envoyant un signal comme ça en permanence tu brouilles complètement les autres signaux sur la même porteuse. Du coup en face le récepteur ne reçoit que du « bruit » incompréhensible.
Publié par skywodd | 2 février 2014, 17 h 05 minBonjour
Je débute avec Arduino et mon projet consiste à lire des valeurs numériques exprimées en millisecondes, sur une carte SD, puis fabriquer une trame constitué uniquement de ces valeurs
Pour exemple j’ai sur la SD les valeur 200 ;100 ;50 ;100 ;30 ; etc. Tout ça en millisecondes et je voudrais que la valeur 200 mette la sortie PWE de l’Arduino à l’état haut pendant 200 milli , puis la valeur 100 à l’état bas pendant 100 milli , la valeur 50 à l’état haut pendant 50 milli etc.
Pour l’instant j’arrive à afficher les valeurs de la SD sur le moniteur série, mais je bloque pour le reste.
Si vous aviez une idée pour résoudre mon problème ce serait cool.
Merci d’avance.
Publié par Tricotin | 5 février 2014, 13 h 26 minJe complete un peu mon projet
Je souhaite récupérer à la sortie d’une console lumiere les data (protocol DMX)
Apres avoir programmé celle ci mes projecteur à l’autre bout vont réagir d’une certaine façon.
Certain vont s’allumer d’autres vont diminuer leur intensité etc.
L’idée c’est de remplacer la console par un arduino qui renverra vers mes projecteurs exactement la même trame en boucle que celle envoyée par la console.
Ce-ci me permettrai de me passer de la consolle vue que le protocole DMX n’attends pas de message retour vers la console donc vers l’arduino.
J’espere avoir été assez claire mais je suis vraiment novice en programmation arduino et c’est pourquoi je me passionne en ce moment en lisant l’excellent ouvrage de Christian Tavernier sur la programmation arduino.
Publié par Tricotin | 5 février 2014, 15 h 44 minC’est le genre de question a poser sur le forum arduino, ici ce serait trop long à expliquer ;)
http://forum.arduino.cc/index.php/board,33.0.html
Publié par skywodd | 9 février 2014, 13 h 12 minOk je vais aller sur ce forum merci
Publié par Tricotin | 10 février 2014, 21 h 27 minBonjour
En fait je me suis mal expliqué
J’ai déjà stocké à la main ,sur une carte SD, l’équivalent de 3 trames qui représente trois fonctions de la console lumière
J’ai récupéré ces 3 trames à l’aide d’un analyseur logique puis j’ai mesuré les créneaux positif et négatif en Microseconds et les est recopier sur la carte SD sous forme de fichier TXT
Ca représente 150 lignes c’étais fastidieux mais c’est fait .
Je n’ai besoin que de la partie restitution de trame
Le programme que je désire mettre dans l’Arduino consisterais à copier les données de la carte SD dans un tableau
Puis allé lire la ligne n° 1 de ce tableau et fabriquer un créneau positif de la valeur stocké en Microseconds sur la ligne N° 1
Puis allé lire la ligne n° 2 de ce même tableau et fabriquer un créneau négatif de la valeur stocké en Microseconds sur la ligne N° 2 et ainsi de suite jusqu’a la ligne 50
J’aurai donc recréé la trame n°1 que je ferai tourner en boucle pendant 10 secondes .
Puis j’irais lire la trame n°2 en procédant de la même façon en commencent par la ligne 51 jusqu’a la ligne 100 pendant 10 secondes également
Puis la trame n° 3 de 101 à 150 pendant 10 secondes et je repartirais sur la trame n° 1 en boucle indéfiniment
Il ne me reste plus qu’à connecter la sortie programmé de l’Arduino sur la ligne data de mes projecteurs et ils vont jouer les 3 fonctions les une après les autres en boucle
Voila j’espère avoir été un peu plus claire
Merci d’avance
Publié par Tricotin | 11 février 2014, 3 h 33 minCe qu’il te faut c’est une boucle infinie, un test pour gérer la fin du fichier et la fonction parseInt() ;)
En gros l’algo serait :
ouvrir le fichier // http://arduino.cc/en/Reference/SDopen
Tant que (infini) // for(;;) { } ou while(1) { }
– lire un nombre // http://arduino.cc/en/Reference/StreamParseInt
– envoyer le nombre en dmx
– si fin de fichier // http://arduino.cc/en/Reference/FileAvailable
— revenir au début du fichier // http://arduino.cc/en/Reference/FileSeek
Publié par skywodd | 22 février 2014, 16 h 07 minSalut en fait pour l’instant je cherche juste à recopier le fichier SD dans un tableau puis le relire
Mais je ne sais pas comment faire
Si tu a quelques lignes de codes ça m’aiderais bien
Meme ce serais cool
Merci d’avance
Publié par Tricotin | 23 février 2014, 17 h 10 minTrès bon tuto, très clair. J’ai un souci d’un ordre un peu plus « électronique », que les problèmes évoqués au dessus : il semblerait que mon environnement soit blindé de parasites (même en supprimant / éloignant au maximum les différentes sources possibles). Résultat, je ne récupère pas à chaque coup le signal, et ça empire visiblement avec la longueur du message… Ca semble venir principalement de l’émetteur, j’ai donc essayé de rajouter une résistance de 100k entre la masse et l’alimentation, mais ça n’améliore pas les choses… Une idée?
J’ai commandé le même jeu d’émetteur récepteur que toi, je verrai si ça donne plus de satisfaction…
Publié par kayagni | 24 février 2014, 21 h 47 minBonjour j’ai modifier tout le sketch et j’arrive à relire sur le moniteur série les valeurs qui sont stockées sur la carte
La question que je me pose es que je relis bien un tableau, à priori oui, puisque si je met une valeur inférieure à 176 sur la ligne // int valeurs[176]; // j’ai des chiffres et des symboles aberrants sur le moniteur série
Par conte si je met une valeur égale ou supérieure à 176 j’affiche bien les valeurs contenues sur la carte sd
Pouvez vous me confirmer que je relie bien un tableau et non pas la carte sd directement
Là j’ai un petit doute
Voici le nouveau sketch
Merci
#include
File myFile;
int valeurs[176];
void setup()
{
Serial.begin(9600);
pinMode(10, OUTPUT);
SD.begin(4);
// Transfert valeurs de SD vers Tableau
myFile = SD.open(« toto.txt »,FILE_READ);
if (myFile!=false) {
while (myFile.available()) {
for (int lect =0; lect <myFile.size(); lect++) {
valeurs[lect]= myFile.read();
}
// lecture des valeurs du tableau vers moniteur
for (int i =0; i <myFile.size(); i++) {
Serial.write( valeurs[i]);
}}
}
}
void loop()
{
}
Le contenue de la carte sd
12565
355
355
715
715
355
355
715
715
355
355
715
715
355
355
715
715
355
355
715
715
355
355
715
715
355
12565
Publié par Tricotin | 26 février 2014, 0 h 55 minmyFile.size() te retourne le nombre d’octets contenu dans le fichier, pas le nombre de valeurs.
myFile.read() te retourne un octet, pas un int, utilise myFile.parseInt() a la place ;)
Publié par skywodd | 1 mars 2014, 18 h 09 minOk merci cool
Publié par Tricotions | 3 mars 2014, 14 h 37 minLorsque je fais un cast de la valeur de mon pointeur, si j’envoie la valeur 420, le récepteur me retourne… 164… Je n’arrive pas à comprendre où est la boulette… Une idée?
Publié par kayagni | 1 mars 2014, 2 h 38 minCode ?
Publié par skywodd | 1 mars 2014, 18 h 10 minSalut merci de ton tuto, je voulais savoir si il était obligatoire d’utiliser 2 arduino ou si on pouvait remplacer l’une des deux par un pont en H ?
Publié par Antoine | 5 mars 2014, 1 h 05 minTu as obligatoirement deux Arduino, un pour émettre, un pour recevoir (et si tu le souhaite contrôler un pont en H).
Publié par skywodd | 6 mars 2014, 22 h 03 minJ’avais pensé par exemple a une petite telecommande ?
Publié par Antoine | 5 mars 2014, 2 h 24 minça fait longtemps, j’essaie de réaliser une simple transmission à base RT4 + RR3, PIC12f, MANCHESTERE, mikroe.
sur simulation fonctionne, mais sur la réalité n’aime pas fonctionner, quelqu’un pour m’aider??
cordialement
Publié par AKLI NA | 30 mars 2014, 13 h 22 minsalut pouvez vous m’aider à resoudre mon prob :) je cherche un code qui permet d’envoyer une tonalité à l’aide d un emetteur tx-saw 433mgh +arduino uno(comme si une station radio fm ) à une téléphone portable sous une fréq b1 déterminée et merci d’avance
Publié par mhamdi nour elhak | 7 avril 2014, 3 h 25 minSalut, merci pour ton tuto, je dois réaliser pour mon projet de terminal (au bac) une station météo. Je m’occupe de l’émetteur récepteur 433mhz qui doit capter la donnée d’un pluviomètre connecté à l’émetteur et le récepteur doit l’envoyé sur un afficheur lcd et qu’il puisse afficher correctement le degrés de pluviométrie. Je ne sais toujours pas comment je vais faire déjà que le temps me manque mais pour l’instant j’ai un autre problème.
Le message s’envoie bien puisque je reçois un message sur l’arduino du récepteur, par contre le message est: « 65114100117105110111 » et non « Rx : Arduino ». Comment cela fait il ?
Merci d’avance :)
Publié par Arthur | 7 avril 2014, 16 h 37 minRemplace :
Par :
Publié par skywodd | 9 avril 2014, 12 h 05 minmerci de ta réponse, j’avais oublié de répondre mais à la fin j’ai mit » Serial.print(char(buf[i])); » et ça a marché. :)
Publié par Arthur | 11 mai 2014, 1 h 39 minpour les émetteurs/ récepteurs–> conseil après fait des tests sur quelques ref différentes, utiliser les modules Aurel Wireless pour une meilleure porté et meilleure sensibilité du récepteur
Publié par kaim | 2 mai 2014, 10 h 39 minhttp://www.alnoa.fr/2014/05/sonnerie-portail-arduino-sans-fil/
Publié par alnoa | 7 mai 2014, 19 h 10 minA reblogué ceci sur Alex CNC.
Publié par alnoa | 9 mai 2014, 19 h 03 minSalut Skywodd et salut tout le monde.
Tutoriel très intéressant et compréhensible.
Pardonnez-moi d’avance (s’iou plait, ne me battez pas hein) mais je n’es pas lu la globalité des questions/réponses suivant le tuto.
Donc ma question, et mon projet est:
je souhaiterai non pas transmettre un simple message « arduino » mais transmettre une température venant de mon capteur ds18b20, hors l’ide me dis que ce n’est pas une bonne valeurs.
Pourriez vous m’indiquer le sentier a suivre a fin d’y comprendre le blocage,
par avance merci.
Cordialement,
-Visvic-
Publié par VISVIC | 22 juin 2014, 20 h 15 minil faut surement convertir tes valeurs du capteur car dans l’exemple c’est un char utiliser.
Publié par laul | 23 juin 2014, 13 h 37 min@LAUL, c’est ce que j’ai pensé aussi, mais c’est la ou s’arrète mes connaissance (donc connaissance nul lol) pour savoir comment le convertir et le reconvertir apres le signal recu …
Publié par VISVIC | 23 juin 2014, 19 h 51 minPrendre en compte que si vous devez utiliser le pin 10 sans se servir de la fonction ptt, il vous faut changer le pin ptt via vw_set_ptt_pin(); ou vw_set_ptt_inverted.
Publié par alnoa | 6 août 2014, 18 h 39 minsuper merci
Publié par alnoa | 20 octobre 2014, 13 h 44 minBonjour, super tuto merci.
J’ai repris les deux sketch arduino émetteur / récepteur, j’ai essayé d’afficher les résultat du récepteur sur écran LCD mais il n’y a que le test qui fonction en début de programme.
Je n’arrive pas à voir d’ou vient mon erreur. Avez-vous une idée?
merci. Marc.
//********EMETTEUR**********
#include // inclusion de la librairie VirtualWire
const char *msg1 = « Arduino »; // Tableau qui contient notre message 7 caracteres + 1 nul
const char *msg2 = « ERREUR « ;// Tableau qui contient notre message 7 caracteres + 1 nul
void setup() // Fonction setup()
{
Serial.begin(9600); // Initialisation du port série pour avoir un retour sur le serial monitor
Serial.println(« Tuto VirtualWire »); // Petit message de bienvenue
vw_setup(2000); // initialisation de la librairie VirtualWire à 2000 bauds (note: je n’utilise pas la broche PTT)
}
void loop() // Fonction loop()
{
Serial.print(« TX Debut envoi1 « ); // On signale le début de l’envoi
vw_send((uint8_t *)msg1, strlen(msg1)); // On envoie le message
vw_wait_tx(); // On attend la fin de l’envoi
Serial.println(« Done Fin Envoi1″); // On signal la fin de l’envoi
delay(3000); // Et on attend 1s pour pas flooder
Serial.print(« TX Debut envoi2 « ); // On signale le début de l’envoi
vw_send((uint8_t *)msg2, strlen(msg2)); // On envoie le message
vw_wait_tx(); // On attend la fin de l’envoi
Serial.println(« Done Fin Envoi2″); // On signal la fin de l’envoi
delay(3000); // Et on attend 1s pour pas flooder
}
**************************************************************************************************
//****************RECEPTEUR***************
#include // inclusion de la librairie VirtualWire
#include // Inclusion de la librairie pour afficheur LCD
int retro = 9; // retroéclairage sur broche 9
int led =13;
const int RS=2; //declaration constante de broche Afficheur LCD
const int E=3; //declaration constante de broche
const int D4=4; //declaration constante de broche Afficheur LCD
const int D5=5; //declaration constante de broche Afficheur LCD
const int D6=6; //declaration constante de broche Afficheur LCD
const int D7=7; //declaration constante de broche Afficheur LCD
LiquidCrystal lcd(RS, E, D4, D5, D6, D7);// initialisation LCD en mode 4 bits
void setup() // Fonction setup()
{
pinMode(led, OUTPUT); // Pin 13 etat en sortie
pinMode(retro, OUTPUT);
lcd.begin(16, 2); // Afficheur LCD 2 lignes 16 caractères
delay(10); // pause rapide pour laisser temps initialisation
analogWrite(retro, 125); // Ecriture analogique PWM ou LMI réglage luminosité rétroéclairage de 0 à255
delay(10); // pause rapide pour laisser temps initialisation
// Test du LCD
lcd.clear();// Efface ecran
lcd.setCursor(0, 0) ; // positionne le curseur à l’endroit voulu (colonne, ligne) (1ère=0 !)
lcd.print(« Tuto VirtualWire ») ; // affiche la chaîne texte – message de test
delay(1000); // pause
vw_setup(2000); // initialisation de la librairie VirtualWire à 2000 bauds (note: je n’utilise pas la broche PTT)
vw_rx_start(); // Activation de la partie réception de la librairie VirtualWire
}
void loop() // Fonction loop()
{
uint8_t buf[VW_MAX_MESSAGE_LEN]; // Tableau qui va contenir le message reçu (de taille maximum VW_MAX_MESSAGE_LEN)
uint8_t buflen = VW_MAX_MESSAGE_LEN; // Taille maximum de notre tableau
if (vw_wait_rx_max(200)) // Si un message est reçu dans les 200ms qui viennent
{
if (vw_get_message(buf, &buflen)) // On copie le message, qu’il soit corrompu ou non
{
lcd.clear();// Efface ecran
lcd.setCursor(0, 1) ; // positionne le curseur (colonne, ligne)
lcd.print(« RX Debut »);
delay (500);
for (byte i = 0; i < buflen; i++) // Si il n'est pas corrompu on l'affiche via Serial
{
lcd.setCursor(0, 0) ; // positionne le curseur (colonne, ligne)
lcd.print(buf[i]);
}
delay (500);
lcd.setCursor(0, 1);
lcd.print(" ");// efface la 2eme ligne par 16 caracteres espace
lcd.setCursor(0, 1) ; // positionne le curseur (colonne, ligne)
lcd.print("RX Fin");
delay (500);
if(strcmp("Arduino", (char*)buf) == 0)
{
lcd.setCursor(0, 1);
lcd.print(" ");// efface la 2eme ligne par 16 caracteres espace
lcd.setCursor(0, 1) ; // positionne le curseur (colonne, ligne)
lcd.print("pin 13 HIGH");
delay (500);
digitalWrite(13, HIGH);
}
else if(strcmp("ERREUR ", (char*)buf) == 0)
{
lcd.setCursor(0, 1);
lcd.print(" ");// efface la 2eme ligne par 16 caracteres espace
lcd.setCursor(0, 1) ; // positionne le curseur (colonne, ligne)
lcd.print("pin 13 LOW");
delay (500);
digitalWrite(13, LOW);
}
}
}
}
Publié par Marc | 25 octobre 2014, 15 h 32 minBonjour, je pense avoir un problème avec le rétroéclairage.
J’ai remplacé
analogWrite(retro, 125); // Ecriture analogique PWM ou LMI réglage luminosité rétroéclairage de 0 à255
par
digitalWrite(9, HIGH);
mais je ne peu pas régler la luminosité du rétroéclairege.
Quelqu’un as-t-il une idée.
Cordialement.
Marc.
Publié par Marc | 26 octobre 2014, 11 h 29 minBonjour, dans la librairie « VirtualWire » il est spécifier (Caution: VirtualWire takes over Arduino Timer1, and this will affect the PWM capabilities of the digital pins 9 and 10.
J’ ai donc changer de broche.
Tout est OK
Cordialement.
Marc.
Publié par Marc | 30 octobre 2014, 8 h 27 minSalut, super tutot.
J’essaye de faire en sorte que lorsque je reçois le message correctement, cela active un relais via la sortie 13, mais je galère au niveau du code, quelqu’un pour m’éclairer ?
#include // inclusion de la librairie VirtualWire
void setup() // Fonction setup()
{
Serial.begin(9600); // Initialisation du port série pour avoir un retour sur le serial monitor
Serial.println(« Tuto VirtualWire »); // Petit message de bienvenue
pinMode (13, OUTPUT);
vw_setup(2000); // initialisation de la librairie VirtualWire à 2000 bauds (note: je n’utilise pas la broche PTT)
vw_rx_start(); // Activation de la partie réception de la librairie VirtualWire
}
void loop() // Fonction loop()
{
uint8_t buf[VW_MAX_MESSAGE_LEN]; // Tableau qui va contenir le message reçu (de taille maximum VW_MAX_MESSAGE_LEN)
uint8_t buflen = VW_MAX_MESSAGE_LEN; // Taille maximum de notre tableau
// REMARQUE ULTRA IMPORTANTE :
// Par le passé ces deux lignes se trouvaient en « haut de programme », c’était donc des variables globales.
// Elles ne doivent PAS être globales, c’est très important !
//
// Pourquoi ?
// C’est très simple. Posez vous la question suivante : que vaut « buflen » si la réception d’un message échoue,
// où qu’on reçoit un message de moins de VW_MAX_MESSAGE_LEN octets ?
// Au début « buflen » vaut VW_MAX_MESSAGE_LEN, mais après « buflen » vaudra une valeur < VW_MAX_MESSAGE_LEN.
// Et paf, la taille de votre buffer vient de diminuer pour la réception suivante, et ainsi de suite.
if (vw_wait_rx_max(200)) // Si un message est reçu dans les 200ms qui viennent
{
if (vw_get_message(buf, &buflen)) // On copie le message, qu'il soit corrompu ou non
{
Serial.print("RX : ");
for (byte i = 0; i < buflen; i++) // Si il n'est pas corrompu on l'affiche via Serial
Serial.print(buf[i]);
Serial.println("");
}
}
if ( buf == "Test reussi")
{ digitalWrite(13, HIGH);
}
}
Publié par naleur | 25 novembre 2014, 16 h 04 minbonjour,
pour commencer, très bon tuto, ça permet aux noob dont je fait parti de comprendre les bases.
maintenant, et même aprés avoir lu tous les post je n’arrive pas a mes fins, a savoir:
envoyer une commande genre « onlumiere3″ et que de l’autre coté la reception de cette commande active une sortie de mon choix.
contrainte supplementaire, cette valeure « onlumiere3″ se couple avec && « si l’inter local est sur 1″
un bon samaritain pour me montrer la voie a prendre ?
d’avance merci.
Publié par nexen | 2 février 2015, 0 h 35 min