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.
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 😀
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 minAvec 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 !
Publié par Adrien | 28 août 2015, 9 h 54 minAvec 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).
Publié par Skywodd | 13 septembre 2015, 14 h 00 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 minbonjour tout le monde
comment puis-je faire pour envoyer les informations de mes capteurs de température et de comptage ??
Publié par baptiste | 12 mars 2015, 9 h 12 minBonjour, Comment je fais pour synchroniser l’émetteur et le récepteur?
Publié par afaf | 19 mars 2015, 11 h 21 minIl n’y a pas de synchronisation avec ce genre de module.
Publié par Skywodd | 27 mars 2015, 10 h 26 minBonjour, 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.
Publié par CielArt | 9 avril 2015, 11 h 19 minSi tu veux un fonctionnement type télécommande de TV :
void loop() // Fonction loop() { if (digitalRead(2) == LOW) { // En partant du principe que l'interrupteur est câblé sur la broche D2 avec un résistance tirage à VCC vw_send((uint8_t *)msg, strlen(msg)); vw_wait_tx(); delay(1000); } }
Publié par Skywodd | 9 avril 2015, 14 h 01 minSalut, 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 ??
Publié par Foxlight_ | 21 juin 2015, 15 h 12 minEt qu’elle matos prendre svp ?
Publié par Foxlight_ | 21 juin 2015, 15 h 14 minPour faire tourner les moteurs ?
Publié par Skywodd | 3 juillet 2015, 17 h 12 minRegarde les premiers commentaires de l’article. Je donne un exemple pour allumer une led à distance.
Publié par Skywodd | 3 juillet 2015, 17 h 12 minS’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.
Publié par Onytis | 31 octobre 2015, 15 h 07 minVoir mon commentaire plus haut (cast int) : https://skyduino.wordpress.com/2011/12/29/tutoriel-arduino-et-emetteurrecepteur-433mhz-virtualwire/#comment-3248
Publié par Skywodd | 11 novembre 2015, 18 h 19 minMerci 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 ?
Publié par Onytis | 13 novembre 2015, 19 h 47 minComme ça :
#include <VirtualWire.h> void setup() { Serial.begin(9600); vw_setup(2000); vw_rx_start(); } void loop() { uint8_t buf[VW_MAX_MESSAGE_LEN]; uint8_t buflen = VW_MAX_MESSAGE_LEN; if (vw_wait_rx_max(200)) { if (vw_get_message(buf, &buflen)) // On copie le message, qu'il soit corrompu ou non { int val = *((int*) buf); // Ligne magique Serial.print("RX : "); Serial.println(val); } } }
Publié par Skywodd | 23 novembre 2015, 14 h 00 minBonjour
Quel est le débit de ce genre d’émétteur recepteur ?
merci
Publié par MoisSI | 17 novembre 2015, 20 h 00 minA 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.
Publié par Skywodd | 23 novembre 2015, 14 h 14 minBonjour, 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
Publié par pat65 | 26 novembre 2015, 13 h 17 minÇ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 ?
Publié par iannick | 2 janvier 2016, 22 h 43 minLa 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 ?
Publié par Skywodd | 6 janvier 2016, 10 h 56 minSalut,
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
Publié par Noury | 6 janvier 2016, 16 h 34 minLa porteuse 868MHz est utilisable mais il existe pas beaucoup de matos dessus à l’exception des alarmes sans fil et autres modules Z-Waze.
Publié par Skywodd | 25 janvier 2016, 11 h 49 minBonjour,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?
Publié par progetsin | 5 janvier 2016, 16 h 21 minIl faudrait que tu nous donnes ton code pour qu’on puisse t’aider ^^
Publié par Onytis | 5 janvier 2016, 19 h 08 min// 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??
Publié par progetsin | 8 janvier 2016, 8 h 19 minHello World
Publié par JefferyRilk | 8 janvier 2016, 18 h 14 minBonjour.
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?
Publié par jb | 11 janvier 2016, 22 h 33 minEnvoi du binaire sinon ça prend trop de place (voir commentaires plus haut).
Publié par Skywodd | 25 janvier 2016, 11 h 54 minbonjour,
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
Publié par faudot | 18 janvier 2016, 16 h 14 minAvec un pont diviseur et analogRead() : http://www.instructables.com/id/How-to-Use-a-Light-Dependent-Resistor-LDR/
Publié par Skywodd | 25 janvier 2016, 12 h 07 minMerci 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
Publié par Leon | 27 janvier 2016, 11 h 02 minBonjour, comment se fait’il que je suis obliger d’ouvrir le moniteur série pour que l’émetteur commence a envoyer des données ?
Publié par fab | 23 février 2016, 18 h 46 minMerci pour le tuto! C’est tout à fait ce qu’il me fallait 🙂
Publié par Enikka | 28 février 2016, 17 h 31 minBonjour, 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
Publié par Arthur P | 7 mars 2016, 21 h 29 minBonjour 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)
#include <VirtualWire.h> // receiver (digital 11) // // Simple example of how to use VirtualWire to receive messages // Implements a simplex (one-way) receiver with an Rx-B1 module // // See VirtualWire.h for detailed API docs // Author: Mike McCauley // Copyright (C) 2008 Mike McCauley // $Id: receiver.pde,v 1.3 2009/03/30 00:07:24 mikem Exp $ float a; #undef int #undef abs #undef double #undef float #undef round++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ void setup() { Serial.begin(9600); // Debugging only Serial.print("Receiver longueur maximum du message :"); Serial.print(VW_MAX_MESSAGE_LEN); Serial.println(" en fait 27 caracteres utiles"); // Initialise the IO and ISR vw_set_ptt_inverted(true); // Required for DR3100 vw_setup(2000); // Bits per sec vw_rx_start(); // Start the receiver PLL running } void loop() { uint8_t buf[VW_MAX_MESSAGE_LEN]; uint8_t buflen = VW_MAX_MESSAGE_LEN; char msg[27]; if (vw_get_message(buf, &buflen)) // Non-blocking { int i; digitalWrite(13, true); // Flash a light to show received good message // Message with a good checksum received, dump it. Serial.print("Recu: "); for (i = 0; i < buflen; i++) { Serial.print((char)buf[i]); } Serial.println(""); digitalWrite(13, false); // ecriture du message for (i = 0; i < buflen; i++){ msg[i]= buf[i]; Serial.print((char)msg[i]); } Serial.println(""); // décorticage du message char => chiffre => nombre Serial.print(" 1 "); // premier nombre String inString = ""; // string pour retenir les chiffres float a; // float pour retenir le nombre for (i = 0; i < 6; i++){ msg[i]= buf[i]; Serial.print((char)msg[i]); inString += (char)msg[i]; // assemblage des chiffres } Serial.println(""); Serial.print(" inString : "); Serial.println(inString); a = inString.toFloat(); // fabrication du nombre Serial.print(" a : "); Serial.println(a); Serial.print(" 2 "); // deuxieme nombre inString = ""; for (i = 7; i < 13; i++){ msg[i]= buf[i]; Serial.print((char)msg[i]); inString += (char)msg[i]; // assemblage des chiffres } Serial.println(""); Serial.print(" inString : "); Serial.println(inString); a = inString.toFloat(); // fabrication du nombre Serial.print(" a : "); Serial.println(a); Serial.print(" 3 "); // troisieme nombre inString = ""; for (i = 14; i < 20; i++){ msg[i]= buf[i]; Serial.print((char)msg[i]); inString += (char)msg[i]; // assemblage des chiffres } Serial.println(""); Serial.print(" inString : "); Serial.println(inString); a = inString.toFloat(); // fabrication du nombre Serial.print(" a : "); Serial.println(a); Serial.print(" 4 "); // quatrieme nombre inString = ""; for (i = 21; i < 27; i++){ msg[i]= buf[i]; Serial.print((char)msg[i]); inString += (char)msg[i]; // assemblage des chiffres } Serial.println(""); Serial.print(" inString : "); Serial.println(inString); a = inString.toFloat(); // fabrication du nombre Serial.print(" a : "); Serial.println(a); } }
Publié par Bernard Barrois | 15 mars 2016, 22 h 20 minDésolé le premier script est mal passé je retente :
#include <VirtualWire.h> // receiver (digital 11) // // Simple example of how to use VirtualWire to receive messages // Implements a simplex (one-way) receiver with an Rx-B1 module // // See VirtualWire.h for detailed API docs // Author: Mike McCauley // Copyright (C) 2008 Mike McCauley // $Id: receiver.pde,v 1.3 2009/03/30 00:07:24 mikem Exp $ float a; #undef int #undef abs #undef double #undef float #undef round++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ void setup() { Serial.begin(9600); // Debugging only Serial.print("Receiver longueur maximum du message :"); Serial.print(VW_MAX_MESSAGE_LEN); Serial.println(" en fait 27 caracteres utiles"); // Initialise the IO and ISR vw_set_ptt_inverted(true); // Required for DR3100 vw_setup(2000); // Bits per sec vw_rx_start(); // Start the receiver PLL running } void loop() { uint8_t buf[VW_MAX_MESSAGE_LEN]; uint8_t buflen = VW_MAX_MESSAGE_LEN; char msg[27]; if (vw_get_message(buf, &buflen)) // Non-blocking { int i; digitalWrite(13, true); // Flash a light to show received good message // Message with a good checksum received, dump it. Serial.print("Recu: "); for (i = 0; i < buflen; i++) { Serial.print((char)buf[i]); } Serial.println(""); digitalWrite(13, false); // ecriture du message for (i = 0; i < buflen; i++){ msg[i]= buf[i]; Serial.print((char)msg[i]); } Serial.println(""); // décorticage du message char => chiffre => nombre Serial.print(" 1 "); // premier nombre String inString = ""; // string pour retenir les chiffres float a; // float pour retenir le nombre for (i = 0; i < 6; i++){ msg[i]= buf[i]; Serial.print((char)msg[i]); inString += (char)msg[i]; // assemblage des chiffres } Serial.println(""); Serial.print(" inString : "); Serial.println(inString); a = inString.toFloat(); // fabrication du nombre Serial.print(" a : "); Serial.println(a); Serial.print(" 2 "); // deuxieme nombre inString = ""; for (i = 7; i < 13; i++){ msg[i]= buf[i]; Serial.print((char)msg[i]); inString += (char)msg[i]; // assemblage des chiffres } Serial.println(""); Serial.print(" inString : "); Serial.println(inString); a = inString.toFloat(); // fabrication du nombre Serial.print(" a : "); Serial.println(a); Serial.print(" 3 "); // troisieme nombre inString = ""; for (i = 14; i < 20; i++){ msg[i]= buf[i]; Serial.print((char)msg[i]); inString += (char)msg[i]; // assemblage des chiffres } Serial.println(""); Serial.print(" inString : "); Serial.println(inString); a = inString.toFloat(); // fabrication du nombre Serial.print(" a : "); Serial.println(a); Serial.print(" 4 "); // quatrieme nombre inString = ""; for (i = 21; i < 27; i++){ msg[i]= buf[i]; Serial.print((char)msg[i]); inString += (char)msg[i]; // assemblage des chiffres } Serial.println(""); Serial.print(" inString : "); Serial.println(inString); a = inString.toFloat(); // fabrication du nombre Serial.print(" a : "); Serial.println(a); } }
Publié par Bernard Barrois | 15 mars 2016, 22 h 23 minsalut 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 ?
Publié par QUENTIN WAVELET | 16 mars 2016, 22 h 08 minBonjour,
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.
Publié par Benjamin | 29 mars 2016, 14 h 00 mindonc la portée de ton système n’excède pas les 10 15 m ?
Publié par juju | 7 avril 2016, 16 h 18 mindsl 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 ??
Publié par juju | 7 avril 2016, 16 h 24 minBonjour , 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
Publié par Nicolas | 18 avril 2016, 10 h 13 min