Processing Forum

Exporting Points Coordinate to Rhino for Grasshopper ( with DWG? )

[0 Replies]
- 24-Jan-2013 02:58 AM
- Forum: Contributed Library Questions
Hello Processing Community

I am trying to export the Coordinate and their color code of a list of points ( 2000-5000 ) to Rhino for Grasshopper analyzing. I have tried the beginRAW(), but it said "only supports lines and triangles". But I do not want them to have any kind of form when they are exported to Rhino. Any work around?

Thank you for all contribution!
3. //-----Importing Libraries-----Starts
4. import processing.opengl.*;
5. import peasy.*;
6. import peasy.org.apache.commons.math.*;
7. import peasy.org.apache.commons.math.geometry.*;
8. import toxi.processing.*;
9. import processing.dxf.*;
10. //-----Importing Libraries-----Ends
12. //-----Defining Vectors-----Starts
13. Vec3D globalDrift, dir, focusPoint;
14. Vector particles;
15. //-----Defining Vectors-----Ends
17. //-----Defining Planes-----Starts
18. Plane focalPlane;
19. //-----Defining Planes-----Ends
21. public float neighbor, viscosity, speed, turbulence, strokefactor, cameraRate, rebirthRadius, spread, spread_, independence, dofRatio, backcolour;
22. public int n;
23. public boolean paused, label, stopR, dxfExport;
25. PeasyCam cam;
26. CameraState state;
28. int focusX;
29. float focusPointx=0;
30. float focusPointy=0;
31. float focusPointz=0;
33. void setup() {
34. size(2200, 1300, OPENGL);
35. smooth();
36. frameRate(30);
37. cam = new PeasyCam(this, focusPointx, focusPointy, focusPointz, 1700);
38. state = cam.getState();
40. // {
41. // println("COM Ports");
42. // println(myPort.list());
43. // println("=========");
44. // myPort = new Serial(this, Serial.list()[5], 9600);
45. // }
47. setParameters();
48. makeGUI();
50. focusPoint = new Vec3D();
51. dir = new Vec3D();
52. globalDrift = new Vec3D(0, 1. / 3, 2. / 3);
54. particles = new Vector();
55. for (int i = 0; i < n; i++)
56. particles.add(new Particle());
57. }
59. void draw() {
61. Particle leader = (Particle) particles.get(0);
62. focusPoint = leader.position;
63. focusPointx = leader.position.x;
64. focusPointy= leader.position.y;
65. focusPointz= leader.position.z;
67. println(focusPoint);
68. translate(-focusPoint.x, -focusPoint.y, -focusPoint.z);
70. float[] camPosition = cam.getPosition();
71. focalPlane = new Plane(dir, new Vec3D(camPosition[0], camPosition[1], camPosition[2]));
73. background(backcolour);
74. noFill();
75. hint(DISABLE_DEPTH_TEST);
77. //--------------------- if export is TRUE
78. if (dxfExport) {
79. beginRaw(DXF, "output.dxf");
80. }
82. for (int i = 0; i < particles.size(); i++) {
83. Particle cur = ((Particle) particles.get(i));
84. if (!paused)
85. cur.update();
86. cur.draw();
87. }
89. if (particles.size() > n)
90. particles.setSize(n);
91. while (particles.size () < n)
92. particles.add(new Particle());
94. globalDrift.addSelf(
95. turbulence / neighbor,
96. turbulence / neighbor,
97. turbulence / neighbor);
99. // arduinoRead();
100. // println(spread);
101. // spread=spread_;
103. //--------------------- finish export and set dxfExport to FALSE
104. if (dxfExport) {
105. endRaw();
106. dxfExport = false;
107. }
109. //-----Camera Rotation-----Starts
110. float[] look = cam.getLookAt();
111. double disn = cam.getDistance();
112. float[]rot = cam.getRotations();
113. Rotation rotn = new Rotation(RotationOrder.XYZ,
114. (double)rot[0], (double)rot[1], (double)rot[2]);
115. if (!stopR) {
116. Rotation rotd = new Rotation(RotationOrder.XYZ, -.002, -.002, -.002);
117. Vector3D npos = new Vector3D(
118. (double)look[0], (double)look[1], (double)look[2]);
119. state = new CameraState(rotd.applyTo(rotn), npos, disn);
120. }
121. else {
122. Rotation rotd = new Rotation(RotationOrder.XYZ, -.0, -.0, -.0);
123. Vector3D npos = new Vector3D(
124. (double)look[0], (double)look[1], (double)look[2]);
125. state = new CameraState(rotd.applyTo(rotn), npos, disn);
126. }
127. cam.setState(state, 0);
128. }
130. //-----Camera Rotation-----Ends
132. Particle randomParticle() {
133. return ((Particle) particles.get((int) random(particles.size())));
134. }
136. void keyPressed() {
137. if (key == 'p')
138. paused = !paused;
139. if (key == 'l')
140. label = !label;
141. if (key == 'r')
142. stopR = !stopR;
143. switch (key) {
145. case 'x':
146. dxfExport = true;
147. println("DXF export complete!");
148. break;
149. }
150. }
154. //CLASS_PARTICLE---------------------------------------------------------
156. Vec3D centerForce = new Vec3D();
158. class Particle {
159. Vec3D position, velocity, force;
160. Vec3D localOffset;
161. int red, green, blue;
163. Particle() {
164. initialisePosition();
165. velocity = new Vec3D();
166. force = new Vec3D();
167. localOffset = Vec3D.randomVector();
169. red = (int) random(0, 255);
170. green = (int) random(0, 255);
171. blue = (int) random(0, 255);
172. }
174. void initialisePosition() {
175. position = Vec3D.randomVector();
176. position.scaleSelf(random(rebirthRadius));
177. if (particles.size() == 0)
178. position.addSelf(dir);
179. else
180. position.addSelf(randomParticle().position);
181. }
183. void draw() {
184. float distanceToFocalPlane = focalPlane.getDistanceToPoint(position);
185. distanceToFocalPlane *= 1 / dofRatio;
186. distanceToFocalPlane = constrain(distanceToFocalPlane, 1, 80);
187. strokeWeight(distanceToFocalPlane*strokefactor);
189. float r = red;
190. float g = green;
191. float b = blue;
193. stroke(r, g, b, constrain(255 / (distanceToFocalPlane * distanceToFocalPlane), 1, 255));
195. point(position.x, position.y, position.z);
197. if (label) {
198. textSize(8);
199. fill(constrain(255 / (distanceToFocalPlane * distanceToFocalPlane), 1, 255));
200. text(red, position.x, position.y, position.z);
201. text(green, position.x, position.y-14, position.z);
202. text(blue, position.x, position.y-28, position.z);
203. }
204. }
206. void addFlock() {
207. force.addSelf(
208. noise(
209. position.x / neighbor + globalDrift.x + localOffset.x * independence,
210. position.y / neighbor,
211. position.z / neighbor)
212. - .5,
213. noise(
214. position.x / neighbor,
215. position.y / neighbor + globalDrift.y + localOffset.y * independence,
216. position.z / neighbor)
217. - .5,
218. noise(
219. position.x / neighbor,
220. position.y / neighbor,
221. position.z / neighbor + globalDrift.z + localOffset.z * independence)
222. - .5);
223. }
224. void addVisco() {
225. force.addSelf(velocity.scale(-viscosity));
226. }
227. void addCen() {
228. centerForce.set(position);
229. centerForce.subSelf(dir);
230. float distanceToCenter = centerForce.magnitude();
231. centerForce.normalize();
232. centerForce.scaleSelf(-distanceToCenter / (spread * spread));
233. force.addSelf(centerForce);
234. }
235. void update() {
236. force.clear();
237. addFlock();
238. addVisco();
239. addCen();
240. velocity.addSelf(force); // mass = 1
241. position.addSelf(velocity.scale(speed));
242. }
243. }
246. //CLASS_GUI-------------------------------------
250. import controlP5.*;
252. public ControlP5 control;
253. public ControlWindow w;
255. void setParameters() {
256. n = 4000;
257. dofRatio = 75;
258. neighbor = 300;
259. speed = 60;
260. viscosity = .35;
261. spread = 100;
262. independence = .4;
263. rebirthRadius = 350;
264. turbulence =2.8;
265. strokefactor = 8.5;
266. cameraRate = 0;
267. backcolour = 0;
268. }
270. void makeGUI() {
271. control = new ControlP5(this);
273. w = control.addControlWindow("controlWindow", 10, 10, 350, 700);
274. w.hideCoordinates();
275. w.setTitle("Particle Control");
277. int y = 0;
278. control.addSlider("n", 1, 30000, n, 10, y += 16, 256, 14).setWindow(w);
279. control.addSlider("dofRatio", 1, 2000, dofRatio, 10, y += 16, 256, 14).setWindow(w);
280. control.addSlider("neighbor", 1, width * 2, neighbor, 10, y += 16, 256, 14).setWindow(w);
281. control.addSlider("speed", 0, 100, speed, 10, y += 16, 256, 14).setWindow(w);
282. control.addSlider("viscosity", 0, 1, viscosity, 10, y += 16, 256, 14).setWindow(w);
283. control.addSlider("spread", 40, 180, spread, 10, y += 16, 256, 14).setWindow(w);
284. control.addSlider("independence", 0, 1, independence, 10, y += 16, 256, 14).setWindow(w);
285. control.addSlider("turbulence", 0, 4, turbulence, 10, y += 16, 256, 14).setWindow(w);
286. control.addSlider("strokefactor", 0.1, 20, strokefactor, 10, y += 16, 256, 14).setWindow(w);
287. control.addSlider("backcolour", 0, 255, backcolour, 10, y += 16, 256, 14).setWindow(w);
288. control.addToggle("paused", false, 10, y += 16, 14, 14).setWindow(w);
289. control.addToggle("label", false, 10, y += 26, 14, 14).setWindow(w);
290. control.addToggle("stopR", false, 10, y += 26, 14, 14).setWindow(w);
291. control.setAutoInitialization(true);
292. }

Two Way Serial communication with Arduino & Processing

[2 Replies]
- 12-Dec-2012 07:40 AM
- Forum: Integration and Hardware
Hi. I have manage to send the sensor data "tune" to the processing, but when i am trying to send the data back to Arduino,(when "tune" is less than -100, LED on pin 13 lights up, later it will be implemented to a servo action) the reaction time is very slow, and it seems the things are out of sync. I have googled and people said is the buffer problem, but i cannot manage to find a way to sort it out.
Thank you for answering!

Processing
2. import processing.serial.*;
3. Serial myPort;
4. float value;
5. int val;
6. int state;
8. void setup()
9. {
10. println("COM Ports");
11. println(myPort.list());
12. println("=========");
13. myPort = new Serial(this, Serial.list()[5], 9600);
14. }
16. void draw()
17. {
18. }
20. void serialEvent(Serial p) {
21. // get message till line break (ASCII > 13)
22. if ( myPort.available() > 0) {
23. // while ( myPort.available() > 0);
24. String message = myPort.readStringUntil(13);
26. if (message != null) {
27. value = float(message);
28. // println(value);
29. }
30. }
31. if (value < -100) {
32. state=1;
33. }
34. else {
35. state=0;
36. }
37. myPort.write(state);
38. println(state);
39. }
Arduino
2. /*
3. * Therremin with TTL Oscillator 4MHz
4. * Timer1 for freauency measurement
5. * Timer2 for gate time
6. */
8. #include <Stdio.h>
9. #define cbi(sfr, bit) (_SFR_BYTE(sfr) &= ~_BV(bit))
10. #define sbi(sfr, bit) (_SFR_BYTE(sfr) |= _BV(bit))
12. //! Macro that clears all Timer/Counter1 interrupt flags.
13. #define CLEAR_ALL_TIMER1_INT_FLAGS (TIFR1 = TIFR1)
15. int pinLed = 13; // LED connected to digital pin 13
16. int pinFreq = 5;
17. int pinFreq2 = 6;
18. int incomingByte;
20. void setup()
21. {
22. pinMode(pinLed, OUTPUT); // sets the digital pin as output
23. pinMode(pinFreq, INPUT);
24. pinMode(pinFreq2, INPUT);
25. pinMode(8, OUTPUT);
27. Serial.begin(9600); // connect to the serial port
29. // hardware counter setup ( refer atmega168.pdf chapter 16-bit counter1)
30. TCCR1A=0; // reset timer/counter1 control register A
31. TCCR1B=0; // reset timer/counter1 control register A
32. TCNT1=0; // counter value = 0
33. // set timer/counter1 hardware as counter , counts events on pin T1 ( arduino pin 5)
34. // normal mode, wgm10 .. wgm13 = 0
35. sbi (TCCR1B ,CS10); // External clock source on T1 pin. Clock on rising edge.
36. sbi (TCCR1B ,CS11);
37. sbi (TCCR1B ,CS12);
39. // timer2 setup / is used for frequency measurement gatetime generation
40. // timer 2 presaler set to 256 / timer 2 clock = 16Mhz / 256 = 62500 Hz
41. cbi (TCCR2B ,CS20);
42. sbi (TCCR2B ,CS21);
43. sbi (TCCR2B ,CS22);
45. //set timer2 to CTC Mode
46. cbi (TCCR2A ,WGM20);
47. sbi (TCCR2A ,WGM21);
48. cbi (TCCR2B ,WGM22);
49. OCR2A = 124; // CTC at top of OCR2A / timer2 interrupt when coun value reaches OCR2A value
51. // interrupt control
53. sbi (TIMSK2,OCIE2A); // enable Timer2 Interrupt
55. }
57. volatile byte i_tics;
58. volatile byte f_ready ;
59. volatile byte mlt ;
60. unsigned int ww;
62. int cal;
63. int cal_max;
65. char st1[32];
66. long freq_in;
67. long freq_zero;
68. long freq_cal;
70. unsigned int dds;
71. int tune;
72. int cnt=0;
74. void loop()
75. {
76. cnt++;
78. f_meter_start();
80. tune=tune+1;
81. while (f_ready==0) { // wait for period length end (100ms) by interrupt
82. digitalWrite(8, (dds+=tune) >> 15); // kind of DDS tonegenerator / connect speaker to portb.0 = arduino pin8
83. }
84. tune = freq_in-freq_zero;
85. Serial.println(tune);
87. // Initialisation
88. if (cnt == 10) {
89. freq_zero=freq_in;
90. freq_cal=freq_in;
91. cal_max=0;
92. Serial.print("INITIALISATION");
93. }
95. // calibration
96. if (tune>0) { // try autocalibrate when out of range
97. freq_zero=freq_in;
98. freq_cal=freq_in;
99. cal_max=0;
100. Serial.print("CALIBRATION");
101. Serial.println("");
102. }
103. cal = freq_in-freq_cal;
104. if ( cal < 0) cal*=-1; // absolute value
105. if (cal > cal_max) cal_max=cal;
107. // digitalWrite(pinLed,1); // let LED blink
109. if ( tune < 0) tune*=-1; // absolute value
110. // sprintf(st1, " %04d",tune);
112. // digitalWrite(pinLed,0);
114. // see if there's incoming serial data:
115. if (Serial.available() > 0) {
116. // while (Serial.available() > 0)
117. incomingByte = Serial.read();
118. }
119. digitalWrite(pinLed, incomingByte);
120. }
122. //******************************************************************
123. void f_meter_start() {
124. f_ready=0; // reset period measure flag
125. i_tics=0; // reset interrupt counter
126. sbi (GTCCR,PSRASY); // reset presacler counting
127. TCNT2=0; // timer2=0
128. TCNT1=0; // Counter1 = 0
129. cbi (TIMSK0,TOIE0); // dissable Timer0 again // millis and delay
130. sbi (TIMSK2,OCIE2A); // enable Timer2 Interrupt
131. TCCR1B = TCCR1B | 7; // Counter Clock source = pin T1 , start counting now
132. }
134. //******************************************************************
135. // Timer2 Interrupt Service is invoked by hardware Timer2 every 2ms = 500 Hz
136. // 16Mhz / 256 / 125 / 500 Hz
137. // here the gatetime generation for freq. measurement takes place:
139. ISR(TIMER2_COMPA_vect) {
141. if (i_tics==50) { // multiple 2ms = gate time = 100 ms
142. // end of gate time, measurement ready
143. TCCR1B = TCCR1B & ~7; // Gate Off / Counter T1 stopped
144. cbi (TIMSK2,OCIE2A); // disable Timer2 Interrupt
145. sbi (TIMSK0,TOIE0); // ensable Timer0 again // millis and delay
146. f_ready=1; // set global flag for end count period
148. // calculate now frequeny value
149. freq_in=0x10000 * mlt; // mukt #ovverflows by 65636
150. freq_in += TCNT1; // add counter1 value
151. mlt=0;
153. }
154. i_tics++; // count number of interrupt events
155. if (TIFR1 & 1) { // if Timer/Counter 1 overflow flag
156. mlt++; // count number of Counter1 overflows
157. sbi(TIFR1,TOV1); // clear Timer/Counter 1 overflow flag
158. }
159. }

Converting from Arduino to Processing

[0 Replies]
- 11-Dec-2012 10:10 AM
- Forum: Integration and Hardware
Hi All. I want to create a project simular to this link: PROJECT

I want to use the same detection method but instead, i will control the servo and also the graphics in processing. But i am struggling to find a way to convert the code to processing.

Or Do i need not change the code but rather ask the arduino to send a message to processing?
1. /* Theremin Test
2. *
3. * Therremin with TTL Oscillator 4MHz
4. * Timer1 for freauency measurement
5. * Timer2 for gate time
6. * connect Oscillator on digital pin 5
7. * connect Speaker with 1K Resistor in series on pin 8
9. * KHM 2008 / Martin Nawrath
10. * Kunsthochschule fuer Medien Koeln
11. * Academy of Media Arts Cologne
13. */
14. #include <Stdio.h>
15. #define cbi(sfr, bit) (_SFR_BYTE(sfr) &= ~_BV(bit))
16. #define sbi(sfr, bit) (_SFR_BYTE(sfr) |= _BV(bit))
18. //! Macro that clears all Timer/Counter1 interrupt flags.
19. #define CLEAR_ALL_TIMER1_INT_FLAGS (TIFR1 = TIFR1)
21. int pinLed = 13; // LED connected to digital pin 13
22. int pinFreq = 5;
24. void setup()
25. {
26. pinMode(pinLed, OUTPUT); // sets the digital pin as output
27. pinMode(pinFreq, INPUT);
28. pinMode(8, OUTPUT);
30. Serial.begin(57600); // connect to the serial port
32. // hardware counter setup ( refer atmega168.pdf chapter 16-bit counter1)
33. TCCR1A=0; // reset timer/counter1 control register A
34. TCCR1B=0; // reset timer/counter1 control register A
35. TCNT1=0; // counter value = 0
36. // set timer/counter1 hardware as counter , counts events on pin T1 ( arduino pin 5)
37. // normal mode, wgm10 .. wgm13 = 0
38. sbi (TCCR1B ,CS10); // External clock source on T1 pin. Clock on rising edge.
39. sbi (TCCR1B ,CS11);
40. sbi (TCCR1B ,CS12);
42. // timer2 setup / is used for frequency measurement gatetime generation
43. // timer 2 presaler set to 256 / timer 2 clock = 16Mhz / 256 = 62500 Hz
44. cbi (TCCR2B ,CS20);
45. sbi (TCCR2B ,CS21);
46. sbi (TCCR2B ,CS22);
48. //set timer2 to CTC Mode
49. cbi (TCCR2A ,WGM20);
50. sbi (TCCR2A ,WGM21);
51. cbi (TCCR2B ,WGM22);
52. OCR2A = 124; // CTC at top of OCR2A / timer2 interrupt when coun value reaches OCR2A value
54. // interrupt control
56. sbi (TIMSK2,OCIE2A); // enable Timer2 Interrupt
58. }
60. volatile byte i_tics;
61. volatile byte f_ready ;
62. volatile byte mlt ;
63. unsigned int ww;
65. int cal;
66. int cal_max;
68. char st1[32];
69. long freq_in;
70. long freq_zero;
71. long freq_cal;
73. unsigned int dds;
74. int tune;
76. int cnt=0;
78. void loop()
79. {
80. cnt++;
81. // add=analogRead(0);
83. f_meter_start();
85. tune=tune+1;
86. while (f_ready==0) { // wait for period length end (100ms) by interrupt
87. PORTB=((dds+=tune) >> 15); // kind of DDS tonegenerator / connect speaker to portb.0 = arduino pin8
88. }
89. tune = freq_in-freq_zero;
90. // use the tune value here for your own purposes like control of servos, midi etc.
92. // startup
93. if (cnt==10) {
94. freq_zero=freq_in;
95. freq_cal=freq_in;
96. cal_max=0;
97. Serial.print("** START **");
98. }
100. // autocalibration
101. if (cnt % 20 == 0) { // try autocalibrate after n cycles
102. Serial.print("*");
103. if (cal_max <= 2) {
104. freq_zero=freq_in;
105. Serial.print(" calibration");
106. }
107. freq_cal=freq_in;
108. cal_max=0;
109. Serial.println("");
110. }
111. cal = freq_in-freq_cal;
112. if ( cal < 0) cal*=-1; // absolute value
113. if (cal > cal_max) cal_max=cal;
115. digitalWrite(pinLed,1); // let LED blink
116. Serial.print(cnt);
117. Serial.print(" ");
119. if ( tune < 0) tune*=-1; // absolute value
120. sprintf(st1, " d",tune);
121. Serial.print(st1);
122. Serial.print(" ");
124. Serial.print(freq_in);
125. Serial.print(" ");
126. /*
127. Serial.print(freq_zero);
128. Serial.print(" ");
129. Serial.print(cal_max);
130. */
131. Serial.println("");
132. digitalWrite(pinLed,0);
134. }
135. //******************************************************************
136. void f_meter_start() {
137. f_ready=0; // reset period measure flag
138. i_tics=0; // reset interrupt counter
139. sbi (GTCCR,PSRASY); // reset presacler counting
140. TCNT2=0; // timer2=0
141. TCNT1=0; // Counter1 = 0
142. cbi (TIMSK0,TOIE0); // dissable Timer0 again // millis and delay
143. sbi (TIMSK2,OCIE2A); // enable Timer2 Interrupt
144. TCCR1B = TCCR1B | 7; // Counter Clock source = pin T1 , start counting now
145. }
147. //******************************************************************
148. // Timer2 Interrupt Service is invoked by hardware Timer2 every 2ms = 500 Hz
149. // 16Mhz / 256 / 125 / 500 Hz
150. // here the gatetime generation for freq. measurement takes place:
152. ISR(TIMER2_COMPA_vect) {
154. if (i_tics==50) { // multiple 2ms = gate time = 100 ms
155. // end of gate time, measurement ready
156. TCCR1B = TCCR1B & ~7; // Gate Off / Counter T1 stopped
157. cbi (TIMSK2,OCIE2A); // disable Timer2 Interrupt
158. sbi (TIMSK0,TOIE0); // ensable Timer0 again // millis and delay
159. f_ready=1; // set global flag for end count period
161. // calculate now frequeny value
162. freq_in=0x10000 * mlt; // mukt #ovverflows by 65636
163. freq_in += TCNT1; // add counter1 value
164. mlt=0;
166. }
167. i_tics++; // count number of interrupt events
168. if (TIFR1 & 1) { // if Timer/Counter 1 overflow flag
169. mlt++; // count number of Counter1 overflows
170. sbi(TIFR1,TOV1); // clear Timer/Counter 1 overflow flag
171. }
172. }

Generating OBJECTS one next to each other randomly.

[9 Replies]
- 22-Nov-2012 10:56 AM
- Forum: Programming Questions
I am an architecture student which I am developing a simulator where the program will put blocks together according to some parameters of the user input.

The image above is the logic diagram of what I am trying to do as the first step before introducing more complexity. I have been trying to find examples from the internet, but seems there isn't any simular project.

So I have a few questions for the processing communicate.
1. What is the best way to code this system? I will add more relationships between the the type of modules later
2. What external library should i use if i need any?
3. Any precedent?
Many thanks to the community! I have got a code as a starting point abou the creation of new modules below.
1. int moduleCount_=100;
3. ArrayList moduleCollection;
5. void setup() {
6. size(600, 600);
8. moduleCollection = new ArrayList();
10. for (int i = 0; i<moduleCount_; i++) {
12. if (i<1) {
13. Module myModule = new Module (width/2, height/2, 10, 10, 0);
14. moduleCollection.add(myModule);
15. }
16. else {
17. moduleCollection.get(i-1);
21. Module myModule = new Module (int(random(0, width/10))*10, 100, 10, 10, random(100, 200));
22. moduleCollection.add(myModule);
23. }
24. }
25. }
27. void draw() {
28. background(255);
30. for (int i = 0; i < moduleCount_; i++) {
31. Module myModule=(Module) moduleCollection.get(i);
32. myModule.display();
33. }
34. }
35. class Module {
36. //GLOBALS VALUES
37. float xPos, yPos; //xy position
38. float xDim, yDim; //xy Dimension
39. float cFill;
41. Module(float xPos_, float yPos_, float xDim_, float yDim_, float cFill_) {
42. xPos = xPos_;
43. yPos = yPos_;
44. xDim = xDim_;
45. yDim = yDim_;
46. cFill=cFill_;
47. }
48. //Drawing of Modules
49. void display() {
50. rectMode(CENTER);
51. fill(cFill);
52. rect(xPos, yPos, xDim, yDim);
53. }
54. }

Array function with variable Count

[2 Replies]
- 17-Nov-2012 01:35 PM
- Forum: Integration and Hardware
Hi All! I am new to processing.

I am try to control the number of squares array displayed on the screen by using a resister value from Arduino. But i cannot get it working!

When the moduleCount is 0, is fine, when it is more than 0, then it has problem displaying/drawing the square.

__________________________________

import processing.serial.*;

import cc.arduino.*;

int moduleCount;

int moduleCount_;

int count;

int reading;

int i;

Arduino arduino;

Module [] moduleCollection = new Module[moduleCount_];

void setup() {

size(600, 600);

//Locate Arduino Port

println("COM Ports");

println(Arduino.list());

println("=========");

arduino = new Arduino(this, Arduino.list()[5], 57600);

for (int i = 0; i<moduleCount_; i++) {

moduleCollection[i]=new Module(width/2, height*0.9-i*10, random(100, 200));

}

}

void loop() {

}

void draw() {

background(255);

//Read from Arduino

reading=arduino.analogRead(0);

//Map resistance value to Count

float count = map(reading, 0, 1023, 1, 50);

moduleCount=int(count);

println(moduleCount);

for (int i = 0; i < moduleCount_; i++) {

moduleCollection[i].display();

}

moduleCount_=moduleCount;

}

class Module {

//GLOBALS VALUES

float xpos, ypos; //xy position

float cFill;

Module(float xpos_, float ypos_, float cFill_) {

xpos = xpos_;

ypos = ypos_;

cFill=cFill_;

}

//Drawing of Modules

void display() {

rectMode(CENTER);

fill(cFill);

rect(xpos, ypos, 10, 10);

}

}

________________________________________

Activity Trend