Projekt 5 Alalisvoolumootor ja selle kiirus

Antud projekt eeldab, et kasutatakse juba kokku pandud kahe mootoriga roboti komplekti. Mootori draiveri ühendamisel tuleb jälgida, et sisendsignaalid oleks ühendatud õigetesse Arduino plaadi viikudesse. Vastasel juhul draiver ei toimi korrektselt. Mootorite juhtmed ühendada draiveri kruviklemmide külge
Ühendused on järgnevad:

• Draiver A-1A → Arduino D10
• Draiver A-1B → Arduino D12
• Draiver B-1A → Arduino D11
• Draiver B-2A → Arduino D13

NB! Jälgida mootori draiveri toite polaarsust. Valesti ühendamisel draiver lakkab töötamast.

Mootori juhtimiseks on soovitav eelnevalt uurida H-silla tööpõhimõtet. Tööpõhimõtte tundmine lihtsustab näidetest arusaamist. Kui mõni mootor peaks juhtumisi pöörlema vastupidiselt programmis määratud suunale, siis vahetada omavahel selle mootori draiveri poolsed juhtmed.
Programmis alustame ühendusviikude määramisega ning seejärel määrame vastavad viigud ka väljundiks. Mootorite juhtimiseks tekitame juurde funktsiooni mootorid(vasak, parem). Funktsiooni sisendiks on 2 parameetrit, milleks on vasaku ja parema mootori pöörlemise suunad. Vastavalt suunale muudetakse väljundite olekuid madalaks või kõrgeks. Väljundite muutmise loogika tuleneb mootori draiveri andmelehest. Võib katsetada peatsüklis mootorite juhtimise käsku erinevate manöövrite sooritamiseks.

/*
Nimetus: Näide #5.1
Kirjeldus: Alalisvoolumootor ja H-sild
*/
 
// Mootori viikude määramine draiveri juhtimiseks.
// Mootori liikumissuund sõltub ka mootori ühendamise polaarsusest.
const int vasak_A = 10; // Draiveri viik A-1A
const int vasak_B = 12; // Draiveri viik A-1B
const int parem_A = 11; // Draiveri viik B-1A
const int parem_B = 13; // Draiveri viik B-2A
 
void setup() 
{
// Seadista mootori draiverit juhtivad viigud väljundiks
pinMode(vasak_A,OUTPUT);
pinMode(vasak_B,OUTPUT);
pinMode(parem_A,OUTPUT);
pinMode(parem_B,OUTPUT);
 
// Peata mootorid algselt
mootorid(0,0); 
 
// Viide, et robot laua pealt kohe plehku ei paneks
delay(2000); 
}
 
void loop() 
{
  // Robot sõidab otse
  mootorid(1,1); 
 
  // Viite ajal robot jääb liikuma eelnevalt määratud suunda
  delay(2000); 
 
  // Robot keerab vasakule
  mootorid(-1,1); 
 
  // Viite ajal robot jääb liikuma eelnevalt määratud suunda
  delay(500); 
}
 
// Funktsioon mootori liikumissuundade määramiseks
void mootorid(int vasak, int parem)
{
 
  // Vasak mootor
  if(vasak == 1)
  { //vasak mootor edasi
    digitalWrite(vasak_A,HIGH);
    digitalWrite(vasak_B,LOW);
  }
  else if(vasak == -1)
  { // Vasak mootor tagasi
    digitalWrite(vasak_A,LOW);
    digitalWrite(vasak_B,HIGH);
  }
  else
  { // Vasak mootor seisma
    digitalWrite(vasak_A,LOW);
    digitalWrite(vasak_B,LOW);
  }
 
  // Parem mootor
  if(parem == 1)
  { // Parem mootor edasi
    digitalWrite(parem_A,HIGH);
    digitalWrite(parem_B,LOW);
  }
  else if(parem == -1)
  { // Parem mootor tagasi
    digitalWrite(parem_A,LOW);
    digitalWrite(parem_B,HIGH);
  }
  else
  { // Parem mootor seisma
    digitalWrite(parem_A,LOW);
    digitalWrite(parem_B,LOW);
  }
}

Mootori kiiruse juhtimiseks on vaja kasutada pulsilaiusmodulatsioon ehk PWM signaali. Tegemist on praktiliselt sama signaali tüübiga, mida kasutasime LED ereduse juhtimisel. Kasutades PWM signaali, lülitatakse sisend pidevalt sisse ja välja, mis tekitab mootorile toitepingest madalama keskmise pinge. Näiteks toitepinge 5 V ja 50% töötsükliga PWM signaaliga puhul tekib mootori klemmidele keskmine pinge 2,5 V.
Programmi töö on sarnane näitele #5.1, kus mootoreid juhiti diskreetselt ehk liigub või ei liigu. Antud näites juhime lisaks mootori kiirust ning selleks on vaja kasutada käsku analogWrite(), mis tekitab soovitud töötsükliga PWM signaali. Antud käsk toimib vaid kindlatel Arduino viikudel (UNO-l: D3, D5, D6, D9, D10 ja D11). Käsu sisendiks saab kasutada väärtusi 0-255 ehk 8 bitti. Sellest tulenevalt on ka mootorite juhtimise funktsiooni parameetrite vahemik -255 kuni 255, kus negatiivne arv näitab tagurpidi liikumist ja null seisma jäämist. Võib eksperimenteerida erinevate kiiruste ja suundadega.

/*
Nimetus: Näide #5.2 Alalisvoolumootori kiiruse reguleerimine
Kirjeldus: Programm demonstreerib alalisvoolumootori kiiruse juhtimist 
           L9110 draiveri näitel.
*/
 
// Mootori viikude määramine draiveri juhtimiseks.
// Mootori liikumissuund sõltub ka mootori ühendamise polaarsusest.
const int vasak_A = 10; // Draiveri viik A-1A
const int vasak_B = 12; // Draiveri viik A-1B
const int parem_A = 11; // Draiveri viik B-1A
const int parem_B = 13; // Draiveri viik B-2A
 
void setup() 
{
  // Mootori juht viikude väljundiks seadistamine
  pinMode(vasak_A,OUTPUT);
  pinMode(vasak_B,OUTPUT);
  pinMode(parem_A,OUTPUT);
  pinMode(parem_B,OUTPUT);
 
  mootorid(0,0); // Esialgu peatame mootorid
  delay(2000); // Viide, et robot laua pealt kohe plehku ei paneks
}
void loop()
 {
  mootorid(100,100); // Robot sõidab otse aeglaselt
  delay(2000); // Viite ajal robot jääb liikuma eelnevalt määratud suunda
  mootorid(100,255); // Robot keerab sujuvalt vasakule
  delay(2000); // Viite ajal robot jääb liikuma eelnevalt määratud suunda
  mootorid(-255,-255); // Robot tagurdab kiiresti
  delay(2000); // Viite ajal robot jääb liikuma eelnevalt määratud suunda
  mootorid(-255,-100); // Robot tagurdab sujuvalt paremale
  delay(2000); // Viite ajal robot jääb liikuma eelnevalt määratud suunda
  mootorid(150,-150); // Robot keerab kohapeal paremale
  delay(2000); // Viite ajal robot jääb liikuma eelnevalt määratud suunda
}
 
// Funktsioon mootori liikumissuuna ja kiiruse määramiseks
void mootorid(int vasak, int parem)
 {
  // Vasak mootor
  if(vasak > 0 && vasak <= 255)
  { // Vasak mootor otse
    analogWrite(vasak_A,vasak);
    digitalWrite(vasak_B,LOW);
  }
  else if(vasak < 0 && vasak >= -255)
  { // Vasak mootor tagurpidi
    analogWrite(vasak_A,255+vasak);
    digitalWrite(vasak_B,HIGH);
  }
  else
  { // Vasak mootor seisma
    digitalWrite(vasak_A,LOW);
    digitalWrite(vasak_B,LOW);
  }
 
  // Parem mootor
  if(parem > 0 && parem <= 255)
  { // Parem mootor otse
    analogWrite(parem_A,parem);
    digitalWrite(parem_B,LOW);
  }
  else if(parem < 0 && parem >= -255)
  { // Parem mootor tagurpidi
    analogWrite(parem_A,255+parem);
    digitalWrite(parem_B,HIGH);
  }
  else
  { // Parem mootor seisma
    digitalWrite(parem_A,LOW);
    digitalWrite(parem_B,LOW);
  }
}

Modifitseerida näiteprogrammi nii, et robot sõidab kaheksa kujulist trajektoori.

Modifitseerida näiteprogrammi nii, et robot teeb iseseisvalt paralleelparkimist ette määratud kohta.