I've used NRF24L01+ chipset 2.4GHz wireless modules with Arduino before, and found them to be great, and super cheap (~$10 for 10 of them on ebay!). They have 3 modes of transmission: 250kbps, 1Mbps, and 2Mbps. The range decreases accordingly with higher bitrate, but the time spent sending a message does too. There are multiple Arduino libraries (e.g. RF24, ...
Your best strategy would be to write your own bootloader.
The existing bootloader receives data through the serial port and writes it, a page at a time, to the flash. Your custom bootloader, instead, would receive the data through the nRF module and write it to flash, a page at a time.
You could use the source code for the existing bootloader (maybe use ...
If you look at the specification or datasheet for the nRF24l01+, you will see that the 32 byte payload is the maximum that the device can handle.
If you need to transmit anything larger than 32 bytes, you will need to develop a protocol that splits up your data into chunks of 32 bytes or less and sends the data in several packets.
The actual ...
It does seem possible, check out this thread on Arduino forums, where cpixip worked directly with the NRF24 SPI interface to accomplish that.
Here is the code he published, in case the link won't be available:
// Poor Man's Wireless 2.4GHz Scanner
// uses an nRF24L01p connected to an Arduino
// Cables are:
// SS -&...
As most of the people have posted, the values for the pipe are arbitrary, but must follow the rules per the API:
Pipes 1-5 should share the first 32 bits. Only the least significant
byte should be unique, e.g.
Before I answer your question, I think an explanation on Hex and Decimal values are needed.
The 40 bit hexadecimal is a number representation ...
There is an Arduino optiboot fork for this now, which seems to handle what you want.
You would use a PC, RPi or whatever that could run avrdude to send the update to an Arduino acting as the update server, which transmits the code to the client.
The instructions on the page seem quite comprehensive.
The read() method works character-wise, not element-wise. Then you
have to rethink your algorithm to loop over characters:
store each character in a buffer
send the whole buffer (i.e. a single element) when you see a delimiter
const size_t BUFFER_SZ = ...;
size_t pos = 0; // current write position in buffer
The NRF24L01+ has inputs that are 5V tolerant! So you only need to provide 3.3V on the Vcc pin of the module, which you can do by putting a voltage regulator between it, and the 5V of the Trinket. So there isn't really any need to convert the Trinket to 3.3V.
PS Remember to add some capacitors to the output of the voltage regulator, as the NRF needs a ...
If you're working with remote sensor nodes, perhaps consider the MySensors library.
It's got support for two methods of delivering OTA updates - one using a node.js controller running on a rPi; and another third-party solution with a .NET front-end.
Failing that, you could borrow the bootloader code from the library and customise to your own needs.
Many questions so broad answers, but hopefully informative for your research
What is the nature of the data sent between units? I want to send integers, possibly even text. Is that possible? Do I need to convert to binary or something?
It depends broadly on what you use. If you use an ethernet peripheral then the communications will be entire ethernet ...
Yes, and yes.
A module without an antenna is exactly the same as a module with an antenna, it's just that the antenna is part of the PCB. Yes, the module with the antenna will have more sensitivity (able to receive fainter signals) as well as more transmitting power.
The same is true of the modules with the power amplifier. They again have even more ...
What you are asking is very tricky at best. Your average Arduino doesn't have enough memory to start storing arrays of Strings.
Instead you will need to "distil" the information as it comes in and store the distilled information.
If the possible keys are all known beforehand then you can assign a number to each possible key - say RCP is 1, CMD is 2, VAL is ...
The main thing that I can see wrong with your sketch is that the logic of your methodology is backwards.
You are spending most of your time either with the radio asleep, or not in listening mode, so it can not receive anything.
Instead you need to spend all your time in listening mode waiting for messages to arrive, and only when the button changes state ...
In your situation, your best bet is probably to use the standard C function strcpy:
char* source = "abcdef";
Note that source string does not have to be declared as char source and can be declared as the rather standard C string char*.
Also, since you are limiting the size of the string to be passed ...
You have two options:
Use an nRF24L01+ on the Arduino and dismantle the controller to rip out the innards, replacing them with another Arduino and another nRF24L01+.
Do not use the nRF24L01+, instead, rip apart the car and salvage the receiver from it, then work out how you can wire that to the Arduino.
The car's controller will not talk to the nRF24L01+. ...
It's likely an issue related to the modules' electric supply. The effects can be packet loss (even down to zero bps) or loss of communication with the module.
Two things have to be covered with the nRF modules for them to work:
current draw (i.e. power),
decoupling/filtering (i.e. bypass capacitors).
Since you don't mention specific devices, I'm ...
According to the source code:
const static unsigned int max_frame_payload_size = MAX_FRAME_SIZE-sizeof(RF24NetworkHeader);
that would be 24 bytes. Maximum lenght of payload for NRF24L01+ is 32 bytes and the RF24NetworkHeader seem to be 8 bytes long. So you can send up to 24 bytes in one package.
Here is the stripped RF24NetworkHeader declaration ...
Why wouldn't you be able to?
The compiler runs on the computer, not on the Arduino board. You don't need a board to be connected to compile either. If you enable verbose output during compile in the Arduino IDE settings it will tell you where it puts the resulting .hex file, after which you can use avr-dude to upload it to the target MCU.
If you want to ...
Your error is: .../packages/esp8266/hardware/esp8266/2.4.2/libraries/SPI/src/SPI.h:1:23: fatal error: SPI_Class.h: No such file or directory...
You have some wrong SPI library there. The original folder packages/esp8266/hardware/esp8266/2.4.2/libraries/SPI doesn't contain src subfolder.
I have not used the RF24 libary, but below are the register settings that should be written during void setup() to use the ACK_PAYLOAD functionality (N.B. nRF24L01+ only, does not exist on nRF24L01. Check you are using the right version of the radio!)
0x00 CONFIG = PTX mode
0x0B RX_PW_P0 = Number of data bytes in pipe 0
0x1C DYNPD = 0x01. Enable ...
You can use the RF24 library that you can install right away from the Arduino IDE. It provides you all you need. Just use two instances of RF24 with different CSN and CE pins assigned to get started.
RF24 radioA(7, 8); // CE, CSN
RF24 radioB(5, 6); // CE, CSN
Use the simple ping sketch as a starting point and add a second radio to it.
Yes, you can. The mirf library is using the regular arduino functions pinMode and digitalWrite to manipulate the pins. So A0 and A1 should work as expected.
Please note that when you use SPI (which the NRF does), you have to use pin 10 (SS) as an OUTPUT (as to not put the AVR into SPI slave mode).
This is the core of embedded design and "hacking" and highlights one of my peeves about Arduino design: too much focus on the pin numbers and physical location on the PCBs, rather than the actual functions on those pins.
So? Physically move the pins on the Motor Shield. Here are 3 options in order of the most hack-ish to most-clean:
1) Use an edge cutter ...
I believe nRF2401 is low level tx/rx chip working in 2.4GHz band. But it's not WiFi module. To use it as WiFi you probably need implement WiFi stack. I think guy in video set up channel and counting receved data only.
In my situation the issue was with the Transmitter not continuing to transmit after a delay. I was able to resolve the issue using the powerDown (http://maniacbug.github.io/RF24/classRF24.html#aa0a51923a09ba4f3478aba9be0f8a6a1) and powerUp (http://maniacbug.github.io/RF24/classRF24.html#a5cdaf47aa0edd6dca1b9a8bb7972a1a3) functions. Here is a snipet of my ...
FWIW, I had packet loss issues using these boards, until I introduced those 3.3 V piggy back boards to supply current. I use them on both RX and TX now, but experimentation showed that the RX was where it made the crucial difference. Omitting the filter cap also didn't make any difference.
I don't know why these 5 V to 3.3 V piggy back boards were so ...
The pins could be wrong for ATMega328.
It should be.
NRF24L01 - Arduino UNO
GND - GND
VCC - 3.3V
CE - 7
CSN - 8
SCK - 13
MOSI - 11
MISO - 12
or B. You need to connect a 500uF electrolytic capacitor to your NRF24L01+ VCC and GND pins directly. To reduce noise related issues. With clone arduinos/cheap regulators/clone NRFs then noise might start creating ...