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);
}

 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

/* ArduinoBasics: Sonar Project - Created by Scott C on 10 Jan 2013
 http://arduinobasics.blogspot.com/2013/01/arduino-basics-sonar-project-tutorial.html
 
 This project uses the Adafruit Motor shield library (copyright Adafruit Industries LLC, 2009
 this code is public domain, enjoy!)
 
 The HC-SR04 sensor uses some code from the following sources:
 From Virtualmix: http://goo.gl/kJ8Gl
 Modified by Winkle ink here: http://winkleink.blogspot.com.au/2012/05/arduino-hc-sr04-ultrasonic-distance.html
 And modified further by ScottC here: http://arduinobasics.blogspot.com/
 on 10 Nov 2012.
*/

#include <AFMotor.h>
#include <Servo.h> 

// DC hobby servo
Servo servo1;

/* The servo minimum and maximum angle rotation */
static const int minAngle = 0;
static const int maxAngle = 176;
int servoAngle;
int servoPos;
int servoPin = 10;


/* Define pins for HC-SR04 ultrasonic sensor */
#define echoPin A0 // Echo Pin = Analog Pin 0
#define trigPin A1 // Trigger Pin = Analog Pin 1
#define LEDPin 13 // Onboard LED
long duration; // Duration used to calculate distance
long HR_dist=0; // Calculated Distance
int HR_angle=0; // The angle in which the servo/sensor is pointing
int HR_dir=1; // Used to change the direction of the servo/sensor
int minimumRange=5; //Minimum Sonar range
int maximumRange=200; //Maximum Sonar Range

/*--------------------SETUP()------------------------*/
void setup() {
 //Begin Serial communication using a 9600 baud rate
 Serial.begin (9600);
 
 // Tell the arduino that the servo is attached to Digital pin 10.
 servo1.attach(servoPin);
 
 //Setup the trigger and Echo pins of the HC-SR04 sensor
 pinMode(trigPin, OUTPUT);
 pinMode(echoPin, INPUT);
 pinMode(LEDPin, OUTPUT); // Use LED indicator (if required)
}

/*----------------------LOOP()--------------------------*/
void loop() {
 
 /* check if data has been sent from the computer: */
 if (Serial.available()) {
 
 /* This expects an integer from the Serial buffer */
 HR_angle = Serial.parseInt();
 
 /* If the angle provided is 0 or greater, then move servo to that 
 position/angle and then get a reading from the ultrasonic sensor */
 if(HR_angle>-1){
 /*Make sure that the angle provided does not go beyond the capabilities
 of the Servo. This can also be used to calibrate the servo angle */
 servoPos = constrain(map(HR_angle, 0,180,minAngle,maxAngle),minAngle,maxAngle);
 servo1.write(servoPos);
 
 /* Call the getDistance function to take a reading from the Ultrasonic sensor */
 getDistance();
 }
 }
}

/*--------------------getDistance() FUNCTION ---------------*/
void getDistance(){ 
 
 /* The following trigPin/echoPin cycle is used to determine the
 distance of the nearest object by bouncing soundwaves off of it. */ 
 digitalWrite(trigPin, LOW); 
 delayMicroseconds(2); 

 digitalWrite(trigPin, HIGH);
 delayMicroseconds(10); 
 
 digitalWrite(trigPin, LOW);
 duration = pulseIn(echoPin, HIGH);
 
 //Calculate the distance (in cm) based on the speed of sound.
 HR_dist = duration/58.2;
 
 /*Send the reading from the ultrasonic sensor to the computer */
 if (HR_dist >= maximumRange || HR_dist <= minimumRange){
 /* Send a 0 to computer and Turn LED ON to indicate "out of range" */
 Serial.println("0");
 digitalWrite(LEDPin, HIGH); 
 } else {
 /* Send the distance to the computer using Serial protocol, and
 turn LED OFF to indicate successful reading. */
 Serial.println(HR_dist);
 digitalWrite(LEDPin, LOW);
 }
}

 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

/* Created by ScottC on 10 Jan 2013 
 http://arduinobasics.blogspot.com/2013/01/arduino-basics-sonar-project-tutorial.html
*/

import processing.serial.*;

int distance;
int angle=0;
int direction=1;

int[] alphaVal = new int[100]; // used to fade the lines
int[] distance2 = new int[100]; // used to store the line lengths
int lineSize = 4; // line length multiplier (makes it longer)

String comPortString;
Serial comPort;

/*---------------------SETUP---------------------------*/
void setup( ) {
 size(displayWidth,displayHeight); //allows fullscreen view
 smooth();
 background(0); // set the background to black
 
 /*Open the serial port for communication with the Arduino
 Make sure the COM port is correct - I am using COM port 8 */
 comPort = new Serial(this, "COM8", 9600);
 comPort.bufferUntil('\n'); // Trigger a SerialEvent on new line 
 
 /*Initialise the line alphaValues to 0 (ie not visible) */
 for(int i=0; i<91; i++){
 alphaVal[i] = 0;
 }
}
 
/*---------------------DRAW-----------------*/
void draw( ) {
 background(0); //clear the screen
 
 /*Draw each line and dot */
 for(int i=0; i<91; i++){
 
 /*Gradually fade each line */
 alphaVal[i]=alphaVal[i]-4;
 
 /*Once it gets to 0, keep it there */
 if(alphaVal[i]<0){
 alphaVal[i]=0;
 }
 
 /*The colour of the line will change depending on the distance */
 stroke(255,distance2[i],0,alphaVal[i]);
 
 /* Use a line thickness of 2 (strokeweight) to draw the line that fans
 out from the bottom center of the screen. */
 strokeWeight(2);
 line(width/2, height, (width/2)-cos(radians(i*2))*(distance2[i]*lineSize), height-sin(radians(i*2))*(distance2[i]*lineSize));
 
 /* Draw the white dot at the end of the line which does not fade */
 stroke(255);
 strokeWeight(1);
 ellipse((width/2)-cos(radians(i*2))*(distance2[i]*lineSize), height-sin(radians(i*2))*(distance2[i]*lineSize),5,5);
 }
}

/* A mouse press starts the scan. There is no stop button */
void mousePressed(){
 sendAngle();
}

/*When the computer receives a value from the Arduino, it will update the line positions */
void serialEvent(Serial cPort){
 comPortString = cPort.readStringUntil('\n');
 if(comPortString != null) {
 comPortString=trim(comPortString);
 
 /* Use the distance received by the Arduino to modify the lines */
 distance = int(map(Integer.parseInt(comPortString),1,200,1,height));
 drawSonar(angle,distance);

 /* Send the next angle to be measured by the Arduino */ 
 sendAngle();
 }
}

/*---------------------------sendAngle() FUNCTION----------------*/
void sendAngle(){
 //Send the angle to the Arduino. The fullstop at the end is necessary.
 comPort.write(angle+".");
 
 /*Increment the angle for the next time round. Making sure that the angle sent
 does not exceed the servo limits. The "direction" variable allows the servo
 to have a sweeping action.*/
 angle=angle+(2*direction);
 if(angle>178||angle<1){
 direction=direction*-1;
 }
}

/*-----------------sketchFullScreen(): Allows for FullScreen view------*/
boolean sketchFullScreen() {
 return true;
}

/*----------------- drawSonar(): update the line/dot positions---------*/
void drawSonar(int sonAngle, int newDist){
 alphaVal[sonAngle/2] = 180;
 distance2[sonAngle/2] = newDist;
}

 

 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

/* -------------------------------------------------------
Analog IR Temperature Gauge: written by ScottC on 1st Dec 2012.
http://arduinobasics.blogspot.com/2012/12/arduino-basics-analog-ir-temperature.html


 * Some of the code was adapted from a sketch by Andy Gelme (@geekscape)
 * For more information on using the IRTEMP 
 see www.freetronics.com/irtemp
 
 * IRTemp library uses an Arduino interrupt:
 * If PIN_CLOCK = 2, then Arduino interrupt 0 is used
 * If PIN_CLOCK = 3, then Arduino interrupt 1 is used
 ---------------------------------------------------------*/

#include "IRTemp.h"
#include <Servo.h> 

Servo servo1;
static const byte PIN_DATA = 2;
static const byte PIN_CLOCK = 3; // Must be either pin 2 or pin 3
static const byte PIN_ACQUIRE = 4;

static const bool SCALE=false; // Celcius: false, Farenheit: true

/* Used to capture the temperature from the IRTEMP sensor */
float irTemperature;
int temp;

/* The minimum and maximum temperatures on the gauge. */
static const int minTemp = -45;
static const int maxTemp = 135;


/* The servo minimum and maximum angle rotation */
static const int minAngle = 0;
static const int maxAngle = 175;
int servoPos;

IRTemp irTemp(PIN_ACQUIRE, PIN_CLOCK, PIN_DATA);



/*----------------------SETUP----------------------*/

void setup(void) {
 
 servo1.attach(9); // turn on servo
}


/*-----------------------LOOP-----------------------*/

void loop(void) {
 irTemperature = irTemp.getIRTemperature(SCALE);
 printTemperature("IR", irTemperature);

 /* If you want the ambient temperature instead - then use the code below. */
 //float ambientTemperature = irTemp.getAmbientTemperature(SCALE);
 //printTemperature("Ambient", ambientTemperature);

}

/*-----------printTemperature function---------------*/

void printTemperature(char *type, float temperature) {
 
 temp=(int) temperature;
 servoPos = constrain(map(temp, minTemp,maxTemp,minAngle,maxAngle),minAngle,maxAngle);
 
 if (isnan(temperature)) {
 //is not a number, do nothing
 }
 else {
 
 /* To test the minimum angle insert the code below */
 //servoPos = minAngle;
 
 /*To test the maximum angle, insert the code below */
 //servoPos = maxAngle;

 /* Rotate servo to the designated position */
 servo1.write(servoPos);
 }
}

 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

/*
 HC-SR04 Ping distance sensor:
 VCC to arduino 5v 
 GND to arduino GND
 Echo to Arduino pin 7 
 Trig to Arduino pin 8
 
 This sketch originates from Virtualmix: http://goo.gl/kJ8Gl
 Has been modified by Winkle ink here: http://winkleink.blogspot.com.au/2012/05/arduino-hc-sr04-ultrasonic-distance.html
 And modified further by ScottC here: http://arduinobasics.blogspot.com.au/2012/11/arduinobasics-hc-sr04-ultrasonic-sensor.html
 on 10 Nov 2012.
 */


#define echoPin 7 // Echo Pin
#define trigPin 8 // Trigger Pin
#define LEDPin 13 // Onboard LED

int maximumRange = 200; // Maximum range needed
int minimumRange = 0; // Minimum range needed
long duration, distance; // Duration used to calculate distance

void setup() {
 Serial.begin (9600);
 pinMode(trigPin, OUTPUT);
 pinMode(echoPin, INPUT);
 pinMode(LEDPin, OUTPUT); // Use LED indicator (if required)
}

void loop() {
/* The following trigPin/echoPin cycle is used to determine the
 distance of the nearest object by bouncing soundwaves off of it. */ 
 digitalWrite(trigPin, LOW); 
 delayMicroseconds(2); 

 digitalWrite(trigPin, HIGH);
 delayMicroseconds(10); 
 
 digitalWrite(trigPin, LOW);
 duration = pulseIn(echoPin, HIGH);
 
 //Calculate the distance (in cm) based on the speed of sound.
 distance = duration/58.2;
 
 if (distance >= maximumRange || distance <= minimumRange){
 /* Send a negative number to computer and Turn LED ON 
 to indicate "out of range" */
 Serial.println("-1");
 digitalWrite(LEDPin, HIGH); 
 }
 else {
 /* Send the distance to the computer using Serial protocol, and
 turn LED OFF to indicate successful reading. */
 Serial.println(distance);
 digitalWrite(LEDPin, LOW); 
 }
 
 //Delay 50ms before next reading.
 delay(50);
}

 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

/* The following Processing Sketch was created by ScottC on
 the 10 Nov 2012 : http://arduinobasics.blogspot.com/
 
 Inspired by this Processing sketch by Daniel Shiffman:
 http://processing.org/learning/basics/sinewave.html
 
*/
import processing.serial.*;


int numOfShapes = 60; // Number of squares to display on screen 
int shapeSpeed = 2; // Speed at which the shapes move to new position
 // 2 = Fastest, Larger numbers are slower

//Global Variables 
Square[] mySquares = new Square[numOfShapes];
int shapeSize, distance;
String comPortString;
Serial myPort;

/* -----------------------Setup ---------------------------*/
void setup(){
 size(displayWidth,displayHeight); //Use entire screen size.
 smooth(); // draws all shapes with smooth edges.
 
 /* Calculate the size of the squares and initialise the Squares array */
 shapeSize = (width/numOfShapes); 
 for(int i = 0; i<numOfShapes; i++){
 mySquares[i]=new Square(int(shapeSize*i),height-40);
 }
 
 /*Open the serial port for communication with the Arduino
 Make sure the COM port is correct - I am using COM port 8 */
 myPort = new Serial(this, "COM8", 9600);
 myPort.bufferUntil('\n'); // Trigger a SerialEvent on new line
}

/* ------------------------Draw -----------------------------*/
void draw(){
 background(0); //Make the background BLACK
 delay(50); //Delay used to refresh screen
 drawSquares(); //Draw the pattern of squares
}


/* ---------------------serialEvent ---------------------------*/
void serialEvent(Serial cPort){
 comPortString = cPort.readStringUntil('\n');
 if(comPortString != null) {
 comPortString=trim(comPortString);
 
 /* Use the distance received by the Arduino to modify the y position
 of the first square (others will follow). Should match the
 code settings on the Arduino. In this case 200 is the maximum
 distance expected. The distance is then mapped to a value
 between 1 and the height of your screen */
 distance = int(map(Integer.parseInt(comPortString),1,200,1,height));
 if(distance<0){
 /*If computer receives a negative number (-1), then the
 sensor is reporting an "out of range" error. Convert all
 of these to a distance of 0. */
 distance = 0;
 }
 }
}


/* ---------------------drawSquares ---------------------------*/
void drawSquares(){
 int oldY, newY, targetY, redVal, blueVal;
 
 /* Set the Y position of the 1st square based on 
 sensor value received */
 mySquares[0].setY((height-shapeSize)-distance);
 
 /* Update the position and colour of each of the squares */
 for(int i = numOfShapes-1; i>0; i--){
 /* Use the previous square's position as a target */
 targetY=mySquares[i-1].getY();
 oldY=mySquares[i].getY();
 
 if(abs(oldY-targetY)<2){
 newY=targetY; //This helps to line them up
 }else{
 //calculate the new position of the square
 newY=oldY-((oldY-targetY)/shapeSpeed);
 }
 //Set the new position of the square
 mySquares[i].setY(newY);
 
 /*Calculate the colour of the square based on its
 position on the screen */
 blueVal = int(map(newY,0,height,0,255));
 redVal = 255-blueVal;
 fill(redVal,0,blueVal);
 
 /* Draw the square on the screen */
 rect(mySquares[i].getX(), mySquares[i].getY(),shapeSize,shapeSize);
 }
}

/* ---------------------sketchFullScreen---------------------------*/
// This puts processing into Full Screen Mode
boolean sketchFullScreen() {
 return true;
}

/* ---------------------CLASS: Square ---------------------------*/
class Square{
 int xPosition, yPosition;
 
 Square(int xPos, int yPos){
 xPosition = xPos;
 yPosition = yPos;
 }
 
 int getX(){
 return xPosition;
 }
 
 int getY(){
 return yPosition;
 }
 
 void setY(int yPos){
 yPosition = yPos;
 }
}

 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

// OLED Slideshow: Arduino Sketch written by ScottC 21/07/2012

#include <Wire.h>
#include <SeeedGrayOLED.h> //From http://garden.seeedstudio.com/images/c/c4/SeeedGrayOLED.zip
#include <avr/pgmspace.h>

int counter=0;
 
void setup()
{
 //Allow communication to OLED
 Wire.begin(); 
 
 //Allow Serial communication between Freetronics Eleven and Computer
 Serial.begin(28800);
 
 //Initialise the OLED
 SeeedGrayOled.init();
 //Clear the OLED display
 SeeedGrayOled.clearDisplay();
 //Set to vertical mode - horizontal mode doesn't work with this example
 SeeedGrayOled.setVerticalMode();
 
}
 
void loop(){
 //Listen for Serial comunication
 while (Serial.available()>0) {
 // Read data and send directly to the OLED
 sendMyData(Serial.read());
 counter++;
 
 //When counter reaches 4608 pixels, the picture is complete.
 if(counter>4607){
 //Insert delay to allow viewing of picture.
 delay(4000);
 Serial.println("End of Transmission");
 
 //Reset the counter for the next picture
 counter=0; 
 }
 }
}

// This function was adapted from the SEEED Gray OLED driver so that
// character bytes could be sent directly to the OLED.
void sendMyData(unsigned char Data){
 Wire.beginTransmission(SeeedGrayOLED_Address); // begin I2C transmission
 Wire.send(SeeedGrayOLED_Data_Mode); // data mode
 Wire.send(Data);
 Wire.endTransmission();
}


// This function was adapted from the SEEED Gray OLED driver so that
// commands could be sent directly to the OLED. 
// NOT USED IN THIS EXAMPLE ***********************
void sendMyCommand(unsigned char Cmd){
 Wire.beginTransmission(SeeedGrayOLED_Address); // begin I2C communication
 Wire.send(SeeedGrayOLED_Command_Mode); // Set OLED Command mode
 Wire.send(Cmd);
 Wire.endTransmission(); // End I2C communication
}

  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

/* OLED Slideshow: Processing Sketch Written by ScottC 21/7/2012 

References:
Getting Pixels: http://www.learningprocessing.com/examples/chapter-15/example-15-7/
Greyscale conversion = http://www.openprocessing.org/sketch/60336
*/


import processing.serial.*; /* Needed for Serial Communication */

/* Global variables */
Serial comPort;
String [] comPortList;
String comPortString;
PImage img;
char[] tempGrey=new char[4609];
int startOffset=0;
ArrayList picNames;
int curLoop=1;
int totalPics=0;
int curPicNum=0;
boolean toggleSend=true;
boolean sendBouncer=true;

//Change maxLoops to a number > 1 if you want the pictures to loop.
int maxLoops=1;


void setup() {
 //The size of the display is critical (must match the OLED)
 size(96, 96);
 //setup Serial
 comPortList = Serial.list(); 
 if(comPortList.length>0){
 //baud rates greater than 28800 may produce unexpected results
 comPort = new Serial(this, comPortList[0], 28800);
 comPort.bufferUntil('\n');
 } else{
 println("NO COM PORTS AVAILABLE");
 }
 
 //Create an Array of pictures
 picNames=new ArrayList();
 picNames.add("Picture1.bmp");
 picNames.add("Picture2.bmp");
 picNames.add("Picture3.bmp");
 picNames.add("Picture4.bmp");
 // for more pictures just keep adding them to the list.
 //The actual pictures must be located in the data folder of this project.
 //Select Sketch/Add File to add the files to this folder.
 //Make sure that the name of pictures match the names above.
 
 //Get the total number of pictures added
 totalPics=picNames.size();
}

void draw(){
 if(toggleSend && sendBouncer){
 
 // Debugging code: print("STARTED:");
 // Debugging code: println(picNames.get(curPicNum));
 
 sendImage((String)picNames.get(curPicNum)); //Send the picture to the OLED
 toggleSend=false; //temporarily stop sending any more pictures until authorised
 curPicNum++; //increment in preparation for the next picture
 
 if(curPicNum==totalPics){
 curPicNum=0; //go back to the first picture
 curLoop++; //increment the loop counter
 }
 if(curLoop>maxLoops){
 sendBouncer=false; //Stop any further looping
 println("ANIMATION COMPLETE");
 }
 }
}


void sendImage(String imgName){
 img = loadImage(imgName);
 image(img,0,0,width,height);
 loadPixels();
 int counter=0; 
 for (int x = 0; x < width; x=x+2) {
 for (int y = 0; y < height; y++) {
 counter++;
 int PixLoc = x + y*height; // this reads down then across2.
 //Left pixel nibble
 int Pix1=(round((red(pixels[PixLoc])*0.222+green(pixels[PixLoc])*0.707+blue(pixels[PixLoc])*0.071)))/16;
 //Right pixel nibble
 int Pix2=(round((red(pixels[PixLoc+1])*0.222+green(pixels[PixLoc+1])*0.707+blue(pixels[PixLoc+1])*0.071)))/16;
 //Shift the byte <<4 for the left pixel nibble
 int PixShift1=Pix1<<4;
 //Combine both nibbles to form a byte
 int PixFin = PixShift1+Pix2;
 byte PixByteFin=byte(PixFin);
 //Assign this byte to the tempGrey array
 tempGrey[counter] = char(PixByteFin);
 }
 }
 sendSerial(tempGrey); //Send the image data through the Serial COM Port/
}


//This function will send the byte/Char array to the Freetronics
//Eleven or Arduino.
void sendSerial(char[] Data){
 for(int i=0; i<4608; i++){
 //Needs an offset to get picture to align to screen properly
 //only needs to do this once.
 if(startOffset==0){
 i=i+6;
 startOffset++;
 }
 //Send the picture data to the Freetronics Eleven / Arduino
 comPort.write(Data[i]);
 }
}


//This function will wait for a response from the Freetronics
//Eleven or Arduino before sending any further pictures.
 void serialEvent (Serial myPort) {
 // get the ASCII string:
 String inString = myPort.readStringUntil('\n');
 if (inString != null) {
 println(inString);
 toggleSend=true; // Allow the next picture to be sent
 }
 }

 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

/* This program was created by ScottC on 9/5/2012 to receive serial 
signals from a computer to turn on/off  1-9 LEDs */

void setup() {                
  // initialize the digital pins as an output.
  pinMode(2, OUTPUT);
  pinMode(3, OUTPUT);
  pinMode(4, OUTPUT);
  pinMode(5, OUTPUT);
  pinMode(6, OUTPUT);
  pinMode(7, OUTPUT);
  pinMode(8, OUTPUT);
  pinMode(9, OUTPUT);
  pinMode(10, OUTPUT);
// Turn the Serial Protocol ON
  Serial.begin(9600);
}

void loop() {
  byte byteRead;

   /*  check if data has been sent from the computer: */
  if (Serial.available()) {
  
    /* read the most recent byte */
    byteRead = Serial.read();
    //You have to subtract '0' from the read Byte to convert from text to a number.
    byteRead=byteRead-'0';
    
    //Turn off all LEDS
    for(int i=2; i<11; i++){
      digitalWrite(i, LOW);
    }
    
    if(byteRead>0){
      //Turn on the relevant LEDs
      for(int i=1; i<(byteRead+1); i++){
        digitalWrite(i+1, HIGH);
      }
    }
  }
}

 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

//Created by ScottC on 12/05/2012 to send mouse coordinates to Arduino

import processing.serial.*;

// Global variables
int new_sX, old_sX;
int nX, nY;
Serial myPort;

// Setup the Processing Canvas
void setup(){
  size( 800, 400 );
  strokeWeight( 10 );
 
  //Open the serial port for communication with the Arduino
  //Make sure the COM port is correct
  myPort = new Serial(this, "COM6", 9600);
  myPort.bufferUntil('\n'); 
}

// Draw the Window on the computer screen
void draw(){
  
  // Fill canvas grey
  background( 100 );
    
  // Set the stroke colour to white
  stroke(255); 
  
  // Draw a circle at the mouse location
  ellipse( nX, nY, 10, 10 );

  //Draw Line from the top of the page to the bottom of the page
  //in line with the mouse.
  line(nX,0,nX,height);  
}


// Get the new mouse location and send it to the arduino
void mouseMoved(){
  nX = mouseX;
  nY = mouseY; 
  
  //map the mouse x coordinates to the LEDs on the Arduino.
  new_sX=(int)map(nX,0,800,0,10);

  if(new_sX==old_sX){
    //do nothing
  } else {
    //only send values to the Arduino when the new X coordinates are different.
    old_sX = new_sX;
    myPort.write(""+new_sX);
  }
}

 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

style="color: blue;">import processing.serial.*;

style="color: blue;">import java.io.*;

style="color: rgb(43, 145, 175);">int mySwitch=0;

style="color: rgb(43, 145, 175);">int counter=0;
String [] subtext;
Serial myPort;



style="color: rgb(43, 145, 175);">void setup(){
 
style="color: green;">//Create a switch that will control the frequency of text file reads.
 
style="color: green;">//When mySwitch=1, the program is setup to read the text file.
 
style="color: green;">//This is turned off when mySwitch = 0
 mySwitch=1;
 
 
style="color: green;">//Open the serial port for communication with the Arduino
 
style="color: green;">//Make sure the COM port is correct
 myPort = 
style="color: blue;">new Serial(this, 
style="color: rgb(163, 21, 21);">"COM6", 9600);
 myPort.bufferUntil(
style="color: rgb(163, 21, 21);">'\n');
}


style="color: rgb(43, 145, 175);">void draw() {
 
style="color: blue;">if (mySwitch>0){
 
style="color: green;">/*The readData function can be found later in the code.

style="color: green;"> This is the call to read a CSV file on the computer hard-drive. */
 readData(
style="color: rgb(163, 21, 21);">"D:/mySensorData.txt");
 
 
style="color: green;">/*The following switch prevents continuous reading of the text file, until

style="color: green;"> we are ready to read the file again. */
 mySwitch=0;
 }
 
style="color: green;">/*Only send new data. This IF statement will allow new data to be sent to

style="color: green;"> the arduino. */
 
style="color: blue;">if(counter<subtext.length){
 
style="color: green;">/* Write the next number to the Serial port and send it to the Arduino 

style="color: green;"> There will be a delay of half a second before the command is

style="color: green;"> sent to turn the LED off : myPort.write('0'); */
 myPort.write(subtext[counter]);
 delay(500);
 myPort.write(
style="color: rgb(163, 21, 21);">'0');
 delay(100);
 
style="color: green;">//Increment the counter so that the next number is sent to the arduino.
 counter++;
 } 
style="color: blue;">else{
 //If the text file has run out of numbers, then read the text file again in 5 seconds.
 delay(5000);
 mySwitch=1;
 }
} 



style="color: green;">/* The following function will read from a CSV or TXT file */

style="color: rgb(43, 145, 175);">void readData(String myFileName){
 
 File file=
style="color: blue;">new File(myFileName);
 BufferedReader br=
style="color: blue;">null;
 
 try{
 br=
style="color: blue;">new BufferedReader(
style="color: blue;">new FileReader(file));
 String text=
style="color: blue;">null;
 
 
style="color: green;">/* keep reading each line until you get to the end of the file */
 
style="color: blue;">while((text=br.readLine())!=
style="color: blue;">null){
 /* Spilt each line up into bits and pieces using a comma as a separator */
 subtext = splitTokens(text,
style="color: rgb(163, 21, 21);">",");
 }
 }
style="color: blue;">catch(FileNotFoundException e){
 e.printStackTrace();
 }
style="color: blue;">catch(IOException e){
 e.printStackTrace();
 }
style="color: blue;">finally{
 try {
 
style="color: blue;">if (br != null){
 br.close();
 }
 } 
style="color: blue;">catch (IOException e) {
 e.printStackTrace();
 }
 }
}

 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

style="color: green;">/* This program was created by ScottC on 8/5/2012 to receive serial 

style="color: green;">signals from a computer to turn on/off 1-9 LEDs */


style="color: rgb(43, 145, 175);">void setup() { 
 
style="color: green;">// initialize the digital pins as an output.
 pinMode(2, OUTPUT);
 pinMode(3, OUTPUT);
 pinMode(4, OUTPUT);
 pinMode(5, OUTPUT);
 pinMode(6, OUTPUT);
 pinMode(7, OUTPUT);
 pinMode(8, OUTPUT);
 pinMode(9, OUTPUT);
 pinMode(10, OUTPUT);

style="color: green;">// Turn the Serial Protocol ON
 Serial.begin(9600);
}


style="color: rgb(43, 145, 175);">void loop() {
 
style="color: rgb(43, 145, 175);">byte byteRead;

 
style="color: green;">/* check if data has been sent from the computer: */
 
style="color: blue;">if (Serial.available()) {
 
 
style="color: green;">/* read the most recent byte */
 byteRead = Serial.read();
 
style="color: green;">//You have to subtract '0' from the read Byte to convert from text to a number.
 byteRead=byteRead-
style="color: rgb(163, 21, 21);">'0';
 
 
style="color: green;">//Turn off all LEDs if the byte Read = 0
 
style="color: blue;">if(byteRead==0){
 
style="color: green;">//Turn off all LEDS
 digitalWrite(2, LOW);
 digitalWrite(3, LOW);
 digitalWrite(4, LOW);
 digitalWrite(5, LOW);
 digitalWrite(6, LOW);
 digitalWrite(7, LOW);
 digitalWrite(8, LOW);
 digitalWrite(9, LOW);
 digitalWrite(10, LOW);
 }
 
 
style="color: green;">//Turn LED ON depending on the byte Read.
 
style="color: blue;">if(byteRead>0){
 digitalWrite((byteRead+1), HIGH); 
style="color: green;">// set the LED on
 }
 }
 }

 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

style="color: rgb(0, 128, 0);">/* TextFile Sender: Written by Scott C on 5th April 2013

style="color: rgb(0, 128, 0);"> using Processing Version 2.0b8 */

import processing.serial.*;

Serial comPort;

style="color: rgb(43, 145, 175);">int counter=0; 
style="color: rgb(0, 128, 0);">// Helps to keep track of values sent.

style="color: rgb(43, 145, 175);">int numItems=0; 
style="color: rgb(0, 128, 0);">//Keep track of the number of values in text file
boolean sendStrings=
style="color: rgb(0, 0, 255);">false; 
style="color: rgb(0, 128, 0);">//Turns sending on and off
StringLoader sLoader; 
style="color: rgb(0, 128, 0);">//Used to send values to Arduino


style="color: rgb(43, 145, 175);">void setup(){
 comPort = 
style="color: rgb(0, 0, 255);">new Serial(
style="color: rgb(0, 0, 255);">this, Serial.list()[0], 9600);
 background(255,0,0); 
style="color: rgb(0, 128, 0);">//Start with a Red background
}


style="color: rgb(43, 145, 175);">void draw(){
}



style="color: rgb(43, 145, 175);">void mousePressed() {
 
style="color: rgb(0, 128, 0);">//Toggle between sending values and not sending values
 sendStrings=!sendStrings;
 
 
style="color: rgb(0, 128, 0);">//If sendStrings is True - then send values to Arduino
 
style="color: rgb(0, 0, 255);">if(sendStrings){
 background(0,255,0); 
style="color: rgb(0, 128, 0);">//Change the background to green
 
 
style="color: rgb(0, 128, 0);">/*When the background is green, transmit

style="color: rgb(0, 128, 0);"> text file values to the Arduino */
 sLoader=
style="color: rgb(0, 0, 255);">new StringLoader();
 sLoader.start();
 }
style="color: rgb(0, 0, 255);">else{
 background(255,0,0); 
style="color: rgb(0, 128, 0);">//Change background to red
 
style="color: rgb(0, 128, 0);">//Reset the counter
 counter=0;
 }
}




style="color: rgb(0, 128, 0);">/*============================================================*/

style="color: rgb(0, 128, 0);">/* The StringLoader class imports data from a text file

style="color: rgb(0, 128, 0);"> on a new Thread and sends each value once every half second */

style="color: rgb(0, 0, 255);">public 
style="color: rgb(0, 0, 255);">class 
style="color: rgb(43, 145, 175);">StringLoader extends Thread{
 
 
style="color: rgb(0, 0, 255);">public StringLoader(){
 
style="color: rgb(0, 128, 0);">//default constructor
 }
 
 
style="color: rgb(0, 0, 255);">public 
style="color: rgb(43, 145, 175);">void run() {
 String textFileLines[]=loadStrings(
style="color: rgb(163, 21, 21);">"d:/mySensorData.txt");
 String lineItems[]=splitTokens(textFileLines[0], 
style="color: rgb(163, 21, 21);">",");
 numItems=lineItems.length;
 
style="color: rgb(0, 0, 255);">for(
style="color: rgb(43, 145, 175);">int i = counter; i<numItems; i++){
 comPort.write(lineItems[i]);
 delay(500);
 comPort.write(
style="color: rgb(163, 21, 21);">"0");
 }
 counter=numItems;
 }
}