Bluetooth Tutorial 1

Introduction:

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)

Parts Required:
Freetronics Eleven or any compatible Arduino.
Bluetooth shield
Grove Chainable RGB LED
Grove Wire connectors




The Video:





The Arduino Sketch:

Arduino Code:
You can download the Arduino IDE from this site.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159

/* This project combines the code from a few different sources. This project was put together by ScottC on the 15/01/2013 http://arduinobasics.blogspot.com/ Bluetooth slave code by Steve Chang - downloaded from : http://www.seeedstudio.com/wiki/index.php?title=Bluetooth_Shield Grove 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 1 int 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 LED char 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 colour if(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 colour if(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 colour if(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){ unsigned char 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 data void 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 processing void 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); }

The code above was formatted using hilite.me

Notes:

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:

• PART ONE
• PART TWO
• PART THREE
• PART FOUR (with video)

---

 
 

If you like this page, please do me a favour and show your appreciation :

 
Visit my ArduinoBasics Google + page.
Follow me on Twitter by looking for ScottC @ArduinoBasics.
Have a look at my videos on my YouTube channel.

 
 

 
 
 

However, if you do not have a google profile...
Feel free to share this page with your friends in any way you see fit.

Colour Sensing - Intro

Now that I have different patterns for the different coloured Mega Bloks, I will try to get processing to "Identify" or tell me which Blok is which. I am essentially trying to make a DIY colour sensor.
I know that if I get the RGB LED to produce different coloured light (rather than just white), I will be able to get more information/patterns from my Red and Yellow LED sensors, however, I think I have enough information from the white light to tell the difference between the Red, the yellow and the green Mega Bloks.

We'll see how we go. Stay tuned.

For more information about what project I referring to - jump to this Blog Posting:
Arduino UNO: LED Sensor Part Two

Arduino UNO: LED Sensor, Part Two

Building on the last project, I am now using a Red and a Yellow LED as a Sensor to detect light coming from an RGB LED.

Putting different coloured Mega Bloks over the LEDs has different effects on the Sensors as the RGB LED gets brighter and brighter.

I used the Processing Language to control the brightness of the RGB LED through a Serial command, and then use the resulting Sensor readings from the Yellow and the Red LEDs to create a chart or plot.

Here are the results of my experiment.

Red Mega Blok

Yellow Mega Blok

Green Mega Blok

When the displayed bars are RED, it indicates that the Red LED is absorbing MORE light than the Yellow LED (and vice versa). Hence this is a "Difference Chart".
The Green Mega Blok absorbs more Red Light than the other blocks, therefore producing a big difference between Red LED sensor readings and Yellow Sensor readings.

Here is the list of components required to perform this experiment

• Arduino UNO
• Breadboard
• 1 x Red LED
• 1 x Yellow LED
• 1 x RGB LED
• 5 x 330 ohm resistors
• 8 wires to connect the circuit
• Processing programming language.
• 3 x Mega Bloks (Red, Yellow and Green)

All parts hardware parts except for the wires and the Mega Bloks
can be found in the Sparkfun Inventors Kit.

Here is the Sketch: (created in Fritzing):

Here is the Arduino Code:

arduino code RedYellow Sensor with RGB LED

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

//Define the pins for the Red LED Sensor
#define Red_LED_Sensor_POS 4
#define Red_LED_Sensor_NEG 5

//Define the pins for the Yellow LED Sensor
#define Yellow_LED_Sensor_POS 7
#define Yellow_LED_Sensor_NEG 8

//Define the pin for the RGB LED torch
#define RGB_LED_RedPin 9
#define RGB_LED_GreenPin 10
#define RGB_LED_BluePin 11
int intensity=0;


//Define the maximum cycles/time allowed for each LED to capture light
long max_darkness=80000;


void setup(){
  //Setup the RED LED Sensor
  pinMode(Red_LED_Sensor_POS,OUTPUT);
  digitalWrite(Red_LED_Sensor_POS,LOW);
  
  //Setup the YELLOW LED Sensor
  pinMode(Yellow_LED_Sensor_POS,OUTPUT);
  digitalWrite(Yellow_LED_Sensor_POS,LOW);
  
  //No need to setup the RGB LED Pins
    
  //Turn on Serial Protocol
  Serial.begin(9600);
}

void loop()
{      
  
  byte byteRead;
   // check if data has been sent from the computer:
  if (Serial.available()) {
    // read the most recent byte (which will be from 0 to 255):
    byteRead = Serial.read();
    // set the brightness of the LED:
    analogWrite(RGB_LED_RedPin, byteRead);
    analogWrite(RGB_LED_GreenPin, byteRead);
    analogWrite(RGB_LED_BluePin, byteRead);
  
  //Read the amount of Yellow light
  read_LED('Y', Yellow_LED_Sensor_NEG);
  
  //Read the amount of Red light
  read_LED('R', Red_LED_Sensor_NEG);
  }
}

void read_LED(char LED_Colour, int LED_Pin){

  // Charge the LED by applying voltage in the opposite direction
  pinMode(LED_Pin,OUTPUT);
  digitalWrite(LED_Pin,HIGH);
  
  //Read the amount of Light coming into the LED sensor
  long darkness=0;
  int lightLevel=0;
  pinMode(LED_Pin,INPUT);
  digitalWrite(LED_Pin,LOW);
  
  while((digitalRead(LED_Pin)!=0) && darkness < max_darkness){
     darkness++;
  }
  
  lightLevel=((max_darkness-darkness)+1)/80;
  
  //Print the LED colour
  Serial.println(LED_Colour);
  //Print the light level
  Serial.println(lightLevel);
}

code formatter

Here is the Processing Code:

processing code Read Serial Chart and Write Serial

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

/* Processing code for this example */
 
 // Graphing sketch
 
 //This sketch was written by ScottC, but was adapted from a sketch
 //written by Tom Igoe in 2005
 
 // This example code is in the public domain.
 
 import processing.serial.*;
 
 Serial myPort;        // The serial port
 int xPos = 1;         // horizontal position of the graph
 float YellowVal=0;    // The variable to hold the Yellow Sensor Reading
 float RedVal=0;       // The variable to hold the Red Sensor Reading
 float Diff=0;         // The variable to hold the difference between the readings
 int Switcher=0;       // Used to control the flow of the program
 
 void setup () {
 // set the window size:
 size(1020, 750);        
 
 // List all the available serial ports
 println(Serial.list());
 // I use COM13 for my Serial Port - you will need to change this to suit your system
 myPort = new Serial(this, "COM13", 9600);
 // don't generate a serialEvent() unless you get a newline character:
 myPort.bufferUntil('\\n');
 // set inital background:
 background(0);
 //Send a value to the Arduino to start the feedback mechanism
 myPort.write(0);
}
 void draw () {
 // everything happens in the serialEvent()
 }
 
 void serialEvent (Serial myPort) {
 // get the ASCII string:
 String inString = myPort.readStringUntil('\\n');
 
 if (inString != null) {
   // trim off any whitespace:
   inString = trim(inString);
   
   //The arduino sends 2 sensor readings. The following code 
   //helps to identify which reading is which.
   if(inString.equals("Y")){
     Switcher=0;
   } else if (inString.equals("R")){
     Switcher=1;
   } else {
     
     //Convert the String to a float
     float inByte = float(inString); 
     //Map the reading, so that the chart fits within the window.
     inByte = map(inByte, 0, 1000, 0, height);
     
     if(Switcher==0){
       //Save the reading from the yellow sensor to YellowVal
       YellowVal=inByte;
     } else {
       //Save the reading from the red sensor to RedVal
       RedVal=inByte;
       //Calculate the difference between the readings
       Diff=RedVal-YellowVal;
       
       //If the yellow sensor is greater, plot with a yellow line
       //If the red sensor reading is greater, plot a red line.
       if(Diff<=0){
         stroke(255,255,0);
         Diff=abs(Diff);
       } else {
         stroke(255,0,0);
       }
       // draw the line:
       line(xPos, height, xPos, height - Diff);
 
       // at the edge of the screen, go back to the beginning:
       if (xPos > width) {
         xPos = 0;
         background(0);
         //Send a value to the Arduino to change the intensity
         //of the RGB LED and take another reading
         myPort.write(xPos); 
       } else {
         // increment the horizontal position: Increment by more
         // to get less readings and to make it quicker
         xPos+=4;
         if (xPos>0){
           //Send a value to the Arduino to change the intensity
           //of the RGB LED and take another reading
           myPort.write(xPos/4);
         } else {
           myPort.write(xPos);
         }
       }
     }
   }
 }
}

code formatter