Hello !
Trace: • Riistvaraline viide

Differences

This shows you the differences between two versions of the page.

Link to this comparison view

Next revision		Previous revision
et:examples:sensor:reflectance_sensor [2023/10/16 20:37] – created heiko.pikneret:examples:sensor:reflectance_sensor [2023/10/16 21:16] (current) – heiko.pikner
Line 9: Line 9:
 ===== Teooria ===== ===== Teooria =====
  
-[{{  :examples:sensor:ir_distance:sensor_ir_distance_gp2y0a21yk_picture.jpg?240|Sharp GP2Y0A21YK}}] +ToDo
- +
-Objekti kauguse mõõtmiseks on olemas triangulatsioonimeetodil töötavad optilised andurid. Levinuimad neist on firma Sharp poolt toodetavad infrapuna (inglise keeles //infra-red//, lühend IR) lainepikkusel töötavad analoogpinge väljundiga kaugusandurid. Sharp-i anduritel on läätsega IR LED, mis kiirgab kitsast valguskiirt. Objektilt peegeldunud kiir suunatakse läbi teise läätse positsioonitundlikule fotoelemendile (inglise keeles //position-sensitive detector//, lühend PSD). PSD-le langeva kiire asukohast sõltub selle juhtivus. Juhtivus muundatakse pingeks ja seda näiteks mikrokontrolleri analoog-digitaalmuunduriga digitaliseerides saab välja arvutada kauguse. Erinevatelt kaugustelt peegelduvate kiirte teekonda näitab kõrvalolev joonis. +
- +
-[{{  :examples:sensor:ir_distance:sensor_ir_distance_principle.png?240|IR kaugusmõõdiku valguskiire teekond}}] +
- +
-Sharp-i kaugusandurite väljund on pöördvõrdeline - kauguse kasvades see väheneb ja järjest aeglasemalt. Täpne kauguse ja väljundi vaheline graafik on toodud andurite andmelehel. Anduritel on vastavalt tüübile ka mõõtepiirkond, milles nende väljund on usaldusväärne. Maksimaalsele reaalselt mõõdetavale kaugusele seab piiri kaks aspekti: peegelduva valguse intensiivsuse vähenemine ja PSD-e võimetus registreerida väikest peegeldunud kiire asukoha muutust. Liiga kaugete objektide mõõtmisel jääb anduri väljund ligikaudu samaks, mis maksimaalselt mõõdetava kauguse puhulgi. Minimaalne mõõdetav kaugus on piiratud Sharp-i andurite omapära tõttu - nimelt hakkab väljundpinge kauguse vähenedes teatud kaugusel (olenevalt andurist 4-20 cm)  järsult jälle vähenema. Sisuliselt tähendab see, et ühele väljundpinge väärtusele vastab kaks kaugust. Probleemide ärahoidmiseks tuleb vältida objektide andurile liiga lähedale sattumist.+
  
 ===== Praktika  ===== ===== Praktika  =====
  
-[{{  :examples:sensor:ir_distance:sensor_ir_distance_graph.png?240|Tüüpiline Sharp IR kaugusmõõdiku pinge-kauguse graafik}}]+<pagebreak> 
 +<code c> 
 +// Kodulabori QTR_RC jooneanduri näidisprogramm 
 +// Peegeldumise mõõtmise funktsioon on blokeeruv 
 +#include <stdio.h> 
 +#include <homelab/pin.h> 
 +#include <homelab/delay.h> 
 +#include <homelab/timer.h> 
 +#include <homelab/module/lcd_gfx.h>
  
-Kodulabori andurite komplektis on Sharp-i infrapuna kaugusmõõdik GP2Y0A21YK mõõtepiirkonnaga 10-80 cm. Anduri väljundpinge on kuni 3 V sõltuvalt mõõdetavast kaugusest. Anduri saab ühendada Kodulabori mooduli külge valitud analoogkanalisse. Eelnevate andurite harjutuste baasil saab lihtsalt teha programmi, mis mõõdab kaugusmõõdiku väljundpinget, kuid lisaks on selle harjutuse eesmärk veel pinge kauguseks teisendamise protsessi tutvustamine.+// Kodulabor III 
 +pin pin_rc_in_1 = PIN(B, 2); 
 +pin pin_rc_in_2 = PIN(B, 1); 
 +pin pin_rc_in_3 = PIN(B, 0); 
 +pin pin_rc_in_4 = PIN(A, 7);
  
-GP2Y0A21YK andmelehel on toodud väljundpinge ja mõõdetud kauguse vahelise sõltuvuse graafik. See pole lineaarne, kuid väljundpinge ja kauguse pöördväärtuse graafik peaaegu juba on, ning sellest on suhteliselt lihtne leida valem pinge kauguseks teisendamiseks. Valemi leidmiseks tuleb sama graafiku punktid sisestada mõnda tabelarvutuse programmi ja nendest uuesti graafik luua. Tabelarvutusprogrammides on graafiku punktide põhjal võimalik arvutada automaatselt välja trendijoon. Järgnevalt on toodud GP2Y0A21YK väljundpinge ja kauguse korrigeeritud pöördväärtuse vahelise seose graafik koos lineaarse trendijoonega. Väljundpinge on valemi lihtsustamise nimel juba teisendatud 10-bitiseks +5 V võrdluspingega analoog-digitaalmuunduri väärtuseks.+unsigned short QTR_RC_measure(pin rc_in_pin) 
 +{ 
 +    if(_sys_freq == 2) 
 +        Homelab_clock_init();
  
-[{{  :examples:sensor:ir_distance:sensor_ir_distance_gp2y0a21yk_graph_calculation.png?400|Kauguse ja ADC väärtuse lineariseerimise graafik}}]+    // Pin setup 
 +    pin_setup_output(rc_in_pin);
  
-Nagu graafikult näha, kattub trendijoon (sinine) üsna täpselt graafiku punktidega (punane joon). Selline kattuvus on saavutatud kauguse korrigeerimiskonstandi abil. Korrigeerimiskonstant on leitud katse-eksitusmeetodil - läbi on proovitud erinevaid arve, kuni on leitud selline, mille korral graafik kattub trendijoonega kõige rohkem. Antud graafiku puhul on see +2, ehk kõigile reaalsetele kaugustele on graafikus 2 otsa liidetud. Kuna nii on graafik väga sarnane lineaarsele trendijoonele, võib teha üldistuse ja öelda, et kauguse ja pinge vaheline seos on järgmine:+    // Reset timer 
 +    TC_ClearOverflowFlag(&TCD1); 
 +    TC_Restart(&TCD1);
  
-1 / (d + k) = a ⋅ ADC + b+    // Set timer D0 Normal mode 
 +    // Top value 9000 (~270cm) 
 +    // with clock freq of F_CPU / 64 
 +    TC_SetPeriod(&TCD1,20000); 
 +    TC1_ConfigClockSource( &TCD1, TC_CLKSEL_DIV1_gc);
  
-kus+    // Create trigger pulse 
 +    pin_set(rc_in_pin);
  
-  * d on kaugus sentimeetrites +    // Wait ~10 us 
-  * k on korrigeerimiskonstant (leitud katse-eksitusmeetodil) +    while (TCD1.CNT < 50);
-  * ADC on pinge digitaliseeritud väärtus +
-  * a on lineaarliige (väärtus tuleb trendijoone võrrandist) +
-  * b on vabaliige (väärtus tuleb trendijoone võrrandist)+
  
-Valemist saab avaldada kauguse d:+    // Reset timer 
 +    TC_SetCount(&TCD1,0);
  
-d = (1 / (a ⋅ ADC + B)) - k+    // Wait for echo start 
 +    pin_setup_input(rc_in_pin);
  
-Põhimõtteliselt saakski selle valemiga kauguse välja arvutada, kuid see eeldaks ujukoma-arvutusi, sest jagatises tekivad murdarvud. Täisarvudega opereeriva mikrokontrolleri jaoks tuleb valemit lihtsustada ja suuremate tegurite peale ümber teisendada. Valemi jagatist lineaarliikmega läbi jagades saab see kuju:+    while (pin_get_value(rc_in_pin)) 
 +    { 
 +        // Timeout ? 
 +        if (TC_GetOverflowFlag(&TCD1)) 
 +        { 
 +            return 0; 
 +        } 
 +    }
  
-d = (1 / a) / (ADC + B / a) - k +    // Convert time to distance: 
- +    //   distance = timer * (1 / (F_CPU / 8)) * speed / 2 
-Viies valemisse korrigeerimiskonstandi väärtuse ja trendijoone võrrandist saadud lineaar- ja vabaliikme (saadud jooniselt), tuleb kauguse arvutamise valemiks: +    return (unsigned long)TCD1.CNT;
- +
-d = 5461 / (ADC - 17) - 2 +
- +
-See valem on arvutatav 16-bitiste täisarvudega ja täiesti jõukohane AVR-ile. Enne arvutamist tuleb aga veenduda, et ADC väärtus oleks üle 17, sest muidu tekib nulliga jagamine või negatiivne kaugus, mis on ebaloogiline. +
- +
-Järgnevalt on toodud Kodulabori teegis kirja pandud funktsioon ADC väärtuse sentimeetriteks teisendamise kohta. Lineaar- ja vabaliige ning korrigeerimiskonstant pole funktsiooni jäigalt sisse kirjutatud, vaid need antakse ette IR kaugusanduri parameetrite struktuuri objektiga. Hoides parameetreid eraldi konstandis, saab hiljem programmi lihtsalt lisada uusi IR kaugusandurite mudeleid. +
- +
-<code c> +
-// IR kaugusanduri parameetrite struktuur +
-typedef const struct +
-{ +
- const signed short a; +
- const signed short b; +
- const signed short k;+
 } }
-ir_distance_sensor; 
  
-// GP2Y0A21YK anduri parameetrite objekt 
-const ir_distance_sensor GP2Y0A21YK = { 5461, -17, 2 }; 
- 
-// IR kaugusanduri ADC väärtuse sentimeetriteks teisendamine 
-// Tagastatakse -1, kui teisendus ei õnnestunud 
-signed short ir_distance_calculate_cm(ir_distance_sensor sensor, 
- unsigned short adc_value) 
-{ 
- if (adc_value + sensor.b <= 0) 
- { 
- return -1; 
- } 
-  
- return sensor.a / (adc_value + sensor.b) - sensor.k; 
-} 
-</code> 
- 
-Teisenduse tegemiseks tuleb välja kutsuda //ir_distance_calculate_cm// funktsioon, mille esimene parameeter on IR kaugusanduri parameetrite objekt, teine aga ADC väärtus. Funktsioon tagastab arvutatud kauguse sentimeetrites. Väära tehte (ehk siis ebaloomuliku ADC väärtuse) korral tagastab funktsioon -1. IR kaugusanduri ja teisendusfunktsiooni kasutamist demonstreerib järgnev programm. Kasutusel on LCD ekraan, kus kuvatakse mõõtetulemust. Ebaloomuliku kauguse puhul kuvatakse küsimärki. 
-<pagebreak> 
-<code c> 
-// Kodulabori IR kaugusmõõdiku näidisprogramm 
-// LCD ekraanil kuvatakse mõõdetud kaugus sentimeetrites 
-#include <stdio.h> 
-#include <homelab/adc.h> 
-#include <homelab/delay.h> 
-#include <homelab/module/sensors.h> 
-#include <homelab/module/lcd_gfx.h> 
- 
-#define ADC_CHANNEL 0 
  
 // Põhiprogramm // Põhiprogramm
 int main(void) int main(void)
 { {
- signed short value, distance;+ unsigned short reading_1; 
 + unsigned short reading_2; 
 + unsigned short reading_3; 
 + unsigned short reading_4;
  char text[16];  char text[16];
- 
-        // Robootika Kodulabor II Andurite moodul väliste andurite viik 
- //pin ex_sensors = PIN(G, 0); 
- //pin_setup_output(ex_sensors); 
- //pin_set(ex_sensors); 
  
  // LCD ekraani seadistamine  // LCD ekraani seadistamine
  lcd_gfx_init();  lcd_gfx_init();
  lcd_gfx_clear();  lcd_gfx_clear();
- lcd_gfx_goto_char_xy(1,2); + lcd_gfx_goto_char_xy(1, 1); 
- lcd_gfx_write_string("Kaugusandur");+ lcd_gfx_write_string("Jooneandurid");
  
- // ADC muunduri seadistamine + // Väike paus 
- adc_init(ADC_REF_AVCC, ADC_PRESCALE_8);+ sw_delay_ms(100);
  
- // Lõputu tsükkel+  // Lõputu tsükkel
  while (1)  while (1)
  {  {
- // Anduri väljundpinge 4-kordselt ümardatud väärtuse lugemine + // Mõõtmine 
- value = adc_get_average_value(ADC_CHANNEL, 4);+ reading_1 = QTR_RC_measure(pin_rc_in_1); 
 + //sw_delay_ms(10); 
 + reading_2 = QTR_RC_measure(pin_rc_in_2); 
 + //sw_delay_ms(10); 
 + reading_3 = QTR_RC_measure(pin_rc_in_3); 
 + //sw_delay_ms(10); 
 + reading_4 = QTR_RC_measure(pin_rc_in_4);
  
- // ADC väärtuse kauguseks ümberarvutamine + // Mõõtmine õnnestus? 
- distance = ir_distance_calculate_cm(GP2Y0A21YK, value);+ if (reading_1 > 0) 
 + { 
 + // Kauguse tekstiks teisendamine 
 + sprintf(text, "%3d     ", reading_1); 
 + } 
 + // Mõõtmisel tekkis viga? 
 + else 
 + { 
 + // Vea tekst 
 + sprintf(text, "Viga    "); 
 + }
  
- lcd_gfx_goto_char_xy(1,3);+ // Teksti kuvamine LCD teise rea alguses 
 + lcd_gfx_goto_char_xy(3, 3); 
 + lcd_gfx_write_string(text);
  
- // Kauguse või veateate kuvamine + // Mõõtmine õnnestus? 
- if (distance >= 0)+ if (reading_2 > 0)
  {  {
- sprintf(text, "%3d cm   ", distance);+ // Kauguse tekstiks teisendamine 
 + sprintf(text, "%3d     ", reading_2);
  }  }
 + // Mõõtmisel tekkis viga?
  else  else
  {  {
- sprintf(text, "Viga   ");+ // Vea tekst 
 + sprintf(text, "Viga    ");
  }  }
  
- lcd_gfx_goto_char_xy(1,3);+ // Teksti kuvamine LCD teise rea alguses 
 + lcd_gfx_goto_char_xy(3, 4);
  lcd_gfx_write_string(text);  lcd_gfx_write_string(text);
- sw_delay_ms(500);+ 
 + // Mõõtmine õnnestus? 
 + if (reading_3 > 0) 
 + { 
 + // Kauguse tekstiks teisendamine 
 + sprintf(text, "%3d     ", reading_3); 
 + } 
 + // Mõõtmisel tekkis viga? 
 + else 
 + { 
 + // Vea tekst 
 + sprintf(text, "Viga    "); 
 + } 
 + 
 + // Teksti kuvamine LCD teise rea alguses 
 + lcd_gfx_goto_char_xy(3, 5); 
 + lcd_gfx_write_string(text); 
 + 
 + // Mõõtmine õnnestus? 
 + if (reading_4 > 0) 
 + { 
 + // Kauguse tekstiks teisendamine 
 + sprintf(text, "%3d     ", reading_4); 
 + } 
 + // Mõõtmisel tekkis viga? 
 + else 
 + { 
 + // Vea tekst 
 + sprintf(text, "Viga    "); 
 + } 
 + 
 + // Teksti kuvamine LCD teise rea alguses 
 + lcd_gfx_goto_char_xy(3, 6); 
 + lcd_gfx_write_string(text); 
 + 
 + // Väike paus 
 + sw_delay_ms(100);
  }  }
 } }
et/examples/sensor/reflectance_sensor.1697488634.txt.gz · Last modified: 2023/10/16 20:37 by heiko.pikner
CC Attribution-Share Alike 4.0 International
www.chimeric.de Valid CSS Driven by DokuWiki do yourself a favour and use a real browser - get firefox!! Recent changes RSS feed Valid XHTML 1.0