Balanseerija

• Priit Suurküla
• Siim Sülla
• Holger Kruusla
• Martin Parker

• Robot toetub maapinnale ainult kahe rattaga
• Robot on autonoomne
• Robot suudab püsti seista ja sõita mööda joont

Meie Roboti ideelahenduse leidmine koosnes kahest osast. Esiteks visuaalse lahenduse leidmine, et robot näeks atraktiivne ja ilus välja ning ühtlasi oleks lihtsalt koostatav. Teiseks ja ühtlasi ka olulisemaks oli leida meile sobiv roboti tööpõhimõte. Selleks oli kolm võimalust: Güroskoobi, Infrapuna-, või Ultraheli kaugusandurite kasutamine.

• Disain ja mehaanika

See oli üks esimestest asjadest, mille me reaalselt (3D mudelina) valmis saime. Kokku valmis 2 mudelit, seega polnud sobiva lahenduse valik ülemäära keeruline. Alljärgnevatel piltidel meie Disainilahendused.

Oma projekti realiseerimiseks valisime teise disaini variandi (parempoolne lahendus). Valik osutus selliseks mitmetel kaalutlustel. Suurimaks kasuteguriks oli sellise variandi lihtsus. Kogu roboti kere koosneb kaheksast detailist, mis kõik valmistatakse CNC pingil. Sellega seoses jäävad ära eisimese lahenduse puhul vajalikuks osutunud treimis, keermelõikus, mõõtmis, ning saagimis tööd, mida teise variandi puhul teeb meie eest CNC pink. Esimese variandi suureks puuduseks oli ka Ultraheli andurite paigutamine, kuna andurite „vaateväli“ on üsna lai siis peavad andurid asetsema roboti kerest teatud kaugusel ning kindla nurga all, et kere ei hakkaks andurite tööd segama.

• Balanseerimise tööpõhimõte.

Kuna kõik variandid on omamoodi huvitavad ning kõigil neist on oma valupunktid ,mida lahendada, siis oli otsustamine päris keeruline. Kuna güroskoobid on suhteliselt kallid ja roboti programmeerimine güroskoopi kasutades on võrreldes teistega mõnevõrra keerulisem otsustasime sellest lahendusest loobuda. Järgi jäid kaugusandurid. Lähema uurimise käigus selgus, et infrapuna andurid ei peegelda kõigilt pindadelt ühetaoliselt tagasi ja annavad seetõttu häiringuid ning tuli meil ka neist loobuda, sest joon mida mööda robot peab sõitma on musta värvi ning võib hakata IR andurite tööd häirima. Ultraheli andureid uurides selgus, et sellise lahendusega on valmistatud balanseerivaid roboteid. Kuna kodulabori komplekti kuulub samuti ultraheliandur, siis otsustasime, et neid kasutades saame roboti prototüübi kiiresti valmis ning sellega seoses jääb meil rohkem aega katsetusteks ja koodi kirjutamiseks.

Kõike eelnevat arvesse võttes otsustasime, et põhjalikumalt hakkame arendama teist disainilahendust koos ultraheli anduritega, mis tagavad roboti balansseerimise.

Lahendus

• Kasutame kahte ultraheliandurit roboti asendi määramiseks maapinna suhtes
• Roboti ajuks on ATMega128 mikrokontroller
• Kahte ratast veavad kaks DC mootorit

Roboti projekteerimisel lähtusime sellest, et see oleks huvitava välimusega ning, et seda oleks võimalikult lihtne kokku panna (lahti võtta). Roboti kere koosneb kahest identsest küljest, mille sisse on lõigatud tapiavad ja freesitud mootorite kinnitus avad. Kahe külje vahele paigutuvad horisontaalplaadid moodulite ning patareide jaoks. Nende asetus on paigutatud nii, et oleks lihtne moodulplaatidele ligi pääseda (paigaldada progammaatori juhet, andurite ja mootorite juhtmeid jne). Kuna tapid lähevad avadesse ainult ühte moodi ning horisontaalplaate on kõigest kolm erinevat siis on kere kokku panemine hämmastavalt lihtne. (juhul kui moodulid ning andurid on eelnevalt plaatidele monteeritud). Roboti ratasteks kasutame tavalisi lego rattaid (http://www.peeron.com/inv/parts/2903), mis on meie roboti tarvis vastavalt modifitseeritud. Rataste tsentrisse on puuritud suuremad augud,mis on ka keermestatud. Alloleval pildil ratas koos kinnitusega (ratas kinnitub mootori võllile kahe kruvi abil).

Ratta kinnnitamiseks mootori võllile on treitud nn Rattakinnitus võll, mille ühte otsa on puuritud auk, mis ühtib mootori võlli läbimõõduga ning samasse otsa ka kaks võlli teljega risti asetsevat auku, mis hiljem keermestatakse M3 keermega ning, mille eesmärgiks on pingu tekitamine mootori võllile, et ratas kindlalt kinni püsiks. Võlli teises otsas on M8 keere ratta ning mutri kinnituseks. Lihtsustatud Rattakinnituse detailijoonis ja Kinnituse prototüübi valmis lahendus.

Roboti kere selgrooks on küljed, nende külge kinnituvad praktiliselt kõik teised kere detailid: mootorid ning horisontaalplaadid moodulite, akude ja ultraheliandurite kinnituseks. Motorite kinnituseks on külje siseküljele freesitud mootori diameetriga võrdne süvend ning puuritud augud vastavalt mootori tüübi kinnitusele (antud juhul lahendatud süvend alumiinium plaadiga kuhu puuritud mootori kinnitamiseks 2 auku ning 1 auk mootori võlli tarvis). Järgnevat on kujutatud lihtsustatud külje detailijoonis, kuhu on märgitud tapiavade paigutus ning nende suurused. Kontuurjoonte raadiused on märkimata kuna antud juhul on kontuuri põhiline eesmärk huvitava disaini loomine ( tähtis on tapiavade paigutus, suurus ning omavahelised kaugused).

Roboti prototüübi valmis küljelahendus.

Järgmised võtmedetailid roboti kere juures on rohelised horisontaalplaadid, mis annavad robotile soovitud jäikuse ning tugevuse. Horisontaalplaate on meie roboti juures kolme erinevat tüüpi. Üks alusplaat, mille eesmärgiks on suurema jäikuse tekitamine. Kolm identset plaati, millest kahele kinnituvad kontrolleri- ning mootorite moodul ning ühele patareid. Kaks identset plaati ultraheli andurite kinnitamiseks. Kõik horisontaalplaadid kinnituvad külgedele tappide ning kruvidega (soovi korral võib jätta kruviaugud tegemata ning kinnitada plaadid liimiga kuna praktika näitas ,et tapid hoiavad ise juba robotit üsna hästi koos).

Alusplaadi detailijoonis.

Moodulite plaadi detailijoonis.

Andurite kinnitusplaadi detailijoonis.

Moodulite kinnitamiseks Horisontaalplaatidele puuritakse plaatidesse augud (vastavalt moodulplaatide kinnitus aukudele) ning keermestatakse need augud. Moodulid kinnitatakse kruvidega, mooduli ning horisontaali vahele asetatakse ka puksid, mille kõrguseks on 3-5 mm ning avad puksides vastavalt kinnituskruvide läbimõõdule. Robot kasutab 8x 1.5v patareid mille hoidmiseks on kaks patarei pesa , kumbki mahutab neli patareid. Kuna patareipesadel puuduvad kinnitamiseks mõeldud avad siis nende kinnnitamiseks oleme esialgu mõelnud kasutada kahepoolset teipi.

Ultraheliandurid kinnituvad horisontaalplaatidele analoogselt mooduplaatidega. Andurite ning plaadi vahele asetatakse puksid ning kruvitakse andurid plaadi külge. Kuna tegemist on kahel rattal sõitva robotiga siis on vältimatu ,et robot aegajalt „ninuli“ kukub. Kukkumisest tekkivate vigastuste vältimiseks kinnitasime ultraheliandurite juurde vedrud „bumperid“ ,mis roboti kukkumisel summutavad suurema põrutuse. Vedru on kinnitatud horisontaalplaadile pleki tüki abil (vedru nurka on võimailik korrigeerida pleki tükki paenutades). Kuna vedru kinnitamine pleki tüki külge oli komplitseeritud, siis tuli selleks üsna palju vaeva näha. Esmalt tuli „vedru „ peene juhtme abil pleki külge punuda ning kinnituse tugevamaks muutmiseks jootsime sinna ka tina. Vedrude ning ultraheliandurite kinnitus on järgneval pildil.

Üldine elektroonika plokkskeem

Jooneandurite elektriskeem

Info kuvamiseks ja välimuse atraktiivsemaks muutmiseks on roboti peale (Patareide pesade peal) kinnitatud visuaalne väljundplaat mis koosneb viiest rohelisest ledist, mida on võimalik programmerida meile vajaliku infot kuvama. Plaat on kinnitatud kahepoolse teibiga.

Visuaalse väljundplaadi pilt

Visuaalse väljundplaadi elektriskeem

// Standardteegid
#include <homelab/pin.h>
 
// isetehtud teekide lisamine
#include "Mootor.h"
#include "Sensors.h"
 
// Definitsioonid
#define ENK  181 // esimene normaal kaugus
#define TNK  177 // tagumine normaal kaugus
#define VIGA 40  // jäme mõõteviga
 
#define NUPP_PORT PINC
#define NUPP1_PIN PC6
 
// Ultraheli anduri viigud
pin pin_trigger_e = PIN(G, 1);
pin pin_echo_e    = PIN(G, 0);
pin pin_trigger_t = PIN(C, 1);
pin pin_echo_t    = PIN(C, 0);
 
short esimene,tagumine,esimene_v[5],tagumine_v[5];
 
void Filter(short lugem, short kaugus)
{
	// võrdleb tegelikuga ja otsustab mida sellega teha
	if((lugem > kaugus + VIGA)||(lugem < kaugus - VIGA))
	{
		if(kaugus == ENK)
			esimene = esimene_v[4];
		else
			tagumine = tagumine_v[4];		
	}
	else // nihutab tulemusi
	{
		if(kaugus == ENK)
		{
			for(int j=0;j<4;j++)
			{
				esimene_v[j] = esimene_v[j+1];
			}
			esimene_v[4] = lugem;
		}
		else
		{
			for(int j=0;j<4;j++)
			{
				tagumine_v[j] = tagumine_v[j+1];
			}
			tagumine_v[4] = lugem;
		}
	}
 
 
}
// -------------------------------------------------------------
// Põhifunktsioon Main
// -------------------------------------------------------------
pin test[5] = {PIN(C,3), PIN(C,5), PIN(C,7), PIN(C,2), PIN(C,4)};
 
int main(void)
{
	// PORTC defineerimine
	DDRC = (1<<PC2)|(1<<PC3)|(1<<PC4)|(1<<PC5)|(0<<PC6)|(1<<PC7);
 
	short k = 0; // andurite abimuutuja kordamööda mõõtmisel
	short suund_p, suund_v, uh_vahe;
	short Kp, Ki, Kd;
	short error_p, previous_error_p, integral_p, derivative_p;
	short error_v, previous_error_v, integral_v, derivative_v;
	long speed_v, speed_p, M_p, M_v;
	short p_error=0,i_error=0,d_error=0,lerror=0;
	long Kpj,Kij,Kdj,J=0;
 
	suund_p = EDASI;
	suund_v = EDASI;
 
	// PWM ja adc initsialiseerimine
	init_adc();	
	adc_compare();
	pwm_init();
 
	// esimeste lugemite sisestamine
	for(int j=0;j<5;j++)
	{
		esimene_v[j] = ENK;
		tagumine_v[j] = TNK;
	}
 
	// Joonejälgimise PID
	Kpj=80;	
	Kdj=0;
	Kij=0;
 
	// PID kordajad
	Kp = 18;
	Ki = 10; // lõppvalemis jagatud 10-ga
	Kd = 2;
 
	integral_p = 0;
	derivative_p = 0;
	error_p = 0;
	previous_error_p = error_p;
	M_p = 0;
 
	integral_v = 0;
	derivative_v = 0;
	error_v = 0;
	previous_error_v = error_v;
	M_v = 0;
 
	while(1)
	{			
		// Ultraheli andurite lugemine
		if(k==0)
		{
 
			esimene = ultrasonic_measure1(pin_trigger_e, pin_echo_e);
			// Filtreerib ja parandab
			Filter(esimene, ENK);
			k++;	
		}
		else
		{
			tagumine = ultrasonic_measure1(pin_trigger_t, pin_echo_t);
			// Filtreerib ja parandab
			Filter(tagumine, TNK);
			k=0;
		}		
		uh_vahe = ((TNK-tagumine_v[4]) - (ENK-esimene_v[4])) ;
 
		// Edasiliikumiseks vajaliku nurgahälbe tekitamine
		if((uh_vahe==1)||(uh_vahe==2)||(uh_vahe==3)||(uh_vahe==4)) uh_vahe = 0;
 
		// jooneandurite lugemine
		sensor = read_sensors();
 
		// Vigade määramine
		error_p = uh_vahe/2;
		error_v = uh_vahe/2;
 
		// Parem
		integral_p += error_p;
		if(integral_p > 400) integral_p = 400;
		if(integral_p < -400) integral_p = -400;
		derivative_p = error_p - previous_error_p;
		// Vasak
		integral_v += error_v;
		if(integral_v > 400) integral_v = 400;
		if(integral_v < -400) integral_v = -400;
		derivative_v = error_v - previous_error_v;
		// Momentide arvutamine
		M_p = Kp*(error_p) + Ki*integral_p/10 + Kd*derivative_p;
		M_v = Kp*(error_v) + Ki*integral_v/10 + Kd*derivative_v;
 
		speed_p = max_speed*M_p/400-100;
		speed_v = max_speed*M_v/400-100;
 
		previous_error_p = error_p;
		previous_error_v = error_v;
 
		if(speed_p <= 0)
		{
			speed_p = -speed_p;
			suund_p = EDASI;
		}
		else
		{
			suund_p = TAGASI;
		}
 
		if(speed_v <= 0)
		{
			speed_v = -speed_v;
			suund_v = EDASI;
		}
		else
		{
			suund_v = TAGASI;
		}
 
		p_error=jooneasukoht(PAREM);
		i_error+=p_error;
		d_error=p_error-lerror;
		lerror=p_error;
		J=(Kpj*p_error+Kij*i_error+Kdj*d_error)/100;
		if(J>100)J=100;		
		if(J<-100)J=-100;
		speed_v = (speed_v*(100-J)/100);
		speed_p = (speed_p*(100+J)/100);
 
		if(speed_p > max_speed) 
		{
			speed_p = max_speed;
		}
		if(speed_v > max_speed)
		{
			speed_v = max_speed;
		}
		Motors(PAREM,speed_p,suund_p);
		Motors(VASAK,speed_v,suund_v);
 
	}
}

Siin on ülejäänud lähtekood → AVR Studio projekt

Pärast 9 nädalat tööd on valmis robot balanseeriv joonejälgija. Järgnevalt on näha meie roboti prototüüp ja kõik tähtsamad detailid ning nende kinnitused komplektselt. Ühtlasi on antud pildi järgi võimlaik teostada roboti kokku monteerimine ilma koostejooniseta.

Eesmärk oli kasutada ära võimalult palju olemasolevaid komponente ja materjale. Hinnad ei ole hetkel täpsed, kuna paljusid komponente ei pidanud me ise ostma.

Lisaks tuleks CNC freespingi ja muude töövahendite kasutamise hind.

Ülesanded said üsna alguses ära jaotatud ning samuti oli osaliselt olemas ajakava, sest aine nõudis teatud ajaks vastavat roboti valmidust.

Koostöö oli hea ning saime roboti üsna kiiresti valmis ning jäi päris palju aega programmeerimiseks.

1. Nädal - Nädal 1
2. Nädal - Nädal 2
3. Nädal - Nädal 3

Üldiselt õnnestus meil antud ülesande täitmine üsnagi edukalt. Robot suudab iseseisvalt end tasakaalustada ning ka algtasemel joont järgida. Saime mehaanika üsnagi lihtsalt projekteeritud ja koostatud, elektroonika oli enamjaolt olemas tuli ainult moodulid ja komponendid omavahel sobitada. Kõige rohkem aega võttis programmeerimine ja testimine. Üks põhjus miks meil korraliku tasakaalu saavutamine kaua aega võttis oli lihtsate algoritmide kasutamine, nimelt ei kasutanud me alguses eriti matemaatikat vaid pigem võrdlustehnikat. Palju parema tulemuse saavutasime siis kui võtsime kasutusele PID regulaatori. Seega soovitan teistel kohe sellest alustada.

Üks suurimaid puudusi sellel robotil on kiiruse mõõtmise võimaluse puudumine. Soovitan kindlasti kasutada sellise ülesande täitmisel kas koodritega või Halli anduritega mootoreid. Võib kasutada ka muid piisavalt töökindlaid mooduseid kiiruse määramiseks.

1. ATmega128 datasheet
2. nBot balansseerija
3. Roboticlabi praktilised näited

Video roboti toimimisest - PID demo