To get the most out of this tutorial - it is best to start at tutorial Part 1, and then progress to Part 2 then Part 3 and then do Part 4 last.
Doing the RF tutorials in this order will help you to understand the process better.
If you are looking for a way to communicate between Arduinos, but don't have much cash at your disposal, then look no further.
These RF modules are not only affordable, but easy to use. They are much easier to set up than an XBee,
plus you can use them without the need of a special shield.
Before you rush out and buy a ton of these modules, make sure that you are not breaking any radio transmission laws in your country.
Do your research, and buy them only if you are allowed to use them in your area.
There are a few [OPTIONAL] libraries that can be used to help you and your particular project.
I will mention at this point however, that I did NOT use any libraries in this particular tutorial. That's right. I will show how easy it is to transmit data from one arduino to another using these RF modules WITHOUT libraries.
Also if you are looking for an easy way to record the signals and play them back without a computer - then jump to this tutorial.
Video
Project 1- RF Blink
Firstly we need to test if the RF modules are working. So we will design a very simple transmit and receive sketch to test
their functionality. We will use the Arduino's onboard LED to show when the transmitter is transmitting,
and when the other Arduino is receiving. There will be a slight delay between the two Arduinos. You can solder an antenna onto these modules, however I did not do this, I just kept the modules close together (1-2cm apart). I also found that I was getting better accuracy when I used 3V instead of 5V to power the receiver. While using 5V for VCC on the receiver, I would get a lot of interference, however with 3V, I hardly got any noise. If you find you are getting unpredictable results, I would suggest you switch to 3V on the receiver and move the transmitter and receiver modules right next to each other. Remember this is just a check... you can experiment with an antenna or a greater distance afterwards.
Here are the parts that you will need to carry out this project:
Notice the pin called "ATAD". It took me a while to figure out what ATAD stood for, when I suddenly realised that this was just a word reversed.
It should be DATA (not ATAD). Nevertheless, this is the pin responsible for transmitting the signal.
We will make the Arduino's onboard LED illuminate when the transmitter pin is HIGH, and go off when LOW as described in the following table.
And this is the Arduino Sketch to carry out the data transmission.
Arduino sketch - Transmitter
The Receiver
If all goes to plan, the onboard LED on this Arduino should light up (and go off) at the same time as the onboard LED on
the transmitting Arduino. There is a chance that the receiver may pick up stray signals from other transmitting devices using
that specific frequency. So you may need to play around with the threshold value to eliminate the "noise".
But don't make it too big, or you will eliminate the signal in this experiment.
You will also notice a small delay between the two Arduinos.
Arduino sketch - Receiver
When a HIGH signal is transmitted to the other Arduino. It will produce an AnalogRead = 0.
When a LOW signal is transmitted, it will produce an AnalogRead = 400.
This may vary depending on on your module, and voltage used.
The signals received can be viewed using the Serial Monitor, and can be copied into a spreadsheet to create a chart like this:
You will notice that the HIGH signal (H) is constant, whereas the LOW signal (L) is getting smaller with each cycle. I am not sure why the HIGH signal produces a Analog reading of "0". I would have thought it would have been the other way around. But you can see from the results that a HIGH signal produces a 0 result and a LOW signal produces a value of 400 (roughly).
In tutorial 4 - we use the information gathered in the first 3 tutorials and do away with the need for a computer. We will listen for a signal, store the signal, and then play it back by pressing a button. Similar to a universal remote ! No libraries, no sound cards, no computer. Just record signal and play it back. Awesome !!
If you like this page, please do me a favour and show your appreciation :
In the previous two parts of the this tutorial, we went through a
number of simple sketches to get you acquainted with the way that the
Arduino handles various data types when passed through the Serial COM
port. Here are the main themes from part ONE:
Stage One:
Echoing data with the Arduino
Stage Two: Using
Delimiters to split data.
Stage Three:
Arduino Maths, simple addition
Stage Four:
Sending a double to an Arduino, and then doubling it.
Stage Five:
Sending Sensor data from the Arduino to the Serial
Monitor
Stage Seven:
Arduino and Processing join forces for more fun
Stage Eight: A
simple project that shows Serial communication from Arduino to
Processing
In Part Three - we will reverse the direction of communication and
get
Processing to send data to the Arduino via a USB cable,
Stage Nine: A
simple processing sketch that switches an LED on
the Arduino
Stage Ten:
A processing sketch that reads from a text file
Stage Eleven: A
processing sketch that reads data from a text
file and sends to the Arduino
Stage Twelve: A
processing sketch that trasmits data from a file
to another Arduino via an XBee module.
Stage Nine - Using your computer to switch
an LED
In this stage we create a simple Arduino sketch which will receive a
simple command from the Processing Sketch to switch an LED. The
Processing sketch will allow you to turn an LED on/off by clicking on
the Processing Application window. It will detect the press of the
mouse, and will send a command to the Arduino via the USB Serial COM
port.
/* ===================================================Simple number reader: Written by ScottC - 07 Apr 2013 Arduino Version: 1.04======================================================*/// The onboard LED is on pin # 13int onboardLED = 13;
void setup() {
// Begin Serial communication
Serial.begin(9600);
//Set the onboard LED to OUTPUT
pinMode(onboardLED, OUTPUT);
}
void loop(){
/* Read serial port, if the number is 0, then turn off LED if the number is 1 or greater, turn the LED on. */while (Serial.available() > 0) {
int num=Serial.read()-'0';
if(num<1){
digitalWrite(onboardLED, LOW); //Turn Off LED
} else{
digitalWrite(onboardLED, HIGH); //Turn On LED
}
}
}
/*=========================================================== Toggle Switch: Send Number to Arduino Written by Scott C on 07 Apr 2013 Processing Version: 2.0b8=============================================================*/
import processing.serial.*;
Serial comPort;
boolean ledState=false; //LED is offvoid setup(){
//Open COM Port for Communication
comPort = new Serial(this, Serial.list()[0], 9600);
background(255,0,0); //Start with a Red background
}
void draw(){
}
void mousePressed() {
//Toggle led ON and OFF
ledState=!ledState;
//If ledState is True - then send a value=1 (ON) to Arduinoif(ledState){
background(0,255,0); //Change the background to green/*When the background is green, transmit a value=1 to the Arduino to turn ON LED */
comPort.write('1');
}else{
background(255,0,0); //Change background to red
comPort.write('0'); //Send "0" to turn OFF LED.
}
}
The Video
Stage Ten:
Reading from a Text File
We are now going to give the Arduino a rest (for a moment) and
concentrate on a Processing Sketch that will read from a text file.
Once we learn this skill, we can then build this Processing
functionality into our Arduino Projects. Reading from a text file in
Processing is actually quite easy if you use the loadStrings()
method. However, it is best if you make things easy for yourself by
using delimiters. The most common delimitter is a "comma". The comma
allows the computer to group information according to your needs.
11,22,33,44,55,66
1,1,2,2,3,3,4,4,5,5,6,6
112,223,334,455,566
The examples above contain the same numbers but are delimitted in
different ways.
We are going to import a few different numbers/letters and store them
in an array. We will then iterate through the array to display the
values within.
So let us now create the text file. Copy and paste the following text
into notepad and save the file, but remember where you save it, because
we will need to know location and the name of the file in order to read
from in.
Copy and Paste into Notepad:
100,200,A,B,C,10.2,0.1,wx,yz,arduinobasics
Save the file
I am going to call my file data.txt,
and will be saving it to my D
drive, so the file will be located here:
D:/data.txt
We will now create the processing sketch to read the text file and
display the data on the screen.
We will use the comma delimiters to separate the data so that it
displays in the following way:
/* ============================================================= ReadTextFile and Display on Screen: Written by ScottC on 15th April 2013 using Processing version 2.0b8 Website: http://arduinobasics.blogspot.com/ Projects: http://arduinobasics.blogspot.com/p/arduino-basics-projects-page.html References: Displaying Text: http://processing.org/reference/text_.html Reading Text File: http://processing.org/reference/loadStrings_.html=================================================================*/void setup(){
size(180,250);
background(255);
/* Read the text file */
String[] lines = loadStrings("D:/data.txt");
int numOfLines=lines.length;
for(int i=0;i<numOfLines;i++){
/* Split the data based on a "," delimiter. */
String[] data = splitTokens(lines[i], ",");
int dataCount = data.length;
for(int j=0; j<dataCount; j++){
/* Set the size and colour of the text */
textSize(16);
fill(100,100,255,50+(j*20));
/* Display the text on the screen */
text(data[j],10,16+(16*j));
}
}
}
void draw(){
}
The code above has the ability to display data from multiple lines
within the text file, however for simplicity, I have chosen to use a
single line. If I wanted to display more than one line, I would have to
change the "for-loops".
Stage Eleven: Read
Text File and send to Arduino
In stage 10 we used the
Processing programming language to import
a line of data from a text file, break-up the line into pieces (based
on comma delimiters) and then displayed the data on the Computer
Screen. We will now use this knowledge and take it one step further. We
will create a text file, import the data using processing, but this
time we will send the data to the Arduino. Meanwhile the Arduino will
be waiting patiently for this data, and once it receives the data, it
will react according to our needs. We are going to keep this simple.
The goal is to send two different letters from the Computer to
the Arduino. One letter will turn an LED on, and the other letter will
turn the LED off. We will also send an integer to tell the Arduino how
long to keep the LED on or off.
GOAL:
Turn an LED on and off by reading a
text file.
Our first step in this process is to
create a text file that will store
our important data. We will store two variables in this file. The first
variable will be used to tell the Arduino whether we want to turn the
LED on or whether we want to turn the LED off. We will use the letter
"O" to turn the LED on, and use the letter "X" to turn the LED off.
The second variable will be a time based variable. It will be used to
tell the Arduino "how long" to keep the LED on or off. We will store
this variable as an integer and will represent time in "milliseconds".
1000 milliseconds = 1
second
It makes sense to keep these two
variables as a pair, however we will
separate them using a comma delimitter. We will separate each command
by putting the variables on a new line. Copy and paste the following
data into notepad (or equivalent text editor), and save the file to
your harddrive. I have saved this file as
D:/LEDdata.txt
Text File Data:
Here is
the data to put into your text file (notepad):
/* Read TextFile Data: Written by ScottC on 24 April 2013 Arduino IDE version: 1.0.4 http://arduinobasics.blogspot.com.au/2013/04/serial-communication-tutorial-part-3.html*//* Global Variables */
byte byteRead; //Used to receive data from computer.int timeDelay; //time that the LED is On or Offint maxtimeDelay=10000; //Maximum time delay = 10 secondsint ledPin=13; //LED connected to pin 13 on Arduino UNO.void setup() {
//Set pin 13 (ledPin) as an output
pinMode(ledPin, OUTPUT);
// Turn the Serial Protocol ON
Serial.begin(9600);
}
void loop() {
/* check if data has been sent from the computer: */if (Serial.available()) {
/* read the most recent byte */
byteRead = Serial.read();
switch (byteRead) {
case 69: //This is an enquiry, send an acknowledgement
Serial.println("A");
break;
case 79: //This is an "O" to turn the LED on
digitalWrite(ledPin, HIGH);
break;
case 88: //This is an "X" to turn the LED off
digitalWrite(ledPin, LOW);
break;
case 46: //End of line//Make sure time delay does not exceed maximum.if(timeDelay > maxtimeDelay){
timeDelay=maxtimeDelay;
}
//Set the time for LED to be ON or OFF
delay(timeDelay);
Serial.println("S");
timeDelay=0; //Reset timeDelay;break;
default:
//listen for numbers between 0-9if(byteRead>47 && byteRead<58){
//number found, use this to construct the time delay.
timeDelay=(timeDelay*10)+(byteRead-48);
}
}
}
}
Our next step is to import the data
in the text file into Processing and then
send the data to
the Arduino. You may want to review
Stage 10 of this tutorial for another example of importing text file
data into
Processing. You may also want to review stage 7 which shows how to
receive data from an Arduino.
We will import all of the data from the file when we push a
button on
the Processing Window, and send this data to the Arduino via the USB
cable that is connected to the computer.
We are going to use the same COM port that the Computer uses to upload
Arduino Sketches, therefore it is important that you close the Arduino
Serial Monitor before you run the processing sketch, otherwise you will
get an error which states that the COM port is not available.
/* TextFile Data sender (Stage 11) Written by ScottC on 24th April 2013 using Processing Version 2.0b8 The full tutorial can be found here: http://arduinobasics.blogspot.com/2013/04/serial-communication-tutorial-part-3.html*/
import processing.serial.*;
Serial comPort; //The com port used between the computer and Arduinoint counter=0; // Helps to keep track of values sent.int numItems=0; //Keep track of the number of values in text file
String comPortString; //String received From Arduino
String textFileLines[]; //Array of text file lines
String lineItems[]; //Array of line itemsvoid setup(){
comPort = new Serial(this, Serial.list()[0], 9600); //Setup the COM port
comPort.bufferUntil('\n'); //Generate a SerialEvent when a newline is received
background(255,0,0); //Start with a Red background
}
/* Draw method is not used in this sketch */void draw(){
}
//When the mouse is pressed, write an "E" to COM port. //The Arduino should send back an "A" in return. This will //generate a serialEvent - see below.void mousePressed() {
comPort.write("E");
}
void serialEvent(Serial cPort){
comPortString = cPort.readStringUntil('\n');
if(comPortString != null) {
comPortString=trim(comPortString);
/*If the String received = A, then import the text file change the background to Green, and start by sending the first line of the text file to the Arduino */if(comPortString.equals("A")){
textFileLines=loadStrings("D:/LEDdata.txt");
background(0,255,0);
sendLineNum(counter);
}
/*If the the String received = S, then increment the counter which will allow us to send the next line in the text file. If we have reached the end of the file, then reset the counter and change the background colour back to red. */if(comPortString.equals("S")){
counter++;
if(counter > (textFileLines.length-1)){
background(255,0,0);
counter=0;
} else {
sendLineNum(counter);
}
}
}
}
/*The sendLineNum method is used to send a specific line from the imported text file to the Arduino. The first line item tells the Arduino to either switch the LED on or off. The second line item, tells the Arduino how long to keep the LED on or off. The full-stop is sent to the Arduino to indicate the end of the line. */void sendLineNum(int lineNumber){
lineItems=splitTokens(textFileLines[lineNumber],",");
comPort.write(lineItems[0]);
comPort.write(lineItems[1]);
comPort.write(".");
}
Stage Twelve: To be
continued..
I need to finish my XBee tutorial before doing this stage. But am just
about to start studying again. So this stage probably won't get
completed for another couple of months.
But I hope there is enough content to keep you satisfied for the time
being.
The bluetooth shield used in this
project is a great way to detach the Arduino from your computer. What
is even better, is that the shield allows you to control your arduino
from your mobile phone or other bluetooth enabled device through simple
Serial commands. In this
tutorial we will connect a Grove Chainable RGB LED to the bluetooth
shield directly, and send simple commands using the Bluetooth SPP app
on a Samsung Galaxy S2 to change the colour of the
LED (Red , Green and Blue)
/* This project combines the code from a few different sources.This project was put together by ScottC on the 15/01/2013http://arduinobasics.blogspot.com/Bluetooth slave code by Steve Chang - downloaded from :http://www.seeedstudio.com/wiki/index.php?title=Bluetooth_ShieldGrove Chainable RGB code can be found here :http://www.seeedstudio.com/wiki/Grove_-_Chainable_RGB_LED#Introduction*/#include <SoftwareSerial.h> //Software Serial Port#define uint8 unsigned char #define uint16 unsigned int#define uint32 unsigned long int#define RxD 6 // This is the pin that the Bluetooth (BT_TX) will transmit to the Arduino (RxD)#define TxD 7 // This is the pin that the Bluetooth (BT_RX) will receive from the Arduino (TxD)#define DEBUG_ENABLED 1int Clkpin = 9; //RGB LED Clock Pin (Digital 9)int Datapin = 8; //RGB LED Data Pin (Digital 8)
SoftwareSerial blueToothSerial(RxD,TxD);
/*----------------------SETUP----------------------------*/void setup() {
Serial.begin(9600); // Allow Serial communication via USB cable to computer (if required)
pinMode(RxD, INPUT); // Setup the Arduino to receive INPUT from the bluetooth shield on Digital Pin 6
pinMode(TxD, OUTPUT); // Setup the Arduino to send data (OUTPUT) to the bluetooth shield on Digital Pin 7
pinMode(13,OUTPUT); // Use onboard LED if required.
setupBlueToothConnection(); //Used to initialise the Bluetooth shield
pinMode(Datapin, OUTPUT); // Setup the RGB LED Data Pin
pinMode(Clkpin, OUTPUT); // Setup the RGB LED Clock pin
}
/*----------------------LOOP----------------------------*/void loop() {
digitalWrite(13,LOW); //Turn off the onboard Arduino LEDchar recvChar;
while(1){
if(blueToothSerial.available()){//check if there's any data sent from the remote bluetooth shield
recvChar = blueToothSerial.read();
Serial.print(recvChar); // Print the character received to the Serial Monitor (if required)//If the character received = 'r' , then change the RGB led to display a RED colourif(recvChar=='r'){
Send32Zero(); // begin
DataDealWithAndSend(255, 0, 0); // first node data
Send32Zero(); // send to update data
}
//If the character received = 'g' , then change the RGB led to display a GREEN colourif(recvChar=='g'){
Send32Zero(); // begin
DataDealWithAndSend(0, 255, 0); // first node data
Send32Zero(); // send to update data
}
//If the character received = 'b' , then change the RGB led to display a BLUE colourif(recvChar=='b'){
Send32Zero(); // begin
DataDealWithAndSend(0, 0, 255); // first node data
Send32Zero(); // send to update data
}
}
//You can use the following code to deal with any information coming from the Computer (serial monitor)if(Serial.available()){
recvChar = Serial.read();
//This will send value obtained (recvChar) to the phone. The value will be displayed on the phone.
blueToothSerial.print(recvChar);
}
}
}
//The following code is necessary to setup the bluetooth shield ------copy and paste----------------void setupBlueToothConnection()
{
blueToothSerial.begin(38400); //Set BluetoothBee BaudRate to default baud rate 38400
blueToothSerial.print("\r\n+STWMOD=0\r\n"); //set the bluetooth work in slave mode
blueToothSerial.print("\r\n+STNA=SeeedBTSlave\r\n"); //set the bluetooth name as "SeeedBTSlave"
blueToothSerial.print("\r\n+STOAUT=1\r\n"); // Permit Paired device to connect me
blueToothSerial.print("\r\n+STAUTO=0\r\n"); // Auto-connection should be forbidden here
delay(2000); // This delay is required.
blueToothSerial.print("\r\n+INQ=1\r\n"); //make the slave bluetooth inquirable
Serial.println("The slave bluetooth is inquirable!");
delay(2000); // This delay is required.
blueToothSerial.flush();
}
//The following code snippets are used update the colour of the RGB LED-----copy and paste------------void ClkProduce(void){
digitalWrite(Clkpin, LOW);
delayMicroseconds(20);
digitalWrite(Clkpin, HIGH);
delayMicroseconds(20);
}
void Send32Zero(void){
unsignedchar i;
for (i=0; i<32; i++){
digitalWrite(Datapin, LOW);
ClkProduce();
}
}
uint8 TakeAntiCode(uint8 dat){
uint8 tmp = 0;
if ((dat & 0x80) == 0){
tmp |= 0x02;
}
if ((dat & 0x40) == 0){
tmp |= 0x01;
}
return tmp;
}
// gray datavoid DatSend(uint32 dx){
uint8 i;
for (i=0; i<32; i++){
if ((dx & 0x80000000) != 0){
digitalWrite(Datapin, HIGH);
} else {
digitalWrite(Datapin, LOW);
}
dx <<= 1;
ClkProduce();
}
}
// data processingvoid DataDealWithAndSend(uint8 r, uint8 g, uint8 b){
uint32 dx = 0;
dx |= (uint32)0x03 << 30; // highest two bits 1，flag bits
dx |= (uint32)TakeAntiCode(b) << 28;
dx |= (uint32)TakeAntiCode(g) << 26;
dx |= (uint32)TakeAntiCode(r) << 24;
dx |= (uint32)b << 16;
dx |= (uint32)g << 8;
dx |= r;
DatSend(dx);
}
You don't
need to download a library to get this project running. But if you plan
to use bluetooth shields to get 2 Arduinos to communicate to each
other, then I would advise that you download the library files (which
are just examples) from the Seeedstudio site : here.
Visit this site to setup your phone or laptop for bluetooth
communication to the shield - here
The app used on my Samsung Galaxy S2 phone was "Bluetooth SPP"
You will initially need to enter a pin of '0000' to establish a
connection to the Bluetooth shield - which will appear as
"SeeedBTSlave" or whatever text you place on line 90 of the Arduino
code above.
Warning !
Not all phones are compatible with the bluetooth shield.
If you have used this shield before - please let me know what phone you
used - so that we can build a list and inform others whether their
phone is likely to work with this project or not. Obviously - those
phones that do not have bluetooth within - will not work :).
And I have not tried any other apps either
I got it to work very easily with my Samsung Galaxy S2 using the free
Bluetooth SPP app from the google play store.
This was fun, but I want
to make my own app !
Have a look at my latest 4-part tutorial which takes you
step-by-step through the process of building your own app using the
Processing/Android IDE.
You can build your own GUI interface on your Android Phone and get it
to communicate via Bluetooth to your Arduino/Bluetooth Shield. Click on
the links below for more information:
There are many XBee tutorials out there, but I could not find one that I could apply to my specific Arduino/Shield/Xbee configuration. While this particular configuration may not apply to you, perhaps it will send you in the right direction, so please read on.
Please note, that your XBee shield may require you to perform extra steps, so please do further reading before jumping in head first. I am not an expert, so don't blame me if you fry your board.
Select the Diagnostics, Utilities and MIBs section
Download and install the XCTU 32-bit ver 5.2.7.5 installer (do a virus check after download)
Please note that this is for Windows platforms only !
FYI: We will run the software later
Step 2: Upload the bare-minimum script on your Arduino controller
I perform this step to prevent any previous projects from interfering. This may not be necessary, but I tend to do this before wiring up any of my new projects. This is the script I load onto the Arduino:
Bare Minimum Arduino Sketch:
1
2
3
4
5
6
7
void setup() {
}
void loop() {
}
Step 3: Connect the Shield to Arduino, and XBee to Shield.
Disconnect the Arduino UNO from the computer.
Insert the XBee module into the Shield.
This is the XBee Shield and XBee module side by side
This is the XBee module on the XBee Shield
The pins from the XBee module should slot into the respective headers on the Shield.
Connect the XBee shield to the Arduino
The pins from the XBee shield should slot into the respective headers on the Arduino board.
Move the little white switch in the corner to USB.
There are 2 options - USB mode and XBee mode.
We want USB mode which will allow the computer to communicate with the XBee module
Step 4: Connect Arduino to computer, and run the X-CTU Software
With the XBee module and Shield connected to the Arduino, and the Shield's white switch in USB mode; connect the Arduino to the computer using a USB cable.
This Arduino board appears as COM7 on my computer.
Here is what the X-CTU software looks like when it loads up
Press the Test / Query button to see if the computer can talk to the XBee module.
If successful, you should see something like this:
If you accidentally leave the XBee shield in XBee mode, or if your computer fails to communicate with the XBee module, you may encounter these screens.
If you get a successful Test / Query, then move onto the next step.
Step 5: Read XBee Firmware settings:
We can now try to read the XBee firmware settings by
Selecting the Modem Configuration Tab
Select the Read button to read the XBee firmware settings
Step 6: Download older version of firmware if necessary
If you did not have any issues with the previous step, then continue to step 7, otherwise read on.
In my case, the software could not find the firmware file necessary to read the firmware settings.
In step 4, I could see that I had the XB24 Modem type, and 10E8 firmware version,
I tried downloading new versions, but this did not seem to work, as the computer could not detect any newer updates available. The problem I had, was that I needed an "older version" of firmware to communicate with the XBee module in order to read/write new settings to it.
I could not select the firmware version from the drop down boxes, which indicated that this particular firmware version was not installed on my computer. So here is what I did.
I went back to the Digi site and selected the Firmware update section.
This provided a link to an FTP site with "previous versions" of firmware.
I then selected the relevant firmware version from the list, and downloaded the zip file to a logical folder on my hard-drive.
There is no need to unzip the file, because the X-CTU software will look for a zipped file.
In the X-CTU software, in the Modem Configurations tab, select the "Download new versions button", and select File. Navigate to the zip-file just downloaded and select it.
The software should tell you that it has updated successfully or something to that effect.
The modem type and version should now be an available option in the drop down boxes, however, we will continue where we left off (in step 5) and try an read the firmware settings from the XBee module, by pressing the Read button in the Modem Configurations tab on the X-CTU software.
The
Arduino Sketch
The
Processing Sketch
Copy and Paste into Notepad:
