Bələdçilər · 14 dəq oxu

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.

HC-SR04 ultrasəs məsafə sensoru
HC-SR04: T yazılan çevirici 40 kHz-lik səs göndərir, R yazılan əks-sədanı dinləyir. Maneədən qaçan robotun gözü budur; təxminən 15 dərəcəlik dar bucaqla 2–400 sm arasını ölçü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əsiQeyd
Arduino Uno (və ya Nano)Beyin: ölçür, qərar verir, mühərriklərə komanda göndərirESP32 və Pico da istifadə oluna bilər
HC-SR04Göz: qarşıdakı maneənin məsafəsini ölçür5 V ilə işləyir, 2–400 sm
SG90 servoBoyun: sensoru sola və sağa çevirirSensor 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 verirArduino pini mühərrik cərəyanını verə bilmir
2 reduktorlu TT mühərrik və sərbəst təkərDiferensial 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)Enerji9 V düzbucaqlı batareya kifayət etmir
2 ədəd IR maneə sensoru (istəyə görə)Künc və yan maneələri tuturFC-51 kimi LM393-lü modullar
HC-05 (istəyə görə)Telefondan manual idarəetməYalnız Android ilə işləyir
Arduino Uno
Arduino Uno
L298N
L298N
TT motor
TT motor
18650 Li-ion
18650 Li-ion

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ərrikL298N 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 UnoVIN ← batareyanın müsbət qütbü (açardan sonra)Təxminən 50 mA
SG90 servoArduino 5V + 470 µF kondensatorDayananda ~10 mA, fırlananda 100–250 mA
HC-SR04Arduino 5VTəxminən 15 mA
2 IR sensorArduino 5VHər biri 20–40 mA
HC-05Arduino 5VCütləşmə axtarışında 30–40 mA, qoşulu olanda təxminən 10 mA
Bütün GND-ləri (batareyanın mənfi qütbü, L298N, Arduino, servo, sensorlar) bir-birinə qoş; ortaq torpaq olmasa, sensor mənasız məsafələr oxuyur və servo titrəyir. Servonu mühərriklərlə eyni nazik jumper naqildən qidalandırma. MG90S və ya MG996R kimi daha güclü servo istifadə edəcəksənsə, onu Arduino-dan deyil, 5 V-a tənzimlənmiş ayrıca azaldıcı moduldan (məs. LM2596) qidalandır.

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şulmaArduino UnoESP32Raspberry Pi Pico
L298N ENA (sol mühərrik sürəti)D5GPIO 25GP15
L298N IN1, IN2D7, D8GPIO 27, 33GP14, GP13
L298N ENB (sağ mühərrik sürəti)D6GPIO 26GP10
L298N IN3, IN4D9, D4GPIO 32, 4GP12, GP11
Servo siqnal (narıncı)D3GPIO 13GP16
Servo + (qırmızı), − (qəhvəyi)5V, GNDL298N 5V, GNDL298N 5V, GND
HC-SR04 TRIGA0GPIO 18GP17
HC-SR04 ECHOA1 (birbaşa)GPIO 19, 1 kΩ / 2 kΩ bölücü iləGP18, 1 kΩ / 2 kΩ bölücü ilə
HC-SR04 VCC5VL298N 5VL298N 5V
IR sol OUT, IR sağ OUTA2, A3GPIO 23, 22GP19, GP20
IR sensor VCC5V3V33V3
HC-05 TXD, RXDD10, 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 5VVSYS ← L298N 5V
HC-SR04-ün ECHO pini 5 V-luq siqnal verir; ESP32 və Pico-nun pinləri isə 3,3 V-dur və 5 V-a davamlı deyil. ECHO → 1 kΩ → plataya gedən nöqtə → 2 kΩ → GND şəklində gərginlik bölücü qur: 5 V × 2 / 3 ≈ 3,3 V. TRIG üçün bölücü lazım deyil; 3,3 V-luq siqnal sensoru tətikləməyə kifayət edir. ESP32 və Pico-da plata, servo və HC-SR04 eyni L298N 5V çıxışını bölüşdüyü üçün bu kiçik stabilizatorun təxminən 0,5 A-lıq həddinə yaxınlaşmaq mümkündür; resetlənmə görsən, servonu ayrıca 5 V mənbədən qidalandır.

Sensor başlığını quraşdır və sına

SG90 mikro servo mühərrik
SG90: 9 qramlıq mikro servo; 4,8 V-da 60 dərəcəni təxminən 0,1 saniyəyə fırlanır. HC-SR04-ü daşıyan plastik aparat servonun başlığına vintlənir.
  1. 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.
  2. 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.
  3. 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.
  4. 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.
  5. 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ş.
C++ (Arduino IDE)
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əZonaRobotun etdiyi
60 sm-dən uzaq (və ya əks-səda yoxdur)SərbəstTam sürətlə irəli (PWM 200)
25–60 cmYaxınlaşmaMəsafəyə mütənasib yavaşıyır (PWM 200-dən 130-a)
12–25 cmManeə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ətGeri 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.

C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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 ayarNə 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_DIRSensorun düz irəli baxdığı bucaq və sol tərəfin istiqaməti
STOP_CM, SLOW_CM, BACK_CMDayanma, 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ə:

  1. 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ş.
  2. 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.
  3. 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.
  4. 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əthNiyə 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ırYaxın məsafə üçün IR sensor əlavə et, robotu yavaş sür
Divara əyri yaxınlaşmaqSə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əifdirSü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ğuUltrasəs sensor irəli baxır, döşəmədəki boşluğu görmürDöşəməyə baxan TCRT5000 ilə boşluq aşkarlama
2 sm-dən yaxın cisimlərSensorun ölü zonası: əks-səda səs göndərilməsi bitməmiş qayıdırRobotu 12 sm-də geri çəkiləcək şəkildə tənzimlə
Künclər və dar dəhlizlərSəs iki divar arasında sıçrayıb gec qayıdır, məsafə uzun görünürMedian filtr və bir neçə bucaqdan ölçmə
Bir sensorun görə bilmədiyini başqa sensorla bağlamaq, tək sensoru qüsursuz etməyə çalışmaqdan həmişə daha effektivdir. Amma ilk iş olaraq sürəti azalt: 0,3 m/s ilə gedən robot eyni səhv ölçmə ilə 0,7 m/s-dəki qədər sərt toqquşmaz və ikinci ölçməyə vaxt qalır. Müxtəlif məsafə sensorlarının güclü və zəif tərəflərini Arduino məsafə sensorlarının müqayisəsi yazısında topladıq.

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ətHC-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ənzil2–400 cmTə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 halYumşaq, əyri və nazik səthlərQara 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ərParça, künclər, yaxın maneələrDöşəmə rəngi və masa kənarı
Robotdakı yeriServo ilə fırlanan əsas gözÖn künclərÖn bamperin altı, döşəməyə baxır
TCRT5000 infraqırmızı əksolunma sensoru
TCRT5000: döşəməyə 5–10 mm yaxınlıqda, aşağı baxacaq şəkildə taxılanda masa kənarını və pilləkən boşluğunu fərq edir; əksolunma kəsildiyi anda robot dayanıb geri çəkilə bilə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ərfVəzifəsiHansı rejimdə?
AAvtomatik rejimə keçHər iki rejimdə
MManual rejimə keç, robotu dayandırHər iki rejimdə
F / Bİrəli / geriManual
L / RYerində sola / sağa dönManual
SDayanManual
0–9Sürət pilləsi (PWM 100–240)Manual
  1. 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ş.
  2. Android telefonunun Bluetooth ayarlarında HC-05-i 1234 (olmasa 0000) şifrəsi ilə cütləşdir.
  3. 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.
  4. Ə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.
  5. USB kabelini çıxar və açarı aç; robot 3 saniyə sonra avtomatik rejimdə yola çıxır. Manual rejimə keçib telefondan sür.
Uno-da SoftwareSerial bir bayt alanda digər kəsmələri təxminən 1 ms gözlədir; bu zaman Servo kitabxanasının impulsları uzana bilər və sensor başlığı bir az səyriyə bilər. Robotun davranışını pozmur, amma narahat edirsə, ESP32-nin daxili Bluetooth-una keçə bilərsən. HC-05 və HC-06 iPhone ilə işləmir; iPhone üçün BLE istifadə edən modul və ya BLE ilə proqramlaşdırılmış ESP32 lazımdır.

L293D mühərrik şildi ilə quraşdırma

L293D mühərrik sürücü şildi
L293D mühərrik şildi: Arduino Uno-nun üstünə taxılır; M1–M4 klemmlərinə dörd DC mühərrik, küncdəki başlıqlara iki servo qoşulur.

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.

AyarL298N iləL293D şild ilə
Mühərrik qoşulmasıOUT1–OUT4 klemmləriM1 (sol) və M2 (sağ) klemmləri
Mühərrik kodudrive() daxilində digitalWrite və analogWritedrive() daxilində AFMotor
SERVO_PIN3Servonu taxdığın başlığa görə 9 və ya 10
HC-05D10, D11A4 (RX) və A5 (TX): SoftwareSerial bt(A4, A5)
Kanal başına cərəyan2 A fasiləsiz0,6 A fasiləsiz, 1,2 A ani
Mühərrik qidası12V klemmiEXT_PWR klemmi; PWR jumper-i taxılıdırsa, Arduino da eyni mənbədən qidalanır
C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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.

MicroPython
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 readings

Maneə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

ProblemMümkün səbəbHəll
Robot divara heç dayanmadan toqquşurSensor 0 oxuyur (naqil qırıqdır, TRIG və ECHO tərsdir) və kod bunu açıq sahə sayırTest 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ürSə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ənirServo və mühərrik cərəyanı 5 V xəttini çökdürürServoya 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 edirTək səhv ölçmə və ya döşəmədən gələn əks-sədaSensoru 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ürServo montajı tərsdir, sol və sağ qarışıbSERVO_DIR dəyərini -1 et
Dönmələr çox qısa və ya çox uzundurMS_PER_DEG kalibrlənməyib və ya batareya zəifdirturnBy(360) ilə ölç, dolu batareya ilə yenidən tənzimlə
Küncdə sağa-sola dönüb dururHə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əyriyirServo qidası zəifdir və ya SoftwareSerial kəsmələriServo naqilini qısalt, kondensator əlavə et, lazımsız tez-tez Bluetooth komandası göndərməkdən çəkin
Problemin mənbəyini tapmağın ən sürətli yolu robotu USB-yə qoşulu saxlayıb təkərlər havadakı halda işlətmək və pingCm() dəyərlərini Serial Monitor-a yazdırmaqdır. Dəyərlər məntiqlidirsə, problem mexanikada və ya qida tərəfindədir. Arduino-nun tez-tez yenidən başlamasının digər səbəbləri üçün Arduino özünü resetləyir yazısına baxa bilərsən.

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.

Bütün layihələrə bax
HC-SR04 ilə məsafə ölçmə (Serial ekran)
AR-27Başlanğıc

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.

4.6(50)
82
Maneədən qaçan robot
AR-81Qabaqcıl
Premium

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.

5.0(38)
49
L298N ilə Bluetooth idarəli maşın
AR-80Qabaqcıl
Premium

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…

5.0(39)
66
Servo mühərrikdən istifadə
AR-35Başlanğıc
Premium

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.

4.7(48)
67
HC-SR04 ilə park sensoru
AR-28Orta
Premium

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.

4.8(64)
86
TCRT5000 ilə əksolunma (yaxınlıq) oxumaq
AR-77Orta
Premium

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.

4.6(33)
43
TCRT5000 ilə qara-ağ zəmin aşkarlanması
AR-78Orta
Premium

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.

4.7(40)
49
ESP32 HC-SR04 ultrasəs məsafə ölçəni
ES-14Orta

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.

4.9(29)
48