QTR Reflection Sensor Array

QTR Reflection Sensor Array

මෙන්න ඉන්නවා වැඩකාරය. Pololu QTR reflection sensor array. මේක line followings රොබෝලා වෙනුවෙන්ම pololu සමාගමෙන් හදපු IR sensor array එකක්. අද වෙනකොට line following robotics වල නැතුවම බැරි කෙනෙක් කිව්වට මම වැරදි නෑ කියලත් හිතෙනවා. Pololu බඩු සෑහෙන ගන්න. ඒවගේම තමයි ඉතින් quality එකත්. ඔයාලට ඉස්සරහට හිතේවි QTR sensor එක මෙහෙමනම් මෙයාලගේ අනිත් robotics equipment මොනතරම් performance ද කියලා. හැබැයි මේවා නෑ කියලා robotics කරන්න බෑ කියලා කොහෙවත් සඳහන් වෙලා නෑ හරිද ?

මේ sensor panel එකට Arduino වලට එන QTRSensors.h library එක අපිට මේ වැඩේ කරන්න ගොඩක් උදව් කරනවා. (මේක වෙනව Arduino library manager එකෙන් download කරලා install කරගන්න වෙනවා ) සාමාන්‍ය line tracking sensors වගේ නෙවෙයි, මේකට කිසියම් බුද්ධියක් ආරූඩ කාරලා වගේ දැනෙනෙවා, විශේෂයෙන්ම මේකෙ තියෙන calibration, readline වගේ advanced function නිසා. Readline method එක ගැන කිව්වොත් එකට පුළුවන් sensor එකට යටින් හරියටම black line කොතනද, මොන sensors යටින්ද කියලා calculate කරලා කියන්න.

නිකුත් කරන output signal වර්ගය අනුව, QTR Sensor array වර්ග දෙකක් තියෙනවා. හැබැයි පටලවාගන්න එපා මේ sensors වර්ග දෙකම analog reading තමයි දෙන්නෙ.

·         QTR 8A Reflection Sensor Array

මේක analog signals output කරන sensor එකක්. ඒ කියන්නෙ ඒ ඒ sensors වලින් 0v ත් 5v ත් අතර signal එකක් තමයි නිකුත් කරන්නෙ. Arduino එකේ analog pins වලට තමයි මේක අනිවාර්යෙන්ම සම්බන්ධ කරන්න ඕනි.

·         QTR 8RC Reflection Sensor Array

මේක digital pulses output කරන එකක්. මේක Arduno එකේ digital pins වලට තමයි සම්බන්ධ කරන්න ඕනෙ. එකී pulses වල voltage එක high වෙලා තියෙන කාලය (Duty Cycle) මැනලා තමයි මෙයා අගයන් නිකුත් කරන්නෙ.

ඔය දෙකේ ලොකු වෙනසක් නම් නෑ. Circuitry එකේ පොඩි වෙනසක් විතරයි තියෙන්නේ. QTR 8A එකේ තියෙන්නේ voltage divider circuit එකක්. QTR 8RC එකේ තියෙන්නේ resistor capacitor (RC) circuit එකක්. සමහර robotic experts ලා කියන විදියට QTR 8RC එකේ පොඩි delay එකක් තියෙනවලු QTR 8A එකට සාපේක්ෂව.

ඉහත කී library එකේ inbuit example එකක් එනවා. ඒක කියවලා හොඳට වැඩේ තේරුම් ගන්න පුළුවන්. (go to :- File – Examples – QTRSensors – QTRRCExample; ඔයාගෙ sensor එක analog sensor එක නම් QTRAExample තෝරගන්න. RawValuesExample කියන දැනට එපා) කෝකටත් කියලා ඒ code අකුරක් නෑර මෙහෙම පැහැදිලි කළොත් හොඳයි කියලා හිතුවා.

මේ example එක ඇත්තටම හොඳ පරීක්ෂණයක් කිව්වොත් නිවැරැදි. ඔයාලට මේක පහසුවෙන් කරලා බලන්න පුළුවන් A4 කොළයක insulation tape එකක් අලවලා.

POLOLU QTR 8RC CODE EXAMPLE

#include <QTRSensors.h> 

QTRSensors.h class එක import කර ගැනීම

#define NUM_SENSORS   8

ඔයාලා පාවිච්චි කරන sensor ගණන මෙතන දාන්න ඕනි. ඔය sensor 8 න් ඔයාලට කැමති ප්‍රමාණයක් පාවිච්චි කරන්න පුළුවන්. වැඩිපුර තෝරාගත්ත තරමට වැඩිපුර හොඳයි. ඉතින් line following robot ට 8 ම තෝරාගන්න කියලා නිර්දේශ කරනවා.

#define TIMEOUT  2500

මම කලින් කියපු විදියට QTR-8RC එකෙ readings ගන්නෙ ඒකෙ output pulses වල duty cycle (digital high වෙන කාලය) එක මැනලනේ.  එතකොට TIMEOUT කියන්නෙ කාලය මැනීමේ උපරිම සීමාව. නිර්දේශ කරලා තියෙන විදියට 1000 ත් 3000 ත් අතර අගයක් තමයි මෙතනට දාන්න ඕනේ micro seconds වලින්.  ඒ වගේම sensor panel පොළවට උඩින් තියෙන උස, වටේට පවතින IR කිරණ වගේ දේවල් මෙකට බලපානවා.

#define EMITTER_PIN   2

Sensor panel එකේ LEDON කියලා pin එකක් තියෙනවා. ඒක Arduino එකට සම්බන්ධ වෙන digital හෝ PWM pin number එක මෙතන දාන්න ඕනි. ඇත්තටම මේක තමයි sensor panel එක on/off කරන්න සහ IR led වල brightness එක control කරන්න තියෙන pin එක. Off කරන්න ඔනි නම් digital low signal එකක් pin එකට දෙන්න. ඔයා කිසිම signal එකක් නොදුන්නත් එක default digital high වෙලා තමයි තියෙන්නේ. මෙහෙම එකක් තිබීමෙන් ඇති වාසිය තමයි sensor panel එක අවශ්‍ය නොවන අවස්ථා වලදී sensor panel එක off කිරීමෙන් power save කරගන්න පුළුවන් වීම තමයි. LEDON එක සම්බන්ධ කරන්නෙ නැත්තම් pin number එක වෙනුවට QTR_NO_EMITTER_PIN කියලා ඉස්සරහින් යොදන්න. (#define EMITTER_PIN QTR_NO_EMITTER_PIN)

QTRSensorsRC qtrrc((unsigned char[]) {3, 4, 5, 6, 7, 8, 9, 10}, NUM_SENSORS, TIMEOUT, EMITTER_PIN); 

QTRSensorsRC කියන class එකෙන් qtrrc කියලා object එකක් තමයි මෙතනින් හදලා තියෙන්නෙ. (Object Oriented Programming මතකනේ….) sensors 0 සිට 7 දක්වා sensors ඔයා Arduino එකේ digital pins වලට සම්බන්ධ කරපු pin පිළිවෙල මේකෙ සඟල වරහන් තුළ යොදන්න ඕනි.

unsigned int sensorValues[NUM_SENSORS];

read කරන sensor values memory එකේ තාවකාලිකව save කරගන්න විදියක් තියෙන්න එපැයි. ඒකට තමයි මේ විදියට int data type එකෙන් NUM_SENSORS ප්‍රමාණයේ sensorValues කියන array එකක් හදලා තියෙන්නෙ. දැන් බලනවා ඇති මොකක්ද මේ unsigned කියන්නෙ කියලා. අපිට positive values විතරනේ ලැබෙන්නෙ. ඒක නිසා අපිට int variable එකේ negative values අනවශ්‍යයි. ඒ ඉඩත් positive values වලටම වෙන් කරන එක තමයි මෙතනිදි වෙන්නෙ.

සැයු :- sensorValues array එක ඉස්සරහට ගොඩක් වැදගත් වෙනවා. මේ array එකේ values ආධාරයෙන් ඉස්සරහට junctions හඳුනා ගැනීම වගේ වැදගත් දේවල් කරන්න තියෙනවා.

void setup()

{

මේ QTRSensors.h library එකේ තියෙන විශේෂ ගුණාංගය තමයි මේ QTR sensor එක calibrate එහෙම නැත්තම් ක්‍රමාංකණය කිරීමේ පහසුකමයි. ඔයාලා දන්නවනේ ඕනෑම මිනුම් උපකරණයක් හරියට ක්‍රමාංකණය කළොත් විතරයි අපිට නිවැරැදි පාඨාංක ගන්න පුළුවන් වෙන්නෙ. මේකෙත් වෙන්නෙ ඒ දේමයි. මේ ඒ ඒ sensor වලට එකට කියවගන්න පුළුවන් උපරිම සහ අවම අගයන් මොනවද කියලා බලලා ඒ අනුව පරිමාණය හදන එක.

  delay(500);

  pinMode(13, OUTPUT);

  digitalWrite(13, HIGH);

calibration mode එක දර්ශනය කරන්න Arduino එකේ 13 වෙනි LED එක on කිරීම.

for (int i = 0; i < 400; i++)

{

    qtrrc.calibrate();

හැම sensor එකක්ම 2500 us කාලයක් දහවතාවක් කියවන එක තමයි මෙතනිදි වෙන්නෙ.

  }

මෙන්න මෙතැනදී තමයි හරියටම sensor එක calibrate වෙන්නෙ.  ඒ සඳහා sensor panel එක තත්පර 10 ක කාලයක් තුළ, ඒ ඒ sensors උපරිම සුදු හා උපරිම කළු පෘෂ්ඨ වලට නිරාවරණය කල යුතුයි.

  

digitalWrite(13, LOW)

calibration mode අවසන් බව දර්ශනය කරන්න Arduino එකේ 13 වෙනි LED එක off කිරීම.

  

Serial.begin(9600);  

9600 baud rate එකකින් serial communication එක ආරම්භ කිරීම

  

for (int i = 0; i < NUM_SENSORS; i++)

  {

    Serial.print(qtrrc.calibratedMinimumOn[i]);

    Serial.print(' ');

  }

මේ loop එකෙන් වෙන්නෙ මම කලින් කියපු අවම values මොනවාද කියලා නිරූපණය කිරීමයි. calibratedMinimumOn array එකේ තියෙන්නෙ ඒ ඒ sensor එක හඳුනාගත් අවම අගයන් තමයි. මුළින්ම serial monitor එකේ print කරලා පෙන්වන්නෙ ඔය ටික තමයි.

  Serial.println();

  for (int i = 0; i < NUM_SENSORS; i++)

  {

    Serial.print(qtrrc.calibratedMaximumOn[i]);

    Serial.print(' ');

  }

මෙතන ඉතින් print වෙන්නෙ උපරිම අගයන්.

  Serial.println();

  Serial.println();

  delay(1000);

}

void loop()

{

unsigned int position = qtrrc.readLine(sensorValues);

සැලකිය යුතු කරුණක් තමයි මෙතනිදි වැඩ ගොඩක් වෙනවා. හැබැයි එක code line එකයි.

ඒ ඒ sensor එක 0 ත් 1000 ත් අතර අගයකින් කියවගත් අගයන් sensorValues array එකේ save වෙනවා. නිකුත් කරන IR කිරණ, උපරිම වශයෙන් පරාවර්තනය උනොත් 0 ත්, සම්පූර්ණයෙන්ම පෘෂ්ඨය එය උරා ගත්තොත් 1000 ත් නිරූපණය වෙනවා. සුදු පසුබිමේදී 0 හෝ ඊට ආසන්න අගයකුත්, කළු පසුබිමේදී 1000 හෝ ඊට ආසන්න අගයකුත් පෙන්වන්නෙ මේ නිසයි.

ඊට පස්සෙ calibrate කරගත්ත sensor values ආධාරයෙන් sensorValues array එකේ values යොදාගෙන, මම කලින් කියපු විදියට readLine method එකෙන් position එක calculate කරනවා. මෙතනදි ඒ ඒ sensor values වල බරිත මධ්‍යන්‍යක් (weighted average) තමයි calculate වෙන්නෙ. ඒක unsigned int position variable එකේ ඒක 0 – 7000 අගයකින් save වෙනවා. මෙතන 7000 උනේ sensors 8 ක් නිසා. 6 ක් උනානම් 0-5000 අතර අගයක් තමයි පෙන්වන්නෙ.

අපි ඔය reflection sensor array එක පහළින් තියෙන විදියට ඇඳ ගමු. ඔය අංක කරලා තියෙන්නෙ ඒකෙ තියෙන sensor 8, 0 සිට 7 දක්වා.

Example	sensorValues[ ]								Position
	[0]	[1]	[2]	[3]	[4]	[5]	[6]	[7]
1	0	0	0	1000	0	0	0	0	3000
2	0	0	0	0	0	0	1000	0	6000
3	0	0	0	1000	1000	0	0	0	3500
4	1000	1000	1000	1000	1000	1000	1000	1000	3500
5	0	0	0	0	0	0	0	0	0

දෙයියනේ ! මෙහෙම එකක ආවොත් මොනවගේ value එකක් පෙන්වයිද ? පිළිතුර ඔබට භාරයි.

කියවගත් sensorValues සහ ඒකට අදාළ position එක Serial monitor එකේ print කරනවා මෙතැනදී.

  

   for (unsigned char i = 0; i < NUM_SENSORS; i++)

  {

    Serial.print(sensorValues[i]);

    Serial.print('\t');

  }

 

  Serial.println(position);

 

  delay(250);

}

මේ article එක මෙතනින් නැවැත්තුවට මේ sensor panel එක ගැන තව බොහෝ දේ ඉගෙනගන්න පුළුවන් පහතින්.

**සුභ දවසක් **

REFERENCES

·         https://www.pololu.com/docs/pdf/0J12/QTR-8x.pdf

·         https://www.pololu.com/docs/0J19/all