Bonjour a tous,
J'aimerais réaliser un petit montage qui permet une commande a distance grâce au module NRF24L01. Je débute et je ne comprend que partiellement les codes que j'ai trouvé sur internet. J'en ai testé plusieurs d'entre eux, aucun n'a fonctionné. Pouvez vous m'aider a allumer une led a distance grâce a ces modules ?
Merci
Salut,
Et si tu nous donnais le code et tes branchements ?
Quelques liens au hasard : http://playground.arduino.cc/Interfa...dware/Nrf24L01
http://itechnofrance.wordpress.com/2...avec-larduino/
Pour allumer et éteindre une led, tu as juste à transmettre une valeur binaire et à analyser la variable coté récepteur !
Bonsoir Yoruk, merci pour ta réponse
Pour ce qui est de mes branchement je fais en fonction du code, mon branchement actuel est celui de ce tuto http://tiptopboards.free.fr/arduino_...c.php?f=2&t=22
Ce que je n'arrive pas a faire c'est transmettre cette valeur justement... Même avec un code simple cela ne marche pas. j'ai aussi essayer celui ci http://forum.arduino.cc/index.php?topic=138663.0
Quels sont les symptômes ? Tu ne reçois absolument rien ? Tu as bien ajouté les résistances pour ajuster les niveaux ?
oui j'ai ajouter les résistance comme le tuto par contre elle sont de 1k au lieu de 10 je ne sais pas si cela peut venir de ça. quand j'appuis sur le bouton rien ne se passe.
J'ai peur que 1k soit léger...
Tu n'as absolument rien dans la console ?
Je vais essayer de remédier a ca alors. Je ne sais pas du tout comment me servir de la console si ce n'est qu'il faut insérer la fonction serialprint...
Bin... Pour l'instant tu as juste à regarder ce qui s'affiche. La première carte génère des codes au hasard, qu'elle envoie à la seconde carte, puis la seconde carte renvoie la même. Au final, la première carte affiche et compare ce qu'elle a reçu.
Si elle ne te met même pas "Envoi:", c'est que la boucle ne démarre pas.
Tu parles d'un bouton ?
D'accord, effectivement rien ne s'affiche. Oui car ce que je voudrais faire c'est mettre un bouton poussoir sur la première carte qui lors de la pression sur celui lui enverrait le chiffre 1 par exemple. Le deuxième arduino pourrait allumer la led a la réception de ce chiffre.
Je ne comprend pas pourquoi rien ne fonctionne.
Fais déjà fonctionner ce qui est proposé par le site sans modifications, après on en reparle...
OU poste ton vrai code et des vrais branchements !
voici mon cablage ainsi que le code :
- Pin 9 - CE
- Pin 10 - CS(N)
- Pin 11 - MOSI
- Pin 12 - MISO
- Pin 13 - SCK
recepteur:
- Pin 3 - LED
transmetteur:
- Pin 7 - Button
Code du transmetteur :
#include <SPI.h>
#include "nRF24L01.h"
#include "RF24.h"
int msg[1];
RF24 radio(9,10);
const uint64_t pipe = 0xE8E8F0F0E1LL;
int Bp = 7;
void setup(void){
pinMode(Bp, INPUT)
Serial.begin(9600);
radio.begin();
radio.openWritingPipe(pipe);}
void loop(void){
if (digitalRead(Bp) == HIGH){
msg[0] = 111;
radio.write(msg, 1);}}
Code du recepteur :
#include <SPI.h>
#include "nRF24L01.h"
#include "RF24.h"
int msg[1];
RF24 radio(9,10);
const uint64_t pipe = 0xE8E8F0F0E1LL;
int Led = 3;
void setup(void){
Serial.begin(9600);
radio.begin();
radio.openReadingPipe(1,pipe);
radio.startListening();
pinMode(Led, OUTPUT);}
void loop(void){
if (radio.available()){
bool done = false;
while (!done){
done = radio.read(msg, 1);
Serial.println(msg[0]);
if (msg[0] == 111){delay(10);digitalWrite(Le d, HIGH);}
else {digitalWrite(Led, LOW);}
delay(10);}}
else{Serial.println("No radio available");}}
Hmmm... Avec les phénomènes de rebond et autres, je garantis pas que le bouton fonctionne... Surtout si tu n'as pas placé de résistance de tirage.
Tente le code proposé par le site (sans bouton), il débugge pas mal et nous pourrons voir où ça coince. Il ajoute également des tempos pour éviter des bugs selon l'auteur.
Tu peux toujours tenter pour l'émetteur:
Afin de voir si la transmission est réalisée. Mais tente vraiment le code du site.Code:#include <SPI.h> #include "nRF24L01.h" #include "RF24.h" int msg[1]; RF24 radio(9,10); const uint64_t pipe = 0xE8E8F0F0E1LL; int Bp = 7; void setup(void){ pinMode(Bp, INPUT) Serial.begin(9600); radio.begin(); radio.openWritingPipe(pipe);} void loop(void){ if (digitalRead(Bp) == HIGH){ Serial.print("Envoi en cours"); delay(1000); msg[0] = 111; radio.write(msg, 1);}}
PS : ajoute des balises CODE lorsque tu postes.
J'ai essayer votre code dans le moniteur le message "Envoi en cours" se répète sans que je touche au bouton. Coter réception c'est le message "No radio available" qui se répète. J'ai également essayer de supprimer le bouton mais cela n'a pas été concluant. Pensez vous que le problème viens des résistances ?
Peut être que ça vient des résistances... As tu au dessus de 10k ? En dessous, j'ai peur que tu abimes les portes.
Tu as tenté le code du site, tel quel ?
oui j'ai essayer mais ça ne marche pas, je vais tacher de me procurer des résistances de 10kilos pour essayer, je vous tiens au courant.
C'est à dire "ça ne marche pas" ? Tu as du retour console ou pas ?
Le récepteur ne donne pas de valeur. Y a t-il un moyen de savoir si l'émetteur émet bien quelque chose ?
La console te renvoie quelque chose coté émetteur ?
Dans la console l’émetteur affichait hier "Envoi en cours", aujourd'hui plus rien je ne sais pas pourquoi. Il l'affichait a répétition sans que je touche une seule fois au bouton.
Je me pose une question, mon module est très légèrement défirent de ceux utilisé dans les tuto. Le mien possède deux broches VCC et deux broches GND. Cela change t-il quelque chose ?
Tu as testé le code et le branchement de façon identique à ce qui est présenté sur le site (sans bouton ?)
Ce programme est le seul qui ne possède aucune erreur de compilation. Je ne sais pas corriger les autres...
Il fallait commencer par là dès le début... Donne tes erreurs de compilation !
Bon ça y es j'ai enfin réussi a faire fonctionner un programme, il fallait retirer les résistances... Toutefois ce programme envoie des valeurs a chaque fois différente et je ne trouve pas dans quelle partie du code elle sont définies. Le savez-vous ? J’aimerais envoyer la valeur de mon choix pour pouvoir allumer une led.
/*
*Copyright*(C)*2011*J.*Coliz*< maniacbug@ymail.com>
*This*program*is*free*software ;*you*can*redistribute*it*and/or
*modify*it*under*the*terms*of* the*GNU*General*Public*License
*version*2*as*published*by*the *Free*Software*Foundation.
**/
/**
***Example*for*Getting*Started *with*nRF24L01+*radios.*
**
***This*is*an*example*of*how*t o*use*the*RF24*class.**Write*t his*sketch*to*two*
***different*nodes.**Put*one*o f*the*nodes*into*'transmit'*mo de*by*connecting*
***with*the*serial*monitor*and *sending*a*'T'.**The*ping*node *sends*the*current*
***time*to*the*pong*node,*whic h*responds*by*sending*the*valu e*back.**The*ping*
***node*can*then*see*how*long* the*whole*cycle*took.
**/
#include*<SPI.h>
#include*"nRF24L01.h"
#include*"RF24.h"
#include*"printf.h"
//
//*Hardware*configuration
//
//*Set*up*nRF24L01*radio*on*SPI* bus*plus*pins*9*&*10*
RF24*radio(9,10);
//
//*Topology
//
//*Radio*pipe*addresses*for*the* 2*nodes*to*communicate.
const uint64_t pipes[2] = { 0xF0F0F0F0E1LL, 0xF0F0F0F0D2LL };
//
//*Role*management
//
//*Set*up*role.**This*sketch*use s*the*same*software*for*all*th e*nodes
//*in*this*system.**Doing*so*gre atly*simplifies*testing.**
//
//*The*various*roles*supported*b y*this*sketch
typedef*enum*{*role_ping_out*= *1,*role_pong_back*}*role_e;
//*The*debug-friendly*names*of*those*roles
const char* role_friendly_name[] = { "invalid", "Ping out", "Pong back"};
//*The*role*of*the*current*runni ng*sketch
role_e*role*=*role_pong_back;
void setup(void)
{
**//
**// Print preamble
**//
**Serial.begin(57600);
**printf_begin();
**printf("\n\rRF24/examples/GettingStarted/\n\r");
**printf("ROLE: %s\n\r",role_friendly_name[role]);
**printf("*** PRESS 'T' to begin transmitting to the other node\n\r");
**//
**// Setup and configure rf radio
**//
**radio.begin();
**// optionally, increase the delay between retries & # of retries
**radio.setRetries(15,15);
**// optionally, reduce the payload size. seems to
**// improve reliability
**//radio.setPayloadSize(8);
**//
**// Open pipes to other nodes for communication
**//
**// This simple sketch opens two pipes for these two nodes to communicate
**// back and forth.
**// Open 'our' pipe for writing
**// Open the 'other' pipe for reading, in position #1 (we can have up to 5 pipes open for reading)
**//if ( role == role_ping_out )
**{
****//radio.openWritingPipe(pipes[0]);
****radio.openReadingPipe(1,pi pes[1]);
**}
**//else
**{
****//radio.openWritingPipe(pipes[1]);
****//radio.openReadingPipe(1,pipes[0]);
**}
**//
**// Start listening
**//
**radio.startListening();
**//
**// Dump the configuration of the rf unit for debugging
**//
**radio.printDetails();
}
void loop(void)
{
**//
**// Ping out role. Repeatedly send the current time
**//
**if (role == role_ping_out)
**{
****// First, stop listening so we can talk.
****radio.stopListening();
****// Take the time, and send it. This will block until complete
****unsigned long time = millis();
****printf("Now sending %lu...",time);
****bool*ok*=*radio.write( &time, sizeof(unsigned long) );
****
****if (ok)
******printf("ok...");
****else
******printf("failed.\n\r");
****// Now, continue listening
****radio.startListening();
****// Wait here until we get a response, or timeout (250ms)
****unsigned long started_waiting_at = millis();
****bool*timeout*=*false;
****while ( ! radio.available() && ! timeout )
******if (millis() - started_waiting_at > 200 )
********timeout*=*true;
****// Describe the results
****if ( timeout )
****{
******printf("Failed, response timed out.\n\r");
****}
****else
****{
******// Grab the response, compare, and send to debugging spew
******unsigned long got_time;
******radio.read( &got_time, sizeof(unsigned long) );
******// Spew it
******printf("Got response %lu, round-trip delay: %lu\n\r",got_time,millis()-got_time);
****}
****// Try again 1s later
****delay(1000);
**}
**//
**// Pong back role. Receive each packet, dump it out, and send it back
**//
**if ( role == role_pong_back )
**{
****// if there is data ready
****if ( radio.available() )
****{
******// Dump the payloads until we've gotten everything
******unsigned long got_time;
******bool*done*=*false;
******while (!done)
******{
********// Fetch the payload, and see if this was the last one.
********done*=*radio.read( &got_time, sizeof(unsigned long) );
********// Spew it
********printf("Got payload %lu...",got_time);
// Delay just a little bit to let the other unit
// make the transition to receiver
delay(20);
******}
******// First, stop listening so we can talk
******radio.stopListening();
******// Send the final one back.
******radio.write( &got_time, sizeof(unsigned long) );
******printf("Sent response.\n\r");
******// Now, resume listening so we catch the next packets.
******radio.startListening();
****}
**}
**//
**// Change roles
**//
**if ( Serial.available() )
**{
****char c = toupper(Serial.read());
****if ( c == 'T' && role == role_pong_back )
****{
******printf("*** CHANGING TO TRANSMIT ROLE -- PRESS 'R' TO SWITCH BACK\n\r");
******// Become the primary transmitter (ping out)
******role*=*role_ping_out;
******radio.openWritingPipe(pi pes[0]);
******radio.openReadingPipe(1, pipes[1]);
****}
****else if ( c == 'R' && role == role_ping_out )
****{
******printf("*** CHANGING TO RECEIVE ROLE -- PRESS 'T' TO SWITCH BACK\n\r");
******
******// Become the primary receiver (pong back)
******role*=*role_pong_back;
******radio.openWritingPipe(pi pes[1]);
******radio.openReadingPipe(1, pipes[0]);
****}
**}
}
//*vim:cin:ai:sts=2*sw=2*ft=cpp
Attention, s'il n'y a rien pour protéger les portes des modules radio, je ne sais pas si elles vont aimer !
Le code à l'air d'envoyer le nombre de millisecondes écoulées depuis le démarrage de la carte :
Utilise la fonction radio.write pour envoyer ce que tu veux !Code:unsigned long time = millis(); printf("Now sending %lu...",time); bool ok = radio.write( &time, sizeof(unsigned long) );
Merci des conseilles, et donc la variable qui stock le message recu c'est got_time ?
Sur la carte réceptrice, oui ça à l'air d'être ça.
D'accord, merci beaucoup pour votre aide
