UNIVERSITATEA DIN PITEŞTI

FACULTATEA DE ELECTRONICĂ, COMUNICAȚII ŞI CALCULATOARE

Proiect la practică

Sortarea culorilor folosind placa de dezvoltare Arduino

Student : Ivănuş Andrei-Ionel

SECPI 111

1
Cuprins :
Capitolul 1. Introducere ....................................................................... 4
Capitolul 2. Arduino ............................................................................ 5
Capitolul 3. Proiectare hardware ......................................................... 8
Capitolul 4. Proiectare software .......................................................... 12
Capitolul 5. Proiectarea machetei ........................................................ 15
Capitolul 6. Rezultatele simularilor ..................................................... 18
Bibliografie .......................................................................................... 20

2
Lista de figuri :

Figura 1. Placa de dezvoltare Arduino

Figura 2. Placa reală de dezvoltare Arduino
Figura 3. Placa reală de dezvoltare Arduino UNO
Figura 4. Schema bloc
Figura 5. Diagrama pinilor pe Arduino Nano
Figura 6. Modulul sensor de culoare TCS230
Figura 7. Micro servomotor SG90 90°
Figura 8. Piesele carcasei ȋn AutoCAD
Figura 9. Părţile componente ale carcasei
Figura 10. Rezultatul pentru bomboanele albastre
Figura 11. Rezultatul pentru bomboanele verzi
Figura 12. Rezultatul pentru bomboanele roşii

3
Capitolul 1. Introducere

Proiectul de sortare a culorilor Arduino demonstrează operațiunile mașinilor de sortare care sunt utilizate
în mod obișnuit de industrii. Acest proiect are o placă Arduino și un senzor de culoare care poate organiza
obiecte bazate pe culoare. Construcția fizică este un design 3D care intră în funcțiune.

Construcția fizică este realizată din plăci fibrolemnoase tăiate și lipite în raport cu designul 3D. Arduino
nano servește ca regulator primar în care sunt conectate componentele precum senzorul de culoare și
servomotoarele. Analizează datele primite de la senzorul de culoare și apoi transmite o comandă
servomotoarelor. Senzorul de culoare este atașat cu fața în jos pe măsură ce verifică culoarea obiectului și
această verificare corespunde unei frecvențe de culoare cu o funcție personalizată care ajută la
identificarea culorii obiectului. Servo-ul de sus asigură că o bucată de obiect este livrată după identificarea
culorii obiectului, care mișcă obiectul de la sursă la senzorul de culoare, apoi la orificiul de cădere cu un
mâner al platformei culisante de către un servo inferior. Această platformă de glisare este apoi setată
pentru a livra obiectul în containerul de grup în care se stochează obiectul colorat.

Acest proiect de sortare a culorilor Arduino este aplicabil în organizarea de obiecte mici având în vedere
capacitățile hardware-ului care conduce acest proiect. În afară de organizarea obiectelor mici bazate pe
culoare, este, de asemenea, o referință bună pentru dezvoltarea unui sistem mai mare care să poată sorta
obiecte mai mari, mai ales în industrii.

4
Capitolul 2. Arduino

2.1 . Istoric Arduino

Figura 1. Placa de dezvoltare Arduino

Arduino este o companie open-source care produce atât plăcuțe de dezvoltare bazate
pe microcontrolere, cât și partea de software destinată funcționării și programării acestora. Pe lângă
acestea include și o comunitate uriașă care se ocupă cu creația și distribuirea de proiecte care au ca scop
crearea de dispozitive care pot sesiza și controla diverse activități sau procese în lumea reală.
Proiectul este bazat pe designul plăcilor cu microcontroler produse de câțiva furnizori, folosind
diverse tipuri de microcontrolere. Aceste plăci pun la dispoziția utilizatorului pini I/O, digitali și analogici,
care pot fi interfațați cu o gamă largă de plăcuțe numite scuturi (shield-uri) și/sau cu alte circuite. Plăcile
au interfețe de comunicații seriale, inclusiv USB pe unele modele, pentru a încărca programe
din calculatorele personale. Pentru programarea microcontrolerelor, Arduino vine cu un mediu de
dezvoltare integrat(IDE) bazat pe proiectul Processing, care include suport pentru limbaje de
programare ca C și C++.
Primul Arduino a fost lansat în 2005, având ca țintă asigurarea unei soluții ieftine și simple pentru
începători și profesioniști spre a crea dispozitive capabile să interacționeze cu mediul, folosind senzori și
sisteme de acționare. Cele mai comune exemple sunt dispozitivele pentru utilizatorii începători precum:
roboții simpli, termostatele și/sau detectoarele de mișcare.
Plăcuțele Arduino sunt disponibile comercial sub formă preasamblată sau sub forma unor kituri de
asamblat acasă (do-it-yourself). Specificațiile schemelor sunt disponibile pentru orice utilizator, permițând
oricui să fabrice plăcuțe Arduino. Adafruit Industriesestimase la mijlocul anului 2011 că peste 300.000 de
plăcuțe oficiale Arduino au fost produse, iar în 2013 700.000 de plăcuțe oficiale erau în posesia
utilizatorilor.
Arduino a început în 2005 ca un proiect al unui student al Institutului de Interacțiune a Designului
din Ivrea, Italia. La acea vreme studenții foloseau o plăcuță de dezvoltare BASIC Stamp care costau 100
de dolari, ceea ce era considerat foarte scump pentru studenți. Massimo Banzi, unul dintre fondatori, era
student la Ivrea. Numele "Arduino" provine de la un bar din Ivrea, locul unde o parte din fondatori
obișnuiau să se întâlnească.
Studentul columbian Hernando Barragán a creat platforma de dezvoltare Wiring care a servit ca
bază pentru Arduino. După finalizarea platformei Wiring, mai multe versiuni, mai light și mai ieftine, au
fost create și puse la dispoziția comunităților open-source. Din echipa inițială Arduino au făcut parte
Massimo Banzi, David Cuartielles, Tom Igoe, Gianluca Martino și David Mellis.

5
2.2. Hardware

Figura 2. Placa reală de dezvoltare Arduino

Una dintre primele plăcuțe Arduino cu interfață de comunicații serială RS-232 (stânga sus) și un
microcontroler Atmel ATmega8(cu negru, dreapta jos); Cei 14 pini digitali de intrare/ieșire sunt localizați
în partea de sus, iar cele 6 intrări analogice sunt pe partea dreaptă, jos sub microcontroler.
O plăcuță Arduino este compusă dintr-un microcontroler Atmel AVR de 8-, 16- sau 32-biți (deși
începând cu 2015 s-au folosit microcontrolere de la alți producători) cu componente complementare care
facilitează programarea și încorporarea în alte circuite. Un aspect important la Arduino este că acesta
dispune de conectori standard, care permit utilizatorului să conecteze plăcuța cu procesorul la diferite
module interschimbabile numite shield-uri. Unele shield-uri comunică cu Arduino direct prin pinii digitali
sau analogici, dar altele sunt adresabile individual prin magistrala serială I²C permițând utilizarea mai
multor module în paralel. Până în anul 2015 plăcuțele Arduino oficiale au folosit cipuri Atmel din seria
megaAVR, în special ATmega8, ATmega168, ATmega328, ATmega1280 și ATmega2560, iar în 2015 au
fost adăugate cipuri de la alți producători. O multitudine de alte procesoare au fost folosite de dispozitive
compatibile Arduino.
Multe plăcuțe includ un regulator liniar de 5 V și un oscilator cu cuarț de 16 MHz (sau un
rezonator ceramic în unele variante), deși anumite plăcuțe, cum ar fi LilyPad, funcționează la 8 MHz și nu
necesită regulator, datorită restricțiilor de formă. Un microcontroler instalat pe Arduino vine preprogramat
cu un bootloader care simplifică încărcarea programelor pe memoria flash a cipului, în comparație cu alte
dispozitive care necesită programatoare externe. Acest aspect face Arduino o soluție simplă, permițând
programarea de pe orice computer ordinar. În prezent, bootloader-ul optiboot este bootloader-ul implicit
instalat pe Arduino UNO.
La nivel conceptual, când se folosește mediul de dezvoltare integrat Arduino, programarea tuturor
plăcuțelor se face prin conexiune serială. Implementarea acesteia diferă în funcție de versiunea hardware.
Unele plăcuțe Arduino au implementate convertoare de nivel logic pentru a realiza conversia între nivelele
logice RS-232 și cele TTL. Plăcuțele Arduino din prezent sunt programate prin USB, având integrate
cipuri de conversie USB-serial, cum ar fi FTDI FT232. Unele modele UNO, mai noi, folosesc un cip AVR
separat programat să funcționeze ca un convertor USB-serial, care poate fi reprogramat printr-un port
ICSP dedicat.
Alte variante, cum ar fi Arduino Mini și versiunea neoficială Boarduino, folosesc adaptoare
detașabile USB-serial, cabluri, Bluetooth sau alte metode.

6
 Figura 3. Placa reală de dezvoltare Arduino UNO

Plăcuța Arduino are expuși mulți dintre pinii de intrare/ieșire ai microcontrolerului, pentru ca
aceștia să fie folosiți de alte circuite. Diecimila, Duemilanove și UNO oferă 14 pini digitali de
intrare/ieșire, dintre care 6 pot produce semnale PWM și 6 intrări analogice care, de asemenea, pot fi
folosite ca intrări/ieșiri digitale. Acești pini sunt accesibili prin partea superioară a plăcuței, prin
intermediul unor barete mamă cu pasul între pini de 2,54 mm.

2.3. Software
Programele Arduino pot fi scrise în orice limbaj de programare cu un compilator capabil să producă un
cod mașină binar. Atmel oferă un mediu de dezvoltare pentru microcontrolerele sale, AVR Studio și mai
nou, Atmel Studio.
Proiectul Arduino oferă un mediu integrat de dezvoltare (IDE), care este o aplicație cross-platform, scrisă
în Java. Acesta își are originile în mediul de dezvoltare pentru limbajul de programare Processing și în
proiectul Wiring. Este proiectat pentru a introduce programarea în lumea artiștilor și a celor nefamiliarizați
cu dezvoltarea software. Include un editor de cod cu funcții ca evidențierea sintaxelor, potrivirea
acoladelor și spațierea automată și oferă mecanisme simple cu un singur click, pentru a compila și a
încărca programele în plăcuța Arduino. Un program scris în IDE pentru Arduino se numește sketch.
Arduino IDE suportă limbajele de programare C și C++ folosind reguli speciale de organizare a codului.
Arduino IDE oferă o librărie software numită Wiring, din proiectul Wiring, care oferă multe proceduri
comune de intrare și ieșire. Un sketch tipic Arduino scris în C/C++ este compus din două funcții care sunt
compilate și legate cu un ciot de program main(), într-un program executabil cu o execuție ciclică:
- setup(): o funcție care este rulată o singură dată la începutul programului, când se inițializează
setările.
- loop(): o funcție apelată în mod repetat până la oprirea alimentării cu energie a plăcuței.
După compilarea și legarea cu GNU toolchain inclus, de asemenea, în IDE, mediul de dezvoltare Arduino
trimite comandă către programul avrdude pentru a converti codul executabil într-un fișier text codat
hexazecimal, care poate fi încărcat în placa Arduino de un program de încărcare.

7
Capitolul 3. Proiectare hardware

Date de proiectare

Sa se realizeze un sistem in care separam un sir de bomboane colorate.

Comanda se realizeaza cu o placă de dezvoltare compatibilă cu Arduino Nano (ATmega328p și CH340).
Se va citi culoarea folosind un senzor de culoare TCS230.

Schema bloc a proiectului

Figura 4. Schema bloc

8
Date tehnice ale componetelor

1) Arduino Nano

Diagrama pinilor regasiti pe un Arduino

Pinii pe care ii regasim pe microsistemul arduino se impart in pini analogici si digitali, dupa cum
se poate observa in poza de mai jos:

Figura 5. Diagrama pinilor pe Arduino Nano

Caracteristici tehnice:

Tensiune de alimentare: 5 V;
Tensiune de alimentare suportată de limitator: 7 V - 12 V;
Pini I/O: 14;
Pini PWM: 6 (din cei 14 de I/O);
Pini ADC: 8 (din cei 14 de I/O);
Memorie flash: 32 kB / 16 kB (2 kB folosiți de bootloader);
Curent pentru pini I/O: 40 mA/pin;
Comunicație TWI, SPI și UART;
Frecvență de funcționare: 16 MHz;
Dimensiuni: 45 mm x 18 mm.

9
Placa de dezvoltare este echipată cu același micro-controller performant ( ATmega328p ) de pe Arduino
Uno. Avantajul acesteia îl reprezintă dimensiunile foarte reduse, putând fi integrată în diverse proiecte în
care spațiul componentelor este limitat. Programarea dispozitivului se realizează prin intermediul unui
cablu USB, nefiind nevoie de un programator special deoarece este instalat și un bootloader.

Este ideală pentru proiecte de dimensiuni mici și are avantajul faptului că poate fi programată prin USB.

2) Modulul senzor de culoare TCS230

Figura 6. Modulul sensor de culoare TCS230

Caracteristici tehnice:

Tensiuni de alimentare: 2.7V - 5.5V;

Curent consumat: 3mA;
Răspuns în frecvență prin generare a unui semnal dreptunghiular.
Dimensiuni: 32mm x 25mm.
Eroare de 0.2% la 50khz
Cu ajutorul modulului TCS230 putem determina intensitatea luminii corespunzătoare fiecărei culori.

Funcționarea senzorului se bazează pe conversia lungimii de undă a luminii într-un semnal dreptunghiular
de o anumită frecvență pentru fiecare culoare.

Modulul dispune de 4 led-uri de culori diferite ce pot fi folosite separat. Circuitul integrat dispune si de un
pin de enable. În momentul în care circuitul este în modul sleep, consumul scade până la 15 µA.

Modulul TCS230 folosește o matrice de fotodiode. Acestea sunt elemente de circuit ce permit trecerea
curentului în prezența unei radiații luminoase de o anumită frecvență (culoarea este dependentă de
frecvență).

TCS230 conține o matrice de 8x8 fotodiode, folosind câte 16 diode ce se deschid în prezența luminii roșu,
16 pentru albastru, 16 pentru verde și 16 pentru lumina albă (lumina alba se obține combinând toate
culorile).

Modulul va genera la ieșire un semnal dreptunghiular cu o frecvență dependentă de culoare.

10
3) Micro servomotor SG90 90°

Figura 7. Micro servomotor SG90 90°

Caracteristici tehnice:
Tensiune de alimentare: 4.8V - 6V DC;
Curent mic consumat: 220mA (fara sa fie blocat), 650mA (stall), 15mA (in gol), pentru 5 VD;
Viteză de rotație: 0.12 sec / 60 grade (@ 4.8V), 0.11 sec / 60 grade (@ 6V);
Cuplu: 1.5 kg*cm (@ 4.8V), 1.7 kg*cm (@ 6V).
Masă: 9 grame.

Dimensiuni: 22.2 x 11.8 x 31 mm.

11
Capitolul 4. Proiectare software

Descrierea codului sursă

Deci, trebuie să includem biblioteca "Servo.h", apoi să definim pinii la care va fi conectat senzorul de
culoare, să creăm obiectele servo și să declarăm câteva variabile necesare pentru program. În secțiunea de
configurare trebuie să definim pinii ca ieșiri și intrări, să setăm scalarea frecvențelor pentru senzorul de
culoare, să definim servo-pinii și să pornim comunicarea serială pentru imprimarea rezultatelor culorii
citite pe monitorul serial.

În secțiunea buclă, programul începe cu mișcare motorul servo de sus la poziția tubului incarcat. Reținem
că această valoare de 150 se potrivește pieselor mele și servomotorului meu, deci trebuie să reglăm această
valoare, precum și următoarele valori pentru servomotoare în funcție de construcție.

Apoi, folosind buclă "for", vom roti și vom aduce cuțitul în poziția senzorului de culoare. Folosind o buclă
"for" pentru a putea controla viteza rotației schimbând timpul de întârziere în buclă.

În continuare, după o jumătate de secundă de întârziere, folosind funcția personalizată, readColor () vom
citi culoarea bomboanei. Folosind cele patru știfturi de control și pinul de ieșire a frecvenței senzorului de
culoare citim culoarea bomboanei.

Senzorul citește 3 valori diferite pentru fiecare bomboană, roșu, verde și albastru, iar în funcție de aceste
valori, spunem care este culoarea reală.

12
Codul sursă :
#include <Servo.h>
#define S0 2
#define S1 3
#define S2 4
#define S3 5
#define sensorOut 6
Servo topServo;
Servo bottomServo;
int frequency = 0;
int color=0;
void setup() {
pinMode(S0, OUTPUT);
pinMode(S1, OUTPUT);
pinMode(S2, OUTPUT);
pinMode(S3, OUTPUT);
pinMode(sensorOut, INPUT);
// Setarea scalării frecvenței la 20%
digitalWrite(S0, HIGH);
digitalWrite(S1, LOW);
topServo.attach(7);
bottomServo.attach(8);
Serial.begin(9600);
}
void loop() {
topServo.write(150);
delay(500);
// pozitia cutitului la tub
for(int i = 150; i > 97; i--) {
topServo.write(i);
delay(2);
}
delay(1000);
color = readColor();
delay(50);
switch (color) {
case 1:
bottomServo.write(50); // pozitia rampei la 90°
break;
case 2:
bottomServo.write(85);//pozitia rampei la 85°
break;
case 3:
bottomServo.write(115);// pozitia rampei la 115°
break;
case 0:
break;
}
delay(500);
// pozitia cutitului la senzor
for(int i = 97; i > 65; i--) {
13
 topServo.write(i);
delay(2);
}
delay(500);
// pozitia cutitului la rampa
for(int i = 65; i <150; i++) {
topServo.write(i);
delay(2);
}
color=0;
}
// Funcție personalizată - readColor()
int readColor() {
// Setează filtrarea fotodiodelor roșii
digitalWrite(S2, LOW);
digitalWrite(S3, LOW);
// Citirea frecvenței de ieșire
frequency = pulseIn(sensorOut, LOW);
int R = frequency;
// Imprimarea valorii pe monitorul serial
Serial.print("R= ");// numele de imprimare
Serial.print(frequency);// imprimarea frecvenței de culoare roșii
Serial.print(" ");
delay(50);
// Setează filtrarea fotodiodelor verzi
digitalWrite(S2, HIGH);
digitalWrite(S3, HIGH);
// Citirea frecvenței de ieșire
frequency = pulseIn(sensorOut, LOW);
int G = frequency;
// Imprimarea valorii pe monitorul serial
Serial.print("G= ");// numele de imprimare
Serial.print(frequency);// imprimarea frecvenței de culoare verzi
Serial.print(" ");
delay(50);
// Setează filtrarea fotodiodelor albastre
digitalWrite(S2, LOW);
digitalWrite(S3, HIGH);
// Citirea frecvenței de ieșire
frequency = pulseIn(sensorOut, LOW);
int B = frequency;
// Imprimarea valorii pe monitorul serial
Serial.print("B= ");// numele de imprimare
Serial.print(frequency);// imprimarea frecvenței de culoare albastre
Serial.println(" ");
delay(50);
if(R<108 & R>90){
color = 1; // Roşu
}
if(G<130 & G>115){
color = 2; // Verde
14
 }
if(B<87 &B>72){
color = 3; // albastru
}
return color;
}

15
Capitolul 5. Proiectarea machetei

Lista de materiale :
- o placă de dezvoltare compatibilă cu Arduino Nano (ATmega328p și CH340) ;
- un modul senzor de culoare TCS230 ;
- 2 micro servomotoare SG90 90° ;
- fire colorate mama-tata ;
- fire colorate mama-mama ;
- fire colorate tata-tata ;
- o bucata de carton de 5mm ;
- 3 pahare ;
- 3 cuti Picatura (adeziv instant) ;
- un cutter cu lama ;
- un incarcator cu tensiunea de iesire 5V;
- un cablu de alimentare ;
- o banda adeziva .

16
Pentru proiectarea machetei avem nevoie de un desen al pieselor exterioare realizat din figura de mai jos.

Figura 8. Piesele carcasei ȋn AutoCAD

17
Materialul folosit pentru acest proiect este un carton de 5 mm. Am reproiectat piesele în conformitate cu
desenul de mai sus și folosind un catter cu lamă pentru a taie toate piesele la dimensiune.

Figura 9. Piesele reale ale carcasei

Odată ce am pregătit toate piesele, am început să le asamblez folosind un adeziv instant pe baza de
cianoacrilat.

Apoi, am lipit cele două servomotoare pe platformele lor și le-am atașat la ansamblu.

După aceea, am atașat șina de ghidare pe servomotorul inferior, precum și suportul și platforma necesare
servomotorului superior.

Apoi, conectam componentele împreună conform schemei de circuit.

18
Capitolul 6. Rezultatele simulărilor

Ȋn figurile de mai jos putem vedea rezultatele acestei machete.

Figura 10. Rezultatul pentru bomboanele albastre

19
Figura 11. Rezultatul pentru bomboanele verzi

Figura 12. Rezultatul pentru bomboanele roşii

20
Bibliografie

1. https://howtomechatronics.com/projects/arduino-color-sorter-project/
2. https://ro.wikipedia.org/wiki/Arduino
3. https://www.optimusdigital.ro/ro/compatibile-cu-arduino-nano/1686-placa-de-dezvoltare-
compatibila-cu-arduino-nano-atmega328p-i-ch340.html
4. https://www.optimusdigital.ro/ro/senzori-senzori-optici/1854-modul-senzor-de-culoare-tcs230-
albastru.html
5. https://www.optimusdigital.ro/ro/motoare-servomotoare/26-micro-servomotor-sg90.html
6. https://www.eeweb.com/featured-projects/arduino-color-sorter-project

21