Alalisvoolumootor

Vajalikud teadmised: [HW] Kasutajaliidese moodul, [HW] Kombomoodul, [AVR] Loendurid/Taimerid, [AVR] Analoog-digitaalmuundur, [LIB] Mootorid, [LIB] Analoog-digitaalmuundur

Alalisvoolu mootor

Püsimagnetiga alalisvoolumootorid on laialt levinud erinevates rakendustes, kus olulised on väikesed mõõtmed, suur võimsus ja madal hind. Nende suhteliselt suure pöörlemiskiiruse tõttu kasutatakse neid tihti koos ülekandega (reduktoriga) madalama kiiruse ja suurema pöördemomendi saavutamiseks.

Ideaalne alalisvoolumootori kiiruse (V), voolutugevuse (I), võimsuse (P), efektiivsuse (η) ja jõumomendi (T) vahelise sõltuvuse graafik

Püsimagnetiga alalisvoolumootorid on lihtsa ehitusega ja elementaarse juhtimisega mootorid. Kuigi juhtimine on lihtne, ei ole nende pöörlemiskiirus üldjuhul täpselt juhtsignaaliga määratletav, sest see sõltub mitmetest teguritest, eelkõige võllile rakendatavast koormusest ja toitepingest. Ideaalse alalisvoolumootori jõumomendi ja kiiruse suhe on lineaarne, mis tähendab seda, et mida suurem koormus on võllil, seda madalam on kiirus ja seda suurem on mähist läbiv vool.

Harjadega alalisvoolumootorid töötavad alalispingel ning põhimõtteliselt ei vaja eraldi juhtelektroonikat, kuna kogu vajalik kommutatsioon toimub mootori sees. Mootori töötamise ajal libisevad kaks staatilist harja rootori pöörleval kommutaatoril ning hoiavad mähiseid pinge all. Mootori pöörlemissuuna määrab toitepinge polaarsus. Kui mootorit on vaja juhtida ainult ühes suunas, võib toitevoolu anda relee või muu lihtsa lülitusega, kui mõlemat pidi, siis kasutatakse H-silla-nimelist elektriskeemi.

H-sillas tüürivad mootori pöörlemiseks vajalikku voolu neli transistori (või nende gruppi). H-silla elektriskeem meenutab H-tähte - sellest ka nimi. H-silla eripära seisneb mootorile mõlemat pidi polaarsuse rakendamise võimaluses. Kõrvaloleval pildil on toodud H-silla põhimõtteskeem lülitite näitel. Kui selles skeemis sulgeda kaks diagonaalis asetsevat lülitit, hakkab mootor tööle. Mootori pöörlemissuund sõltub aga sellest, kummas diagonaalis lülitid suletakse. Reaalses H-sillas on lülitite asemel muidugi transistorid, mis on valitud vastavalt mootori voolule ja pingele.

H-silla tööprintsiip lülitite näitel

H-sillaga saab peale pöörlemissuuna muuta ka mootori pöörlemiskiirust. Väiksemate voolude juhtimiseks leiab H-sildu integreeritud komponendina ehk ajurina, suuremate voolude jaoks kasutatakse spetsiaalseid võimsustransistore (Power MOSFET). H-silda koos sinna kuuluva elektroonikaga nimetatakse ka mootorikontrolleriks.

Kuigi alalisvoolumootori kiirust on lihtne juhtida, siis puudub garantii, et soovitud kiirus siiski saavutatakse. Tegelik kiirus sõltub paljudest faktoritest, põhiliselt jõumomendist mootori väljundvõllil, töövoolust ja muudest mootori karakteristikutest. Kiiruse ning väljundmomendi suhe on ideaalsel mootoril lineaarses suhtes, st mida suurem on väljundmoment, seda madalam on kiirus ning seda rohkem tarbib mootor voolu, kuid reaalsete mootorite puhul sõltub see täpse mootori tüübist.

Alalisvoolu mootorit saab juhtida nii analoog kui digitaal signaalidega.

PWM signaali näide ühe perioodi kohta

Tavaliselt on mootori kiirus sõltuvuses mootor klemmidele antavast pingest. Kui mootorit toita nominaalpingega, siis mootor pöörleb vabakäigul nominaalkiirusega. Kui vähendada mootorile antavat pinget, siis mootori kiirus ning arendatav jõumoment samuti vähenevad. Sellist kiiruse juhtimist nimetatakse analoog juhtimiseks. Seda saab realiseerida näiteks transistori või reostaadiga.

Mootori juhtimine PWM-ga

Robootikas juhitakse alalisvoolumootoreid mikrokontrolleritega ning kuna need on digitaalsed seadmed, siis on mõistlik ka mootoreid digitaalselt juhtida. See saavutatakse pulsilaiusmodulatsiooni (inglise keeles Pulse With Modulation, lühend PWM) abil transistoreid kiiresti sisse - välja lülitades. Kogu energia, mis mootorile antakse jääb seisva mootori ja täiskiirusel pöörleva mootori vahepeale. Avatud oleku aja kirjeldamiseks kasutatakse töötsükli mõistet, mida mõõdetakse protsentides. 0 % tähendab, et transistor on pidevalt suletud asendis ning mootor seisab, 100 % tähendab, et transistor on pidevalt avatud ning mootor pöörleb nominaalkiirusel. PWM-i sagedus peab olema piisavalt kõrge, et mootori pöörlemine oleks võimalikult sujuv ning väljundvõlli katkendlik pöörlemine ei tekitaks lisavibratsioone. Samuti tekitab mootori mähis madalatel sagedustel müra. Seetõttu kasutatakse tavaliselt modulatsioonisagedusi üle 20 kHz. Sagedust piirab transistoride efektiivsus, mis kõrgemate sageduste puhul langeb.

Digitaalsel juhtimisel on võrreldes analoogjuhtimisega mitmed eelised. Peamine eelis mikrokontrolleriga juhitavate süsteemide puhul on see, et vaja on vaid ühte digitaalväljundit ning puudub vajadus keerulise digitaal-analoog muunduri järele. Samuti on digitaalne juhtimine efektiivsem, kuna energiat muundatakse vähem soojuseks.

Lihtsustatud juhtimisskeem on näidatud kõrvalasuval joonisel. Juhtpinge Vc tuleb mikrokontrolleri väljundviigult ning lülitab transistori Q sisse-välja umbes 20 kHz sagedusel. Kui transistor Q on sisse lülitatud, liigub kogu vool I läbi mootori M. Sellisel juhul käitub transistor kui suletud lüliti ja pingelang Vq on 0-i lähedane ning mootorile jääb kogu sisendpinge Vdd.

P = I * V

P = I * Vq, ja kui Vq ~ 0, siis P ~ 0 W

See tähendab, et transistor ei kuluta avatud olekus peaaegu üldse energiat. Sarnane situatsioon on ka juhul, kui transistor on suletud olekus. Sellisel juhul ei liigu läbi transistori ega mootori vool. Arvutades transistori läbiva võimsuse:

P = I * Vq, ja kui I = 0, siis P = 0 W

Kokkuvõttes võime öelda, kui transistor on skeemis lülitava elemendina, siis süsteemi efektiivsus on väga kõrge ning transistori kasutatav võimsus on väga madal. Võrreldes lineaarse (analoog) süsteemiga, kus transistor kulutab pool-avatud olekus sama palju voolu, kui juhitav mootor on tegemist väga suure energia kokkuhoiuga. Praktikas ei ole aga olemas kadudeta süsteemi ning tegelikult esinevad kaod ka transistori ümberlülitamisel ühest asendist teise. Seega esinevad suuremad kaod juhul, kui transistore lülitatakse kõrgematel sagedusel.

Kodulaboris kasutatakse alalisvoolumootorite juhtimiseks kombineeritud kiipi, mis sisaldab endas kahte integreeritud H-silda ja kaitsedioode. Mootorit juhitakse kolme digitaalse signaaliga, millest üks on üldine tööd lubav signaal (inglise keeles enable). Teised kaks signaali määravad H-silla transistoride oleku. Kunagi ei tohi olla avatud kaks vertikaalset transistorit, sest see lühistaks toiteallika. Selline olek on ajuri juhtimisel elimineeritud ja valida saab madala või kõrge väärtusega vaid seda, kumb transistor (kas ülemine või alumine) ühest H-silla poolest ehk poolsillast avatud on. Teisisõnu valitakse kahe juhtsignaaliga polaarsust, mis mootori mähise otstele rakendatakse.

Kodulabori Kombomoodulil on võimalus kuni nelja alalisvoolumootori ühendamiseks. Sisuliselt on iga mootori jaoks H-sild, mida juhitakse kahe mikrokontrolleri digitaalse väljundviiguga, sest lubav viik on konstantselt kõrge. Kui mõlemal juhtviigul on sama väärtus, siis mootor ei liigu, kui erinev, siis mootor pöörleb vastavas suunas. H-silla olekut iseloomustab järgmine tabel:

Iga mootorit, mis on ühendatud H-silla külge juhitakse kahe mikrokontrolleri digitaalväljundiga. Mootori kiirust juhitakse taimeritega, mis genereerivad pideva PWM signaali H-sillale, teise viiguga juhitakse mootori pöörlemise suunda. Mootori kiirust juhitakse suhteliste väärtustega 0 - 255, kus 0 tähendab seisvat mootorit ning 255 maksimaalsel kiirusel liikuvat mootorit. Järgnev koodilõik kirjeldab Kodulabor II (ATmega2561) teegis realiseeritud alalisvoolumootorite juhtfunktsioone.

// Mootorite ühendusviigud
static pin dcmotor_pins[4][2] =
{
	{ PIN(B, 7), PIN(B, 4) },
	{ PIN(D, 1), PIN(D, 0) },
	{ PIN(D, 7), PIN(D, 6) },
	{ PIN(D, 5), PIN(D, 4) }
};
static int motorindex[4][2] =
{
	{ 0, 1 },
	{ 2, 3 },
	{ 4, 5 },
	{ 6, 7 }
};
// PWM-i käivitamine valitud mootori jaoks
void dcmotor_drive_pwm_init(unsigned char index, timer2_prescale prescaler)
{
  	unsigned char i, pwm;
 
	pin_setup_output(dcmotor_pins[index][0]);
	pin_setup_output(dcmotor_pins[index][1]);
 
	motor[index] = 1;
  	pwm = PWMDEFAULT;
 
  	// Kõigi kanalite käivitamine
  	for(i=0 ; i<CHMAX ; i++)
  	{
    	  // PWM-i algväärtustamine
    	  compare[i] = pwm;           
    	  compbuff[i] = pwm;          
  	}
 
  	// Timer 2 normaalrežiimis käivitamine
  	timer2_init_normal(prescaler);
  	// Timer 2 katkestuste lubamine
  	timer2_overflow_interrupt_enable(true);
 
  	// Globaalsete katkestuste lubamine
  	sei();
}
// PWM-i genereerimine valitud mootorile
void dcmotor_drive_pwm(unsigned char index, signed char direction, 
unsigned char speed) 
{
	if(direction == -1)
	{
		compbuff[motorindex[index][0]] = 0x00;
		compbuff[motorindex[index][1]] = speed;
	}
	if(direction == 1)
	{
		compbuff[motorindex[index][0]] = speed;
		compbuff[motorindex[index][1]] = 0x00;
	} 
}

Mootorite teegi maatriksis dcmotor_pins määratakse ära viigud, kuhu on ühendatud mootorite juhtsignaalid. Enne mootori juhtimist tuleb see algväärtustada, kutsudes välja funktsiooni dcmotor_drive_pwm_init vastava mootori parameetriga (0-3). See funktsioon seab vastavad viigud väljunditeks. Samuti tuleks seadistada taimeri jagur, Kodulabor II puhul timer2_prescale ning Kodulabor III puhul timer_prescale, mis määrab PWM signaali sageduse. Kodulabor II puhul, kui programmis ei kasutata rohkem taimerit kasutavaid funktsioone, siis on sobilik väärtus TIMER2_NO_PRESCALE. Kui aga kasutatakse näiteks ka ultraheliandurit, siis tuleks valida TIMER2_PRESCALE_8, muidu võib kontrolleri jõudlust väheks jääda ja anduri lugemitesse võib tekkida viga. Kodulabor III puhul seda jälgima ei pea. Suuremaid jaguri väärtuseid pole soovitatav kasutada, sest see muudab mootori pöörlemise katkendlikuks ja tekitab vibratsiooni.

Mootorite kiiruse juhtimiseks kasutatakse funktsiooni dcmotor_drive_pwm. See funktsioon vajab kolme väärtust: esiteks mootori numbrit, mille kiirust reguleeritakse, teiseks suunda (-1, 0, +1), kus -1 tähistab pöörlemist ühes suunas, +1 teises ning 0 tähistab seismist ning kolmandaks kiirust vahemikus 0 - 255. Kiiruse väärtus ei ole seotud mingi kindla pöörlemiskiirusega vaid on suhteline väärtus mootori maksimaalse pöörlemiskiiruse ja seisva mootori vahel. Mootori reaalne pöörlemiskiirus sõltub mootorist, toitepingest ning koormusest. Mootori kiiruse täpsus on 8-bitti, mis tähendab, et minimaalne juhtimistäpsus on 1/255 mootori maksimaalsest kiirusest.

Järgnevalt on toodud näiteprogramm, mis paneb esimese mootori pöörlema poolel kiirusel ja teise mootori kiirust juhitakse potentsiomeetriga.

// Kodulabori mootori juhtimise näidisprogramm
#include <homelab/module/motors.h>
#include <homelab/adc.h>
 
// Põhiprogramm
int main(void)
{
	// Kiiruse hoidmise muutuja
	int speed;
 
	// Analoog-digitaalmuunduri käivitamine
	adc_init(ADC_REF_AVCC, ADC_PRESCALE_8);
 
	// Mootorite DC1 ja DC2 eelseadistamine (ilma taimeri jagurita)
	// Kodulabor II
	//dcmotor_drive_pwm_init(1, TIMER2_NO_PRESCALE);
	//dcmotor_drive_pwm_init(2, TIMER2_NO_PRESCALE);
	// Kodulabor III
	dcmotor_drive_pwm_init(1, TIMER_NO_PRESCALE);
	dcmotor_drive_pwm_init(2, TIMER_NO_PRESCALE);
 
	// Lõputu tsükkel
	while (1)
  	{
           // Potentsiomeetri 4 keskmise lugemi võtmine ja salvestamine muutujasse
 
           // Kodulabor II
	    // Kuna potentsiomeetri väärtus on 10-bitine kuid DC mootori
	    // funktsioon on 8-bitine, tuleb ADC väärtus muundada 8-bitiseks 
	    // jagades ADC väärtus neljaga või nihutades bitinihutustehtega
	    // ADC väärtust paremale 2 kohta (>>2)
	   // speed = adc_get_average_value(3, 4)/4;
 
	   // Kodulabor III
	    // Kuna potentsiomeetri väärtus on 12-bitine kuid DC mootori
	    // funktsioon on 8-bitine, tuleb ADC väärtus muundada 8-bitiseks 
	    // jagades ADC väärtus kaheksaga või nihutades bitinihutustehtega
	    // ADC väärtust paremale 3 kohta (>>3)
	      speed = adc_get_average_value(15, 4)/8;
 
         //DC mootori juhtimine saadud potentsiomeetri väärtuse kaudu
	   dcmotor_drive_pwm(1, 1, speed);
	   dcmotor_drive_pwm(2, 1, 128);
  	}
}