Operácie

Triedenie lentiliek: Rozdiel medzi revíziami

Z SensorWiki

(Princíp činnosti)
 
(21 medziľahlých úprav od rovnakého používateľa nie je zobrazených.)
Riadok 1: Riadok 1:
[[Súbor:Lentilky.jpg]]
+
[[File:Lentilky.jpg|thumb|left|400px]]
  
[[File:MMfigures.jpg|thumb|500px|The seven cartoon "spokescandies" for M&M's since 2022]]
 
  
 
'''Lentilky''' sú obvykle čokoládové alebo ovocné cukríky v tvare šošovky (''franc.'' lentille, ''angl.'' lentil) s rôznofarebnoou cukrovou krustou na povrchu.  
 
'''Lentilky''' sú obvykle čokoládové alebo ovocné cukríky v tvare šošovky (''franc.'' lentille, ''angl.'' lentil) s rôznofarebnoou cukrovou krustou na povrchu.  
Riadok 14: Riadok 13:
 
* [https://en.wikipedia.org/wiki/Skittles_(confectionery) Skittles]
 
* [https://en.wikipedia.org/wiki/Skittles_(confectionery) Skittles]
  
 +
__TOC__
  
  
Knižnica ColorPAL
 
  
  
Postup inštalácie (ak ešte nie je na počítači knižnica nainštalovaná):
 
  
1. Choďte na nižsieuvedenú stránku, kliknite na zelené tlačítko Code (vpravo hore), z rozbaľovacieho menu si vyberte Download ZIP...
+
== Snímač farby ColorPAL ==
  https://github.com/westpoint-robotics/ColorPAL
 
2. Po nahratí rozbaľte ColorPAL-master.zip a vyberte folder ColorPAL (bez prípony  '-master'). Presu+nte ho do adresára
 
C:\Users\USername\Documents\Arduino\libraries
 
3. Reštartujte Arduino IDE a knižnica by mala byť pridaná.
 
  
 +
Senzorov na snímanie farieb je [[Senzory na rozpoznávanie farieb|viacero rozličných druhov]], my sa budeme zaoberať snímačom ColorPAL firmy Parallax.
 +
Opis senzora vypracovali študenti Bc. Tamás Vincze a Bc. Adam Rozsár v rámci semestrálneho projektu.
  
=== Color sensor ===
+
[[Obrázok:SnimacFarbyColorPal.jpg|thumb|right]]
  
Parallax ColorPAL module contains TAOS TSL12T photodiode with integrated Q/U converter.
 
  
[[Súbor:TSL12_Schematic.png|center]]
 
  
Following text will show You a basic connection and operation of the Parallax ColorPal digital colour sensor module.
 
  
[[Obrázok:Parallax_ColorPal.jpg]]
+
=== Vlastnosti ===
  
Product page:
+
* Sníma celý rozsah farieb o ktorých dáva informáciu vo forme RGB (Red/Green/Blue) komponentov.
[http://www.parallax.com/StoreSearchResults/tabid/768/txtSearch/colorpal/List/0/SortField/4/ProductID/617/Default.aspx #28380 ColorPAL]
+
* Sníma spektrum okolitého osvetlenia s citlivosťou až 44uW/cm2 na lsb.
 +
* Generuje 24 bitové farby pomocou vstavaného RGB LED.
 +
* Možnosť pripojenia priamo na skúšobnú dosku alebo pomocou predlžovacích káblov.
 +
* Na detekciu a generovanie farby využíva sériovú komunikáciu cez jeden pin.
 +
* Detekcia a generovanie farieb je riadené pomocou vstavaného mikrokontrolera.
 +
* Disponuje vstavanou EEPROM pamäťou pre uloženie snímaných informácií a generačných programov.
 +
* Autorun funkcia umožňuje spustenie vopred určeného programu iba použitím napájania.
  
* [http://www.parallax.com/Portals/0/Downloads/docs/prod/sens/28380ColorPAL.pdf Documentation] (.pdf)
+
[[Súbor:Obr8.jpg|center]]
* [http://www.parallax.com/Portals/0/Downloads/docs/prod/sens/28380-TSL12T-TSL13T-D.pdf Chip datasheet] (.pdf)
 
  
Schematic diagram:
+
=== Princíp činnosti ===
  
[[Obrázok:Parallax_ColorPAL_Schematic.png]]
+
Na rozdiel od snímačov s CMOS detektormi, ktoré prostredníctvom filtrov merajú priamo množstvo odrazeného svetla v jednotlivých zložkách, tento snímač aktívne osvetľuje vzorku rozličnými svetlami (červené, modré a zelené). Postupne odmeria množstvo odrazeného svetla jednotlivých zložiek a z toho potom vieme odhadnúť farbu objektu.  
  
Demo program:
+
ColorPAL používa RGB LED na osvetlenie meranej farby (jedna farba naraz), spolu so široko spektrovým prevodníkom svetlo-napätie na meranie odrazeného svetla. Podľa množstva svetla ktoré sa odráža od meranej farby pri osvetlení od červenej, zelenej a modrej LED diódy je možné určiť farbu vzorky. ColorPAL používa na meranie odrazeného svetla fotodiódu TAOS typu TSL13T alebo 12T, ktorá má krivku spektrálnej citlivosti nasledovnú:
  
<source lang="c">
+
<center>
/*====================================================
+
[[Súbor:Obr1.png]]
/ Connect ColorPAL SIG signal to Arduino pin 2 and 3
+
::'''Obr. 1: Krivka spektrálnej citlivosti prevodníka svetlo-napätie'''
/ Add 2K pullup resistor from pins 2 & 3 to +5v
+
</center>
/ See the result on the serial terminal,
 
/ Baud Rate = 115200 kbps 
 
/ Works with Arduino 0.20, not with 1.00 and above?
 
/ Source: http://be470merchantuy.blogspot.com/2012/02/lab-3-serialread-and-colorpal.html
 
/====================================================*/
 
  
#include <SoftwareSerial.h>
+
Prevodník je kombináciou fotodiódy a transimpedančného zosilňovača v jednom integrovanom obvode. Aktívna plocha fotodiódy je 0.5 mm x 0.5 mm a senzor vníma žiarenie s vlnovou dĺžkou v rozsahu od 320 nm do 1050 nm.Výstupné napätie sa mení lineárne s intenzitou dopadajúceho žiarenia.
SoftwareSerial ColorPAL(2, 3); // rx = 2, tx = 3
 
  
int red, grn, blu;
+
<center>
 +
[[Súbor:TSL12_Schematic.png|center]]
 +
::'''Obr. 2: Fotografia TSL13T, funkčná schéma zapojenie prevodníka a zapojenie vývodov fotodiódy.'''
 +
</center>
  
int gotcolor = 0;
+
Výstupom snímača je napätie, úmerné celého žiarenia ktoré detekuje a ktoré sú potom merané podľa hore uvedenej krivky spektrálnej citlivosti. Keď predmet je osvetlený iba červenou LED, tak snímač bude reagovať s napätím úmerným červenej zložky z farby predmetu a podobne s modrou a zelenou. Snímač a RGB LED diódy sú umiestnené vedľa seba v jednej plastickej trubice.
int letter;
 
  
int redBlackRef=8;
+
=== Použitie ===
int redWhiteRef=234;
+
Senzor používa 3 piny: regulované +5V napájanie, zem a sériový dátový pin s otvoreným kolektorom. Pri práci sme snímač napojili na skúšobnú dosku podľa Obr. 2. Museli sme dávať pozor, aby bol jumper vhodne nastavený, na Vdd a nie na Vin.
  
int grnBlackRef=3;
+
Pomocou predlžovacieho káblika sa senzor jednoducho pripojí k Acrob doske do konektora pre servomotorčeky:
int grnWhiteRef=166;
 
  
int bluBlackRef=6;
+
[[Obrázok:Parallax_ColorPAL_Schematic3.png]]
int bluWhiteRef=285;
 
  
 +
== Software na meranie ==
  
void setup(){
 
  
Serial.begin(115200); // Start communication with serial port read value
+
Po pripojení senzora k mikropočítaču Arduino / Acrob, budete potrebovať okrem samotného programu aj doinštalovať knižnicu <code>ColorPal.h</code>
ColorPAL.begin(4800); // Send signal to led to read value
 
  
pinMode(2,INPUT); // serial pin out from color pal
+
=== Knižnica ColorPAL ===
pinMode(3,INPUT); // from same serial pin, signal pulls up, sends, pulls down, reads
 
digitalWrite(2,HIGH); // Enable the pull-up resistor
 
digitalWrite(3,HIGH); // Enable the pull-up resistor
 
  
pinMode(2,OUTPUT); // send signal out
+
Postup inštalácie (ak ešte nie je na počítači knižnica nainštalovaná):
pinMode(3,OUTPUT);
 
digitalWrite(2,LOW); // turn pin off so pin 3 can go high
 
digitalWrite(3,LOW);
 
  
pinMode(2,INPUT); // Input signal to print
+
1. Choďte na nižsieuvedenú stránku, kliknite na zelené tlačítko Code (vpravo hore), z rozbaľovacieho menu si vyberte Download ZIP...
pinMode(3,INPUT);
+
  https://github.com/westpoint-robotics/ColorPAL
 +
2. Po nahratí rozbaľte ColorPAL-master.zip a vyberte folder ColorPAL (bez prípony  '-master'). Presu+nte ho do adresára
 +
C:\Users\USername\Documents\Arduino\libraries
 +
3. Reštartujte Arduino IDE a knižnica by mala byť pridaná.
  
Serial.println("Pass 1");
 
delay(20);
 
  
while( digitalRead(2) != HIGH || digitalRead(3) != HIGH ) {
+
=== Demonštračný program ===
Serial.println("In the loop");
 
delay(50);
 
}
 
  
Serial.println("Pass 2");
+
Nasledovný program inicializuje senzor a v slučke potom vyčítava jednotlivé farebné zložky, ktoré po sériovej linke posiela do počítača.
  
pinMode(2,OUTPUT);
+
<tabs>
pinMode(3,OUTPUT);
+
<tab  name="Arduino Demo"><source lang="cpp">
digitalWrite(2,LOW);
 
digitalWrite(3,LOW);
 
delay(100); // spec is 80, but not all ColorPAL units work with 80
 
  
pinMode(2,INPUT);
+
#include <ColorPAL.h>    /* Kniznica pre pracu so senzorom      */
pinMode(3,OUTPUT);
 
delay(100);
 
  
}
+
#define SW1 6            /* Ak chceme meranie ovladat tlacitkom */
 +
#define LED1 13          /* LEDka na doske                      */
  
// This oscillates back and forth on one wire to turn off led, send signal,
+
ColorPAL sensor;        /* Vytvori instanciu senzora          */
// turn on led, read signal. very fast strobe read - arduino is not capable of
 
// one wire signal communication over digital ports, so this is a way around
 
// that over 2 wires communicating with 1 pin on the sensor.
 
//---------------------------------
 
 
 
void loop()
 
{
 
 
  readColor();
 
  
  int redCorrect = (255*(red-redBlackRef))/(redWhiteRef-redBlackRef);
+
int red;                /* Premenne na jednotlive farby        */
  int bluCorrect = (255*(blu-bluBlackRef))/(bluWhiteRef-bluBlackRef);
+
int grn;
  int grnCorrect = (255*(grn-grnBlackRef))/(grnWhiteRef-grnBlackRef);
+
int blu;
  
 +
char buffer[20];        /* Docasny buffer na textovy retazec  */
  
  Serial.print("R");
 
  Serial.print(redCorrect);
 
  Serial.print(" ");
 
  Serial.print(red);
 
  Serial.print(" G");
 
  Serial.print(grnCorrect);
 
  Serial.print(" ");
 
  Serial.print(grn);
 
  Serial.print(" B");
 
  Serial.print(bluCorrect);
 
  Serial.print(" ");
 
  Serial.println(blu);
 
  
  //int redCorrect = red;
+
void setup()
  //int bluCorrect = grn;
+
{
  //int grnCorrect = blu;
+
  pinMode(SW1,INPUT_PULLUP);
 +
  pinMode(LED1,OUTPUT);
  
  if (redCorrect > 240 && redCorrect <=255 && grnCorrect >240 && grnCorrect <=255 && bluCorrect >240 && bluCorrect <= 255)
+
  sensor.attachPAL(10);    /* Senzor je pripojeny na D10      */
  {
+
   Serial.begin(9600);      /* Rychlost seriovej linky 9600Bd   */
    Serial.print("White");
+
}
    delay(100);
 
  }
 
 
 
 
 
  if (redCorrect > 0 && redCorrect <= 40 && grnCorrect >0 && grnCorrect <=40 && bluCorrect >0 && bluCorrect <= 40){
 
    Serial.print("Black");
 
    delay(100);
 
   }
 
 
 
  if (redCorrect > 140 && redCorrect <= 255 && grnCorrect >0 && grnCorrect <=80 && bluCorrect >0 && bluCorrect <= 130){
 
    Serial.print("Red");
 
    delay(100);
 
   }
 
 
 
  if (redCorrect > 200 && redCorrect <= 255 && grnCorrect >0 && grnCorrect <=200 && bluCorrect >130 && bluCorrect <= 255){
 
    Serial.print("Pink");
 
     delay(100);
 
   }
 
 
 
  if (redCorrect > 200 && redCorrect <= 255 && grnCorrect >80 && grnCorrect <=160 && bluCorrect >0 && bluCorrect <= 120){
 
    Serial.print("Orange");
 
    delay(100);
 
  }
 
 
 
  if (redCorrect > 180 && redCorrect <= 255 && grnCorrect >200 && grnCorrect <=255 && bluCorrect >0 && bluCorrect <= 255){
 
      Serial.print("Yellow");
 
      delay(100);
 
    }
 
 
 
  if (redCorrect > 120 && redCorrect <= 200 && grnCorrect >0 && grnCorrect <=230 && bluCorrect >120 && bluCorrect <= 255){
 
      Serial.print("Purple");
 
      delay(100);
 
    }
 
  
  if (redCorrect > 0 && redCorrect <= 180 && grnCorrect >100 && grnCorrect <=255 && bluCorrect >0 && bluCorrect <= 170){
 
      Serial.print("Green");
 
      delay(100);
 
  }
 
  
  if (redCorrect > 0 && redCorrect <= 180 && grnCorrect >0 && grnCorrect <=255 && bluCorrect >170 && bluCorrect <= 255){
+
void loop()  
      Serial.print("Blue");
 
      delay(100);
 
  }
 
 
 
  gotcolor = 0;
 
  delay(100);
 
 
 
}  /* End of loop()  */
 
 
 
/* ***************************************** */
 
/* Function readColor()                      */
 
/* Reads ColorPAL, putting results in the    */
 
/*      red, grn, blu variables            */
 
/* ***************************************** */
 
void readColor()  
 
 
{  
 
{  
   char rByte[9];
+
   red = sensor.redPAL();   // Reads sensors and returns red value
   char dummy[4];
+
   grn = sensor.greenPAL(); // Reads sensors and returns green value
 +
  blu = sensor.bluePAL();  // Reads sensors and returns blue value
 
    
 
    
   delay(20);
+
   buffer[19] = '\0';
  ColorPAL.begin(4800);
+
  buffer[18] = '\0';
  ColorPAL.print("= (00 $ m) !"); // set up loop to continuously send color data
 
  pinMode(3,INPUT);
 
  gotcolor = 0;
 
  while (gotcolor == 0)
 
  {
 
    rByte[0] = ColorPAL.read();
 
    if( rByte[0] == '$' )
 
      {
 
      gotcolor = 1;
 
      for (int i=0; i<9; i++)
 
          {
 
          rByte[i] = ColorPAL.read();
 
          // Serial.print(rByte[i]);
 
          }
 
      Serial.println("");
 
    dummy[0] = rByte[0];
 
    dummy[1] = rByte[1];
 
    dummy[2] = rByte[2];
 
    dummy[3] = 0;
 
 
 
    red = strtol(dummy,NULL,16);
 
 
 
    dummy[0] = rByte[3];
 
    dummy[1] = rByte[4];
 
    dummy[2] = rByte[5];
 
 
    
 
    
    grn = strtol(dummy,NULL,16);
+
                            // Tu si pripravime retazec na odvysielanie
 
+
                            // v tvare R0000 G0000 B0000 <CR>
    dummy[0] = rByte[6];
+
    dummy[1] = rByte[7];
+
  sprintf(buffer, "R%4.4d G%4.4d B%4.4d\015", red, grn, blu);
    dummy[2] = rByte[8];
 
  
    blu = strtol(dummy,NULL,16);
+
  Serial.println(buffer);   // A tu ho odvysielame
    }
 
  }
 
/* End of function readColor() */
 
 
 
</source>
 
 
 
If the program works correctly, it will send to the serial port (115 200 Bd) following data:
 
 
 
 
 
R27 32 G106 71 B40 50
 
Green
 
R37 41 G134 89 B50 61
 
Green
 
R34 39 G126 84 B46 57
 
Green
 
 
 
R19 25 G84 57 B27 36
 
 
R18 24 G78 53 B26 35
 
 
R15 22 G65 45 B23 32
 
 
R15 22 G68 47 B22 31
 
 
   
 
   
  R14 21 G68 47 B21 30
+
  delay(100);              // 10 merani za sekundu nam staci
 +
}  
  
R16 23 G31 23 B26 35
+
 
Black
+
 
R16 23 G32 24 B30 39
 
Black
 
R15 22 G26 20 B21 30
 
Black
 
R10 17 G21 17 B19 27
 
  
 +
</source></tab>
 +
</tabs>
  
 +
Ak bude všetko v poriadku, program začne merať farby a posielať na sériový port (9600 Bd) podobné data:
  
 +
R0027 G0106 B0040
 +
R0037 G0134 B0050
 +
R0034 G0126 B0046
 +
...
  
  
 +
=== Ukážková aplikácia ===
  
== Demo software ==
+
Vyššieuvedený program by mal fungovať (žiaľ nie vždy celkom spoľahlivo) aj s originálnym programom Philippa Pilgrima (Parallax)
 
+
na rozpoznávanie farieb <code>TCS3200_ColorPAL_match.exe</code>.
 
+
* Originál https://www.parallax.com/package/colorpal-color-sensor-downloads/?wpdmdl=2901&refresh=641fd7e2308fd1679808482&ind=1600309026340&filename=28380-ColorPAL-Color-Matching-Program-BS-Sample-Files.zip
Following Arduino code works with an original Parallax (or PhiPi) ColorDemo.exe program available at
+
* Lokálna kópia https://senzor.robotika.sk/mems/ColorPalDemo.zip
the following address: http://www.parallax.com/Portals/0/Downloads/docs/prod/sens/ColorPAL_programs.zip
 
  
 
[[Obrázok:ColorPAL_demo.png|center]]
 
[[Obrázok:ColorPAL_demo.png|center]]
  
<source lang="c">
 
/*====================================================
 
/ Connect ColorPAL SIG signal to Arduino pin 2 and 3
 
/ Baud Rate = 9600 kbps
 
/ Works with Arduino 0.20, not with 1.00 and above?
 
/====================================================*/
 
  
#include <SoftwareSerial.h>
+
== Meranie ==
  
SoftwareSerial ColorPAL(2, 3); // rx = 2, tx = 3
+
Vašou úlohou je teraz namerať primerané množstvo vzoriek lentiliek z každej farby. Meranie aj niekoľkokrát zopakujte. Cieľom je získať .csv súbor v nasledovnom formáte:
  
int red, grn, blu;
+
r,g,b,target,target_name
 +
25,57,181,0,blue
 +
25,63,191,0,blue
 +
189,38,31,1,orange
 +
188,45,41,1,orange
 +
49,109,93,2,green
 +
49,111,94,2,green
  
int gotcolor = 0;
+
Význam stĺpcov '''r''', '''g''' a '''b''' je zrejmý, '''target_name''' je názov farby a '''target''' je unikátne číslo pre každú farbu.
int letter;
 
  
char colorByte[9];
+
Aby ste získali požadované dáta, musíte upraviť formátovací reťazec vo vzorovom programe vyššie. Potom jednotlivé merania skopírujete z terminálového okna a doeditujete požadované údaje.
  
void setup(){
+
Meranie si môžete trocha zjednodušiť, ak si pripojíte k procesoru tlačítko a dáta zmeriate a vyšlete len raz, po stlačení tlačítka:
  
  // for colordemo 9600,
+
<tabs>
Serial.begin(9600); // Start communication with serial port read value
+
<tab  name="Testovanie tlačítka"><source lang="cpp">
ColorPAL.begin(4800); // Send signal to led to read value
 
  
pinMode(2,INPUT); // serial pin out from color pal
+
while (digitalRead(SW1) == HIGH)     // tlačítko je aktívne do nuly
pinMode(3,INPUT); // from same serial pin, signal pulls up, sends, pulls down, reads
+
  {
digitalWrite(2,HIGH); // Enable the pull-up resistor
+
    /* len tu cakaj a nic nerob */
digitalWrite(3,HIGH); // Enable the pull-up resistor
+
  }
  
pinMode(2,OUTPUT); // send signal out
 
pinMode(3,OUTPUT);
 
digitalWrite(2,LOW); // turn pin off so pin 3 can go high
 
digitalWrite(3,LOW);
 
  
pinMode(2,INPUT); // Input signal to print
+
  /* hotovo, tlacitko je stlacene */
pinMode(3,INPUT);
 
  
delay(20);
+
</source></tab>
 +
</tabs>
  
while( digitalRead(2) != HIGH || digitalRead(3) != HIGH ) {
+
Ďalšie zjednodušenie by mohlo spočívať v zadávaní požadovanej farby, takže by procesor rovno vyslal celý riadok vhodný do .csv súboru. Dalo by sa to napríklad pomocou
delay(50);
+
funkcie [https://www.arduino.cc/reference/en/language/functions/communication/serial/readstringuntil/ readStringUntil()], takto nejako:
}
 
 
 
 
 
pinMode(2,OUTPUT);
 
pinMode(3,OUTPUT);
 
digitalWrite(2,LOW);
 
digitalWrite(3,LOW);
 
delay(100); // spec is 80, but not all ColorPAL units work with 80
 
 
 
pinMode(2,INPUT);
 
pinMode(3,OUTPUT);
 
delay(100);
 
 
 
 
 
  delay(20);
 
  ColorPAL.begin(4800);
 
  ColorPAL.print("= (00 $ m) !"); // set up loop to continuously send color data
 
  pinMode(3,INPUT);
 
  
 +
<tabs>
 +
<tab  name="Čítanie informácie zo sériového portu"><source lang="cpp">
  
 +
void setup()
 +
{
 +
  Serial.begin(9600); // opens serial port, sets data rate to 9600 bps
 
}
 
}
  
// This oscillates back and forth on one wire to turn off led, send signal,
+
void loop()  
// turn on led, read signal. very fast strobe read - arduino is not capable of
 
// one wire signal communication over digital ports, so this is a way around
 
// that over 2 wires communicating with 1 pin on the sensor.
 
//---------------------------------
 
 
 
void loop()
 
 
{
 
{
 +
  // check if data is available
 +
  if (Serial.available() > 0) {
 +
    // read the incoming string:
 +
    String incomingString = Serial.readStringUntil('\n');
  
  readColor();
+
    // prints the received data
  gotcolor = 0;
+
    Serial.print("I received: ");
   delay(100);
+
    Serial.println(incomingString);
 +
   }
 +
}
  
/* End of loop()  */
+
</source></tab>
 +
</tabs>
  
  
/* ***************************************** */
+
== Strojové učenie ==
/* Function readColor()                      */
 
/* Reads ColorPAL, putting results in the    */
 
/*      red, grn, blu variables            */
 
/* ***************************************** */
 
void readColor()
 
{
 
  char rByte[9];
 
  char dummy[4];
 
  
//  delay(20);
+
Ak ste už zmerali svoj balíček cukríkov, mali by ste mať pripravený .csv súbor v ktorom je všetko potrebné. Ďalšia úloha je natrénovať nejaký algoritmus na nameraných dátach a implementovať ho potom do Arduina, aby správne rozpoznávalo jednotlivé lentilky.  
//  ColorPAL.begin(4800);
 
//  ColorPAL.print("= (00 $ m) !"); // set up loop to continuously send color data
 
  
  pinMode(3,INPUT);
+
Okrem asi najznámejších ML (Machine Learning) algoritmov, ktorými sú neurónové siete existuje aj množstvo ďalších, pričom niektoré sú na implementáciu do malých mikropočítačov vhodnejšie ako iné. My využijeme tzv. Decision Tree, teda
  gotcolor = 0;
+
rozhodovací strom. Asi by ste ho dokázali implementovať aj intuitívne, ale výhodou algoritmu strojového učenia je, že nájde optimálny strom, teda taký, kde bude minimálny počet rozhodovacích vetiev.  
  while (gotcolor == 0)
 
  {
 
    rByte[0] = ColorPAL.read();
 
    if( rByte[0] == '$' )
 
      {
 
      gotcolor = 1;
 
      for (int i=0; i<9; i++)
 
          {
 
          rByte[i] = ColorPAL.read();
 
          }
 
  
    Serial.print("R0");
+
Ďalej budeme pracovať v Google Colab notebooku, kde máte všetko pripravené.
    Serial.print(rByte[0]);
 
    Serial.print(rByte[1]);
 
    Serial.print(rByte[2]);
 
    Serial.print(" G0");
 
    Serial.print(rByte[3]);
 
    Serial.print(rByte[4]);
 
    Serial.print(rByte[5]);
 
    Serial.print(" B0");
 
    Serial.print(rByte[6]);
 
    Serial.print(rByte[7]);
 
    Serial.print(rByte[8]);
 
    Serial.println();   
 
  
    }
 
  }
 
}  /* End of function readColor() */
 
</source>
 
  
 +
== Strojové učenie ==
  
== Snímač farby ColorPAL ==
+
Ak ste už zmerali svoj balíček cukríkov, mali by ste mať pripravený .csv súbor v ktorom je všetko potrebné. Ďalšia úloha je natrénovať nejaký algoritmus na nameraných dátach a implementovať ho potom do Arduina, aby správne rozpoznávalo jednotlivé lentilky.  
 
 
*Vypracovali:
 
:::::'''Bc. Tamás Vincze'''
 
:::::'''Bc. Adam Rozsár'''
 
  
*Študijný odbor:  '''Aplikovaná mechatronika'''
+
Okrem asi najznámejších ML (Machine Learning) algoritmov, ktorými sú neurónové siete existuje aj množstvo ďalších, pričom niektoré sú na implementáciu do malých mikropočítačov vhodnejšie ako iné. My využijeme tzv. Decision Tree, teda
 +
rozhodovací strom. Asi by ste ho dokázali implementovať aj intuitívne, ale výhodou algoritmu strojového učenia je, že nájde optimálny strom, teda taký, kde bude minimálny počet rozhodovacích vetiev.
  
*Ročník:          '''2.Ing'''
+
Ďalej budeme pracovať v Google Colab notebooku, kde máte všetko pripravené.
  
== Zadanie ==
+
<center>
Zobrazte na LCD aktuálnu snímanú farbu zmeranú snímačom ColorPal.
+
<html>
 +
<img src="https://upload.wikimedia.org/wikipedia/commons/thumb/d/d0/Google_Colaboratory_SVG_Logo.svg/160px-Google_Colaboratory_SVG_Logo.svg.png" /><BR>
 +
</html>
 +
<FONT Size="+2">  🡆 [https://colab.research.google.com/drive/10V87_bsniOzooZXJJax5IvIUFiMXY-v4?usp=sharing Google Colab Notebook]</FONT>
 +
</center>
  
[[Obrázok:SnimacFarbyColorPal.jpg]]
 
  
'''Literatúra:'''
+
Ak by vám niečo z nejakého dôvodu nefungovalo, môžete použiť  [https://senzor.robotika.sk/mems/files/RGBvalues.csv tento vzorový .csv súbor] na odladenie vášho postupu.
  
* [http://www.parallax.com/StoreSearchResults/tabid/768/txtSearch/28380/List/0/SortField/4/ProductID/617/Default.aspx Product Page] (parallax.com)
+
== Implementácia ==
* [http://www.parallax.com/Portals/0/Downloads/docs/prod/sens/28380ColorPAL.pdf Datasheet]
 
* [http://www.parallax.com/Portals/0/Downloads/docs/prod/sens/28380-TSL12T-TSL13T-D.pdf Sensor datasheet]
 
  
 +
Navrhnutý algoritmus preneste do mikropočítača a otestujte na novej vzorke lentiliek (môžete si napr. vymeniť so susedom). Rozpoznávanie (klasifikáciu) bude realizovať nižšie uvedený program. Nezabudnite mu však dodať aj z Google Colab notebooku vygenerované súbory <code>Pipeline.h</code> a <code>Classifier.h</code>:
  
==Snímač a generátor farby ColorPAL==
+
<tabs>
'''Vlastnosti'''
+
<tab  name="Čítanie informácie zo sériového portu"><source lang="cpp">
*Sníma celý rozsah farieb o ktorých dáva informáciu vo forme RGB (Red/Green/Blue) komponentov.
+
#include <ColorPAL.h>    /* Kniznica pre pracu so senzorom */
*Sníma spektrum okolitého osvetlenia s citlivosťou až 44uW/cm2 na lsb.
 
*Generuje 24 bitové farby pomocou vstavaného RGB LED.
 
*Možnosť pripojenia priamo na skúšobnú dosku alebo pomocou predlžovacích káblov.
 
*Na detekciu a generovanie farby využíva sériovú komunikáciu cez jeden pin.
 
*Detekcia a generovanie farieb je riadené pomocou vstavaného mikrokontrolera.
 
*Disponuje vstavanou EEPROM pamäťou pre uloženie snímaných informácií a generačných programov.
 
*Autorun funkcia umožňuje spustenie vopred určeného programu iba použitím napájania.
 
  
[[Súbor:Obr8.jpg]]
+
#include "Pipeline.h"    /* Vygenerovane z Google Colab */
 +
#include "Classifier.h"
  
== Princíp činnosti ==
+
ColorPAL sensor;
ColorPAL používa RGB LED na osvetlenie meranej farby (jedna farba naraz), spolu so široko spektrovým prevodníkom svetlo-napätie na meranie odrazeného svetla. Podľa množstva svetla ktoré sa odráža od meranej farby pri osvetlení od červenej, zelenej a modrej LED diódy je možné určiť farbu vzorky. ColorPAL používa sveteľný senzor TAOS typu TSL13T, ktorý má krivku spektrálnej citlivosťi nasledovný:
 
  
[[Súbor:Obr1.png]]
+
void setup()  
::'''Obr. 1: Krivka spektrálnej citlivosti prevodníka svetlo-napätie'''
 
 
 
Prevodník je kombináciou fotodiódy a transimpedančného zosilňovača v jednom integrovanom obvode. Aktívna plocha fotodiódy je 0.5 mm x 0.5 mm a senzor vníma žiarenie s vlnovou dĺžkou v rozsahu od 320 nm do 1050 nm.Výstupné napätie sa mení lineárne s intenzitou dopadajúceho žiarenia.
 
 
 
[[Súbor:Obr2.jpg]]
 
::'''Obr. 2: Funkčná schéma zapojenie prevodníka'''
 
[[Súbor:Obr3.jpg]]
 
::'''Obr. 3: Pohľad z hora prevodníka'''
 
 
 
Výstupom snímača je napätie, úmerné celého žiarenia ktoré detekuje a ktoré sú potom merané podľa hore uvedenej krivky spektrálnej citlivosti. Keď predmet je osvetlený iba červenou LED, tak snímač bude reagovať s napätím úmerným červenej zložky z farby predmetu a podobne s modrou a zelenou. Snímač a RGB LED diódy sú umiestnené vedľa seba v jednej plastickej trubice.
 
 
 
 
 
==Použitie==
 
Senzor používa 3 piny: regulované +5V napájanie, zem a sériový dátový pin s otvoreným kolektorom. Pri práci sme snímač napojili na skúšobnú dosku podľa Obr. 2. Museli sme dávať pozor, aby bol jumper vhodne nastavený, na Vdd a nie na Vin.
 
 
 
[[Súbor:Obr2.png]]
 
::'''Obr. 4: Schéma zapojenia snímača ColorPAL'''
 
 
 
== Programovanie ==
 
Komunikácia s ColorPAL-om je realizovaná cez sériovú linku, prijímanie a odosielanie medzi 2400 a 7200 baudom. ColorPAL má v sebe zabudovaný pullup rezistor, preto nie je potrebné používať externý. Pretože používa open-drain protokol, pin ktorý sa používa na komunikáciu s ColorPAL-om by mal byť vždy nastavený ako vstupný, okrem prípadu keď je v stave 0. Pri inicializovaní snímača musíme čakať aby ColorPAL dal tento pin do jednotky predtým než začneme posielať príkazy.
 
 
 
 
 
Snímač môže pracovať v rôznych režimoch:
 
 
 
*Priamy režim: príkazy sú prijímané a vykonávané ihneď
 
*Bufferovací režim: príkazy sú prijímané a uložené do buffera pre použitie v budúcnosti
 
*Vykonávací režim: príkazy, ktoré sú uložené do EEPROM pamäte, sa vykonajú
 
 
 
 
 
Snímač vieme resetovať tromi rôznymi spôsobmi:
 
*Powerup: pri prvom zapnutí ColorPAL začne vykonávať príkazy, ktoré sú uložené vo vnútornej pamäti EEPROM na adrese 00.  Pri novom, ešte neprogramovanom snímači tento program prejde do priameho módu.
 
*Short Break: 7 milisekundová logická 0 resetuje snímač a začne sa vykonávať Powerup.
 
*Long Break: 80< milisekundová logická 0 resetuje snímač a vstúpi do Priameho módu.
 
 
 
[[Súbor:Obr20.jpg]]
 
 
 
== Riešenie ==
 
 
 
Sériová linka používa piny D0 a D1 portu D mikropočítača. LCD panel,ktorý sme na paneli mali vopred zapojený používa tiež PORTD pre komunikáciu, kvôli čomu sme tento LCD modul nevedeli použiť na výpis výsledku merania snímača. Zapojili sme nový LCD modul, ktorý používa PORTB ako riadiacu zbernicu a PORTC ako dátovú zbernicu. Patričné zmeny sme vykonali aj v hlavičkových súboroch:
 
 
 
[[lcd.c]], [[lcd.h]]
 
 
 
Presné zapojenie LCD modulu je na Obr.5.
 
 
 
[[Súbor:Obr.5.jpg]]
 
::'''Obr. 5: Zapojenie LCD modulu'''
 
 
 
Potrebovali sme pripojiť k projektu ešte ďalšie súbory:[[serial.c]]  [[serial.h]]
 
 
 
Zdrojový kód nášho programu:
 
<source lang="c">
 
#include "lcd.h"
 
#include "serial.h"
 
#include <stdio.h>
 
 
 
char sgetc(void)
 
 
{
 
{
while ((UCSR0A & (1 << RXC0)) == 0)                // Počká kým sú prijaté dáta
+
  sensor.attachPAL(10);    /* Senzor je pripojeny na D10 */
  {
+
  Serial.begin(9600);     /* Rychlost seriovej linky    */
    //  Nerobí nič, pokiaľ nie sú dáta prijaté a nie je pripravené čítať z UDR
 
  };
 
      return UDR0;                               // prijatý bajt sa uloží do UDR0 
 
 
}
 
}
  
 
+
void loop()  
int main(void)
 
 
{
 
{
char buffer[9];
+
  // get RGB values
inituart();
+
 +
  int r = sensor.redPAL();    // Reads sensors and returns red value
 +
  int g = sensor.greenPAL();  // Reads sensors and returns green value
 +
  int b = sensor.bluePAL();  // Reads sensors and returns blue value
 +
 
 +
  // print values to Serial
 +
  Serial.print("RGB: ");
 +
  Serial.print(r,3);
 +
  Serial.print(",");
 +
  Serial.print(g,3);
 +
  Serial.print(",");
 +
  Serial.print(b,3);
 +
   
 +
  // perform feature extraction
 +
  float features[] = {r, g, b};
 +
   
 +
  if (!pipeline.transform(features))
 +
      return;
  
int i;
+
  // perform classification on pipeline result
 +
  Serial.print(" |  Predicted color: ");
 +
  Serial.println(tree.predictLabel(pipeline.X));
  
FILE mystdout = FDEV_SETUP_STREAM(sendchar, NULL, _FDEV_SETUP_WRITE); // "sendchar" je funkcia pre posielanie jedného znaku
+
  delay(300);
+
}
inituart();                                                          //inicializácia sériovej linky
+
</source></tab>
_delay_ms(80);
+
</tabs>
unsigned char znak;
 
_delay_ms(2000);
 
  
    lcdInit4();                            // inicializacia v 4-bitovom rezime
 
    lcdControlWrite(1<<LCD_CLR);            // display clear
 
    lcdControlWrite(0x40);                  // pozicia 0,0
 
  
lcdDataWrite(znak='A'); 
+
Ak máte chuť, môžete si dostavať aj mechanický triedič, ktorý vám lentilky roztriedy podľa farieb:
lcdDataWrite(znak='H');      //testovanie výpisu na LCD panel
 
lcdDataWrite(znak='O');
 
lcdDataWrite(znak='J');
 
  
 +
* [https://learn.parallax.com/tutorials/language/blocklyprop/candy-sorter-blocklyprop-project Triedič z kartónu]
 +
* [https://interestingengineering.com/video/make-your-very-own-arduino-based-color-candy-sorting-machine Kvalitnejší triedič]
 +
* [https://www.thingiverse.com/thing:2762922 3D printed Color Sorter]
 +
* [https://www.instructables.com/Arduino-MM-Color-Sorter/ Iný 3D Color Sorter s návodom]
 +
* [https://hackaday.io/project/7579-3d-printed-skittles-sorting-machine Ďalší 3D triedič s návodom]
 +
* [https://www.youtube.com/watch?v=Ku9PKRoH1CE Veľmi dôvtipný mechanizmus s jediným motorčekom]
 +
* ... [https://www.google.com/search?client=firefox-b-d&q=arduino+color+sorter a celá kopa ďalších]
  
stdout = &mystdout;          // Odteraz funguje printf();
 
 
  DDRD&=0xF8; //nastavenie používaných pinov D0,D1 a D2 ako vstupné
 
PORTD=0x00; //bez nastavenia pull-up rezistorov
 
 
DDRD|=0x06;            //nastavenie pinov D1 a D2 ako výstupné
 
PORTD=0x00;
 
 
_delay_ms(80);  // 80 ms logická nula pre vstup do priameho módu
 
 
DDRD&=0xFA;            //nastavenie pinu D2 ako vstupný
 
inituart();
 
 
stdout = &mystdout;
 
 
/* printf("=C!");
 
_delay_ms(2000);
 
printf("=R!");
 
_delay_ms(2000);                      //testovanie RGB LED
 
printf("=Q!");
 
_delay_ms(2000);
 
printf("=B!");
 
_delay_ms(2000);*/
 
 
printf("=(00 @ m )!");                                //posielanie príkazu na opakované meranie-pred výstupný údaj vloží znak "@"
 
                                                     
 
DDRD&=0xF8;                                  // nastavenia pinov D0,D1 a D2 ako vstupné                                     
 
  for (;;)                                       
 
  {
 
while(sgetc()!='@');                          //ak v prijatých dátach sa vyskytne znak "@"
 
for(i=0;i<9;i++)                              //uloží nasledujúcich 9 znakov do bufferu
 
buffer[i]=sgetc();                     
 
lcdControlWrite(0xC0);                //skočí na druhý riadok LCD modulu
 
for(i=0;i<9;i++)
 
lcdDataWrite(buffer[i]);              //výpis znakov na LCD
 
 
}
 
    for(;;);
 
    return 0;
 
}
 
</source>
 
  
Počas riešenia úlohy sa nám vyskytol problém že sme sa nevedeli dostať do priameho režimu. Presvedčili sme sa s osciliskopom že na dátovom pine snímača sa nevyskytuje 80 milisekundová log. 0 a preto sa snímač nedostal do požadovaného módu. Použili sme pin D2 portu D pre správne nastavenie log. 0 pre vstup do priameho módu.  
+
Je to len hračka? Nie, pozrite sa napríklad na tento [https://www.colorsorter-realtech.com/Productd/43.html priemyselný triedič kávových zŕn]:
Posielaním príkazov sme nemali problém cez sériovú linku snímača, RGB LED sme vedeli vysvecovať pomocou LED príkazov podľa datasheet-u. Prijaté dáta sme vedeli zobrazovať len na termináli. Snímač nám vrátil 9 číslicové hexa kódy v tvare @RRRGGGBBB. Tento údaj nám dáva informáciu o tom, v akom pomere sú prítomné jednotlivé zložky (červená, zelená a modrá) žiarenia odrazeného od skúmanej farby. Jednotlivé hexa zložky sme premenili na decimálne hodnoty, ktoré sme potom prepočítali na RGB kód. Pomocou týchto RGB kódov sme prispeli ku grafickému zobrazeniu meranej farby použitím grafického editora. (Obr. 6) Prepočty jednotlivých farieb vidíme v tabulke:
 
  
[[Súbor:Obr10.jpg]]
+
[[Súbor:ColorSorterCoffeeBeans.jpg|center|500px|thumb|Triedič kávových zŕn ]]
  
 +
== Literatúra: ==
  
== Záver ==
+
* Product Page: [https://www.parallax.com/product/colorpal-color-sensor/  #28380 ColorPAL] (parallax.com)
 +
* [https://www.parallax.com/package/colorpal-color-sensor-downloads/ Downloads] (parallax.com)
 +
* Product manual [https://senzor.robotika.sk/mems/files/28380-ColorPAL.pdf ver.A] a [https://senzor.robotika.sk/mems/files/28380-ColorPAL_RevB.pdf ver.B]  (local)
 +
* [https://senzor.robotika.sk/mems/files/28380-SensorDatasheet.pdf Sensor datasheet] (local)
 +
* [https://senzor.robotika.sk/mems/files/ColorPalDemo.zip Demo software] (local)
 +
* Vzorový [https://senzor.robotika.sk/mems/files/RGBvalues.csv .csv súbor]
 +
* Ak chceme aj zobrazenie na displeji, pozri [[LCD displej]]
 +
* Pozri aj ďalšie [[Senzory na rozpoznávanie farieb]]
  
Vykonali sme pár meraní na týchto farbách s nasledovnými výsledkami:
 
  
[[Súbor:Obr9.jpg]]
 
::'''Obr. 6: Porovnanie reálnych a snímaných farieb so snímačom ColorPAL'''
 
  
Z výsledkov merania je zrejmé že snímač nie je celkom presný. K presnejšiemu meraniu potrebujeme nakalibrovať snímač a použiť korekciu.
+
[[File:MMfigures.jpg|thumb|500px|The seven cartoon "spokescandies" for M&M's since 2022|center]]

Aktuálna revízia z 10:56, 26. marec 2023

Lentilky.jpg


Lentilky sú obvykle čokoládové alebo ovocné cukríky v tvare šošovky (franc. lentille, angl. lentil) s rôznofarebnoou cukrovou krustou na povrchu. V Česku ich vyrábala firma Sfinx Holešov už od roku 1907 (konkurenčné M&M's sa vyrábajú až od r. 1941). Unikátny výrobný proces českých lentiliek trvá viac ako osem hodín. Firma Sfinx sa v roku 1992 stala súčasťou koncernu Nestlé, čo žiaľ znamenalo aj koniec Lentiliek, pretože od apríla 2021 prevzala výrobu továreň v Hamburgu a to jednak z ekologických dôvodov, ako aj z dôvodu „harmonizácie“ (= zjednotenie receptúry) so značkou Smarties.

Na toto cvičenie si musíte zaobstarať niektoré z týchto cukríkov:



Snímač farby ColorPAL

Senzorov na snímanie farieb je viacero rozličných druhov, my sa budeme zaoberať snímačom ColorPAL firmy Parallax. Opis senzora vypracovali študenti Bc. Tamás Vincze a Bc. Adam Rozsár v rámci semestrálneho projektu.

SnimacFarbyColorPal.jpg



Vlastnosti

  • Sníma celý rozsah farieb o ktorých dáva informáciu vo forme RGB (Red/Green/Blue) komponentov.
  • Sníma spektrum okolitého osvetlenia s citlivosťou až 44uW/cm2 na lsb.
  • Generuje 24 bitové farby pomocou vstavaného RGB LED.
  • Možnosť pripojenia priamo na skúšobnú dosku alebo pomocou predlžovacích káblov.
  • Na detekciu a generovanie farby využíva sériovú komunikáciu cez jeden pin.
  • Detekcia a generovanie farieb je riadené pomocou vstavaného mikrokontrolera.
  • Disponuje vstavanou EEPROM pamäťou pre uloženie snímaných informácií a generačných programov.
  • Autorun funkcia umožňuje spustenie vopred určeného programu iba použitím napájania.
Obr8.jpg

Princíp činnosti

Na rozdiel od snímačov s CMOS detektormi, ktoré prostredníctvom filtrov merajú priamo množstvo odrazeného svetla v jednotlivých zložkách, tento snímač aktívne osvetľuje vzorku rozličnými svetlami (červené, modré a zelené). Postupne odmeria množstvo odrazeného svetla jednotlivých zložiek a z toho potom vieme odhadnúť farbu objektu.

ColorPAL používa RGB LED na osvetlenie meranej farby (jedna farba naraz), spolu so široko spektrovým prevodníkom svetlo-napätie na meranie odrazeného svetla. Podľa množstva svetla ktoré sa odráža od meranej farby pri osvetlení od červenej, zelenej a modrej LED diódy je možné určiť farbu vzorky. ColorPAL používa na meranie odrazeného svetla fotodiódu TAOS typu TSL13T alebo 12T, ktorá má krivku spektrálnej citlivosti nasledovnú:

Obr1.png

Obr. 1: Krivka spektrálnej citlivosti prevodníka svetlo-napätie

Prevodník je kombináciou fotodiódy a transimpedančného zosilňovača v jednom integrovanom obvode. Aktívna plocha fotodiódy je 0.5 mm x 0.5 mm a senzor vníma žiarenie s vlnovou dĺžkou v rozsahu od 320 nm do 1050 nm.Výstupné napätie sa mení lineárne s intenzitou dopadajúceho žiarenia.

TSL12 Schematic.png
Obr. 2: Fotografia TSL13T, funkčná schéma zapojenie prevodníka a zapojenie vývodov fotodiódy.

Výstupom snímača je napätie, úmerné celého žiarenia ktoré detekuje a ktoré sú potom merané podľa hore uvedenej krivky spektrálnej citlivosti. Keď predmet je osvetlený iba červenou LED, tak snímač bude reagovať s napätím úmerným červenej zložky z farby predmetu a podobne s modrou a zelenou. Snímač a RGB LED diódy sú umiestnené vedľa seba v jednej plastickej trubice.

Použitie

Senzor používa 3 piny: regulované +5V napájanie, zem a sériový dátový pin s otvoreným kolektorom. Pri práci sme snímač napojili na skúšobnú dosku podľa Obr. 2. Museli sme dávať pozor, aby bol jumper vhodne nastavený, na Vdd a nie na Vin.

Pomocou predlžovacieho káblika sa senzor jednoducho pripojí k Acrob doske do konektora pre servomotorčeky:

Parallax ColorPAL Schematic3.png

Software na meranie

Po pripojení senzora k mikropočítaču Arduino / Acrob, budete potrebovať okrem samotného programu aj doinštalovať knižnicu ColorPal.h

Knižnica ColorPAL

Postup inštalácie (ak ešte nie je na počítači knižnica nainštalovaná):

1. Choďte na nižsieuvedenú stránku, kliknite na zelené tlačítko Code (vpravo hore), z rozbaľovacieho menu si vyberte Download ZIP...

 https://github.com/westpoint-robotics/ColorPAL

2. Po nahratí rozbaľte ColorPAL-master.zip a vyberte folder ColorPAL (bez prípony '-master'). Presu+nte ho do adresára

C:\Users\USername\Documents\Arduino\libraries

3. Reštartujte Arduino IDE a knižnica by mala byť pridaná.


Demonštračný program

Nasledovný program inicializuje senzor a v slučke potom vyčítava jednotlivé farebné zložky, ktoré po sériovej linke posiela do počítača.

#include <ColorPAL.h>    /* Kniznica pre pracu so senzorom      */

#define SW1 6            /* Ak chceme meranie ovladat tlacitkom */
#define LED1 13          /* LEDka na doske                      */

ColorPAL sensor;         /* Vytvori instanciu senzora           */

int red;                 /* Premenne na jednotlive farby        */
int grn;
int blu;

char buffer[20];         /* Docasny buffer na textovy retazec   */


void setup() 
{
   pinMode(SW1,INPUT_PULLUP);
   pinMode(LED1,OUTPUT);

   sensor.attachPAL(10);    /* Senzor je pripojeny na D10       */
   Serial.begin(9600);      /* Rychlost seriovej linky 9600Bd   */
}


void loop() 
{ 
  red = sensor.redPAL();    // Reads sensors and returns red value
  grn = sensor.greenPAL();  // Reads sensors and returns green value
  blu = sensor.bluePAL();   // Reads sensors and returns blue value
  
  buffer[19] = '\0';
  buffer[18] = '\0';
  
                            // Tu si pripravime retazec na odvysielanie 
                            // v tvare R0000 G0000 B0000 <CR>
 
  sprintf(buffer, "R%4.4d G%4.4d B%4.4d\015", red, grn, blu);

  Serial.println(buffer);   // A tu ho odvysielame 
 
  delay(100);               // 10 merani za sekundu nam staci
}

Ak bude všetko v poriadku, program začne merať farby a posielať na sériový port (9600 Bd) podobné data:

R0027 G0106 B0040
R0037 G0134 B0050
R0034 G0126 B0046
...


Ukážková aplikácia

Vyššieuvedený program by mal fungovať (žiaľ nie vždy celkom spoľahlivo) aj s originálnym programom Philippa Pilgrima (Parallax) na rozpoznávanie farieb TCS3200_ColorPAL_match.exe.

ColorPAL demo.png


Meranie

Vašou úlohou je teraz namerať primerané množstvo vzoriek lentiliek z každej farby. Meranie aj niekoľkokrát zopakujte. Cieľom je získať .csv súbor v nasledovnom formáte:

r,g,b,target,target_name
25,57,181,0,blue
25,63,191,0,blue
189,38,31,1,orange
188,45,41,1,orange
49,109,93,2,green
49,111,94,2,green

Význam stĺpcov r, g a b je zrejmý, target_name je názov farby a target je unikátne číslo pre každú farbu.

Aby ste získali požadované dáta, musíte upraviť formátovací reťazec vo vzorovom programe vyššie. Potom jednotlivé merania skopírujete z terminálového okna a doeditujete požadované údaje.

Meranie si môžete trocha zjednodušiť, ak si pripojíte k procesoru tlačítko a dáta zmeriate a vyšlete len raz, po stlačení tlačítka:

 while (digitalRead(SW1) == HIGH)     // tlačítko je aktívne do nuly
  {
    /* len tu cakaj a nic nerob */
  }


   /* hotovo, tlacitko je stlacene */

Ďalšie zjednodušenie by mohlo spočívať v zadávaní požadovanej farby, takže by procesor rovno vyslal celý riadok vhodný do .csv súboru. Dalo by sa to napríklad pomocou funkcie readStringUntil(), takto nejako:

void setup() 
{
  Serial.begin(9600); // opens serial port, sets data rate to 9600 bps
}

void loop() 
{
  // check if data is available
  if (Serial.available() > 0) {
    // read the incoming string:
    String incomingString = Serial.readStringUntil('\n');

    // prints the received data
    Serial.print("I received: ");
    Serial.println(incomingString);
  }
}


Strojové učenie

Ak ste už zmerali svoj balíček cukríkov, mali by ste mať pripravený .csv súbor v ktorom je všetko potrebné. Ďalšia úloha je natrénovať nejaký algoritmus na nameraných dátach a implementovať ho potom do Arduina, aby správne rozpoznávalo jednotlivé lentilky.

Okrem asi najznámejších ML (Machine Learning) algoritmov, ktorými sú neurónové siete existuje aj množstvo ďalších, pričom niektoré sú na implementáciu do malých mikropočítačov vhodnejšie ako iné. My využijeme tzv. Decision Tree, teda rozhodovací strom. Asi by ste ho dokázali implementovať aj intuitívne, ale výhodou algoritmu strojového učenia je, že nájde optimálny strom, teda taký, kde bude minimálny počet rozhodovacích vetiev.

Ďalej budeme pracovať v Google Colab notebooku, kde máte všetko pripravené.


Strojové učenie

Ak ste už zmerali svoj balíček cukríkov, mali by ste mať pripravený .csv súbor v ktorom je všetko potrebné. Ďalšia úloha je natrénovať nejaký algoritmus na nameraných dátach a implementovať ho potom do Arduina, aby správne rozpoznávalo jednotlivé lentilky.

Okrem asi najznámejších ML (Machine Learning) algoritmov, ktorými sú neurónové siete existuje aj množstvo ďalších, pričom niektoré sú na implementáciu do malých mikropočítačov vhodnejšie ako iné. My využijeme tzv. Decision Tree, teda rozhodovací strom. Asi by ste ho dokázali implementovať aj intuitívne, ale výhodou algoritmu strojového učenia je, že nájde optimálny strom, teda taký, kde bude minimálny počet rozhodovacích vetiev.

Ďalej budeme pracovať v Google Colab notebooku, kde máte všetko pripravené.


🡆 Google Colab Notebook


Ak by vám niečo z nejakého dôvodu nefungovalo, môžete použiť tento vzorový .csv súbor na odladenie vášho postupu.

Implementácia

Navrhnutý algoritmus preneste do mikropočítača a otestujte na novej vzorke lentiliek (môžete si napr. vymeniť so susedom). Rozpoznávanie (klasifikáciu) bude realizovať nižšie uvedený program. Nezabudnite mu však dodať aj z Google Colab notebooku vygenerované súbory Pipeline.h a Classifier.h:

#include <ColorPAL.h>    /* Kniznica pre pracu so senzorom */

#include "Pipeline.h"    /* Vygenerovane z Google Colab */
#include "Classifier.h"

ColorPAL sensor;

void setup() 
{
   sensor.attachPAL(10);    /* Senzor je pripojeny na D10 */
   Serial.begin(9600);      /* Rychlost seriovej linky    */
}

void loop() 
{
  // get RGB values
 
  int r = sensor.redPAL();    // Reads sensors and returns red value
  int g = sensor.greenPAL();  // Reads sensors and returns green value
  int b = sensor.bluePAL();   // Reads sensors and returns blue value
  
  // print values to Serial
  Serial.print("RGB: ");
  Serial.print(r,3);
  Serial.print(",");
  Serial.print(g,3);
  Serial.print(",");
  Serial.print(b,3);
    
  // perform feature extraction
  float features[] = {r, g, b};
    
  if (!pipeline.transform(features))
      return;

  // perform classification on pipeline result
  Serial.print(" |  Predicted color: ");
  Serial.println(tree.predictLabel(pipeline.X));

  delay(300);
}


Ak máte chuť, môžete si dostavať aj mechanický triedič, ktorý vám lentilky roztriedy podľa farieb:


Je to len hračka? Nie, pozrite sa napríklad na tento priemyselný triedič kávových zŕn:

Triedič kávových zŕn

Literatúra:


The seven cartoon "spokescandies" for M&M's since 2022