Hi, I am trying to make two arduinos communicate, the final goal is to make a airplane and its controller
But I can't make them work reliably...
CONTEXT :
I have 6 nrf24L01+,
Two of them give me no life sign.
One of them always returns that communication succeded even when the other board is not connected to a power source (and don't seems to really send data)
And the 3 others are.. changing their minds
yesterday, I could make the controller and the plane communicate almost perfectly. (not a very smooth communication, but enough)
today, I plug the boards, and nothing, can't get them to work...
I am desesperate...
I am using the nrf24l01 lite library with the baseRX and baseTX examples
THE REAL QUESTION :
My goal is to make an airplane, there is 3 stages of "making an airplane" :
- Create it literaly from scratch, like my first goal. As you can see my radio controller is literaly made on a piece of cardboard, can't be more DIY.
- Enter the fpv game : buy a real radio controller and a receptor board that is premade and will drive the motors by itself.
- Buy everything premade
The first option was the best :
- fun (before I get desesperate)
- cheap
- Highly customisable (free on the shape of the plane/boat/car or what you want. Free on the program, if it worked I could take it further with auto stabilization, autopilot, or much more)
The second one is
- not too expensive
- offers medium customisation (on the shape of the plane, but I think not on the program, I don't know this word very well but a premade card can't be changed. What if I want to create an autopilot, add a gyro or a gps ? I don't want to buy another entire card every time I want a new function.
And I don't want the third one, expensive and not so fun...
So I am wondering, what is wrong with my nRF24L01+ ? Are they ALL dead ? Is it often the case ?! Concretely, even if they work, is it enough for a sensitive object that need strong reliability like an airplane ?
Should I perseverate in the fully arduino way, or go to the second option ? Maybe it's more free than i think, but I don't have much information on it.
Do you have any advice to make the communication works ?
programs :
BasicRX
/*
Demonstrates simple RX and TX operation.
Any of the Basic_TX examples can be used as a transmitter.
Please read through 'NRFLite.h' for a description of all the methods available in the library.
Radio Arduino
CE -> 9
CSN -> 10 (Hardware SPI SS)
MOSI -> 11 (Hardware SPI MOSI)
MISO -> 12 (Hardware SPI MISO)
SCK -> 13 (Hardware SPI SCK)
IRQ -> No connection
VCC -> No more than 3.6 volts
GND -> GND
*/
#include <SPI.h>
#include <NRFLite.h>
const static uint8_t RADIO_ID = 0; // Our radio's id. The transmitter will send to this id.
const static uint8_t PIN_RADIO_CE = 9;
const static uint8_t PIN_RADIO_CSN = 10;
struct RadioPacket // Any packet up to 32 bytes can be sent.
{
uint8_t FromRadioId;
uint32_t OnTimeMillis;
uint32_t FailedTxCount;
};
NRFLite _radio;
RadioPacket _radioData;
void setup()
{
Serial.begin(115200);
// By default, 'init' configures the radio to use a 2MBPS bitrate on channel 100 (channels 0-125 are valid).
// Both the RX and TX radios must have the same bitrate and channel to communicate with each other.
// You can run the 'ChannelScanner' example to help select the best channel for your environment.
// You can assign a different bitrate and channel as shown below.
// _radio.init(RADIO_ID, PIN_RADIO_CE, PIN_RADIO_CSN, NRFLite::BITRATE2MBPS, 100) // THE DEFAULT
// _radio.init(RADIO_ID, PIN_RADIO_CE, PIN_RADIO_CSN, NRFLite::BITRATE1MBPS, 75)
// _radio.init(RADIO_ID, PIN_RADIO_CE, PIN_RADIO_CSN, NRFLite::BITRATE250KBPS, 0)
if (!_radio.init(RADIO_ID, PIN_RADIO_CE, PIN_RADIO_CSN))
{
Serial.println("Cannot communicate with radio");
while (1); // Wait here forever.
}
}
void loop()
{
while (_radio.hasData())
{
_radio.readData(&_radioData); // Note how '&' must be placed in front of the variable name.
String msg = "Radio ";
msg += _radioData.FromRadioId;
msg += ", ";
msg += _radioData.OnTimeMillis;
msg += " ms, ";
msg += _radioData.FailedTxCount;
msg += " Failed TX";
Serial.println(msg);
}
}
BasicTX
/*
Demonstrates simple RX and TX operation.
Any of the Basic_RX examples can be used as a receiver.
Please read through 'NRFLite.h' for a description of all the methods available in the library.
Radio Arduino
CE -> 9
CSN -> 10 (Hardware SPI SS)
MOSI -> 11 (Hardware SPI MOSI)
MISO -> 12 (Hardware SPI MISO)
SCK -> 13 (Hardware SPI SCK)
IRQ -> No connection
VCC -> No more than 3.6 volts
GND -> GND
*/
#include <SPI.h>
#include <NRFLite.h>
const static uint8_t RADIO_ID = 1; // Our radio's id.
const static uint8_t DESTINATION_RADIO_ID = 0; // Id of the radio we will transmit to.
const static uint8_t PIN_RADIO_CE = 9;
const static uint8_t PIN_RADIO_CSN = 10;
struct RadioPacket // Any packet up to 32 bytes can be sent.
{
uint8_t FromRadioId;
uint32_t OnTimeMillis;
uint32_t FailedTxCount;
};
NRFLite _radio;
RadioPacket _radioData;
void setup()
{
Serial.begin(115200);
// By default, 'init' configures the radio to use a 2MBPS bitrate on channel 100 (channels 0-125 are valid).
// Both the RX and TX radios must have the same bitrate and channel to communicate with each other.
// You can run the 'ChannelScanner' example to help select the best channel for your environment.
// You can assign a different bitrate and channel as shown below.
// _radio.init(RADIO_ID, PIN_RADIO_CE, PIN_RADIO_CSN, NRFLite::BITRATE2MBPS, 100) // THE DEFAULT
// _radio.init(RADIO_ID, PIN_RADIO_CE, PIN_RADIO_CSN, NRFLite::BITRATE1MBPS, 75)
// _radio.init(RADIO_ID, PIN_RADIO_CE, PIN_RADIO_CSN, NRFLite::BITRATE250KBPS, 0)
if (!_radio.init(RADIO_ID, PIN_RADIO_CE, PIN_RADIO_CSN))
{
Serial.println("Cannot communicate with radio");
while (1); // Wait here forever.
}
_radioData.FromRadioId = RADIO_ID;
}
void loop()
{
_radioData.OnTimeMillis = millis();
Serial.print("Sending ");
Serial.print(_radioData.OnTimeMillis);
Serial.print(" ms");
// By default, 'send' transmits data and waits for an acknowledgement. If no acknowledgement is received,
// it will try again up to 16 times. This retry logic is built into the radio hardware itself, so it is very fast.
// You can also perform a NO_ACK send that does not request an acknowledgement. In this situation, the data packet
// will only be transmitted a single time and there is no verification of delivery. So NO_ACK sends are suited for
// situations where performance is more important than reliability.
// _radio.send(DESTINATION_RADIO_ID, &_radioData, sizeof(_radioData), NRFLite::REQUIRE_ACK) // THE DEFAULT
// _radio.send(DESTINATION_RADIO_ID, &_radioData, sizeof(_radioData), NRFLite::NO_ACK)
if (_radio.send(DESTINATION_RADIO_ID, &_radioData, sizeof(_radioData))) // Note how '&' must be placed in front of the variable name.
{
Serial.println("...Success");
}
else
{
Serial.println("...Failed");
_radioData.FailedTxCount++;
}
delay(1000);
}
