Bonjour a tous,
Il y a quelque jours j'ai eu un problème avec mes deux modules NRF24L01 ainsi que mes deux arduinos. Je voulais envoyé une valeur avec l'un et la recevoir avec l'autre. J'ai trouver beaucoup de tutos mais aucun ne fonctionnais jusqu'à ce que l'exemple du logiciel arduino fonctionne. J'ai découvert grâce a celui-ci (code identique émetteur/récepteur) qu'il fallait lancé la communication avec un des deux arduinos en temps qu’émetteur. Ce qui donne un échec, arrêter, puis émettre avec le deuxième pour que ça fonctionne. Est-ce pour cette raison que les autres codes ,qui sont différents selon l’émetteur ou le récepteur, ne marche pas ? Comment pourrais-je résoudre ce problème ? Voici le code exemple qui fonctionne après la petite manip que je viens d'expliquer :
/*
*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 };
//
int msg[1];
//
//*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)
{
**
**pinMode(SW1, INPUT);//
**// 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);
****msg[0]*=*111;
****bool*ok*=*radio.write(msg, 1);
****
****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
-----