Pagaliau atrodo pavyko parašyti tokį kodą, kad mano robotas važinėtų po kambarį išvengdamas kliūčių be jokios pagalbos. Pradėsiu nuo teorinės dalies: roboto logika.

Roboto navigacijos tikslas buvo paprastas: aptikus kliūtį apsidairyti, surasti laisvą kelią, pasisukti į tą pusę ir toliau važiuoti nauju keliu iki kitos kliūties. Aš esu iš tų programuotojų, kurie daugiau stengiasi panaudoti jau kažkieno sukurtus algoritmus ir idėjas, bet šiuo atveju man nepasisekė: niekur negalėjau rasti man tinkamo jau sukurto kodo todėl teko viską kuri pačiam nuo nulio. Sudėliojus pradinį logikos variantą viskas atrodė nesudėtinga, bet realiai susidūriau su keletu labai įdomių iššūkių.

Inercija

Kitaip, nei dauguma savaeigių robotų, kurių video žiūrėjau analizuodamas logiką, maniškis varomas ne servo, o varikliukais. Servo naudojančios parduodamos robotų platformos sustoja praktiškai iš karto, bet už tai yra labai lėti. Arduino mikrokontroleriui detektavus kliūtį ir varikliams nurodžius sustoti, mano žaislinė mašinėlė iš inercijos pavažiuodavo dar 5-10 cm dėl ko imdavo veikti visai kita programos dalis, atsimušdavo į kliūtį ir nebeužtekdavo vietos apsisukti arba robotas pradėdavo “dairytis” kito kelio dar nesustojęs.

Baterijos

Jeigu robotui važiuojant į priekį staiga pastebėjus kliūtį labai arti perduodavau impulsą iš karto važiuoti atgal baterijos išsikraudavo per pusvalandį. Po sustabdymo teko palaukti ~0,5 s, kad robotas sulėtėtų arba suspėtų visai sustoti ir tik tada siųsdavau kitas komandas.

Nuo baterijos įkrovimo taip pat priklausė ir važiavimo greitis, o nuo jos ir inercija. Dėl šios priežasties naudodamasis ultragarsiniu nuotolio matuokliu pradėjau kaupti informacija apie atstumą iki objekto ir laiką kada matavimas atliktas. Tokiu būdu galėjau įvertinti roboto greitį ir jį dinamiškai reguliuoti, kad išlaikyčiau 35-40 cm/s nepriklausomai nuo baterijų įkrovos.

Kliūčių išvengimas

Nustatyti į kurią pusę reikia suktis po to kai robotas surasdavo kliūti buvo palyginus nesudėtinga: roboto “galva” atsistoja -90 laipsnių kampu ir kas 10 lapsnių išmatuoja atstumą iki objektų.

Tarkim robotas nustato, kad laisviausias kelias yra 60 laipsnių į kairę kaip tai parodyta viršuje esančiame paveikslėlyje juoda linija. Kaip tuomet nustatyti, kad robotas jau pasisuko 60 lapsnių? Turint magnetinį kompasą būtų labai paprasta, bet kad toks sensorius kainuoja virš £20! Besukant galvą šovė išganinga mintis: tereikia nuspręsti į kurią pusę suktis ir tuomet besisukant matuoti atstumą iki objekto su tuo pačiu atstumo sensorium iki kol bus “surastas” tas atstumas. Ši geniali idėja pasiteisino iki kol nesusidūriau su kita problema – paklaidom.

Paklaidos

Su paklaidom buvau susidūręs tik spręsdamas fizikos laboratorinius. Kuriant kompiuterines programas paklaidos beveik neegzistuoja, bet viskas apsiverčia aukštyn kojom, kai pradedi programuoti fiziniam pasauliui: į paklaidas teko atsižvelgti robotui sukantis aplink beieškant nustatyto laisvo kelio ir įvertinti, kad matuojant gali būti ~1cm paklaida. Jas taip pat reikėjo įvertinti ir matuojant roboto greitį, nes kartais gaudavau, kad mano robotas kambaryje skrieja 100 km/h greičiu.

Nenumatytos kliūtys

Eksperimentuojant kelyje pasitaikydavo nenumatytų kliūčių: kokia numesta tapkė ar mažas sūnaus žaislas, kurio nuotolio sensorius nedetektuodavo, nes kliūtis būdavo per žemai. Dėl tos priežasties teko sukurti specialų kodą naudojantį atstumo sensoriaus duomenis, kurio pagalba robotas nustatydavo, kad jis užstrigo ir pabandydavo 1s pavažiuoti atgal.

Dėl šio patobulinimo robotas užstrigęs net ir už netikėtos kliūties sugeba grįžti atgal ir ieškoti kito kelio.

Per arti esantys objektai

Per arti priartėjus prie kokio nors objekto, gali neužtekti vietos apsisukti, todėl sukūriau dar vieną paprogramę, kurios pagalba važiuodamas atgal robotas pabando pasidaryti daugiau vietos ir tik tada apsidairyti.

Čia vėl reikėjo atkreipti dėmesį, kad judėdamas atgal robotas irgi gali užstrigti.

Visa roboto logika

Kartu sudėjus visas viršuje aprašytas paprogrames gavau tokią bendrą roboto logiką:

Aišku iki idealios logikos labai toli, nes norint padaryti, kad robotas geriau “jaustų” aplinką, reikia turėti daugiau sensorių: bent po vieną IR (infraraudonųjų spindulių) atstumo detektorių ties kiekvienu žaislo kampu, akselerometrą, magnetinį kompasą ir nuvažiuoto kelio detektorius. Ghm.. na gal kol kas apsiribosiu su tuom ką turiu. :)

Kituose įrašuose važinėjančio roboto video ir Arduino kodas.

Šį šeštadienį lankiausi Birmingemo Howduino – vienos dienos hakerių susitikime. Nelabai žinojau ko tikėtis iš tokio tipo įvykio, todėl ir važiavau be jokios išankstinės nuostatos. :) Po trumpo organizacinio pristatymo apie 11 val. ryto prasidėjo darbas: vieni dalyviai išsiskirstė į mokymo grupes, kiti ėmėsi dirbti prie savo projektų.

Mano užduotis

Mano tos dienos tikslas buvo šią radijo bangom valdomą mašinėlę paversti į kliūtis apvažiuojantį robotą.

Šiam projektui anksčiau įsigytą mašiną palikau namie, nes ši – daug mažesnė, kompaktiškesnė ir naudoja mažiau energijos. Ji taipogi yra varoma dviem atskirais varikliukais, valdančiais po vieną ratų pusę.

Pradedam ardymą!

Viršuje – išardytos mašinėlės nuotrauka. Pats žaislas tikrai geros kokybės, nes su juo galima važinėti per purvą ir net plaukti vandeniu. Ką gali žinoti, gal ir šiai savybei rasim robotizuotą pritaikymą. :) Nuo mašinėlės važiuoklės dalies einančius laidus nukirpau maždaug ties viduriu ir prilitavau ilgesnius, kad galėčiau eksperimentuoti. Visą radijo bangom valdomą elektroniką atidėjau į šalį. Galbūt ją panaudosiu vėliau, kai galėsiu padaryti dvigubą mašinėlės valdymą: perjungiamą tarp valdymo radijo bangom arba robotizuoto.

Trumpa pertraukėlė: mano darbo stalas. Labai nervino prastas apšvietimas, bet atmosfera buvo puiki: apie 40 hakerių vienoje vietoje besidalinančių idėjomis ir elektronikos dalimis. Visi nuolat prie ko nors dirbo, žiūrėjo kaip sekėsi kitiems ar patys pasakojo savo problemas ir įspūdžius.

Viskas paruošta testavimui: apversta važiuoklė, kad betestuojant nenuriedėtų kartu su visom elektroninėm dalim, L293D varikliukų valdymo mikroschema ant prototipinės plokštės, Arduino MEGA, SRF05 atstumo detektorius ant servo. Beje, servo nebuvo naudojamas, nes būčiau nesuspėjęs laiku užbaigti, kadangi būtų tekę rašyti daug sudėtingesnį kodą norint padaryti atstumo detektorių besisukiojantį 180 laipsnių kampu.

Kodas

Dalį kodo pasiskolinau iš LuckyLarry’s Obstacle avoidance robot.

const int numOfReadings = 10; // number of readings to take/ items in the array
int readings[numOfReadings];  // stores the distance readings in an array
int arrayIndex = 0;           // arrayIndex of the current item in the array
int total = 0;                // stores the cumlative total
int averageDistance = 0;      // stores the average value
unsigned long distance = 0;

const int motor1Pin1 = 2;    // H-bridge leg 1
const int motor1Pin2 = 3;    // H-bridge leg 2
const int motor2Pin1 = 4;    // H-bridge leg 3
const int motor2Pin2 = 5;    // H-bridge leg 4
const int enable1Pin = 9;    // H-bridge enable pin
const int enable2Pin = 10;   // H-bridge enable pin
const int ledPin = 13;       // LED

#define echoPin 6             // the SRF04's echo pin
#define initPin 7             // the SRF04's init pin
unsigned long pulseTime = 0;  // variable for reading the pulse
long servoAngle = 90;         // variable for reading the pulse
int servoDirection = 1;

void setup() {
  pinMode(ledPin, OUTPUT);

  // set all the other pins you're using as outputs:
  pinMode(motor1Pin1, OUTPUT);
  pinMode(motor1Pin2, OUTPUT);
  pinMode(enable1Pin, OUTPUT);

  pinMode(motor2Pin1, OUTPUT);
  pinMode(motor2Pin2, OUTPUT);
  pinMode(enable2Pin, OUTPUT);

  // set enablePin high so that motor can turn on:
  digitalWrite(enable1Pin, HIGH);
  digitalWrite(enable2Pin, HIGH);

  // make the init pin an output:
  pinMode(initPin, OUTPUT);
  // make the echo pin an input:
  pinMode(echoPin, INPUT);

  for (int thisReading = 0; thisReading < numOfReadings; thisReading++)
  {
    readings[thisReading] = 0;
  }

  // blink the LED 3 times. This should happen only once.
  // if you see the LED blink three times, it means that the module
  // reset itself,. probably because the motor caused a brownout
  // or a short.
  blink(ledPin, 3, 100);
}

void loop() {
  digitalWrite(initPin, HIGH);         // send 10 microsecond pulse
  delayMicroseconds(10);               // wait 10 microseconds before turning off
  digitalWrite(initPin, LOW);          // stop sending the pulse
  pulseTime = pulseIn(echoPin, HIGH);  // Look for a return pulse, it should be high as the pulse goes low-high-low
  distance = pulseTime/58;             // Distance = pulse time / 58 to convert to cm.
  total= total - readings[arrayIndex]; // subtract the last distance
  readings[arrayIndex] = distance;     // add distance reading to array
  total= total + readings[arrayIndex]; // add the reading to the total
  arrayIndex = arrayIndex + 1;         // go to the next item in the array

  // At the end of the array (10 items) then start again
  if (arrayIndex >= numOfReadings)  {
    arrayIndex = 0;
  }

  averageDistance = total / numOfReadings;      // calculate the average distance
  delay(10);

  // check the average distance and move accordingly

  if (averageDistance <= 20){
    // go backwards
    digitalWrite(motor1Pin1, HIGH);
    digitalWrite(motor1Pin2, LOW);
    digitalWrite(motor2Pin1, HIGH);
    digitalWrite(motor2Pin2, LOW);

  }

  if (averageDistance <= 60 && averageDistance > 20) {
    // turn
    digitalWrite(motor1Pin1, HIGH);
    digitalWrite(motor1Pin2, LOW);
    digitalWrite(motor2Pin1, LOW);
    digitalWrite(motor2Pin2, LOW);
  }

  if (averageDistance > 60)   {
    // go forward
    digitalWrite(motor1Pin1, LOW);
    digitalWrite(motor1Pin2, HIGH);
    digitalWrite(motor2Pin1, LOW);
    digitalWrite(motor2Pin2, HIGH);

  }

}

/*
blinks an LED
*/
void blink(int whatPin, int howManyTimes, int milliSecs) {
  int i = 0;
  for ( i = 0; i < howManyTimes; i++) {
    digitalWrite(whatPin, HIGH);
    delay(milliSecs/2);
    digitalWrite(whatPin, LOW);
    delay(milliSecs/2);
  }
}

Šis kodas nuolat seka vidutinį atstumą iki artimiausio objekto:

• Jeigu atstumas daugiau nei 60cm, tuomet robotas juda į priekį;
• Jeigu atstumas tarp 20cm ir 60cm, robotas bando apvažiuoti sukdamas į kairę;
• Jeigu atstumas mažiau už 20cm, robotas juda atgal.

Veikia!

Ištestuotavus ir pataisius keleta smulkmenų robotas surinktas ant stalo ir veikia!

Važinėjančio roboto video:

Click here to view the embedded video.

Kas toliau?

Iki mano visų idėjų įgyvendinimo dar teks padirbėti:

• Reikia išnaudoti servo, kad robotas geriau matytų aplinką;
• Išspręsti problemas dėl greito baterijų išeikvojimo, nes staiga keičiant varikliukų sukimosi kryptį  kenčia baterijos;
• Padaryti, kad robotukas sustotų ir apsidarytų įvertindamas atstumus;
• Susikurtų atminty aplinkos žemėlapį;
• Sugebėtų susirasti įkroviklį ir jame pakrauti baterijas kai nusėda;
• Mėgtų arba bijotų stiprios šviesos.

Ką sukūrė kiti?

Kiti dalyviai daugiausia eksperimentavo su šviesa ir bandė valdyti kompiuterį su Arduino.

Daugiau apie Howduino galite pasiskaityti ir pasižiūrėti:

• Daugiau nutoraukų ir video Howduino Flickr grupėje
• FizzPOP blogo įrašas apie Howduino.

Būtinai parašysiu kaip sekėsi toliau hakinti mašinėlę.

Kaip ir žadėjau toliau tęsiu eksperimentus su davikliais. Prie jau pajungto LCD ekrano prijungiau SRF05: ultragarsinį atstumo detektorių, kuris bus roboto rega ir leis neatsimušti į kliūtis. Įrenginys yra tos dvi “akys” schemos dešinėje viršuje. Veikimo principas nesudėtingas: garsiakalbio pagalba siunčiams aukšto dažnio (40 kHz) garsas ir mikrofonas laukia kol nuo netoliese esančio daikto sugrįš aidas. Kai tik aidas sugrįžta išmatuojamas laikas kiek toks procesas užtruko ir atstumas grąžinamas atgal į Arduino kaip impulso trukmė daviklio išėjime. Visa tai vaizdžiai atrodo taip:

Click here to view the embedded video.

Pagaliau nuspirkau FireWire kabelį. Dabar savo eksperimentus galiu filmuoti su DV kamera ir kokybė nepalyginamai geresnė nei nei filmuojant su telefonu.

Kodo galabaliukas, kuris veikia mikroprocesoriuje:

// include the library code:
#include <LiquidCrystal.h>

#define echoPin 6             // the SRF05's echo pin
#define initPin 7             // the SRF05's init pin
unsigned long pulseTime = 0;  // variable for reading the pulse

// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

void setup() {
 // set up the LCD's number of rows and columns:
 lcd.begin(16, 2);

 // make the init pin an output:
 pinMode(initPin, OUTPUT);
 // make the echo pin an input:
 pinMode(echoPin, INPUT);
}

void loop() {
 digitalWrite(initPin, HIGH);
 delayMicroseconds(10);
 digitalWrite(initPin, LOW);

 pulseTime = pulseIn(echoPin, HIGH);

 lcd.setCursor(0,0);
 lcd.print(pulseTime / 58, DEC);
 lcd.print("cm");

 delay(100);
 lcd.clear();
}

Kas 100 milisekundžių programa nusiunčia impulsą į SRF05, sulaukia iš jo atsakymo ir rezultatą parodo LCD ekrane.

Su šiuo davikliu galima sukonstruoti labai įdomų instrumentą pavadintą theremin. Net nežinau kaip jis verčiasi į lietuvių kalbą. Principą yra lengviau pademonstruoti, negu paaiškinti:

Click here to view the embedded video.

Click here to view the embedded video.

Daugiau informacijos apie instrumentą su Arduino:

• Arduino: A Basic Theremine
• Arduino: Basic Theremin meets Processing!

Roboto kūrimas eitųsi kur kas greičiau jeigu pažingsniui nebloginčiau visko ką darau, bet aprašymas tebūnie irgi proceso dalis. :) Galite matyti kaip sekasi mokintis.

Kuo toliau eksperimentuoju su savo Arduino MEGA, tuo man jis labiau patinka. Aš visada galvojau, kad mikroprocesoriai, jų programavimas ir apskritai pritaikymas yra iš kosmoso srities ir man iki jo toli toli, bet su Arduino viskas per daug paprasta. Iš tiesų, eksperimentuoti taip paprasta, kad dabar net gailiuosi, jog to nedariau iki šiol. Anglijoj elektroninių komponentų pasirinkimas internetinės parduotuvėse yra didžiulis. Ypač pamėgau Rapid dėl nepaprastai didelio įvairiausių komponentų kiekio ir Oomlout už puikų atviros hardware idėjos palaikymą.

Iš pastarųjų kaip tik ir noriu pademonstruoti įsigytą LCD ekraną už vos £6 (!!!).

Click here to view the embedded video.

Surinkti buvo labai paprasta, nes Oomlout atsiuntė išsamią pajungimo schemą, o be to visa informacija apie kiekvieną jų produktą yra laisvai pasiekiama internete.

Kažko labai šustro daryti nebandžiau, nes norėjau tik susipažinti kaip veikia LCD ekranėlis, o pagrindinis tikslas gi yra sukurti autonominį kliūtis apvažiuojantį robotą, todėl čia yra tik pasiruošimo ir mokinimosi darbai. LCD ekranėlis ateityje rodys roboto būseną ir gelbės kaip debuginimo pagalbininkas. Visas kodas, kurio pagrindu bėga ši eilutę atrodo taip:

// include the library code:
#include <LiquidCrystal.h>

// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

void setup() {
  // set up the LCD's number of rows and columns:
  lcd.begin(16, 2);
}

void loop() {

  lcd.print("                 arvydas.net");

  lcd.setCursor(16,1);
  lcd.autoscroll();

  for (int thisChar = 0; thisChar &lt; 28; thisChar++) {
    lcd.print(" ");
    delay(250);
  }
  lcd.noAutoscroll();

  lcd.clear();
}

Štai kodėl iki šiol negaliu atsidžiaugti kaip su Arduino pagalbinių bibliotekų ir API pagalba galima paprastai valdyti LCD. Šis paprastumo principas jaučiasi kad ir ką darytum su Arduino: bandytum prijungti sensorius, sukurti šviesoforą ar net susirinkti savo Arduino iš atskirų dalių. Prisipirkau dar visą galybę kitokio elektroninio gėrio savo projektui, bet apie kiekvieną iš jų truputį vėliau.

Elektronika kaip hobiu domėjausi nuo 5 klasės, tik dėl visiškai kitokio darbo pobūdžio prie elektroninių komponentų nebuvau rimčiau prisėdęs jau daugiau nei 7 metai. Įsivaizduokit koks džiaugsmas mane apėmė, kai sužinojau, kad mano OggCamp 2009 laimėta Arduino MEGA yra miniatiūrinė elektroninių prototipų kūrimo platforma! Viskas būtų gerai, jei tik prieš pradėdamas eksperimentuoti su šituo gėriu būčiau žinojęs, kad viskas nebus taip paprasta kaip atrodė iš pirmo žvilgsnio, bet apie viską iš pradžių. :)

Kas yra Arduino MEGA?

Tai yra ATMega mirkroprocesorium (didelis juodas blynas plokštės viduryje) paremta pigi prototipinių elektroninių įrenginių kūrimo plokštė, žmonėms, kurie mažai nusimano apie elektroniką. Įdomu yra tai, kad Arduino – atviro programinio kodo ir harware platforma. Visi brėžiniai, techniniai duomenis ir programavimo informacija yra prieinama viešai ir bet kas pagal pateiktą informaciją gali susirinkti plokštę pats arba užsisakyti jau surinktą. Arduino platformų yra įvairių, mano turima MEGA turi daugiausia įėjimų/išėjimų tarp kurių 32 skaitmeniniai, 16 analoginių ir 4 grupės skirtų bendravimui tarpusavyje tarp pačių plokščiu arba kitais įrenginiais nuosekliu protokolu. Plokštės suprojektuotos taip, kad ant jų galima būtų dėti shield’us (šarvus). Tai yra kitos plokštės, kurios maunasi viena ant kitos ir ant pačios Arduino, bendraujančios su mikroprocesoriaus smegenim per įėjimus/išėjimus ir galinčios atlikti bala žino kiek funkcijų: rodyti LCD displėjuje tekstą, priimti signalus iš jungiklių, temperatūros, šviesos, drėgnumo, slėgio ir kitokių daviklių, dirbti kaip ethernet ar wireless įrenginys, kuris suteikia plokštei galimybę bendrauti internetu ir t.t. Visų galimybių išvardinti neįmanoma, nes jos apribotos tik fantazija ir piniginės storumu. :) Pavyzdžiui, čia – Arduino tinklo plokštė, kurios pagalba galima jungtis prie interneto:

Arduino programavimas

Programavimas vyksta prijungus Arduino plokštę prie kompiuterio per USB jungtį ir su specialiu IDE sukompiliavus kodą jis nusiunčiamas tiesiai į mikroprocesoriaus atmintį. Po to USB jungtį galima atjungti ir įrašyta programa toliau veiks pajungus plokštei atskirą maitinimo šaltinį.

Pirmoji programa

Paprasčiausia programa – mirksintis šviesos diodas, kurią aš nusprendžiau šiek tiek patobulinti ir sukurti pėsčiųjų šviesoforą. Kaip jis veikia galite pamatyti čia:

Click here to view the embedded video.

O čia yra kodas kuris veikia mikroprocesoriuje:

int carRedPin =  13;
int carYellowPin =  12;
int carGreenPin =  11;
int pedestrianRedPin =  10;
int pedestrianGreenPin =  9;

// The setup() method runs once, when the sketch starts

void setup()   {
  pinMode(carRedPin, OUTPUT);
  pinMode(carYellowPin, OUTPUT);
  pinMode(carGreenPin, OUTPUT);
  pinMode(pedestrianRedPin, OUTPUT);
  pinMode(pedestrianGreenPin, OUTPUT);
}

// the loop() method runs over and over again,
// as long as the Arduino has power

void blink(int light)
{
  digitalWrite(light, LOW);
  delay(500);
  digitalWrite(light, HIGH);
  delay(500);
  digitalWrite(light, LOW);
  delay(500);
  digitalWrite(light, HIGH);
  delay(500);
  digitalWrite(light, LOW);
  delay(500);
  digitalWrite(light, HIGH);
  delay(500);
  digitalWrite(light, LOW);
}

void loop()
{
  digitalWrite(carRedPin, HIGH);
  digitalWrite(pedestrianGreenPin, HIGH);
  delay(3000);

  blink(pedestrianGreenPin);

  digitalWrite(pedestrianRedPin, HIGH);
  digitalWrite(pedestrianGreenPin, LOW);
  delay(1000);
  digitalWrite(carYellowPin, HIGH);
  delay(1000);
  digitalWrite(carRedPin, LOW);
  digitalWrite(carYellowPin, LOW);
  digitalWrite(carGreenPin, HIGH);
  delay(3000);

  blink(carGreenPin);

  digitalWrite(carYellowPin, HIGH);
  delay(2000);
  digitalWrite(carYellowPin, LOW);
  digitalWrite(carRedPin, HIGH);
  delay(1000);
  digitalWrite(pedestrianRedPin, LOW);
}

Pradžiai nurodau kurios jungtys veiks kaip išėjimai, tada pagrindiniame cikle loop tam imituojant šviesoforą tikru laiku yra įjungiami vieni šviesos diodai ir tam tikru metu išjungiami kiti.

Mano istorija su Arduino

Čia tikriausiai taisyklė, kad mano eksperimentavimas su elektronika niekada nebūna paprastas. Arduino neišimtis. Iš pradžių man niekaip nepavyko nusiųsti paprasčiausios demonstracinės programos į plokštę, nes IDE metė klaidą, kad nepavyksta susibendrauti su MEGA. Jau buvau beveik įsitikinęs , kad gavau defektuotą plokštę, bet rankų vis tiek nenuleidau. Dovanotam arkliui į dantis nežiūrima. :)

Besiknisdamas forumuose išsiaiškinau, kad mikroprocesoriuje tiesiog nebuvo bootloader’io, kuris yra kaip BIOS kompiuteryje: jo pagalba plokštė gali bendrauti su kompiuteriu per USB, o be to Arduino tėra tik mikroschemų krūva. Standartiškai visos parduodamas Arduino savyje jau turi įdiegtą bootloader, bet mano atveju mikroschema buvo visiškai tuščia.

Nebūdamas visai tikras, kad su pačia Arduino hardware viskas gerai, nusprendžiau rizikuoti ir internetu nusipirkti atskirą programatorių USBTinyISP. Iš tokios detalių krūvos:

Susilitavau tokį įrenginį:

Šio universalaus programatoriaus pagalba į plokštę nusiunčiau bootloader ir pagaliau Arduino pradėjo bendrauti per USB! Iš karto susidūriau su kitu nepatogumu: kiekvieną kartą programuojant mikroprocesorių teko spaudinėti plokštėje esantį Reset mygtuką, nors plokštės nuresetinimas turėjo vykti automatiškai IDE nuspaudus Upload. Šį gerai žinoma Arduino MEGA defektą panaikinau prilitavęs teisingą keramikinį kondensatorių:

Plokštę priversti veikti užtrukau apie savaitę, bet už tai setisfekšinas padarius pirmą veikiančią programą nerealus. :) Pagaliau mano programos “ištrūko” iš kompiuterio ir galės reaguoti į fizinį pasaulį!

Viskas, garantuotai turiu naują “ligą”. :)

Kas toliau?

Dabar kai viskas veikia ir ištestuota pabandysiu įgyvendinti savo seną svajonę ir sukurti kokį nors autonominį kliūtis apvažiuojantį robotą. Šiaip robotų kūrimo platformos kainuoja kosminius pinigus – nuo £100 be jokios elektronikos ir varikliukų. Sumąsčiau genialią mintį: Anglijoj žaislų parduotuvėse visokios radijo bangom valdomos mašinos kainuoja kapeikas, todėl vos už £7 nusipirkau naują tik su pakavimo defektu R/C mašiną ir tikėjausi užsiimti jos vandalizacija.

Tik kuomet vakar prieš išardant dalimis su ja pabandžiau šiek tiek pažaisti, pasirodo nusipirkau visai fainą žaislą, kuris labai jėgiškai driftina ant kilimo. Sūnus, aišku, iš karto pareiškė į jį teises. Na ir ką dabar padarysi? Teks ieškotis kažko kito skrodimui, bet apie tai jau kituose mano įrašuose. :)