Arduino colour sensor and servo pro

Colour sensor with servo project

Making

All we need for this project is one color sensor (TCS3200) and two hobbyist servo motors, which makes this project quite simple but yet very fun to build it. In the first place, using the Solidworks 3D modeling software I made the design of the color sorter and here’s its working principle

Initially, the colored skittles which are held in the charger drop into the platform attached on the top servo motor.Then the servo motor rotates and brings the skittle to the color sensor which detects its color.After that the bottom servo motor rotates to the particular position and then the top servo motor rotates again till the skittle drop into the guide rail.

Connecting method

The code is below

1. /* Arduino Project - Color Sorting Machine
2. *
3. * by Dejan Nedelkovski, www.HowToMechatronics.com
4. *
5. */
6. #include <Servo.h>
8. #define S0 2
9. #define S1 3
10. #define S2 4
11. #define S3 5
12. #define sensorOut 6
14. Servo topServo;
15. Servo bottomServo;
17. int frequency = 0;
18. int color=0;
20. void setup() {
21. pinMode(S0, OUTPUT);
22. pinMode(S1, OUTPUT);
23. pinMode(S2, OUTPUT);
24. pinMode(S3, OUTPUT);
25. pinMode(sensorOut, INPUT);
27. // Setting frequency-scaling to 20%
28. digitalWrite(S0, HIGH);
29. digitalWrite(S1, LOW);
31. topServo.attach(7);
32. bottomServo.attach(8);
34. Serial.begin(9600);
35. }
37. void loop() {
39. topServo.write(115);
40. delay(500);
42. for(int i = 115; i > 65; i--) {
43. topServo.write(i);
44. delay(2);
45. }
46. delay(500);
48. color = readColor();
49. delay(10);
51. switch (color) {
52. case 1:
53. bottomServo.write(50);
54. break;
56. case 2:
57. bottomServo.write(75);
58. break;
60. case 3:
61. bottomServo.write(100);
62. break;
64. case 4:
65. bottomServo.write(125);
66. break;
68. case 5:
69. bottomServo.write(150);
70. break;
72. case 6:
73. bottomServo.write(175);
74. break;
76. case 0:
77. break;
78. }
79. delay(300);
81. for(int i = 65; i > 29; i--) {
82. topServo.write(i);
83. delay(2);
84. }
85. delay(200);
87. for(int i = 29; i < 115; i++) {
88. topServo.write(i);
89. delay(2);
90. }
91. color=0;
92. }
94. // Custom Function - readColor()
95. int readColor() {
96. // Setting red filtered photodiodes to be read
97. digitalWrite(S2, LOW);
98. digitalWrite(S3, LOW);
99. // Reading the output frequency
100. frequency = pulseIn(sensorOut, LOW);
101. int R = frequency;
102. // Printing the value on the serial monitor
103. Serial.print("R= ");//printing name
104. Serial.print(frequency);//printing RED color frequency
105. Serial.print(" ");
106. delay(50);
108. // Setting Green filtered photodiodes to be read
109. digitalWrite(S2, HIGH);
110. digitalWrite(S3, HIGH);
111. // Reading the output frequency
112. frequency = pulseIn(sensorOut, LOW);
113. int G = frequency;
114. // Printing the value on the serial monitor
115. Serial.print("G= ");//printing name
116. Serial.print(frequency);//printing RED color frequency
117. Serial.print(" ");
118. delay(50);
120. // Setting Blue filtered photodiodes to be read
121. digitalWrite(S2, LOW);
122. digitalWrite(S3, HIGH);
123. // Reading the output frequency
124. frequency = pulseIn(sensorOut, LOW);
125. int B = frequency;
126. // Printing the value on the serial monitor
127. Serial.print("B= ");//printing name
128. Serial.print(frequency);//printing RED color frequency
129. Serial.println(" ");
130. delay(50);
132. if(R<45 & R>32 & G<65 & G>55){
133. color = 1; // Red
134. }
135. if(G<55 & G>43 & B<47 &B>35){
136. color = 2; // Orange
137. }
138. if(R<53 & R>40 & G<53 & G>40){
139. color = 3; // Green
140. }
141. if(R<38 & R>24 & G<44 & G>30){
142. color = 4; // Yellow
143. }
144. if(R<56 & R>46 & G<65 & G>55){
145. color = 5; // Brown
146. }
147. if (G<58 & G>45 & B<40 &B>26){
148. color = 6; // Blue
149. }
150. return color;
151. }

Code explain

we need to include the “Servo.h” library, define the pins to which the color sensor will be connected, create the servo objects and declare some variables needed for the program. In the setup section we need to define the pins as Outputs and Inputs, set the frequency-scaling for the color sensor, define the servo pins and start the serial communication for printing the results of the color read on the serial monitor.

In the loop section, our program starts with moving the top servo motor to the position of the skittle charger. Note that this value of 115 suits to my parts and my servo motor, so you should adjust this value as well as the following values for the servo motors according to your build.

Next using the “for” loop we will rotate and bring the skittle to the position of the color sensor. We are using a “for” loop so that we can control the speed of the rotation by changing the delay time in loop.

Next, after half a second delay, using the custom made function, readColor() we will read the color of the skittle. Here’s the code of the custom function. Using the four control pins and the frequency output pin of the color sensor we read color of the skittle. The sensor reads 3 different values for each skittle, Red, Green and Blue and according to these values we tell what the actual color is. For more details how the TCS3200 color sensor works you can check my previous detailed tutorial about it.

Here are the RGB values that I got from the sensor for each skittle. Note that these values can vary because the sensors isn’t always accurate. Therefore, using these “if” statements we allow the sensor an error of around +-5 of the tested value for the particular color. So for example if we have a Red skittle, the first “if” statement will be true and the variable “color” will get the value 1. So that’s what the readColor() custom function does and after that using a “switch-case” statement we rotate the bottom servo to the particular position. At the end we further rotate the top servo motor until the skittle drops into the guide rail and again send it back to the initial position so that the process can repeated.

Finesh