Maneədən qaçan robot yaratmaq: Arduino və HC-SR04 ilə addım-addım
Maneədən qaçan robot: servo üzərində HC-SR04 ilə skanetmə, L298N və L293D qoşulması, dayan-geri çəkil-dön alqoritmi, IR sensor və Bluetooth kodu.
Maneədən qaçan robot qarşısındakı divarı, stulu və ya qutunu toxunmadan fərq edib özünə yeni yol tapan, öz-özünə hərəkət edən robot maşındır. Ən geniş yayılmış quruluşda bir Arduino Uno, bir HC-SR04 ultrasəs məsafə sensoru, sensoru sağa-sola çevirən bir SG90 servo mühərrik, iki reduktorlu DC mühərrik və bir L298N (və ya L293D) mühərrik sürücüsü istifadə olunur. Robot düz irəliləyir, maneəyə yaxınlaşanda dayanır, bir az geri çəkilir, başını iki yana çevirib ölçmə aparır və ən açıq istiqamətə dönərək yoluna davam edir.
Bu bələdçidə Arduino robot maşın yazısında qurduğumuz 2WD maşını eyni pin düzənini saxlayaraq avtonom robota çeviririk. Qoşulma cədvəllərini, məsafə hədlərinin necə hesablandığını, üç mərhələdə böyüyən kodu, sensorun görə bilmədiyi səthləri və bu boşluqları infraqırmızı sensorlarla necə bağlayacağını, nəhayət telefondan Bluetooth ilə manual rejimə keçməyi addım-addım izah edirik. Eyni robotu ESP32 və Raspberry Pi Pico ilə idarə etmək üçün lazım olan kodlar da yazının sonundadır.

Maneədən qaçan robot necə işləyir?
Hər avtonom robot eyni üç addımlıq dövrü saniyədə onlarla dəfə təkrarlayır: hiss et, qərar ver, hərəkət et. Hiss etmə işini HC-SR04 görür: qulağın eşidə bilmədiyi 40 kHz-lik qısa səs göndərir və əks-sədanın qayıtma müddətini ölçür; mikrosaniyə ilə müddəti 58-ə bölsən məsafəni santimetrlə tapırsan. Qərar işini Arduino görür və ölçülən məsafəni sənin təyin etdiyin hədlərlə müqayisə edir. Hərəkət işini isə L298N ilə mühərriklər öz üzərinə götürür. Sensor servonun üstündə dayandığı üçün robot gövdəsini çevirmədən sola və sağa "baxa bilir"; bu da sabit sensorlu robotlara nisbətən daha dəqiq dönmə qərarları verməyə imkan yaradır. Sensorun iş prinsipinin təfərrüatları HC-SR04 məsafə sensoru yazısındadır.
| Hissə | Vəzifəsi | Qeyd |
|---|---|---|
| Arduino Uno (və ya Nano) | Beyin: ölçür, qərar verir, mühərriklərə komanda göndərir | ESP32 və Pico da istifadə oluna bilər |
| HC-SR04 | Göz: qarşıdakı maneənin məsafəsini ölçür | 5 V ilə işləyir, 2–400 sm |
| SG90 servo | Boyun: sensoru sola və sağa çevirir | Sensor plastik aparatla servo başlığına bərkidilir |
| L298N və ya L293D şild | Əzələ: mühərriklərə istiqamət və sürət verir | Arduino pini mühərrik cərəyanını verə bilmir |
| 2 reduktorlu TT mühərrik və sərbəst təkər | Diferensial sürüş | Dönmə iki təkərin əks istiqamətdə fırlanması ilə həyata keçirilir |
| 2 ədəd 18650 batareya (7,4 V) | Enerji | 9 V düzbucaqlı batareya kifayət etmir |
| 2 ədəd IR maneə sensoru (istəyə görə) | Künc və yan maneələri tutur | FC-51 kimi LM393-lü modullar |
| HC-05 (istəyə görə) | Telefondan manual idarəetmə | Yalnız Android ilə işləyir |




Qida mənbəyi: servo robotu resetləməsin
Maneədən qaçan robotda mühərriklərə bir də servo əlavə olunduğu üçün gücün paylanması adi robot maşına nisbətən daha vacibdir. SG90 dayananda təxminən 10 mA çəkir; fırlanmağa başlayan anda cərəyanı 100–250 mA-ə çıxır, çətinlik çəkəndə isə yarım ampərə yaxınlaşır. Bu ani cərəyan mühərriklərin başlanğıc cərəyanı ilə eyni ana düşsə, Arduino-nun 5 V xətti bir anlığa çökür və plata yenidən başlayır. Həll sadədir: mühərriklər batareyadan L298N vasitəsilə, Arduino isə batareyadan VIN vasitəsilə qidalanır; servo, HC-SR04, IR sensorlar və HC-05 Arduino-nun 5V pinini bölüşür və servonun qida uclarının yanına 470 µF-lıq kondensator qoyulur. Servo fırlananda belə 5 V xəttindəki ümumi yük yarım ampərdən aşağı qalır; bu yük qısamüddətli olduğu üçün Uno-nun stabilizatoru onu daşıyır. Batareya ömrünü öz dəyərlərinlə hesablamaq üçün Batareya ömrü alətindən istifadə edə bilərsən.
| Hissə | Haradan qidalanır? | Tipik cərəyan |
|---|---|---|
| 2 TT mühərrik | L298N 12V klemmi ← 2 ədəd 18650 (7,4 V) | Sürüşdə 0,3–0,6 A, başlanğıcda 2 A-ə qədər |
| Arduino Uno | VIN ← batareyanın müsbət qütbü (açardan sonra) | Təxminən 50 mA |
| SG90 servo | Arduino 5V + 470 µF kondensator | Dayananda ~10 mA, fırlananda 100–250 mA |
| HC-SR04 | Arduino 5V | Təxminən 15 mA |
| 2 IR sensor | Arduino 5V | Hər biri 20–40 mA |
| HC-05 | Arduino 5V | Cütləşmə axtarışında 30–40 mA, qoşulu olanda təxminən 10 mA |
Qoşulma sxemi: Arduino Uno, ESP32 və Pico
Mühərrik pinləri robot maşın bələdçisindəki ilə eynidir; beləliklə hazır maşınını sökmədən, yalnız sensor başlığını əlavə edərək bu layihəyə keçə bilərsən. Sürət pinlərinin 5 və 6-da olması şüurlu seçimdir: Uno-da Servo kitabxanası Timer1-dən istifadə etdiyi üçün 9 və 10 nömrəli pinlərdəki PWM-i sıradan çıxarır; mühərrik sürətləri bu pinlərdə olsaydı, servo qoşulan kimi sürət idarəsi pozulardı. HC-SR04 və IR sensorlar A0–A3-ə qoşulur. Uno-nun analoq pinləri lazım olanda 14–19 nömrəli rəqəmsal pinlər kimi də işləyir və bu seçim eyni kodu L293D şild ilə istifadə etməyi asanlaşdırır, çünki şild bu pinlərə toxunmur. Platanın pin düzənini Pinout alətində görə bilərsən.
| Qoşulma | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| L298N ENA (sol mühərrik sürəti) | D5 | GPIO 25 | GP15 |
| L298N IN1, IN2 | D7, D8 | GPIO 27, 33 | GP14, GP13 |
| L298N ENB (sağ mühərrik sürəti) | D6 | GPIO 26 | GP10 |
| L298N IN3, IN4 | D9, D4 | GPIO 32, 4 | GP12, GP11 |
| Servo siqnal (narıncı) | D3 | GPIO 13 | GP16 |
| Servo + (qırmızı), − (qəhvəyi) | 5V, GND | L298N 5V, GND | L298N 5V, GND |
| HC-SR04 TRIG | A0 | GPIO 18 | GP17 |
| HC-SR04 ECHO | A1 (birbaşa) | GPIO 19, 1 kΩ / 2 kΩ bölücü ilə | GP18, 1 kΩ / 2 kΩ bölücü ilə |
| HC-SR04 VCC | 5V | L298N 5V | L298N 5V |
| IR sol OUT, IR sağ OUT | A2, A3 | GPIO 23, 22 | GP19, GP20 |
| IR sensor VCC | 5V | 3V3 | 3V3 |
| HC-05 TXD, RXD | D10, D11 (RXD bölücü ilə) | Lazım deyil (daxili Bluetooth) | GP1, GP0 (UART0) |
| Platanın qidası | VIN ← batareya (açardan sonra) | 5V (VIN) ← L298N 5V | VSYS ← L298N 5V |
Sensor başlığını quraşdır və sına

- Servonu başlığı taxılı olmayanda qoş və aşağıdakı test kodunu yüklə. Kod hər skanın sonunda servonu 90 dərəcəyə gətirib 2 saniyə gözləyir; bu zaman USB kabelini çıxar, servo olduğu yerdə qalır. Başlığı sensor düz irəli baxacaq şəkildə mil üzərinə tax; beləliklə 90 dərəcə "düz irəli" mənasına gəlir.
- HC-SR04-ü plastik aparatla və ya isti silikonla başlığa bərkit. Sensor naqilləri servo fırlananda dartılmayacaq qədər uzun olmalıdır; 140 dərəcəlik skan zamanı naqilin şassiyə ilişməsi tez-tez rast gəlinən nasazlıqdır.
- Sensoru yerdən 8–12 sm hündürə və gövdənin ən ön nöqtəsinə yaxın yerləşdir. Çox alçaqda dayansa, yerdən və xalça toxumasından əks-səda alır; çox yüksəkdə dayansa, alçaq maneələri görə bilmir.
- Sensoru 3–5 dərəcə yuxarı əyilmiş quraşdır. Tam üfüqi və alçaqda qalan sensor, xüsusilə kələ-kötür döşəmələrdə yerdən qayıdan əks-sədanı maneə sayə bilər.
- Serial Monitor-u 9600 baud ilə aç. Əlini sensorun soluna tutanda 125 və 160 dərəcəlik sətirlərdə kiçik dəyərlər görürsənsə, sol tərəf böyük bucaqlardır; tərsi olursa, inkişaf etmiş koddakı SERVO_DIR dəyərini -1 et, ilk kodda isə LEFT_ANGLE ilə RIGHT_ANGLE dəyərlərinin yerini dəyiş.
1#include <Servo.h>
2
3const int SERVO_PIN = 3;
4const int TRIG = A0, ECHO = A1; // analog pinler dijital pin olarak / analog pins used as digital pins
5Servo head;
6
7int pingCm() {
8 digitalWrite(TRIG, LOW); delayMicroseconds(2);
9 digitalWrite(TRIG, HIGH); delayMicroseconds(10); // 10 µs tetik darbesi / 10 µs trigger pulse
10 digitalWrite(TRIG, LOW);
11 unsigned long t = pulseIn(ECHO, HIGH, 25000UL); // en fazla 25 ms bekle (~4,3 m) / wait at most 25 ms (~4.3 m)
12 return t / 58; // 0 = yankı yok / 0 = no echo
13}
14
15void setup() {
16 Serial.begin(9600);
17 pinMode(TRIG, OUTPUT);
18 pinMode(ECHO, INPUT);
19 head.attach(SERVO_PIN);
20 head.write(90); // önce ortala / center first
21 delay(1000);
22}
23
24void loop() {
25 const int angles[] = {20, 55, 90, 125, 160};
26 for (int a : angles) {
27 head.write(a);
28 delay(400); // servo yerine otursun / let the servo settle
29 Serial.print(a);
30 Serial.print(F(" derece / degrees: "));
31 Serial.print(pingCm());
32 Serial.println(F(" cm"));
33 }
34 Serial.println();
35 head.write(90);
36 delay(2000);
37}Hər sətirdə bir bucaq və həmin istiqamətdəki məsafə görünür. Sensorun qarşısında təxminən 4 metr daxilində heç nə yoxdursa, 0 sm oxuyursan: pulseIn() 25 ms ərzində əks-səda gəlməsə 0 qaytarır. Əsas kodda 0-ı "qarşısı açıq" sayacağıq, amma naqili çıxmış və ya TRIG ilə ECHO-su tərs qoşulmuş sensor da çox vaxt 0 oxuyur. Ona görə robotu yerə qoymazdan əvvəl əlini 10, 30 və 60 sm-ə tutub dəyərlərin həqiqətən dəyişdiyini gör; sınaqdan keçirilmədən işə salınan robot divara heç yavaşımadan gedir.
Qərar alqoritmi: dayan, geri çəkil, ən açıq istiqamətə dön
Robotun davranışını məsafəyə görə zonalara bölmək kodu həm sadə, həm də etibarlı edir. Qarşısında maneə olmayanda tam sürətlə irəliləyir, maneə yaxınlaşdıqca yavaşıyır, dayanma həddinə çatanda dayanır və skan edir. Skan zamanı sensor 70 və 35 dərəcə sola, 35 və 70 dərəcə sağa baxır; hər istiqamətdə üç ölçmə aparılır və median istifadə olunur. Robot ən uzun məsafəni verən istiqamətə, həmin bucaq qədər dönür. Heç bir istiqamət açıq deyilsə, məsələn küncə girsə, bir az geri gəlib 180 dərəcə dönür.
| Ölçülən məsafə | Zona | Robotun etdiyi |
|---|---|---|
| 60 sm-dən uzaq (və ya əks-səda yoxdur) | Sərbəst | Tam sürətlə irəli (PWM 200) |
| 25–60 cm | Yaxınlaşma | Məsafəyə mütənasib yavaşıyır (PWM 200-dən 130-a) |
| 12–25 cm | Maneə | Dayanır, ölçməni təsdiqləyir, iki yana skan edir, ən açıq istiqamətə dönür |
| 12 sm-dən yaxın | Çox yaxın | Əvvəl 350 ms geri çəkilir, sonra skan edir |
| Bütün istiqamətlər 35 sm-dən yaxın | Çıxılmaz vəziyyət | Geri gəlir və 180 dərəcə dönür |
Bu hədlər təsadüfi seçilməyib. Dayanma məsafəsi üç ehtiyatın cəmidir: reaksiya ehtiyatı (iki ölçmə arasında qət edilən yol), əyləc ehtiyatı (mühərriklər kəsiləndən sonra robotun sürüşməsi) və dönmə ehtiyatı (robot yerində dönərkən burnunun əngələ toxunmaması). 6 V ilə qidalanan TT mühərrikli maşın təxminən 0,5–0,7 m/s sürətlə gedir və 60 ms-lik ölçmə intervalında 3–4 sm yol alır. Əyləc ehtiyatı təxminən 5 sm-dir, 15 sm enində yerində dönən gövdə üçün dönmə ehtiyatı isə 10 sm civarındadır. Cəmi təxminən 18–20 sm edir; üstünə bir neçə santimetrlik təhlükəsizlik ehtiyatı əlavə olunanda STOP_CM = 25 yaxşı başlanğıc nöqtəsi olur. Robotun daha sürətlidirsə və ya zəmin sürüşkəndirsə, həddi 30–35 sm-ə qaldır. Dar koridorlarda isə çox böyük hədd robotun daim dayanıb ətrafı skan etməsinə səbəb olur; son tənzimləməni öz pistində apar.
Addım-addım kod 1: ilk maneədən qaçan robot
İlk versiya alqoritmin skeletidir: irəli get, 25 sm-də dayan, geri çəkil, sola və sağa bax, daha açıq tərəfə dön. Mühərrik funksiyası drive(sol, sağ) robot maşın bələdçisindəkinin eynisidir və -255 ilə 255 arasında dəyər alır; müsbət irəli, mənfi geri deməkdir. Kodu yüklədikdən sonra əvvəlcə maşını təkərləri havada qalacaq şəkildə qutunun üstünə qoy və əlini sensora yaxınlaşdıraraq dayanma və dönmə davranışını izlə; hər şey düzgündürsə, robotu yerə endir.
1#include <Servo.h>
2
3const int ENA = 5, IN1 = 7, IN2 = 8; // sol motor / left motor
4const int ENB = 6, IN3 = 9, IN4 = 4; // sağ motor / right motor
5const int SERVO_PIN = 3;
6const int TRIG = A0, ECHO = A1;
7
8const int STOP_CM = 25; // bu mesafede dur / stop at this distance
9const int SPEED = 170; // düz gidiş hızı / cruising speed
10const int TURN = 170; // dönüş hızı / turning speed
11const int LEFT_ANGLE = 160, RIGHT_ANGLE = 20; // ters ise yer değiştir / swap if reversed
12
13Servo head;
14
15void drive(int left, int right) { // her biri -255 … 255 / each -255 … 255
16 digitalWrite(IN1, left > 0); digitalWrite(IN2, left < 0);
17 digitalWrite(IN3, right > 0); digitalWrite(IN4, right < 0);
18 analogWrite(ENA, abs(left));
19 analogWrite(ENB, abs(right));
20}
21
22int pingCm() {
23 digitalWrite(TRIG, LOW); delayMicroseconds(2);
24 digitalWrite(TRIG, HIGH); delayMicroseconds(10);
25 digitalWrite(TRIG, LOW);
26 unsigned long t = pulseIn(ECHO, HIGH, 25000UL);
27 if (t == 0) return 400; // yankı yok: önü açık say / no echo: treat as open
28 return t / 58;
29}
30
31int lookAt(int angle) {
32 head.write(angle);
33 delay(400); // servo dönsün ve dursun / let the servo turn and settle
34 return pingCm();
35}
36
37void setup() {
38 int pins[] = {ENA, IN1, IN2, ENB, IN3, IN4, TRIG};
39 for (int p : pins) pinMode(p, OUTPUT);
40 pinMode(ECHO, INPUT);
41 drive(0, 0);
42 head.attach(SERVO_PIN);
43 head.write(90);
44 delay(3000); // yere koyman için süre / time to put it on the floor
45}
46
47void loop() {
48 int front = pingCm();
49 if (front > STOP_CM) {
50 drive(SPEED, SPEED); // yol açık: ileri / path clear: forward
51 delay(60); // ölçümler arası 60 ms / 60 ms between readings
52 return;
53 }
54
55 drive(0, 0); // 1) dur / 1) stop
56 delay(150);
57 drive(-SPEED, -SPEED); // 2) biraz geri çekil / 2) back off a little
58 delay(300);
59 drive(0, 0);
60
61 int left = lookAt(LEFT_ANGLE); // 3) iki yana bak / 3) look both ways
62 int right = lookAt(RIGHT_ANGLE);
63 head.write(90);
64 delay(300);
65
66 if (left < STOP_CM && right < STOP_CM) { // iki yan kapalı: geri dön / both blocked: turn around
67 drive(-TURN, TURN);
68 delay(700);
69 } else if (left > right) { // 4) daha açık tarafa dön / 4) turn to the more open side
70 drive(-TURN, TURN);
71 delay(350);
72 } else {
73 drive(TURN, -TURN);
74 delay(350);
75 }
76 drive(0, 0);
77 delay(100);
78}Bu kod işini görür, amma bir neçə zəifliyi var: tək bir səhv ölçmə robotu boş yerə dayandırır, robot maneəyə həmişə eyni sürətlə yaxınlaşır, yalnız iki istiqamətə baxır və dönmə müddətləri bucağa görə tənzimlənmir. Üstəlik delay() ilə gözlədiyi üçün skan zamanı heç nəyə reaksiya verə bilmir. Gözləmə məntiqinin təfərrüatları millis() və delay() yazısındadır; növbəti versiya bu problemlərin çoxunu həll edir.
Addım-addım kod 2: filtr, mərhələli yavaşıma, IR və Bluetooth
İnkişaf etmiş versiya eyni qoşulmalarla işləyir; IR sensorları və HC-05-i hələ taxmamısansa, problem yoxdur. IR girişləri INPUT_PULLUP ilə təyin olunduğu üçün taxılmamış sensor "maneə yoxdur" (HIGH) oxunur; HC-05 yoxdursa, robot onsuz da avtomatik rejimdə başlayır. Kodun hər hissəsinin nə etdiyini aşağıdakı cədvəldə tapa bilərsən.
1#include <Servo.h>
2#include <SoftwareSerial.h>
3
4// Pinler / Pins
5const int ENA = 5, IN1 = 7, IN2 = 8; // sol motor / left motor
6const int ENB = 6, IN3 = 9, IN4 = 4; // sağ motor / right motor
7const int SERVO_PIN = 3;
8const int TRIG = A0, ECHO = A1;
9const int IR_LEFT = A2, IR_RIGHT = A3; // LOW = engel (takılı değilse HIGH) / LOW = obstacle (HIGH if not fitted)
10SoftwareSerial bt(10, 11); // RX, TX → HC-05 TXD, RXD (RXD bölücüyle / RXD via divider)
11
12// Ayarlar / Settings
13const int BACK_CM = 12; // daha yakınsa geri çekil / closer: back off first
14const int STOP_CM = 25; // dur ve tara / stop and scan
15const int SLOW_CM = 60; // yavaşlamaya başla / start slowing down
16const int GUARD_CM = 15; // manuel modda çarpışma koruması / collision guard in manual mode
17const int MAX_CM = 400;
18const int CRUISE = 200, SLOW = 130, TURN = 170; // PWM hızları / PWM speeds
19const int SERVO_CENTER = 90; // sensör öne bakmıyorsa düzelt / adjust if not facing ahead
20const int SERVO_DIR = 1; // +70 sola bakmıyorsa -1 yap / set to -1 if +70 doesn't look left
21const float MS_PER_DEG = 4.0; // derece başına ms, kalibre et / ms per degree, calibrate
22const unsigned long BT_TIMEOUT = 600; // manuelde komut kesilirse dur / stop if commands stop
23
24Servo head;
25bool autoMode = true;
26int manualLeft = 0, manualRight = 0, manualSpeed = 200;
27unsigned long lastCmd = 0, lastPing = 0;
28
29void drive(int left, int right) { // her biri -255 … 255 / each -255 … 255
30 left = constrain(left, -255, 255);
31 right = constrain(right, -255, 255);
32 digitalWrite(IN1, left > 0); digitalWrite(IN2, left < 0);
33 digitalWrite(IN3, right > 0); digitalWrite(IN4, right < 0);
34 analogWrite(ENA, abs(left));
35 analogWrite(ENB, abs(right));
36}
37
38int pingCm() {
39 digitalWrite(TRIG, LOW); delayMicroseconds(2);
40 digitalWrite(TRIG, HIGH); delayMicroseconds(10);
41 digitalWrite(TRIG, LOW);
42 unsigned long t = pulseIn(ECHO, HIGH, 25000UL); // ~4,3 m zaman aşımı / ~4.3 m timeout
43 return t == 0 ? MAX_CM : (int)(t / 58); // yankı yok = açık alan / no echo = open space
44}
45
46int distanceCm() { // 3 ölçümün ortancası / median of 3 readings
47 int a = pingCm(); delay(60);
48 int b = pingCm(); delay(60);
49 int c = pingCm();
50 return max(min(a, b), min(max(a, b), c));
51}
52
53bool irBlocked(int pin) {
54 return digitalRead(pin) == LOW;
55}
56
57int lookAt(int offset) { // + sol, - sağ (derece) / + left, - right (degrees)
58 head.write(SERVO_CENTER + SERVO_DIR * offset);
59 delay(300); // servo yerine otursun / let the servo settle
60 return distanceCm();
61}
62
63void turnBy(int deg) { // + sola, - sağa / + left, - right
64 if (deg > 0) drive(-TURN, TURN);
65 else drive(TURN, -TURN);
66 delay((unsigned long)(abs(deg) * MS_PER_DEG));
67 drive(0, 0);
68 delay(100);
69}
70
71void avoid() {
72 drive(0, 0); // 1) dur / 1) stop
73 delay(120);
74 int front = distanceCm(); // ortancayla doğrula / confirm with the median
75 bool sides = irBlocked(IR_LEFT) || irBlocked(IR_RIGHT);
76 if (front >= STOP_CM && !sides) return; // yanlış alarm / false alarm
77
78 if (front < BACK_CM || sides) { // 2) çok yakın: geri çekil / 2) too close: back off
79 drive(-TURN, -TURN);
80 delay(350);
81 drive(0, 0);
82 }
83
84 const int offsets[] = {70, 35, -35, -70}; // 3) tara / 3) scan
85 int bestOffset = 0, bestCm = 0;
86 for (int off : offsets) {
87 int cm = lookAt(off);
88 if (cm > bestCm) { bestCm = cm; bestOffset = off; }
89 }
90 head.write(SERVO_CENTER);
91 delay(200);
92
93 if (bestCm < STOP_CM + 10) { // her yön kapalı: çıkmaz / every way blocked: dead end
94 drive(-TURN, -TURN);
95 delay(400);
96 turnBy(180);
97 } else {
98 turnBy(bestOffset); // 4) en açık yöne dön / 4) turn to the most open direction
99 }
100}
101
102void autoStep() {
103 if (millis() - lastPing < 60) return; // 60 ms'de bir ölç / measure every 60 ms
104 lastPing = millis();
105 int d = pingCm();
106 bool l = irBlocked(IR_LEFT), r = irBlocked(IR_RIGHT);
107
108 if (d < STOP_CM || (l && r)) {
109 avoid();
110 } else if (l) { // sol köşede engel: sağa kaç / front-left: dodge right
111 drive(TURN, -TURN);
112 delay(150);
113 } else if (r) { // sağ köşede engel: sola kaç / front-right: dodge left
114 drive(-TURN, TURN);
115 delay(150);
116 } else if (d < SLOW_CM) {
117 int s = map(d, STOP_CM, SLOW_CM, SLOW, CRUISE); // yaklaştıkça yavaşla / slow down as you get closer
118 drive(s, s);
119 } else {
120 drive(CRUISE, CRUISE);
121 }
122}
123
124void manualStep() {
125 if (millis() - lastCmd > BT_TIMEOUT) { // komut yok: dur / no commands: stop
126 manualLeft = 0;
127 manualRight = 0;
128 }
129 static int front = MAX_CM;
130 if (millis() - lastPing >= 60) {
131 lastPing = millis();
132 front = pingCm();
133 }
134 bool forward = manualLeft > 0 && manualRight > 0;
135 if (forward && front < GUARD_CM) drive(0, 0); // çarpışma koruması / collision guard
136 else drive(manualLeft, manualRight);
137}
138
139void handleBluetooth() {
140 while (bt.available()) {
141 char c = bt.read();
142 Serial.println(c); // gelen harfi göster / show the incoming letter
143 lastCmd = millis();
144 if (c == 'A') { // otomatik mod / auto mode
145 autoMode = true;
146 continue;
147 }
148 if (c == 'M') { // manuel mod / manual mode
149 autoMode = false;
150 manualLeft = manualRight = 0;
151 drive(0, 0);
152 head.write(SERVO_CENTER);
153 continue;
154 }
155 if (autoMode) continue; // otomatikte yön harflerini yok say / ignore in auto mode
156 int s = manualSpeed;
157 switch (c) {
158 case 'F': manualLeft = s; manualRight = s; break; // ileri / forward
159 case 'B': manualLeft = -s; manualRight = -s; break; // geri / backward
160 case 'L': manualLeft = -s; manualRight = s; break; // yerinde sola / spin left
161 case 'R': manualLeft = s; manualRight = -s; break; // yerinde sağa / spin right
162 case 'S': manualLeft = 0; manualRight = 0; break; // dur / stop
163 default:
164 if (c >= '0' && c <= '9') manualSpeed = map(c - '0', 0, 9, 100, 240); // hız kademesi / speed level
165 }
166 }
167}
168
169void setup() {
170 int outs[] = {ENA, IN1, IN2, ENB, IN3, IN4, TRIG};
171 for (int p : outs) pinMode(p, OUTPUT);
172 drive(0, 0);
173 pinMode(ECHO, INPUT);
174 pinMode(IR_LEFT, INPUT_PULLUP);
175 pinMode(IR_RIGHT, INPUT_PULLUP);
176 Serial.begin(9600);
177 bt.begin(9600); // HC-05 veri modu hızı / HC-05 data mode baud rate
178 head.attach(SERVO_PIN);
179 head.write(SERVO_CENTER);
180 delay(3000); // yere koyman için süre / time to put it on the floor
181}
182
183void loop() {
184 handleBluetooth();
185 if (autoMode) autoStep();
186 else manualStep();
187}| Funksiya və ya ayar | Nə edir? |
|---|---|
| pingCm() | Tək ölçmə aparır; 25 ms ərzində əks-səda gəlməsə 400 sm (açıq sahə) qaytarır |
| distanceCm() | 60 ms fasilə ilə 3 ölçmə alır və medianını verir; tək sıçrayan dəyəri kənarlaşdırır |
| autoStep() | 60 ms-dən bir ölçür; məsafəyə və IR-lərə görə irəliləyir, yavaşıyır, qaçır və ya avoid() çağırır |
| avoid() | Dayanır, ölçməni təsdiqləyir, lazım olsa geri çəkilir, 4 istiqamətə baxır və ən açıq istiqamətə dönür |
| turnBy(dərəcə) | Robotu verilən bucaq qədər yerində döndərir; müddət MS_PER_DEG ilə hesablanır |
| manualStep() | Telefondan gələn istiqaməti tətbiq edir; irəli gedəndə 15 sm-də dayanır, 600 ms komanda gəlməsə dayanır |
| SERVO_CENTER, SERVO_DIR | Sensorun düz irəli baxdığı bucaq və sol tərəfin istiqaməti |
| STOP_CM, SLOW_CM, BACK_CM | Dayanma, yavaşıma və geri çəkilmə hədləri |
Median filtr maneədən qaçan robot üçün ortalamadan daha yaxşıdır: 24, 26 və 400 sm kimi üç ölçmənin ortalaması 150 sm çıxır və robotu çaşdırır, median isə 26 sm-i seçir. Mövzunu daha dərindən öyrənmək istəsən, sensor məlumatlarının filtrlənməsi yazısına baxa bilərsən. Avtomatik və manual rejim ayrımı da əslində kiçik vəziyyət maşınıdır; bu yanaşmanı Arduino vəziyyət maşını bələdçisində ətraflı izah edirik. Kodu yüklədikdən sonra robotu öz otağına görə bu ardıcıllıqla tənzimlə:
- Servo mərkəzi: Robot düz divara dik dayananda sensor tam qarşıya baxmırsa, SERVO_CENTER dəyərini 85 və ya 95 kimi kiçik addımlarla dəyiş.
- Dönmə müddəti: setup()-ın sonuna müvəqqəti olaraq turnBy(360); sətri əlavə et və robotun tam bir dövrə vurub-vurmadığını izlə. 360 əvəzinə 300 dərəcə dönübsə, MS_PER_DEG dəyərini 4.0 × 360 / 300 = 4.8 et. Bu dəyər batareyaya və döşəməyə görə dəyişdiyi üçün tənzimləməni dolu batareya ilə, robotun gedəcəyi döşəmədə et.
- Dayanma həddi: Robotu divara doğru göndər və dayandığı yerdə burnunun divara məsafəsini ölç. 10 sm-dən azdırsa, STOP_CM dəyərini 5 sm artır.
- Yavaş sürət: SLOW dəyəri mühərriklərin başlanğıc həddindən aşağı qalarsa, robot yaxınlaşma zonasında dayanıb qalır; bu halda SLOW dəyərini 150-yə qaldır.
HC-SR04-ün kor nöqtələri: yumşaq səthlər, əyri divarlar və nazik maneələr
Ultrasəs sensor səsi geri əks etdirən səthləri yaxşı görür; amma hər maneə səsi sensora geri göndərmir. İstehsalçı yaxşı nəticə üçün hədəfin ən azı 0,5 m² böyüklükdə və mümkün qədər düz olmasını tövsiyə edir. Real otaqda isə robotun qarşısına pərdə, divan, stul ayağı və divar künclərı çıxır. Səs bilyard topu kimi gəldiyi bucaqla əks olunur: divara dik baxan sensor güclü əks-səda alır, amma baxış bucağı perpendikulyardan təxminən 30–40 dərəcədən çox sapsa, səs başqa istiqamətə sıçrayır və heç geri qayıtmır. Bu halda pulseIn() 0 qaytarır və kod qarşını açıq sanır. Robotların divara sürtünərək toqquşmasının ən tez-tez səbəbi budur.
| Maneə və ya səth | Niyə görünmür? | Həll |
|---|---|---|
| Pərdə, divan, balış, geyim, heyvan tükü | Yumşaq və məsaməli səth səsi udur, əks-səda çox zəif qayıdır | Yaxın məsafə üçün IR sensor əlavə et, robotu yavaş sür |
| Divara əyri yaxınlaşmaq | Səs başqa istiqamətə əks olunur, əks-səda sensora qayıtmır | Ön künclərə xaricə açılı IR sensor əlavə et, skan bucaqlarını sıx tut |
| Stul və masa ayağı, nazik dirək | Əks etdirən səth çox kiçikdir, əks-səda zəifdir | Sürəti azalt, median filtr istifadə et, yanlara IR əlavə et |
| Sensorun altında qalan alçaq maneə (naqil, astana, başmaq) | Səs konusunun altında qalır | Ön bampere aşağı baxan IR sensor və ya mikrokeçirici əlavə et |
| Masa kənarı, pilləkən boşluğu | Ultrasəs sensor irəli baxır, döşəmədəki boşluğu görmür | Döşəməyə baxan TCRT5000 ilə boşluq aşkarlama |
| 2 sm-dən yaxın cisimlər | Sensorun ölü zonası: əks-səda səs göndərilməsi bitməmiş qayıdır | Robotu 12 sm-də geri çəkiləcək şəkildə tənzimlə |
| Künclər və dar dəhlizlər | Səs iki divar arasında sıçrayıb gec qayıdır, məsafə uzun görünür | Median filtr və bir neçə bucaqdan ölçmə |
IR sensorlarla gücləndirmə
Ultrasəs və infraqırmızı (IR) sensorlar bir-birinin çatışmazlığını tamamlayır. FC-51 kimi IR maneə sensorları infraqırmızı LED və qəbuledicidən ibarətdir; LM393 komparatoru əks olunan işıq kifayət qədər güclü olduqda çıxışı LOW edir və plata üzərindəki LED yanır. Mənzili trimpotla təxminən 2–30 sm arasında tənzimlənir, amma məsafə ölçmür, yalnız "maneə var" və ya "yoxdur" deyir. İki IR sensoru robotun ön künclərinə, xaricə doğru 30–45 dərəcə bucaqla yerləşdirsən, ultrasəs sensorun dar konusundan kənarda qalan stul ayaqlarını və əyri divarları tutursan. İnkişaf etmiş kodda sol IR tətiklənəndə robot qısa an sağa, sağ IR tətiklənəndə sola qaçır; ikisi birdən tətiklənərsə, qarşısında maneə varmış kimi dayanıb skan edir.
| Xüsusiyyət | HC-SR04 (ultrasəs) | FC-51 (IR maneə) | TCRT5000 (IR əksolunma) |
|---|---|---|---|
| Çıxış | Məsafə (sm) | Var / yox (rəqəmsal) | Analoq dəyər və rəqəmsal çıxış |
| Mənzil | 2–400 cm | Təxminən 2–30 sm (tənzimlənən) | Təxminən 1–15 mm |
| Aşkarlama bucağı | Təxminən 15° | Təxminən 35° | Çox dar |
| Zəif olduğu hal | Yumşaq, əyri və nazik səthlər | Qara və mat səthlər, günəş işığı | Hündürlük dəyişimi, günəş işığı |
| Yaxşı gördüyü | Şüşə, qara cisimlər, böyük düz səthlər | Parça, künclər, yaxın maneələr | Döşəmə rəngi və masa kənarı |
| Robotdakı yeri | Servo ilə fırlanan əsas göz | Ön künclər | Ön bamperin altı, döşəməyə baxır |

Masa üstündə gəzən robotlar üçün ən təhlükəli maneə əslində boşluqdur. Ön bamperin altına döşəməyə baxan TCRT5000 modulu taxsan, döşəmə altından itdiyi anı fərq edirsən. Modulun rəqəmsal çıxışını Uno-da boş qalan D2-yə qoş; döşəmə görünməyəndə çıxışın hansı səviyyəyə keçdiyini əvvəl Serial Monitor-da gör, sonra autoStep() funksiyasının ən başında bu pini oxu və döşəmə itibsə, mühərrikləri dərhal dayandırıb robotu geri çək. Bu yoxlama məsafə ölçməsindən əvvəl edilməlidir; yıxılmaq toqquşmaqdan həmişə daha bahalıdır.
Bluetooth ilə manual rejimə keçid
Avtonom robotu bəzən əllə idarə etmək istəyirsən: onu bir otaqdan digərinə aparmaq, maneənin qarşısına gətirib reaksiyasını sınamaq və ya sadəcə oynamaq üçün. İnkişaf etmiş koddakı HC-05 qoşulması bunu təmin edir. Telefon A hərfini göndərəndə robot avtomatik rejimə, M hərfini göndərəndə manual rejimə keçir. Manual rejimdə robot maşın bələdçisindəki idarəetmə hərfləri (F, B, L, R, S) istifadə olunur, amma bir fərqlə: robot irəli gedərkən qarşısında 15 sm-dən yaxın maneə görsə, sənin komandana baxmayaraq dayanır. Bu toqquşmadan qorunma avtonom robotun sensorlarından manual sürüşdə də faydalanmağa imkan verir. HC-05-in cütləşdirmə addımları və AT komandaları HC-05 Bluetooth modulu yazısındadır.
| Hərf | Vəzifəsi | Hansı rejimdə? |
|---|---|---|
| A | Avtomatik rejimə keç | Hər iki rejimdə |
| M | Manual rejimə keç, robotu dayandır | Hər iki rejimdə |
| F / B | İrəli / geri | Manual |
| L / R | Yerində sola / sağa dön | Manual |
| S | Dayan | Manual |
| 0–9 | Sürət pilləsi (PWM 100–240) | Manual |
- HC-05-in TXD pinini D10-a, RXD pinini 1 kΩ / 2 kΩ bölücü vasitəsilə D11-ə, VCC-ni 5V-a, GND-ni GND-yə qoş.
- Android telefonunun Bluetooth ayarlarında HC-05-i 1234 (olmasa 0000) şifrəsi ilə cütləşdir.
- Play Store-dan Bluetooth maşın pultu tətbiqi quraşdır və HC-05-ə qoşul. Arduino-nu USB-yə qoşulu saxlayıb Serial Monitor-u 9600 baud ilə açsan, kod telefondan gələn hər hərfi ekrana yazır.
- Əksər pult tətbiqlərində fara və ya siqnal kimi əlavə düymələr olur və hər biri ayrıca hərf göndərir. Bu hərfləri Serial Monitor-da gör və koddakı 'A' ilə 'M' əvəzinə yaz; düymələri özün təyin etmək istəsən, App Inventor ilə Arduino Bluetooth bələdçisi ilə öz pultunu düzəldə bilərsən.
- USB kabelini çıxar və açarı aç; robot 3 saniyə sonra avtomatik rejimdə yola çıxır. Manual rejimə keçib telefondan sür.
L293D mühərrik şildi ilə quraşdırma

Naqil qarışıqlığını sevmirsənsə, L298N əvəzinə birbaşa Arduino Uno-nun üstünə taxılan L293D mühərrik şildindən (Adafruit Motor Shield V1 və klonları) istifadə edə bilərsən. Şild dörd DC mühərriki idarə edə bilər, iki servo başlığı var və servoları Arduino-nun 5 V xəttindən qidalandırır. Mühərriklər Arduino pinlərinə birbaşa deyil, plata üzərindəki 74HC595 sürüşdürmə reyestri vasitəsilə qoşulub; buna görə onları Library Manager-dən quraşdıracağın Adafruit Motor Shield library (V1 üçün olan, V2 deyil) ilə, yəni AFMotor ilə idarə edirsən. Şild D3, D4, D5, D6, D7, D8, D11 və D12-ni mühərriklər, D9 və D10-u servolar üçün istifadə edir; A0–A5, D2 və D13 boş qalır. HC-SR04 və IR sensorlar onsuz da A0–A3-də olduğu üçün yalnız mühərrik kodunu, servo pinini və HC-05 pinlərini dəyişməyin kifayətdir.
| Ayar | L298N ilə | L293D şild ilə |
|---|---|---|
| Mühərrik qoşulması | OUT1–OUT4 klemmləri | M1 (sol) və M2 (sağ) klemmləri |
| Mühərrik kodu | drive() daxilində digitalWrite və analogWrite | drive() daxilində AFMotor |
| SERVO_PIN | 3 | Servonu taxdığın başlığa görə 9 və ya 10 |
| HC-05 | D10, D11 | A4 (RX) və A5 (TX): SoftwareSerial bt(A4, A5) |
| Kanal başına cərəyan | 2 A fasiləsiz | 0,6 A fasiləsiz, 1,2 A ani |
| Mühərrik qidası | 12V klemmi | EXT_PWR klemmi; PWR jumper-i taxılıdırsa, Arduino da eyni mənbədən qidalanır |
1// L293D shield: ENA–IN4 tanımlarını ve setup()'taki pinMode listesinden bu pinleri sil, drive() fonksiyonunu aşağıdakiyle değiştir
2// L293D shield: delete the ENA–IN4 definitions, remove them from the pinMode list in setup() and replace drive() with the one below
3// Ayrıca / Also: SERVO_PIN = 9 ya da / or 10, SoftwareSerial bt(A4, A5)
4#include <AFMotor.h> // Adafruit Motor Shield V1 kütüphanesi / library
5
6AF_DCMotor leftMotor(1); // M1 klemensi / M1 terminal
7AF_DCMotor rightMotor(2); // M2 klemensi / M2 terminal
8
9void drive(int left, int right) { // her biri -255 … 255 / each -255 … 255
10 leftMotor.setSpeed(min(abs(left), 255));
11 rightMotor.setSpeed(min(abs(right), 255));
12 leftMotor.run(left > 0 ? FORWARD : (left < 0 ? BACKWARD : RELEASE));
13 rightMotor.run(right > 0 ? FORWARD : (right < 0 ? BACKWARD : RELEASE));
14}L293D-nin kanal başına 0,6 A-lıq həddi TT mühərrikli 2WD robotun normal sürüşü üçün kifayətdir; amma təkər maneəyə dayanıb sıxılanda mühərrik 1 A-dən çox cərəyan çəkə bilər və mikrosxem sürətlə qızır. Skan alqoritminin robotu maneəyə dayanmadan dayandırması buna görə şildin də ömrünü uzadır. Şildin jumper ayarları və dörd mühərrikli maşın kodu L293D Motor Shield yazısında, L298N-in daxili quruluşu isə L298N ilə DC mühərrik idarəsi bələdçisindədir.
ESP32 ilə maneədən qaçan robot
ESP32-də iki vacib fərq var. Birincisi, Arduino-nun Servo kitabxanası ESP32-də işləmir; servo siqnalını platanın PWM bloku olan LEDC ilə birbaşa yaradırıq: 50 Hz-lik siqnalda 0,544–2,4 ms-lik impuls 0–180 dərəcəyə uyğundur. Mühərriklər 1 kHz-də, servo 50 Hz-də işlədiyi üçün əvvəl mühərrik kanalları, sonra servo kanalı açılır; beləliklə servo öz taymerindən istifadə edir. İkincisi, ESP32-nin içində klassik Bluetooth olduğu üçün HC-05-ə ehtiyac qalmır; robot telefonda "BlueGrays-Robot" adı ilə görünür və istiqamət ilə rejim hərfləri Uno versiyası ilə eynidir. Kod ESP32 Arduino nüvəsinin 3.x versiyası üçündür (ledcAttach və ledcWrite pin nömrəsi ilə işləyir) və klassik Bluetooth tələb etdiyi üçün ESP32-S3 və ESP32-C3-də kompilyasiya olunmur.
1// ESP32 Arduino çekirdeği 3.x / ESP32 Arduino core 3.x
2#include "BluetoothSerial.h"
3
4const int ENA = 25, IN1 = 27, IN2 = 33; // sol motor / left motor
5const int ENB = 26, IN3 = 32, IN4 = 4; // sağ motor / right motor
6const int SERVO_PIN = 13;
7const int TRIG = 18, ECHO = 19; // ECHO 1 kΩ / 2 kΩ bölücüyle / ECHO via a 1 kΩ / 2 kΩ divider
8const int IR_LEFT = 23, IR_RIGHT = 22; // LOW = engel / LOW = obstacle
9
10const int BACK_CM = 12, STOP_CM = 25, SLOW_CM = 60, GUARD_CM = 15, MAX_CM = 400;
11const int CRUISE = 200, SLOW = 130, TURN = 170;
12const int SERVO_CENTER = 90, SERVO_DIR = 1;
13const float MS_PER_DEG = 4.0; // kalibre et / calibrate
14
15BluetoothSerial bt;
16bool autoMode = true;
17int manualLeft = 0, manualRight = 0;
18unsigned long lastCmd = 0, lastPing = 0;
19
20void drive(int left, int right) { // her biri -255 … 255 / each -255 … 255
21 left = constrain(left, -255, 255);
22 right = constrain(right, -255, 255);
23 digitalWrite(IN1, left > 0); digitalWrite(IN2, left < 0);
24 digitalWrite(IN3, right > 0); digitalWrite(IN4, right < 0);
25 ledcWrite(ENA, abs(left));
26 ledcWrite(ENB, abs(right));
27}
28
29void servoWrite(int angle) { // 0–180° → 544–2400 µs
30 angle = constrain(angle, 0, 180);
31 uint32_t us = map(angle, 0, 180, 544, 2400);
32 ledcWrite(SERVO_PIN, us * 16384 / 20000); // 14 bit, 20 ms periyot / 14-bit, 20 ms period
33}
34
35int pingCm() {
36 digitalWrite(TRIG, LOW); delayMicroseconds(2);
37 digitalWrite(TRIG, HIGH); delayMicroseconds(10);
38 digitalWrite(TRIG, LOW);
39 unsigned long t = pulseIn(ECHO, HIGH, 25000UL);
40 return t == 0 ? MAX_CM : (int)(t / 58);
41}
42
43int distanceCm() { // 3 ölçümün ortancası / median of 3 readings
44 int a = pingCm(); delay(60);
45 int b = pingCm(); delay(60);
46 int c = pingCm();
47 return max(min(a, b), min(max(a, b), c));
48}
49
50bool irBlocked(int pin) { return digitalRead(pin) == LOW; }
51
52void turnBy(int deg) { // + sola, - sağa / + left, - right
53 if (deg > 0) drive(-TURN, TURN);
54 else drive(TURN, -TURN);
55 delay((unsigned long)(abs(deg) * MS_PER_DEG));
56 drive(0, 0);
57 delay(100);
58}
59
60void avoid() {
61 drive(0, 0);
62 delay(120);
63 int front = distanceCm();
64 bool sides = irBlocked(IR_LEFT) || irBlocked(IR_RIGHT);
65 if (front >= STOP_CM && !sides) return; // yanlış alarm / false alarm
66 if (front < BACK_CM || sides) { // geri çekil / back off
67 drive(-TURN, -TURN);
68 delay(350);
69 drive(0, 0);
70 }
71 const int offsets[] = {70, 35, -35, -70};
72 int bestOffset = 0, bestCm = 0;
73 for (int off : offsets) {
74 servoWrite(SERVO_CENTER + SERVO_DIR * off);
75 delay(300);
76 int cm = distanceCm();
77 if (cm > bestCm) { bestCm = cm; bestOffset = off; }
78 }
79 servoWrite(SERVO_CENTER);
80 delay(200);
81 if (bestCm < STOP_CM + 10) { // çıkmaz / dead end
82 drive(-TURN, -TURN);
83 delay(400);
84 turnBy(180);
85 } else {
86 turnBy(bestOffset);
87 }
88}
89
90void setup() {
91 int outs[] = {IN1, IN2, IN3, IN4, TRIG};
92 for (int p : outs) pinMode(p, OUTPUT);
93 pinMode(ECHO, INPUT);
94 pinMode(IR_LEFT, INPUT_PULLUP);
95 pinMode(IR_RIGHT, INPUT_PULLUP);
96 ledcAttach(ENA, 1000, 8); // motor PWM: 1 kHz, 8 bit
97 ledcAttach(ENB, 1000, 8);
98 ledcAttach(SERVO_PIN, 50, 14); // servo: 50 Hz, 14 bit
99 drive(0, 0);
100 servoWrite(SERVO_CENTER);
101 bt.begin("BlueGrays-Robot"); // telefonda görünecek ad / name shown on the phone
102 delay(3000);
103}
104
105void loop() {
106 while (bt.available()) {
107 char c = bt.read();
108 lastCmd = millis();
109 if (c == 'A') autoMode = true; // otomatik / auto
110 else if (c == 'M') { // manuel / manual
111 autoMode = false;
112 manualLeft = manualRight = 0;
113 servoWrite(SERVO_CENTER);
114 }
115 else if (!autoMode) {
116 if (c == 'F') { manualLeft = 200; manualRight = 200; } // ileri / forward
117 else if (c == 'B') { manualLeft = -200; manualRight = -200; } // geri / backward
118 else if (c == 'L') { manualLeft = -200; manualRight = 200; } // sola / left
119 else if (c == 'R') { manualLeft = 200; manualRight = -200; } // sağa / right
120 else if (c == 'S') { manualLeft = 0; manualRight = 0; } // dur / stop
121 }
122 }
123
124 if (millis() - lastPing < 60) return; // 60 ms'de bir / every 60 ms
125 lastPing = millis();
126 int d = pingCm();
127
128 if (!autoMode) {
129 if (millis() - lastCmd > 600) manualLeft = manualRight = 0; // komut yok: dur / no command: stop
130 bool forward = manualLeft > 0 && manualRight > 0;
131 if (forward && d < GUARD_CM) drive(0, 0); // çarpışma koruması / collision guard
132 else drive(manualLeft, manualRight);
133 return;
134 }
135
136 bool l = irBlocked(IR_LEFT), r = irBlocked(IR_RIGHT);
137 if (d < STOP_CM || (l && r)) avoid();
138 else if (l) { drive(TURN, -TURN); delay(150); }
139 else if (r) { drive(-TURN, TURN); delay(150); }
140 else if (d < SLOW_CM) { int s = map(d, STOP_CM, SLOW_CM, SLOW, CRUISE); drive(s, s); }
141 else drive(CRUISE, CRUISE);
142}Raspberry Pi Pico (MicroPython) ilə maneədən qaçan robot
Raspberry Pi Pico-da MicroPython-un time_pulse_us() funksiyası Arduino-dakı pulseIn() kimi işləyir; əks-səda gəlməsə mənfi dəyər qaytardığı üçün bunu 400 sm, yəni açıq sahə sayırıq. Servo üçün 50 Hz-lik PWM və impuls enini nanosaniyə ilə qəbul edən duty_ns() istifadə olunur. GP16-dakı servo ilə GP15 və GP10-dakı mühərrik sürət pinləri fərqli PWM dilimlərində olduğu üçün bir-birinin tezliyini pozmur. Sürətlər bu dəfə faizlə verilir. Pico-da Bluetooth olmadığından manual rejim istəsən, HC-05-i robot maşın bələdçisindəki kimi UART0-a (GP0, GP1) qoşa bilərsən.
1from machine import Pin, PWM, time_pulse_us
2import time
3
4ena = PWM(Pin(15)); ena.freq(1000) # sol motor hızı / left motor speed
5enb = PWM(Pin(10)); enb.freq(1000) # sağ motor hızı / right motor speed
6in1, in2 = Pin(14, Pin.OUT), Pin(13, Pin.OUT)
7in3, in4 = Pin(12, Pin.OUT), Pin(11, Pin.OUT)
8servo = PWM(Pin(16)); servo.freq(50) # servo sinyali, 50 Hz / servo signal, 50 Hz
9trig = Pin(17, Pin.OUT, value=0)
10echo = Pin(18, Pin.IN) # 1 kΩ / 2 kΩ bölücü üzerinden / via a 1 kΩ / 2 kΩ divider
11ir_left = Pin(19, Pin.IN, Pin.PULL_UP) # 0 = engel / 0 = obstacle
12ir_right = Pin(20, Pin.IN, Pin.PULL_UP)
13
14STOP_CM, BACK_CM = 25, 12
15CRUISE, TURN = 75, 65 # hız yüzdesi / speed in percent
16MS_PER_DEG = 4 # kalibre et / calibrate
17SERVO_CENTER = 90 # öne bakmıyorsa düzelt / adjust if not facing ahead
18
19def drive(left, right): # -100 … 100 (%)
20 in1.value(left > 0); in2.value(left < 0)
21 in3.value(right > 0); in4.value(right < 0)
22 ena.duty_u16(int(min(abs(left), 100) * 655))
23 enb.duty_u16(int(min(abs(right), 100) * 655))
24
25def head(offset): # + sol, - sağ / + left, - right
26 angle = max(0, min(180, SERVO_CENTER + offset))
27 servo.duty_ns((544 + angle * 1856 // 180) * 1000) # 0,544–2,4 ms darbe / 0.544–2.4 ms pulse
28
29def ping_cm():
30 trig.value(1); time.sleep_us(10); trig.value(0) # 10 µs tetik / 10 µs trigger
31 t = time_pulse_us(echo, 1, 25000)
32 return 400 if t < 0 else t // 58 # negatif = yankı yok / negative = no echo
33
34def distance_cm(): # 3 ölçümün ortancası / median of 3 readings
35 r = []
36 for _ in range(3):
37 r.append(ping_cm())
38 time.sleep_ms(60)
39 return sorted(r)[1]
40
41def turn_by(deg): # + sola, - sağa / + left, - right
42 if deg > 0:
43 drive(-TURN, TURN)
44 else:
45 drive(TURN, -TURN)
46 time.sleep_ms(int(abs(deg) * MS_PER_DEG))
47 drive(0, 0)
48 time.sleep_ms(100)
49
50def avoid():
51 drive(0, 0)
52 time.sleep_ms(120)
53 front = distance_cm()
54 sides = not ir_left.value() or not ir_right.value()
55 if front >= STOP_CM and not sides:
56 return # yanlış alarm / false alarm
57 if front < BACK_CM or sides: # geri çekil / back off
58 drive(-TURN, -TURN); time.sleep_ms(350); drive(0, 0)
59 best_off, best_cm = 0, 0
60 for off in (70, 35, -35, -70): # tara / scan
61 head(off)
62 time.sleep_ms(300)
63 cm = distance_cm()
64 if cm > best_cm:
65 best_off, best_cm = off, cm
66 head(0)
67 time.sleep_ms(200)
68 if best_cm < STOP_CM + 10: # çıkmaz / dead end
69 drive(-TURN, -TURN); time.sleep_ms(400)
70 turn_by(180)
71 else:
72 turn_by(best_off)
73
74drive(0, 0)
75head(0)
76time.sleep(3) # yere koyman için süre / time to put it down
77while True:
78 d = ping_cm()
79 left_hit, right_hit = not ir_left.value(), not ir_right.value()
80 if d < STOP_CM or (left_hit and right_hit):
81 avoid()
82 elif left_hit:
83 drive(TURN, -TURN); time.sleep_ms(150) # sağa kaç / dodge right
84 elif right_hit:
85 drive(-TURN, TURN); time.sleep_ms(150) # sola kaç / dodge left
86 else:
87 drive(CRUISE, CRUISE)
88 time.sleep_ms(60) # ölçümler arası / between readingsManeədən qaçan robotla layihə ideyaları
- Radar ekranı: Skan zamanı ölçdüyün bucaq və məsafələri serial portdan göndərib kompüterdə yaşıl radar ekranı çək; təfərrüatlar Arduino radar layihəsi yazısındadır.
- Xətt və maneə: Robot xətt izləyən robot kimi pistdə irəliləyərkən qarşısına çıxan qutunun ətrafından dolanıb xətə qayıtsın; yarışlarda tez-tez rast gəlinən tapşırıqdır.
- Divar izləyən robot: Sensoru daim 60 dərəcə sağa çevirib divardan sabit 20 sm məsafədə irəlilə; labirint həllinin ilk addımıdır.
- Ekranlı robot: Məsafəni və rejimi kiçik OLED ekranda göstər; sazlama çox asanlaşır.
- Tozsoran robot prototipi: Təsadüfi istiqamət seçimi, toqquşma açarları və boşluq sensoru ilə evdə gəzən təmizlik robotunun eskizini düzəlt.
- Ağıllı əsa: Eyni məsafə ölçmə məntiqini görmə qüsurlu insanlar üçün titrəyişli xəbərdarlığa çevir; bax: Arduino ağıllı əsa.
- Məktəb və yarış layihəsi: Maneə parkuru, vaxt ölçmə və avtomatik ya da manual rejim nümayişi ilə təqdim et; ideyalar üçün TÜBİTAK Arduino layihə ideyaları yazısına nəzər sal.
Tez-tez edilən səhvlər və həlləri
| Problem | Mümkün səbəb | Həll |
|---|---|---|
| Robot divara heç dayanmadan toqquşur | Sensor 0 oxuyur (naqil qırıqdır, TRIG və ECHO tərsdir) və kod bunu açıq sahə sayır | Test kodunu işə sal, əlinlə 10–60 sm arasını sına, TRIG və ECHO pinlərini yoxla |
| Divara əyri yaxınlaşanda sürtünür | Səs əyri səthdən başqa istiqamətə əks olunur | Ön künclərə IR sensor əlavə et, sürəti azalt |
| Dayanıb skan edəndə Arduino resetlənir | Servo və mühərrik cərəyanı 5 V xəttini çökdürür | Servoya 470 µF kondensator, dolu 18650 batareyalar; lazım olsa servonu ayrıca 5 V mənbədən qidalandır |
| Robot səbəbsiz yerə dayanıb skan edir | Tək səhv ölçmə və ya döşəmədən gələn əks-səda | Sensoru 8–12 sm hündürə qaldır və bir az yuxarı əy; median təsdiqindən istifadə et |
| Robot bağlı tərəfə dönür | Servo montajı tərsdir, sol və sağ qarışıb | SERVO_DIR dəyərini -1 et |
| Dönmələr çox qısa və ya çox uzundur | MS_PER_DEG kalibrlənməyib və ya batareya zəifdir | turnBy(360) ilə ölç, dolu batareya ilə yenidən tənzimlə |
| Küncdə sağa-sola dönüb durur | Hər iki yan həddə yaxındır, qərar daim dəyişir | Çıxılmaz vəziyyət həddini (STOP_CM + 10) artır və ya sonuncu dönülən istiqamətə üstünlük ver |
| Sensor başlığı səyriyir | Servo qidası zəifdir və ya SoftwareSerial kəsmələri | Servo naqilini qısalt, kondensator əlavə et, lazımsız tez-tez Bluetooth komandası göndərməkdən çəkin |
Maneədən qaçan robot sensor oxuma, filtrləmə, qərar vermə və mühərrik idarəsini bir layihədə birləşdirdiyi üçün robototexnikaya keçidin ən yaxşı addımıdır. Əvvəl ilk kodla əsas davranışı gör, sonra inkişaf etmiş versiya ilə hədləri öz otağına görə tənzimlə, ən sonda IR sensorlar və Bluetooth ilə robotunu gücləndir. BlueGrays tətbiqində maneədən qaçan robot, L298N ilə Bluetooth idarəli maşın, HC-SR04 ilə məsafə ölçmə və park sensoru layihələrini dövrə sxemləri və kodları ilə addım-addım tapa bilərsən.
Tez-tez verilən suallar
Maneədən qaçan robot üçün hansı materiallar lazımdır?
Əsas maneədən qaçan robot üçün Arduino Uno, HC-SR04 ultrasəs sensor, SG90 servo, L298N və ya L293D mühərrik sürücüsü, iki reduktorlu DC mühərrikli 2WD şassi dəsti və iki ədəd 18650 batareya kifayətdir. Künclərı görmək üçün iki IR maneə sensoru, telefondan idarə etmək üçün isə HC-05 Bluetooth modulu əlavə edə bilərsən.
Maneədən qaçan robotu servosuz düzəltmək olarmı?
Bəli. Sensor sabit olaraq irəli baxır; robot maneə görəndə əvvəl bir istiqamətə dönür və yenidən ölçür, yol hələ də bağlıdırsa, digər istiqamətə dönür. Bu üsul daha ucuzdur, amma robot hər cəhddə gövdəsini döndərdiyi üçün daha yavaş qərar verir; servo isə dönməzdən əvvəl ən açıq istiqaməti tapmağa imkan verir.
HC-SR04 niyə bəzi maneələri görmür?
Ultrasəs sensor əks-sədaya görə ölçür. Pərdə və divan kimi yumşaq səthlər səsi udur, əyri divarlar səsi başqa istiqamətə əks etdirir, stul ayağı kimi nazik cisimlər isə çox zəif əks-səda verir. Sensor təxminən 15 dərəcəlik konusundan kənarda və ya altında qalan maneələri də görə bilmir; bu boşluqları IR sensorlarla bağlaya bilərsən.
Maneədən qaçan robot neçə sm-də dayanmalıdır?
Başlanğıc üçün 25 sm yaxşı dəyərdir: iki ölçmə arasında qət olunan yol, əyləc məsafəsi və yerində dönmək üçün lazım olan pay toplananda təxminən 20 sm edir, üstünə də kiçik təhlükəsizlik payı əlavə olunur. Sürətli robotlarda və sürüşkən döşəmədə həddi 30–35 sm-ə qaldır; 12 sm-dən yaxın maneədə isə əvvəl geri çəkilmək lazımdır.
Robot üçün L298N, yoxsa L293D şild daha yaxşıdır?
L298N kanal başına 2 A verə bildiyi üçün daha davamlıdır və pinləri istədiyin kimi seçməyə imkan verir. L293D şild Uno-nun üstünə taxıldığı üçün naqilləməni azaldır və dörd mühərrik idarə edə bilər, amma kanal başına fasiləsiz cərəyanı 0,6 A-dir və bir çox pindən istifadə edir. TT mühərrikli kiçik 2WD robot üçün ikisi də iş görür.
Maneədən qaçan robotu telefondan idarə etmək olarmı?
Bəli. Robota HC-05 Bluetooth modulu əlavə edib Android telefondakı pult tətbiqindən hərf göndərərək avtomatik və manual rejim arasında keçə bilərsən. Manual rejimdə ultrasəs sensordan toqquşmadan qorunma kimi istifadə etmək robotun divara sürülməsinin qarşısını alır. ESP32 istifadə etsən, daxili Bluetooth sayəsində ayrıca modula ehtiyac qalmır.
Bu yazıdan sonra edə biləcəyin layihələr
Bütün layihələrə bax
HC-SR04 ilə məsafə ölçmə (Serial ekran)
Yarasalar qaranlıqda yolunu necə tapırsa, HC-SR04 sensoru da elə işləyir: eşidə bilmədiyin bir səs göndərir, əks-sədasını dinləyir və qarşısındakı cismin nə qədər uzaqda olduğunu ölçür.

Maneədən qaçan robot
Öz yolunu tapan ağıllı nəqliyyat vasitəsi düzəltməyə nə deyirsən? Maneədən qaçan robot, qarşısındakı ultrasəs sensoru sayəsində ətrafını daim skan edir.

L298N ilə Bluetooth idarəli maşın
Telefonunu pultə çevirib öz robot maşınını sür. Arduino, Bluetooth modulu vasitəsilə telefondakı idarəetmə tətbiqindən gələn əmrləri alır və mühərrik sürücüsü ilə təkərləri fırladır; maşın irəli…

Servo mühərrikdən istifadə
Kiçik servo mühərrikin qolu ardıcıl üç vəziyyətə dönür: ən əvvələ, tam ortaya və ən sona, hər dayanacaqda iki saniyə gözləyərək.

HC-SR04 ilə park sensoru
Avtomobillərdəki park sensorunun kiçik bənzəri: nəsə yaxınlaşdıqca bip səsləri sürətlənir.

TCRT5000 ilə əksolunma (yaxınlıq) oxumaq
Görünməz işıq göndərib əksini ölçən kiçik sensorla qarşındakı səthi aşkar edirsən.

TCRT5000 ilə qara-ağ zəmin aşkarlanması
Xətt izləyən robotların gözü olan kiçik bir sensorla zəminin qara, yoxsa ağ olduğunu müəyyən edirsən.

ESP32 HC-SR04 ultrasəs məsafə ölçəni
HC-SR04 ultrasəs sensoru göndərdiyi səs dalğasının cisimə çarpıb geri qayıtma müddətini (Time of Flight) ölçərək məsafəni hesablayır. Bu layihədə ESP32 ilə TRIG pininə 10 mikrosaniyəlik impuls göndərib, ECHO pinindən gələn əks-səda müddətini pulseIn() ilə oxuyacağıq. Hesablanan məsafəni sm ilə 16x2 I2C LCD-də göstərəcəyik. HC-SR04 5V ilə işlədiyi üçün ECHO pininə gərginlik bölücü məcburidir — əks halda ESP32-nin 3.3V GPIO-su zədələnir.
Digər yazılar
BlueGrays tətbiqi
Bu dövrəni telefonunda addım-addım qur
Dövrə sxemi, kod və hissə siyahısı bir ekranda. 500-dən çox Arduino, ESP32 və Pico layihəsi səni gözləyir.
Telefonunla skan et
Kameranı koda tut; telefonunun tətbiq mağazası açılır.
ya da mağazada aç

