Ehita oma esimene robot

Mikrokontroller

Mikrokontroller toimib roboti "ajuna", koordineerides selle tegevusi ja tehes otsuseid sisestatud koodi põhjal. Mikrokontroller juhib mootoreid ja ajameid, näiteks rattaid, andes neile juhiseid liikumiseks või muude ülesannete täitmiseks. Samuti loeb see sisendeid erinevatelt sensoritelt - näiteks kaugus-, valgus-, temperatuuri- ja puutesensoritelt -, et robot saaks oma ümbrust paremini mõista ning sellele reageerida.

Mootori juhtimis moodul

Komponent, mis võimaldab juhtida mootoreid, näiteks roboti rataste liikumist või muid mehaanilisi liikumisi. See moodul ühendab roboti juhtarvuti (näiteks mikrokontrolleri või arduino) ja mootori(d), võimaldades edastada elektrilisi signaale, mis kontrollivad mootori kiirust, suunda ja jõudu. See on vajalik, kuna mikrokontroller ei suuda toita mootoreid üksinda ning abistab täpsete liikumiskäskude täitmisel.

Mootor

Mootoreid on erinevaid tüüpi, kuid selle projekti jaoks kasutame DC-mootired, mis juhivad rattaid, et robot saaks liikuda edasi, tagasi või pöörata. Sensorite abil saab jälgida pöörlemise täpsust ja kiirust, võimaldades robotil navigeerida täpsemalt. Mootorite arvust ja paigaldusest tuleneb roboti liikumisvabadus.

Sensorid

Sensorid annavad robotile võimaluse oma keskkonda „tajuda” - näha, kuulda, tunda ja mõõta ümbritsevat, et kohandada oma tegevusi saadud teabe põhjal. Tänu sensoritele saavad robotid töötada iseseisvalt ja reageerida kiiresti muutuvatele tingimustele. Selles projektis kasutame kaugussensorit, mis mõõdab vahemaid objektideni kasutades helilaineid, võimaldades robotil takistusi tuvastada ja vältida.

Aku/Patarei

Aku on üks peamisi energiavarusid, mis võimaldab robotil töötada autonoomselt ilma juhtmevaba ühenduseta. Aku annab elektrit kõikidele komponentidele, sealhulgas mootoritele, anduritele ja mikrokontrollerile. Projektiks kasutame tavapoes müüdavaid 9V patareid.

Rattad

Rattad on üks lihtsamaid ja levinumaid liikumisviise, kuna need võimaldavad sujuvat ja täpset liikumist erinevatel pindadel. Otsustasime need 3D-printida, kuid saad kasutada ka kodust leiduvaid ümaraid objekte, näiteks pudelikork.

Juhtmed

Juhtmed on robotis olulised, kuna need ühendavad erinevad komponendid, näiteks aku, mootorid, mikrokontrolleri ja andurid, võimaldades elektrienergia ja signaalide edastamist. Juhtmete kvaliteet ja paigutus mõjutavad otseselt roboti töökindlust ja tõhusust.

Lüliti

Lüliti abil on mugav lahti ühendada aku väljaspool korpust.

Kere

Roboti kere ehk raam on roboti füüsiline struktuur või "skelett", mis ühendab ja toetab kõiki selle komponente, nagu mootorid, akud, mikrokontroller, sensorid ja muud osad. Roboti kere mängib olulist rolli selle vastupidavuses, stabiilsuses ja liikumises ning on oluline osa roboti disainist. Selle projekti roboti 3D-mudeli skelettist ja ratastest saad siit

1.Samm

Ühenda omavahel mikrokontroller ja mootori juhtimis mooduli.

2.Samm

Pane mootorid skeletti.

3.Samm

Ühenda sensor mootori juhtimis mooduliga.Ühe juhtme pead mootori juhtimis mooduli külge jootma. Ühendus nimega "echo" ühendada pesasse nr 13 ja "trig" ühendada nr 2. Ultraheli sensoril on veel ühendused Vcc ja GND, mida tuleb ühendada pesadesse 5V ja GND.(Vcc -> 5V)(GND -> GND)

4.Samm

Ühenda mootori juhtmed mootori juhtimis mooduli.

5.Samm

Ühenda aku juhe ja aku omavahel.

6.Samm

Ühenda 3D-prinditud rattad mootorite külge.

7.Samm

Ühenda lüliti aku juhtme külge, selleks lõikame aku punase juhtme pooleks ja ühendame nagu pildil.

8.Samm

Kasutades Arduino IDE, lae robotisse see kood. Kiirust saad ise muuta.

                                // C++ kood roboti automaatjuhtimiseks kasutades AFMotor teeki.
                                #include <AFMotor.h>
                                
                                AF_DCMotor motorRB(4); // Right Back motor
                                AF_DCMotor motorRF(3); // Right Front motor
                                AF_DCMotor motorLB(2); // Left Back motor
                                AF_DCMotor motorLF(1); // Left Front motor
                                
                                // Ultrasonic sensor pins
                                const int trigPin = 2;
                                const int echoPin = 13;
                                
                                void setup() {
                                  // Initialize motor speeds
                                  motorRB.setSpeed(200);
                                  motorRF.setSpeed(200);
                                  motorLB.setSpeed(200);
                                  motorLF.setSpeed(200);
                                
                                  // Set ultrasonic sensor pins
                                  pinMode(trigPin, OUTPUT);
                                  pinMode(echoPin, INPUT);
                                
                                  Serial.begin(9600); // Initialize serial communication for debugging
                                }
                                
                                void loop() {
                                  // Measure distance using the ultrasonic sensor
                                  long duration, distance;
                                  digitalWrite(trigPin, LOW);
                                  delayMicroseconds(2);
                                  digitalWrite(trigPin, HIGH);
                                  delayMicroseconds(10);
                                  digitalWrite(trigPin, LOW);
                                
                                  duration = pulseIn(echoPin, HIGH);
                                  distance = duration * 0.034 / 2; // Convert to centimeters
                                
                                  // Debugging output
                                  Serial.print("Distance: ");
                                  Serial.print(distance);
                                  Serial.println(" cm");
                                
                                  // Robot movement logic based on distance
                                  if (distance < 20) {
                                    stopMotors();
                                    turnLeft(); // Turn left if an obstacle is detected
                                  } else {
                                    moveForward(); // Move forward if no obstacles
                                  }
                                
                                  delay(100);
                                }
                                
                                void moveForward() {
                                  motorRB.setSpeed(200);
                                  motorRF.setSpeed(200);
                                  motorLB.setSpeed(200);
                                  motorLF.setSpeed(200);
                                
                                  motorRB.run(FORWARD);
                                  motorRF.run(FORWARD);
                                  motorLB.run(FORWARD);
                                  motorLF.run(FORWARD);
                                }
                                
                                void stopMotors() {
                                  motorRB.run(RELEASE);
                                  motorRF.run(RELEASE);
                                  motorLB.run(RELEASE);
                                  motorLF.run(RELEASE);
                                }
                                
                                void turnLeft() {
                                  motorRB.setSpeed(150);
                                  motorRF.setSpeed(150);
                                  motorLB.setSpeed(150);
                                  motorLF.setSpeed(150);
                                
                                  motorRB.run(FORWARD);
                                  motorRF.run(BACKWARD);
                                  motorLB.run(FORWARD);
                                  motorLF.run(BACKWARD);
                                
                                  delay(500); // Adjust turn delay as needed
                                
                                  stopMotors();
                                }
                                    

Tulemus