One Code to rule them ALL! Arduino sketch doing two things

Got Questions? Click here and post them in the Brainy-Bits Forum to get help!

OVERVIEW

If you looked at our last tutorial, you saw that we were using two different code / sketch… 

One for the Transmitter and a different one for the Receiver.

 

Although there is no problem doing it that way, sometime you could get mixed up and upload the wrong one to the wrong board.

 

In this tutorial we will see an easy way to use one sketch that combines both and upload it to both boards, and let the code detect which board it’s running on and do different actions based on that detection.



TRANSMITTER SCHEMATIC

NRF24L01 2.4GHz wireless module with an Arduino

The transmitter which uses a NANO is using the same connections used in the prior tutorial:

 

Here are the connections:

The Switch is connected to the GND and Pin 8 on the NANO

The NRF24L01 pins:

MISO connects to pin 12 of the NANO

MOSI connects to pin 11 of the NANO

SCK  connects to pin 13 of the NANO

CE connects to pin 9 of the NANO

CSN connects to pin 10 of the NANO

GND and VCC of the NRF24L01 are connected to GND and 3.3V of the NANO

The NRF24L01 uses the SPI communication protocol, so you need to make sure that you are using the SPI pins of the version of the Arduino board you will want to use.

 

The NANO and UNO boards have the same ones:

  • Pin 11 = MOSI (Master Out Slave In)
  • Pin 12 = MISO (Master In Slave Out)
  • Pin 13 = SCK (Serial Clock)

 

But if you plan to use let’s say a MEGA 2560 then those pins will be different.

  • Pin 51 = MOSI (Master Out Slave In)
  • Pin 50 = MISO (Master In Slave Out)
  • Pin 52 = SCK (Serial Clock)

 


RECEIVER SCHEMATIC

The Receiver schematic is the same except that we added a jumper from the A0 pin to GND.

This will be used by the sketch to detect if it’s running on the Receiver or the Transmitter.

 

Here are the connections:

The WS2812 RGB Stick DI (digital In) pin is connected to Pin 8 on the UNO

GND and VCC are connected to the GND and 5V of the UNO

The A0 pin of the UNO is connected to GND

 

The NRF24L01 pins:

MISO connects to pin 12 of the UNO

MOSI connects to pin 11 of the UNO

SCK  connects to pin 13 of the UNO

CE connects to pin 9 of the UNO

CSN connects to pin 10 of the UNO

GND and VCC of the NRF24L01 are connected to GND and 3.3V of the UNO

 


THE ONE CODE

In this tutorial we will be using only one piece of code (sketch) that will be uploaded to both the Transmitter (NANO) and the Receiver (UNO).

 

The code will read the state of the A0 pin and detect if it’s HIGH or LOW.

We set the A0 pin to HIGH at start, since there is nothing connected to the A0 pin of the NANO, it will stay HIGH.

But since we connected the A0 pin of the UNO to GND, then it will be LOW even if we set it to HIGH at startup.

If it’s HIGH then it means it’s running on the NANO (Transmitter) and if LOW then it’s the UNO (Receiver).

After that it’s just a matter of doing actions in the code based on the A0 pin state.

 

As always, Don’t forget to watch our Tutorial video for more information.

 

/* Start of Code */

/* Arduino One Code/Sketch for Two Functions

Created by Yvan / https://Brainy-Bits.com
This code is in the public domain...
You can: copy it, use it, modify it, share it or just plain ignore it!
Thx!

*/

// Include needed Libraries at beginning
#include "nRF24L01.h" // NRF24L01 library created by TMRh20 https://github.com/TMRh20/RF24
#include "RF24.h"
#include "SPI.h"
#include "FastLED.h" // FastLED library for WS2812 RGB Stick http://fastled.io/

// Define the Pins used
#define NUM_LEDS 8 // Number of leds on stick for Receiver
#define LED_PIN 8 // Digital In (DI) of RGB Stick connected to pin 8 of the UNO (Receiver)
#define SwitchPin 8 // Arcade switch is connected to Pin 8 on NANO (Transmitter)
#define board_select A0 // Pin used to detect the running board

// Used Variables
int SentMessage[1] = {000}; // Used to store value before being sent through the NRF24L01 (Transmitter)
int ReceivedMessage[1] = {000}; // Used to store value received by the NRF24L01 (Receiver)
int running_board; // Used to store the identify of the running board
const uint64_t pipe = 0xE6E6E6E6E6E6; // Needs to be the same for communicating between 2 NRF24L01

// Init components
RF24 radio(9,10); // NRF24L01 uses SPI pins + Pin 9 and 10 on UNO and NANO
CRGB leds[NUM_LEDS]; // FastLED Library Init (Receiver)


void setup()
{

// Make board_select Pin HIGH on start
pinMode(board_select, INPUT);
digitalWrite(board_select,HIGH);
delay(100); // Little delay to make sure it is stable at HIGH

// Check to see which board is running
if ( digitalRead(board_select) ) { // If HIGH then it's the NANO (transmitter)
running_board = 0;

pinMode(SwitchPin, INPUT_PULLUP); // Make the switch pin input with pullup resistor
digitalWrite(SwitchPin, HIGH); // Make switch pin HIGH at start
}

else { // Then the pin was detected LOW meaning it's the UNO (Receiver)
running_board = 1;

pinMode(LED_PIN, OUTPUT); // Set RGB Stick UNO (receiver) pin to an OUTPUT

FastLED.addLeds<NEOPIXEL,LED_PIN>(leds, NUM_LEDS); // Setup FastLED Library
FastLED.clear(); // Clear the RGB Stick LEDs 

for(int x = 0; x != NUM_LEDS; x++) { // Light up LED Stick all Red at startup
leds[x] = CRGB::Red;
}

FastLED.setBrightness(50);
FastLED.show();
}

radio.begin(); // Start RF24L01 on both boards

if ( running_board == 0 ) // 0 = Nano (transmitter)
{
radio.openWritingPipe(pipe); // Open writing pipe for transmit
}
else // if not = 0 then it's the UNO (Receiver)
{
radio.openReadingPipe(1,pipe); // Open reading pipe for receive
radio.startListening();
}

}

void loop() {

if ( running_board == 0 ) { // Then it's the Transmitter

if (digitalRead(SwitchPin) == LOW){ // If Switch is Activated
SentMessage[0] = 111;
radio.write(SentMessage, 1); // Send value through NRF24L01 
}

else {
SentMessage[0] = 000;
radio.write(SentMessage, 1);
}
}

if ( running_board == 1 ) // Then it's the Receiver
{
while (radio.available()) 
{
radio.read(ReceivedMessage, 1); // Read information from the NRF24L01

if (ReceivedMessage[0] == 111) // Indicates switch is pressed
{
for(int x = 0; x != NUM_LEDS; x++)
{
leds[x] = CRGB::Green;
FastLED.show();
}
}
else
{
for(int x = 0; x != NUM_LEDS; x++) 
{
leds[x] = CRGB::Red;
FastLED.show();
}
}
delay(10);
}
}
}

/* End of Code */

 


TUTORIAL VIDEO



DOWNLOAD

Copy the above Sketch code in your Arduino IDE software to program your Arduino.

 

Used Libraries:

Download The NRF24L01 Library created by TMRh20 here: https://github.com/TMRh20/RF24

Download The FastLED Library created by focalintent here: https://github.com/FastLED/FastLED/releases

 

Once downloaded, just extract the content of the zip files inside your “arduino/libraries” folder.

Got Questions? Click here and post them in the Brainy-Bits Forum to get help!

Leave a comment

Comments have to be approved before showing up