From 64faa57325e046729c2b5238dfc7f270401ce283 Mon Sep 17 00:00:00 2001 From: jgromes Date: Mon, 13 Sep 2021 18:49:35 +0200 Subject: [PATCH] [nRF24] Added interrupt-driven examples --- .../nRF24_Receive_Interrupt.ino | 150 ++++++++++++++++++ .../nRF24_Transmit_Interrupt.ino | 148 +++++++++++++++++ 2 files changed, 298 insertions(+) create mode 100644 examples/nRF24/nRF24_Receive_Interrupt/nRF24_Receive_Interrupt.ino create mode 100644 examples/nRF24/nRF24_Transmit_Interrupt/nRF24_Transmit_Interrupt.ino diff --git a/examples/nRF24/nRF24_Receive_Interrupt/nRF24_Receive_Interrupt.ino b/examples/nRF24/nRF24_Receive_Interrupt/nRF24_Receive_Interrupt.ino new file mode 100644 index 00000000..6d964bd1 --- /dev/null +++ b/examples/nRF24/nRF24_Receive_Interrupt/nRF24_Receive_Interrupt.ino @@ -0,0 +1,150 @@ +/* + RadioLib nRF24 Receive Example + + This example listens for FSK transmissions using nRF24 2.4 GHz radio module. + Once a packet is received, an interrupt is triggered. + To successfully receive data, the following settings have to be the same + on both transmitter and receiver: + - carrier frequency + - data rate + - transmit pipe on transmitter must match receive pipe + on receiver + + For default module settings, see the wiki page + https://github.com/jgromes/RadioLib/wiki/Default-configuration#nrf24 + + For full API reference, see the GitHub Pages + https://jgromes.github.io/RadioLib/ +*/ + +// include the library +#include + +// nRF24 has the following connections: +// CS pin: 10 +// IRQ pin: 2 +// CE pin: 3 +nRF24 radio = new Module(10, 2, 3); + +// or using RadioShield +// https://github.com/jgromes/RadioShield +//nRF24 radio = RadioShield.ModuleA; + +void setup() { + Serial.begin(9600); + + // initialize nRF24 with default settings + Serial.print(F("[nRF24] Initializing ... ")); + int state = radio.begin(); + if(state == ERR_NONE) { + Serial.println(F("success!")); + } else { + Serial.print(F("failed, code ")); + Serial.println(state); + while(true); + } + + // set receive pipe 0 address + // NOTE: address width in bytes MUST be equal to the + // width set in begin() or setAddressWidth() + // methods (5 by default) + Serial.print(F("[nRF24] Setting address for receive pipe 0 ... ")); + byte addr[] = {0x01, 0x23, 0x45, 0x67, 0x89}; + state = radio.setReceivePipe(0, addr); + if(state == ERR_NONE) { + Serial.println(F("success!")); + } else { + Serial.print(F("failed, code ")); + Serial.println(state); + while(true); + } + + // set the function that will be called + // when new packet is received + radio.setIrqAction(setFlag); + + // start listening + Serial.print(F("[nRF24] Starting to listen ... ")); + state = radio.startReceive(); + if (state == ERR_NONE) { + Serial.println(F("success!")); + } else { + Serial.print(F("failed, code ")); + Serial.println(state); + while (true); + } + + // if needed, 'listen' mode can be disabled by calling + // any of the following methods: + // + // radio.standby() + // radio.sleep() + // radio.transmit(); + // radio.receive(); + // radio.readData(); +} + +// flag to indicate that a packet was received +volatile bool receivedFlag = false; + +// disable interrupt when it's not needed +volatile bool enableInterrupt = true; + +// this function is called when a complete packet +// is received by the module +// IMPORTANT: this function MUST be 'void' type +// and MUST NOT have any arguments! +void setFlag(void) { + // check if the interrupt is enabled + if(!enableInterrupt) { + return; + } + + // we got a packet, set the flag + receivedFlag = true; +} + +void loop() { + // check if the flag is set + if(receivedFlag) { + // disable the interrupt service routine while + // processing the data + enableInterrupt = false; + + // reset flag + receivedFlag = false; + + // you can read received data as an Arduino String + String str; + int state = radio.readData(str); + + // you can also read received data as byte array + /* + byte byteArr[8]; + int state = radio.readData(byteArr, 8); + */ + + if (state == ERR_NONE) { + // packet was successfully received + Serial.println(F("[nRF24] Received packet!")); + + // print data of the packet + Serial.print(F("[nRF24] Data:\t\t")); + Serial.println(str); + + } else { + // some other error occurred + Serial.print(F("[nRF24] Failed, code ")); + Serial.println(state); + + } + + // put module back to listen mode + radio.startReceive(); + + // we're ready to receive more packets, + // enable interrupt service routine + enableInterrupt = true; + } + +} diff --git a/examples/nRF24/nRF24_Transmit_Interrupt/nRF24_Transmit_Interrupt.ino b/examples/nRF24/nRF24_Transmit_Interrupt/nRF24_Transmit_Interrupt.ino new file mode 100644 index 00000000..81b064b3 --- /dev/null +++ b/examples/nRF24/nRF24_Transmit_Interrupt/nRF24_Transmit_Interrupt.ino @@ -0,0 +1,148 @@ +/* + RadioLib nRF24 Transmit with Interrupts Example + + This example transmits packets using nRF24 2.4 GHz radio module. + Each packet contains up to 32 bytes of data, in the form of: + - Arduino String + - null-terminated char array (C-string) + - arbitrary binary data (byte array) + + Packet delivery is automatically acknowledged by the receiver. + + For default module settings, see the wiki page + https://github.com/jgromes/RadioLib/wiki/Default-configuration#nrf24 + + For full API reference, see the GitHub Pages + https://jgromes.github.io/RadioLib/ +*/ + +// include the library +#include + +// nRF24 has the following connections: +// CS pin: 10 +// IRQ pin: 2 +// CE pin: 3 +nRF24 radio = new Module(10, 2, 3); + +// or using RadioShield +// https://github.com/jgromes/RadioShield +//nRF24 radio = RadioShield.ModuleA; + +// save transmission state between loops +int transmissionState = ERR_NONE; + +void setup() { + Serial.begin(9600); + + // initialize nRF24 with default settings + Serial.print(F("[nRF24] Initializing ... ")); + int state = radio.begin(); + if(state == ERR_NONE) { + Serial.println(F("success!")); + } else { + Serial.print(F("failed, code ")); + Serial.println(state); + while(true); + } + + // set transmit address + // NOTE: address width in bytes MUST be equal to the + // width set in begin() or setAddressWidth() + // methods (5 by default) + byte addr[] = {0x01, 0x23, 0x45, 0x67, 0x89}; + Serial.print(F("[nRF24] Setting transmit pipe ... ")); + state = radio.setTransmitPipe(addr); + if(state == ERR_NONE) { + Serial.println(F("success!")); + } else { + Serial.print(F("failed, code ")); + Serial.println(state); + while(true); + } + + // set the function that will be called + // when packet transmission is finished + radio.setIrqAction(setFlag); + + // start transmitting the first packet + Serial.print(F("[nRF24] Sending first packet ... ")); + + // you can transmit C-string or Arduino string up to + // 256 characters long + transmissionState = radio.startTransmit("Hello World!"); + + // you can also transmit byte array up to 256 bytes long + /* + byte byteArr[] = {0x01, 0x23, 0x45, 0x67, + 0x89, 0xAB, 0xCD, 0xEF}; + state = radio.startTransmit(byteArr, 8); + */ +} + +// flag to indicate that a packet was sent +volatile bool transmittedFlag = false; + +// disable interrupt when it's not needed +volatile bool enableInterrupt = true; + +// this function is called when a complete packet +// is transmitted by the module +// IMPORTANT: this function MUST be 'void' type +// and MUST NOT have any arguments! +void setFlag(void) { + // check if the interrupt is enabled + if(!enableInterrupt) { + return; + } + + // we sent a packet, set the flag + transmittedFlag = true; +} + +void loop() { + // check if the previous transmission finished + if(transmittedFlag) { + // disable the interrupt service routine while + // processing the data + enableInterrupt = false; + + // reset flag + transmittedFlag = false; + + if (transmissionState == ERR_NONE) { + // packet was successfully sent + Serial.println(F("transmission finished!")); + + // NOTE: when using interrupt-driven transmit method, + // it is not possible to automatically measure + // transmission data rate using getDataRate() + + } else { + Serial.print(F("failed, code ")); + Serial.println(transmissionState); + + } + + // wait a second before transmitting again + delay(1000); + + // send another one + Serial.print(F("[nRF24] Sending another packet ... ")); + + // you can transmit C-string or Arduino string up to + // 256 characters long + transmissionState = radio.startTransmit("Hello World!"); + + // you can also transmit byte array up to 256 bytes long + /* + byte byteArr[] = {0x01, 0x23, 0x45, 0x67, + 0x89, 0xAB, 0xCD, 0xEF}; + int state = radio.startTransmit(byteArr, 8); + */ + + // we're ready to send more packets, + // enable interrupt service routine + enableInterrupt = true; + } +}