Processing Forum

Screen name:
evilc66

evilc66's Profile

1 Posts

3 Responses

0 Followers

Activity Trend

Last 30 days

Loading Chart...

Show:

Expanded view
List view

Having trouble passing serial data from Arduino to Processing

[4 Replies]
- 08-Nov-2012 02:45 PM
- Forum: Integration and Hardware
First post here! I'm a little wet behind the ears when it comes to Processing, so go easy on me. Let me give you a little background on what I'm doing:

I have an Arduino that is controlling 4 LEDs on separate analog output channels. On the PC side, I have a Processing sketch that I have cobbled together from code I have found on the net (had no idea about Processing when I started, but I'm learning as I go) that has 4 sliders that adjusts the brightness of each LED channel on the Arduino (broadcast over serial). It also allows me to save the settings to EEPROM on the Arduino. So far, so good. The problem I'm having is that when I start the Processing sketch, it defaults the channel values to zero, bringing the LEDs to zero output, regardless of the original state. The Arduino recalls the EEPROM values for each channel on power up, and I would like the Processing sketch to be able to read those values as it starts, and set the sliders in the program according to said values.

The character 'Q' is sent by the Processing sketch to tell the Arduino to send the relevant values over serial (the Arduino is typically only receiving during normal operation). The Arduino spits the right info out, as seen on the serial terminal, but the Processing sketch doesn't seem to be parsing the data correctly. I have used the same basic construct to read the serial data on the Arduino and Processing sketch, but it's still not happy. The class that deals with the sliders deals with the data properly, as I have tried feeding it fixed numbers. It's just the serial side of things that's giving me grief.

On to the code. There are some commented out sections of code, as well as some stuff in there that is unnecessary that was used just for testing.

First up, the Arduino code:
1. #include <Wire.h>
2. #include <EEPROM.h>
4. #define DS1307_ADDRESS 0x68
6. byte rVal, gVal, bVal, wVal;
8. int EEred=0;
9. int EEgreen=1;
10. int EEblue=2;
11. int EEwhite=3;
12. byte rPin=6;
13. byte gPin=9;
14. byte bPin=10;
15. int wPin=11;
17. int second, minute, hour, weekDay, monthDay, month, year;
18. int onMin=00;
19. int onHour=10;
20. int offMin=00;
21. int offHour=21;
23. int moonLights=15;
27. void setup()
28. {
29. // declare the serial comm at 9600 baud rate
30. Serial.begin(9600);
32. rVal=EEPROM.read(EEred);
33. gVal=EEPROM.read(EEgreen);
34. bVal=EEPROM.read(EEblue);
35. wVal=EEPROM.read(EEwhite);
36. /*
37. Serial.println("EEPROM");
38. Serial.println(rVal);
39. Serial.println(gVal);
40. Serial.println(bVal);
41. Serial.println(wVal);
42. */
43. // hour = 15;
45. Wire.begin();
46. }
48. void loop()
49. {
50. readTime();
52. onOff();
55. if(Serial.available()!=0)
56. {
57. // call the returned value from GetFromSerial() function
58. switch(GetFromSerial())
59. {
60. case 'R':
61. rVal=GetFromSerial();
62. break;
64. case 'G':
65. gVal=GetFromSerial();
66. break;
68. case 'B':
69. bVal=GetFromSerial();
70. break;
72. case 'W':
73. wVal=GetFromSerial();
74. break;
76. case 'S':
77. EEPROM.write(EEred, rVal);
78. EEPROM.write(EEgreen, gVal);
79. EEPROM.write(EEblue, bVal);
80. EEPROM.write(EEwhite, wVal);
81. break;
83. case 'Q':
84. Serial.flush();
85. /* Serial.write('R');
86. Serial.write(rVal);
87. Serial.write('G');
88. Serial.write(gVal);
89. Serial.write('B');
90. Serial.write(bVal);
91. Serial.write('W');
92. Serial.write(wVal);
93. */
94. delay(100);
95. Serial.print('R');
96. Serial.print(rVal, DEC);
97. Serial.print('G');
98. Serial.print(gVal, DEC);
99. Serial.print('B');
100. Serial.print(bVal, DEC);
101. Serial.print('W');
102. Serial.println(wVal, DEC);
103. break;
104. }
105. }
107. /*
108. delay(2000);
109. if(hour>22)
110. {
111. hour=0;
112. }
113. else
114. {
115. hour++;
116. }
117. Serial.println(hour);
118. */
119. }
121. // read the serial port
122. int GetFromSerial()
123. {
124. while (Serial.available()<=0) {
125. }
126. return Serial.read();
127. }
129. byte bcdToDec(byte val)
130. {
131. // Convert binary coded decimal to normal decimal numbers
132. return ( (val/16*10) + (val) );
133. }
135. void readTime()
136. {
137. // Reset the register pointer
138. Wire.beginTransmission(DS1307_ADDRESS);
140. byte zero = 0x00;
141. Wire.write(zero);
142. Wire.endTransmission();
144. Wire.requestFrom(DS1307_ADDRESS, 7);
146. second = bcdToDec(Wire.read());
147. minute = bcdToDec(Wire.read());
148. hour = bcdToDec(Wire.read() & 0b111111); //24 hour time
149. weekDay = bcdToDec(Wire.read()); //0-6 -> sunday - Saturday
150. monthDay = bcdToDec(Wire.read());
151. month = bcdToDec(Wire.read());
152. year = bcdToDec(Wire.read());
153. }
155. void onOff()
156. {
157. if(hour>=onHour && hour<offHour)
158. {
159. analogWrite(rPin, rVal);
160. analogWrite(gPin, gVal);
161. analogWrite(bPin, bVal);
162. analogWrite(wPin, wVal);
163. }
164. else
165. {
166. analogWrite(rPin, 0);
167. analogWrite(gPin, 0);
168. analogWrite(bPin, moonLights);
169. analogWrite(wPin, 0);
170. }
171. }
Please excuse the commented out sections.

Next up, Processing:
1. import processing.serial.*;
2. Serial port;
4. sliderV sV1, sV2, sV3, sV4, sV5;
6. color cor;
7. int saveMe = 0;
8. int startup=0;
9. byte index=0;
10. int rVal, gVal, bVal, wVal;
12. void setup() {
13. size(500, 500);
15. println("Available serial ports:");
16. println(Serial.list());
18. // check on the output monitor wich port is available on your machine
19. port = new Serial(this, Serial.list()[2], 9600);
20. port.bufferUntil(' ');
22. getData();
24. // create 3 instances of the sliderV class
25. sV1 = new sliderV(50, 100, 90, 255, #FF0000, rVal);
26. sV2 = new sliderV(125, 100, 90, 255, #03FF00, gVal);
27. sV3 = new sliderV(200, 100, 90, 255, #009BFF, bVal);
28. sV4 = new sliderV(275, 100, 90, 255, #FFFFFF, wVal);
29. sV5 = new sliderV(350, 100, 90, 255, #5A5A5A, 100);
31. }
33. void draw() {
34. background(sV1.p, sV2.p, sV3.p);
36. text("MouseX", 10, 10);
37. text(mouseX, 60, 10);
38. text("MouseY", 10, 30);
39. text(mouseY, 60, 30);
40. text("SaveMe", 10, 50);
41. text(saveMe, 60, 50);
42. text(rVal, 10, 70);
43. text(gVal, 30, 70);
44. text(bVal, 50, 70);
45. text(wVal, 70, 70);
46. text(startup, 90, 70);
48. index=0;
49. sV1.render();
50. index=1;
51. sV2.render();
52. index=2;
53. sV3.render();
54. index=3;
55. sV4.render();
56. index=4;
57. sV5.render();
58. saveBox();
60. // send sync character
61. // send the desired value
62. port.write('R');
63. port.write(sV1.p);
64. port.write('G');
65. port.write(sV2.p);
66. port.write('B');
67. port.write(sV3.p);
68. port.write('W');
69. port.write(sV4.p);
70. port.write('F');
71. port.write(sV5.p);
72. if(saveMe == 1)
73. {
74. //delay(2000);
75. port.write('S');
76. saveMe=0;
77. }
78. }
81. void saveBox()
82. {
83. fill(20);
84. rect(5, 150, 40, -20);
85. fill(255);
86. text("Save", 11, 144);
88. if(mousePressed==true && mouseX>5 && mouseX<45 && mouseY>130 && mouseY<150)
89. {
90. saveMe=1;
91. }
92. }
95. /*
96. Slider Class - www.guilhermemartins.net
97. based on www.anthonymattox.com slider class
98. */
99. class sliderV {
100. int x, y, w, h, p;
101. color cor;
102. boolean slide;
104. sliderV (int _x, int _y, int _w, int _h, color _cor, int _p) {
105. x = _x;
106. y = _y;
107. w = _w;
108. h = _h;
109. p = _p;
110. cor = _cor;
111. slide = true;
112. }
114. void render()
115. {
116. fill(cor);
117. rect(x-1, y-4, w, h+10);
118. noStroke();
119. fill(0);
120. rect(x, h-p+y-5, w-2, 13);
121. fill(255);
122. text(p, x+2, h-p+y+6);
124. if (slide==true && mousePressed==true && mouseX<x+w && mouseX>x){
125. if ((mouseY<=y+h+150) && (mouseY>=y-150)) {
126. p = h-(mouseY-y);
127. if (p<0) {
128. p=0;
129. }
130. else if (p>h) {
131. p=h;
132. }
133. }
134. }
135. }
136. }
138. int GetFromSerial()
139. {
140. while (port.available()==0) {
141. }
142. return port.read();
143. }
145. void getData()
146. {
147. port.write('Q');
148. if(port.available() != 0)
149. {
150. switch(GetFromSerial())
151. {
152. case 'R':
153. rVal=GetFromSerial();
154. // println(rVal);
155. break;
156. case 'G':
157. gVal=GetFromSerial();
158. // println(gVal);
159. break;
160. case 'B':
161. bVal=GetFromSerial();
162. // println(bVal);
163. break;
164. case 'W':
165. wVal=GetFromSerial();
166. // println(wVal);
167. break;
168. }
169. }
170. /*
171. rVal=190;
172. gVal=16;
173. bVal=110;
174. wVal=15;
175. */
176. }
Any assistance you could give a n00b would be greatly appreciated.

«Prev
Next »