Le contenu de cet article a été entièrement réécrit et mis à jour sur le site Carnet du Maker.
Liens vers les nouveaux articles :
- Communiquer sans fil en 433MHz avec la bibliothèque VirtualWire et une carte Arduino / Genuino : https://www.carnetdumaker.net/articles/communiquer-sans-fil-en-433mhz-avec-la-bibliotheque-virtualwire-et-une-carte-arduino-genuino/
N.B. Les commentaires de l’article ont été pris en compte lors de la rédaction des nouveaux articles 😉
Super article ! exactement ce que je cherchais.
Trè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.
Le DR3100 peut émettre / recevoir (mais pas en même temps bien sur) et fonctionne avec VirtuaWire, sinon n’importe quel transmetteur 433MHz devrait marcher.
Ok, merci Skywodd.
Salut 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 ???
Il 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 😉
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
Avec la V023 pas de problème
@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.
Merci beaucoup pour ce tuto!!
Tu me donne de nouvelles possibilités d’utilisation des cartes arduino.
T’es au top continu 🙂
Merci 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
Tient 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.
En 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.
@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 😉
Reprise 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
Salut !! 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
Si 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é.
bonjour,
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
Il suffit d’utiliser la fonction strcmp (en supposant que le message envoyé est au format texte) :
http://www.cplusplus.com/reference/clibrary/cstring/strcmp/
Si a la place de « pin111 » on veut mettre une variable INT il sufit de mettre la variable comme ce si :
Si je comprend bien le lien que tu as mis sa ne peut que comparer des textes
…
Regarde du coté des fonctions « sscanf » et « sprintf » qui permettent de lire / écrire des variables dans une chaine de caractères suivant un format donné.
Un grand merci pour ton aide, je vais essayer de me débrouiller avec sa 🙂
merci
je test cela au plus vite
@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
Ha oui, j’avais pas vu qu’il fallait un cast …
Ça devrait le faire.
merci
la compilation marche reste a tester sur le montage merci encore.
bon 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);
}}
probleme resolu cela venait de mon alimentation qui etait defetueuse .
chgt de l’alim et tout est redevenu ok.
merci
Bonjour,
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
Aprè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.
Apparemment 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.
Aprè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.
Je 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!
Je 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
Salut 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/
Hello 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
bonjour, 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
-> 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 😉
Serial.print(char(buf[i])); au lieu de Serial.print(buf[i]);
Merci pour l’aide !
Serial.write((char)buf[i]);
j’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
Affiche 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).
une 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 !
Le cast float -> double lors de l’appel à dtostrf() peut être qui n’est pas bien passé ?
Bonjours, 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
Il 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.
D’accord un grand merci, je vais lire et regarder tous sa 🙂
Effectivement 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
Merci 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
Trè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?
ah ben c’est bon problème résolu, merci
Salut 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.
autre précision j’utilise une arduino nano pour recevoir les informations
Merci d’avance 🙂
Remplace :
par :
Et le probléme devrait étre réglé.
merci cela a fonctionner 🙂
Bonjour 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 ?
Envois ta valeur sous forme binaire.
Même principe qu’ici :
https://skyduino.wordpress.com/2012/02/01/arduino-transmission-valeur-analogique-par-nrf24l01/
Merci mais sinon j’avais pensé à utiliser la fonction atoi mais je n’ai pas réussit ?
Salut 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
Théoriquement la librairie marche avec n’importe quels modules RF.
OK skywood merci 🙂
bonjour, 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..
>> – 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 ?
bonjour,
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 !!!!
LiquidCrystal 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 😉
merci 🙂
Et si je contrôle le LCD en SPI ça me fais 3 broches + une pour le récepteur ça devrais le faire nan ?
Oui ça devrait aller.
Merci beaucoup 😀
Bonjour,
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.
pourquoi avoir branché l’antenne sur le arduino ?
« 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.
j’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 ?
Est-il possible d’envoyer une variable plutôt qu’une char ?
Merci d’avance
Oui il suffit de faire un cast de pointeur :
Un énorme merci !!! 🙂
Avec cela tu aura l’adresse de val non ?
parce que &val c’est l’adresse de val et en le castant tu le transforme en pointeur mais la tu affiche le pointeur pas la valeur pointée !
Avec le code ci dessus tu obtiendras la valeur de val en réception, sous la forme d’un integer brut (dépendant du compilateur utilisé).
La fonction vw_send prend en paramétre un pointeur sur données (ici &val) et la taille des données (ici sizeof int).
bonjour 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
Ou : sur la broche « antenne » (« ANT »)
Comment : avec un fer à souder et de la soudure …
Je vois pas quoi répondre d’autre …
longueur de l’antenne : 1/4 d’onde
Pour du 433,92 Mhz ça fait : 17,2825 cm soit 17,3 cm
Bonjour 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
VirtualWire 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.
Merci 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 🙂
Bonjour,
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
bonjour,
un tres bon tuto ,
svp je veux savoir quel est la distance maximal qui doit etre entre l’emetteur et le recepteur merci
Ça dépend fortement de l’alimentation et du module utilisaient, ya pas vraiment de distance type.
ah bon alors on dit que la distance que je veux est de 50m est-ce possible ?
les modules entrée de gamme sont entre 60 et 90m théoriquement dans les conditions types
Salut , merci pour le tuto c’est tres utile,
est-ce qu’on peut utiliser ce module pour la transmission audio sans fil ?
Non 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, …).
merci
Salut,
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 .
Salut,
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.
Bonjour 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
Bonjour,
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.
Merci 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/)
C’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.
A 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).
Bonjour 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
La 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
Je vais regarder tout ça merci 😉
Bonjour 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,
4m ça me semble un peu léger, mes modules atteignent les 25m sans trop de probléme.
Hey ! 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.
Deux 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 » 😉
Bonjour 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);
}
}
A mon avis dans le code émetteur tu envois strlen(msg) et non strlen(msg) + 1 octets 😉
Bonjour 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 ! 😉
Bonjour,
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
Salut skywodd, tu dis qu’un 555 sur 1kHz peut bloqué les transmissions en 433MHz. Comment c’est possible ?
Le 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.
Bonjour
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.
Je 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.
C’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
Ok je vais aller sur ce forum merci
Bonjour
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
Ce 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
Salut 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
Trè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…
Bonjour 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
myFile.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 😉
Ok merci cool
Lorsque 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?
Code ?
Salut 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 ?
Tu as obligatoirement deux Arduino, un pour émettre, un pour recevoir (et si tu le souhaite contrôler un pont en H).
J’avais pensé par exemple a une petite telecommande ?
ç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
salut 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
Salut, 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 🙂
Remplace :
Par :
merci 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é. 🙂
pour 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
http://www.alnoa.fr/2014/05/sonnerie-portail-arduino-sans-fil/
A reblogué ceci sur Alex CNC.
Salut 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-
il faut surement convertir tes valeurs du capteur car dans l’exemple c’est un char utiliser.
@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 …
Prendre 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.
super merci
Bonjour, 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);
}
}
}
}
Bonjour, 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.
Bonjour, 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.
Salut, 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);
}
}
bonjour,
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.
bonjour tout le monde
comment puis-je faire pour envoyer les informations de mes capteurs de température et de comptage ??
Bonjour, Comment je fais pour synchroniser l’émetteur et le récepteur?
Il n’y a pas de synchronisation avec ce genre de module.
Bonjour, je suis en T’STI2D et après plusieurs essais a tenter de modifier le programme d’ici pour l’adapter a ce que je veut (Hélas tous des échecs) j’en vient a vous demander votre aide. Je souhaite en effet modifier le délai d’une seconde entre chaque envoie pour un Déclenchement par un simple boutton(le principe d’une télécommande HF) Après plusieurs programmes trouvés sur le net, je vous remercie d’avance si vous pouvez m’aider a finaliser mon projet.
Si tu veux un fonctionnement type télécommande de TV :
Salut, pour un petit drone comment puis-je dire au premier arduino ( un explorez )de dire lui même ( si le joystick bouge ) au deuxième arduino ( un uno ) d’alimenter les moteurs ??
Et qu’elle matos prendre svp ?
Pour faire tourner les moteurs ?
Regarde les premiers commentaires de l’article. Je donne un exemple pour allumer une led à distance.
S’il vous plait, comment je pourrais envoyer la valeur donné par un potentiomètre ? Je suis débutant et je ne vois pas comment faire.
Voir mon commentaire plus haut (cast int) : https://skyduino.wordpress.com/2011/12/29/tutoriel-arduino-et-emetteurrecepteur-433mhz-virtualwire/#comment-3248
Merci beaucoup ! J’avais regardé plus haut mais je n’avais pas vu ce commentaire ^^’. Et niveau réception, comment récupérer cette valeur dans un integer ?
Comme ça :
Bonjour
Quel est le débit de ce genre d’émétteur recepteur ?
merci
A 2Kbps (standard), le débit maximum théorique avec VirtualWire est de 132 octets par seconde.
Mais dans la vraie vie, avec les interférences, c’est plus 27 octets (= un message VirtualWire) par seconde vu qu’il faut répéter au moins 4 fois un message pour le recevoir correctement à l’autre bout.
Bonjour, je tente un petit projet à partir d’une mega2560 et d’une arduino nano
But : récupérer des info venants de capteur d’alarme, la temperature, …et des variable venant de la carte nano.
et pouvoir controller des prises fonctionnant sur DIO (ref54760)
pour cela j’utilise les librairies suivantes :
RCSwitch pour les capteurs alarme
NewRemoteTransmiter pour émettre vers les prises DIO
tout va très bien.
Lorsque je veux inclure la récup de données depuis la Nano j’ai rajouté le librairie virtualwire (transmission de variables)
Là je peux encore recevoir les codes de mes détecteurs et les traiter mais par contre je ne sais plus émettre pour mes prises DIO.
voici un code que j’utilise (simplifié)
Donc emetteur sur pin 11 et recepteur sur pin 2
#include
#include
#include
NewRemoteTransmitter transmitterDIO1(8613114, 11, 260, 3);
void setup() {
vw_setup(2000); // initialisation de la librairie VirtualWire à 2000 bauds (note: je n’utilise pas la broche PTT)
vw_set_rx_pin(2);
vw_rx_start(); // Activation de la partie réception de la librairie VirtualWire
}
void loop() {
lecturevirtualwire(); //décodage des variables Arduino Nano
allumertout();
delay(20000);
}
void allumertout()
{
transmitterDIO1.sendUnit(0, true);
transmitterDIO1.sendUnit(1, true);
transmitterDIO1.sendUnit(2, true);
}
void lecturevirtualwire() {
// code de ton example …
}
Dès que rx_start est activé je ne peux plus emettre.
Actuellement je contourne le probleme en mettant rx_stop avant emission
void allumertout()
{
vw_rx_stopt();
transmitterDIO1.sendUnit(0, true);
transmitterDIO1.sendUnit(1, true);
transmitterDIO1.sendUnit(2, true);
vw_rx_start();
}
Comment se fait il que la lecture d’un code RF entrant puisse bloquer l’émission ?
Toute explication serait la bienvenue
Merci
Ça fonctionne très bien mais ma porté n’est que de quelques mètres… même avec de petites antennes grrrr … Une idée quelqu’un ?
La porteuse 433MHz est tellement saturée que ça m’étonne pas qu’après quelques mètres on ne capte que du bruit.
En général, avec des modules chinois pas cher, j’arrive à une portée grand max de 10-15m.
C’est pour quel type d’application ?
Salut,
Est-ce qu’il y a une autre fréquence qui peut être utilisée ?
Si oui, est-ce qu’il y a des matériels pas trop chers, je pense essentiellement à des prises, et des récepteurs qui fonctionnent avec.
Merci d’avance
La porteuse 868MHz est utilisable mais il existe pas beaucoup de matos dessus à l’exception des alarmes sans fil et autres modules Z-Waze.
Bonjour,j ai un problème avec mon code arduino.
Mon but est de envoyer 1 voir 3 (maximum) position précises a un servomoteur et un moteur pas a pas.
Le seul problème, c est que la partie interrupteur(sans fil) ,je comprend pas les informations donner.
Mon problème n’est pas que le servo ou le moteur ne marche pas(fonctionne sans wifi) .
Mais quand la télécommande envoie les données rien ne se passe.
je ne comprend pas d’où viens le problème?
quelqu’un aurait une idée?
Il faudrait que tu nous donnes ton code pour qu’on puisse t’aider ^^
// Emetteur 433 MHz
// Programme d’émission de données
// Source : https://skyduino.wordpress.com/2011/12/29/tutoriel-arduino-et-emetteurrecepteur-433mhz-virtualwire/
//=====================================================
#include
const char *msg = « 28790658 »;
//Chiffres de 0-9 (les caractères ABC… sont transmis en code A=65,…)
void setup()
{
Serial.begin(9600);
Serial.println(« Tuto VirtualWire »);
vw_setup(2000);
}
void loop()
{
Serial.print(« TX … « );
vw_send((uint8_t *)msg, strlen(msg));
vw_wait_tx();
Serial.println(« Done ! »);
delay(2000); // Et on attend 1s pour pas flooder
}
// ==== Recepteur 433 MHz ===============================
// Source : https://skyduino.wordpress.com/2011/12/29/tutoriel-arduino-et-emetteurrecepteur-433mhz-virtualwire/
//=======================================================
#include
uint8_t buf[VW_MAX_MESSAGE_LEN];
uint8_t buflen = VW_MAX_MESSAGE_LEN;
void setup()
{
Serial.begin(9600);
Serial.println(« Tuto VirtualWire »);
vw_setup(2000);
vw_rx_start();
}
void loop()
{
if (vw_wait_rx_max(200))
{
if (vw_get_message(buf, &buflen))
{
Serial.print(« RX : « );
for (byte i = 0; i < buflen; i++)
//Serial.print(buf[i]);
{Serial.print(buf[i]- '0');
}
Serial.println("");
}
mais je viens de voir que j ai une arduino nano est pas uno est ce que sa change??
Hello World
Bonjour.
quand j’envoie un int superieur a 40000 je recois des choses bizarres. je me sert de itoa pour la conversion.
C’est à cause de la limite d’envoi?
Envoi du binaire sinon ça prend trop de place (voir commentaires plus haut).
bonjour,
je cherche à mesurer une tension, celle d’une photorésistance, donc la tension va varier et il me faut donc un échantillonnage assez précis, grâce à un arduino, je vais avoir un module autonome alimenté par une pile qui enverra la valeur de cette tension à un autre par le biais d’émetteur récepteur.
J’aimerais savoir comment il est possible de récupérer cette tension ?
merci d’avance
Avec un pont diviseur et analogRead() : http://www.instructables.com/id/How-to-Use-a-Light-Dependent-Resistor-LDR/
Merci pour votre travail.
Je tente d’envoyer plusieurs valeurs mais je n’y parviens pas car trop peu de connaissance dans ce langage.
D’apres les post précédents il faut envoyer les valeurs en binaire, mais j’en suis incapable.
J’ai ma fonction avec 2 variables (var1 & var2) de types différents (int & byte)
void txData(){
int var1 = 683;
byte var2 = 16;
comment dois je faire pour placer ces 2 valeurs dans la variable msg et la transmettre
??
??
??
vw_send((uint8_t *)msg, strlen(msg));
}
void rxData(){
Ici je souhaite récupérer mes valeurs var1 & var2
uint8_t buf[VW_MAX_MESSAGE_LEN];
uint8_t buflen = VW_MAX_MESSAGE_LEN;
if (vw_get_message(buf, &buflen))
{
for (byte i = 0; i < buflen; i++){ // Si il n'est pas corrompu on l'affiche via Serial
??
??
??
}
Serial.println(var1);
Serial.println(var2);
}
Merci par avance de votre aide
Bonjour, comment se fait’il que je suis obliger d’ouvrir le moniteur série pour que l’émetteur commence a envoyer des données ?
Merci pour le tuto! C’est tout à fait ce qu’il me fallait 🙂
Bonjour, Merci pour ce tuto, il est très complet (quoique un peti schéma sur fritzing serait super sympa) et le code est vraiment intéressant.
Mais voilà j’ai une question….
Je voudrais faire un drone basé sur une carte arduino qui serait elle même piloté par une autre carte arduino…
Pour la communication sans fil j’ai cherché un système peu chère et je suis tombé sur les émetteurs récepteurs RF 434MHz.
Je veux que le drone soit en liaison constante et à une faible distance de la télécommande arduino mais cela me pose certains problèmes:
Premièrement, je ne suis pas sûr que la vitesse d’envoi des données soit suffisante (je veux juste 16 signaux différents) et que le signal soit assez long pour contenir assez d’information.
Deuxièmement, est ce que la corruption des signal est fréquente ? Je veux garder une liaison constante (une erreur pourrait entraîner un crash) et je compte l’utiliser dans un milieu limité en fréquence hertzienne (au milieu des champs)
Donc, selon vous est ce que le choix d’un module de 434MHz pour une liaison avec un drone en temps réel est une bonne idée ?
Je sais qu’il existe mieux mais je veux une liaison à faible coût et très légère au niveau du poids…
Merci de votre attention
Cordialement,
Arthur P
Bonjour Sky !
je voudrais rajouter deux scripts : un pour l’émission de la température relevé à l’aide d’une sonde DS18B20, l’autre la réception de la température.
On y voit que la longueur d’un message transmis doit être de 27 caractères maximum, et la reconstitution des chiffres et du nombre grave à la fonction : toFloat
Voici la partie émission de 4 nombres positifs et négatifs :
// transmitter.pde
//
// Simple example of how to use VirtualWire to transmit messages
// Implements a simplex (one-way) transmitter with an TX-C1 module
//
// See VirtualWire.h for detailed API docs
// Author: Mike McCauley (mikem@airspayce.com)
// Copyright (C) 2008 Mike McCauley
// $Id: transmitter.pde,v 1.3 2009/03/30 00:07:24 mikem Exp $
#include
#include // Inclusion de la librairie OneWire
const int led_pin = 11; // pin de reception
const int transmit_pin = 12; // pin de transmission
const int receive_pin = 2;
const int transmit_en_pin = 3;
#define DS18B20 0x28 // Adresse 1-Wire du DS18B20
#define BROCHE_ONEWIRE 7 // Broche utilisée pour le bus 1-Wire
OneWire ds(BROCHE_ONEWIRE); // Création de l’objet OneWire ds
float tempa, tempb; // temperature mesuree et son inverse pour avoir un chiffre negatif
static char dtostrfbuffer[15],dtostrfbufferm[15],somme[15];
static char sprintfbuffer[15];
// Fonction recuperant la temperature depuis le DS18B20
// Retourne true si tout va bien, ou false en cas d’erreur
boolean getTemperature(float *temp){
byte data[9], addr[8];
// data : Donnees lues depuis le scratchpad
// addr : adresse du module 1-Wire detecte
if (!ds.search(addr)) { // Recherche un module 1-Wire
ds.reset_search(); // Reinitialise la recherche de module
return false; // Retourne une erreur
}
if (OneWire::crc8(addr, 7) != addr[7]) // Verifie que l’adresse a ete correctement reesolue
return false; // Si le message est corrompu on retourne une erreur
if (addr[0] != DS18B20) // Verifie qu’il s’agit bien d’un DS18B20
return false; // Si ce n’est pas le cas on retourne une erreur
ds.reset(); // On reset le bus 1-Wire
ds.select(addr); // On selectionne le DS18B20
ds.write(0x44, 1); // On lance une prise de mesure de temperature
delay(800); // Et on attend la fin de la mesure
ds.reset(); // On reset le bus 1-Wire
ds.select(addr); // On selectionne le DS18B20
ds.write(0xBE); // On envoie une demande de lecture du scratchpad
for (byte i = 0; i < 9; i++) // On lit le scratchpad
data[i] = ds.read(); // Et on stock les octets resolus
// Calcul de la temperature en degre Celsius
// *temp = ((data[1] << 8) | data[0]) * 0.0625;
tempa = ((data[1] << 8) | data[0]) * 0.0625;
// Pas d'erreur
return true;
}
void setup()
{
Serial.begin(9600); // Debugging only
Serial.println("Transmetteur ds18b20");
// Initialise the IO and ISR
vw_set_tx_pin(transmit_pin);
vw_set_rx_pin(receive_pin);
vw_set_ptt_pin(transmit_en_pin);
vw_set_ptt_inverted(true); // Required for DR3100
vw_setup(2000); // Bits per sec
pinMode(led_pin, OUTPUT);
}
byte count = 1;
void loop()
{
// Lit la temperature ambiante a ~1Hz
if(getTemperature(&tempa)) {
tempb = – tempa;
// Affiche la temperature
Serial.print("Temperature : ");
Serial.print(tempa);
Serial.write(176); // caractere °
Serial.write('C');
Serial.println();
dtostrf(tempa,6, 2, dtostrfbuffer); // signe, deux chiffres et deux chiffres apres la virgule
dtostrf(tempb,6, 2, dtostrfbufferm); // signe, deux chiffres et deux chiffres apres la virgule
Serial.print("dtostrf positif ");
Serial.print(dtostrfbuffer);
Serial.print(" dtostrf negatif ");
Serial.println(dtostrfbufferm);
char msg1[256];
// constitution du message :
// un nombre positif / un nombre negatif / un nombre positif / un nombre negatif
sprintf (msg1,"%s/%s/%s/%s",dtostrfbuffer,dtostrfbufferm,dtostrfbuffer,dtostrfbufferm);
// calcul de la logueur du message
float somma = float(strlen(msg1)); // calcul de la longueur du message dans somma
dtostrf(somma,2,0, somme); // mise de la longueur dans somme en format 6.2
Serial.print("longueur du message = ");
Serial.print(somme);
Serial.println(" =< la longueur maxi du message : 27 caracteres");
digitalWrite(led_pin, HIGH); // Flash a light to show transmitting
Serial.println(msg1);
vw_send((uint8_t *)msg1, strlen(msg1)); // envoi du message des 4 nombres
vw_wait_tx(); // Wait until the whole message is gone
digitalWrite(led_pin, LOW);
delay(1000);
count = count + 1;
}
}
puis la partie réception (le message n'est accepté que si le ChekSum est correct)
Désolé le premier script est mal passé je retente :
salut tout le monde j’utilise un touchscreen et donc j’ai que la broche 0 ou 1 de libre comment je fais pour modifier les valeurs par défaut du recepteur ?
Bonjour,
J’ai réalisé le montage avec des émetteurs et récepteur du même type (Emetteur 433.92 MHz « RT6-433 » et Récepteur 433,92 MHz « RR3-433 »). Les données s’envoient quand je met le moniteur série de l’émetteur mais elles ne sont pas réceptionnées sur le moniteur série du récepteur. J’ai branché le tout sur une plaque Arduino accompagnée de 2 cartes Arduino.
donc la portée de ton système n’excède pas les 10 15 m ?
dsl en fait c’est avec des composant chinois 10-15m et avec ton système ça dépend de la vitesse de transmission des données comme indiqué a la fin de ton article. Es ce bien cela ??
Bonjour , j’utilise pour émetteur un AUREL TX-8L25IA ( 868.3 MHz) et pour récepteur un AUREL RX-AM8SF ( 868.3 MHz) , j’ai testé le programme , mais la partie réception ne marche pas , y a t’il des modification a faire dans les programmes par rapport a mes émetteur récepteur de même fréquence ? Merci de votre réponse