Arduino robot qol qurmaq: servo seçimi, tork hesabı və Bluetooth
Arduino robot qolu addım-addım: MDF və ya 3D çap gövdə, MG996R tork hesabı, pot və coystik idarəsi, qeyd et-oynat, PCA9685 və Bluetooth kodları.
Arduino robot qol, servo mühərriklərlə hərəkət edən oynaqları sayəsində bir əşyanı tutub qaldıra bilən, döndərib başqa yerə qoya bilən masaüstü ölçülü robotdur. Baza, çiyin, dirsək, bilək və qısqacdan ibarət bu quruluş mexaniki dizaynı, mühərrik seçimini, qida idarəsini və kodlaşdırmanı tək layihədə öyrədir. Üstəlik, bir Arduino Uno, bir neçə servo və MDF ya da 3D çap hissələrlə evdə qurmaq mümkündür; zavodlardakı sənaye robot qollarının kiçik bir nüsxəsini öz masanda işlədirsən.
Bu bələdçidə 4 və 6 oxlu robot qolu başdan sona nəzərdən keçiririk: gövdə üçün material seçimi, SG90, MG90S və MG996R arasında doğru servonu tapmaq üçün tork hesabı, xarici 5 V qidalandırma, potensiometr və coystiklə idarə, hərəkətləri yadda saxlayıb təkrar oynatma, 16 kanallı PCA9685 servo sürücü, telefondan Bluetooth idarəsi və ən çox rast gəlinən iki problemin, yəni titrəmə və resetlənmənin həlli. Servo mühərrikin iş prinsipini bilmirsənsə, əvvəlcə Servo mühərrik nədir? yazısına nəzər sala bilərsən.



Robot qol necə işləyir, neçə ox lazımdır?
Robot qolu insan qoluna bənzədə bilərsən. Hər oynaqda bir servo mühərrik olur və Arduino hər servoya "bu bucağa get" komandası göndərir. Servo içindəki potensiometr sayəsində valının harada olduğunu bilir və yük altında belə həmin bucağı saxlayır. Oynaq bucaqlarını birlikdə dəyişməklə qısqacı istədiyin nöqtəyə aparırsan. Qolun edə bildiyi müstəqil hərəkətlərin sayına sərbəstlik dərəcəsi (DOF), gündəlik dildə isə ox deyilir.
| Oynaq | Hərəkəti | Yük vəziyyəti | Tövsiyə olunan servo |
|---|---|---|---|
| Baza (bel) | Qolu sağa-sola döndərir | Çəki qaldırmır, amma bütün qolu daşıyır | MG996R + podşipnik |
| Çiyin | Qolu irəli və geri qaldırır | Ən çox yüklənən oynaq | MG996R və ya 20 kg·cm sinifli servo |
| Dirsək | Ön qolu bükür | Orta-yüksək | MG996R |
| Bilək (yuxarı-aşağı) | Qısqacın bucağını tənzimləyir | Aşağı | MG90S |
| Bilək fırlanması | Qısqacı öz oxu ətrafında çevirir | Çox aşağı | MG90S və ya SG90 |
| Qısqac (gripper) | Əşyanı tutur və buraxır | Sıxma qüvvəsi | SG90 və ya MG90S |
Bazardakı "6 oxlu robot qol" dəstlərinin çoxunda 6 servo olur; qısqac ox sayılmadığı üçün texniki baxımdan bunlar 5 sərbəstlik dərəcəli qol və bir qısqacdır. İlk qolun üçün 4 oxlu dizayn (baza, çiyin, dirsək, qısqac) ən yaxşı başlanğıcdır: 4 servo, 4 potensiometr və bir Arduino Uno kifayətdir, naqil bağlantısı sadə qalır və tork problemləri az olur. Bilək oynaqları qısqacı üfüqi saxlamaq ya da əşyanı fərqli bucaqlardan tutmaq lazım olanda işə yarayır; 5–6 servoya keçəndə PCA9685 sürücü demək olar ki, məcburi olur.
Material siyahısı
| Hissə | 4 oxlu qol | 6 servolu qol | Qeyd |
|---|---|---|---|
| İdarəetmə platası | Arduino Uno və ya Nano | Arduino Uno, Nano və ya ESP32 | Nano-nun əlavə A6 və A7 girişləri potların sayını artırır |
| Servo mühərrik | 4 ədəd SG90 və ya MG90S | 3 ədəd MG996R + 3 ədəd MG90S | Seçimini aşağıdakı tork hesabı ilə yoxla |
| Servo sürücü | Lazım deyil | PCA9685 16 kanallı modul | I2C ilə yalnız 2 siqnal naqili |
| Qida mənbəyi | 5 V 3 A adapter | 5–6 V, ən azı 5 A adapter | Servolar Arduino-dan qidalanmır |
| Kondensator | 470–1000 µF, 16 V | 1000–2200 µF, 16 V | Servo qida xəttinə, qütbə diqqət edərək |
| İdarəetmə elementi | 4 ədəd 10 kΩ potensiometr | 2 ədəd coystik modulu və ya HC-05 | İkisini birlikdə də istifadə edə bilərsən |
| Düymə | 2 ədəd (qeyd, oynat) | Coystik düymələri kifayətdir | INPUT_PULLUP ilə əlavə rezistor lazım olmur |
| Mexanika | 3 mm MDF və ya 3D çap hissələr | 4 mm MDF, 3D çap və ya alüminium braket | 608 podşipnik, M3 bolt və kontr-qayka |
Mexaniki quruluş: MDF, yoxsa 3D çap?
| Material | Üstünlüyü | Çatışmazlığı | Kimə uyğundur? |
|---|---|---|---|
| 3–4 mm MDF (lazer kəsim) | Ucuz, yüngül, asan vintlənir və yapışdırılır | Nəmdən təsirlənir, vint dəlikləri zamanla genişlənir | MeArm tipli ilk qollar, məktəb layihələri |
| 3 mm akril | Gözəl görünür, nəmdən təsirlənmir | Kövrəkdir; vinti sıxanda çatlaya bilər | Sərgi və vitrin layihələri |
| 3D çap (PLA / PETG) | Mürəkkəb hissələr, tam ölçülü servo yuvaları | Çap müddəti uzundur; PLA istidə və daimi yük altında əyilir | Öz dizaynını edənlər; yük daşıyan hissələrdə PETG |
| Alüminium braket dəsti | Çox möhkəmdir, MG996R ilə uyğun hazır hissələr | Ağır və bahalıdır, çiyinə daha çox yük düşür | Daha ağır əşya qaldıracaq 6 servolu qollar |
| Karton, dondurma çubuğu | Demək olar ki, pulsuz, sürətli prototip | Davamsızdır, oynaqlarda boşluq yaranır | Ölçüləri yoxlamaq, uşaqlarla ilk sınaq |
- Qolu qısa və yüngül saxla: Çiyindəki yük məsafə ilə düz mütənasib artır. Qolu 30 sm əvəzinə 24 sm etmək çiyin torkunu təxminən beşdə bir azaldır.
- Ağır servoları bazaya yaxın yerləşdir: Dirsək servosunu çiyin səviyyəsinə götürüb dirsəyi itələyici çubuqla (paralel birləşmə) hərəkət etdirmək MeArm kimi qolların istifadə etdiyi ağıllı üsuldur; çiyin həmin servonun çəkisini daşımaq məcburiyyətində qalmır.
- Bazada podşipnik istifadə et: Qolun bütün çəkisini baza servosunun valına yükləmə. 608 podşipnik (8 mm daxili diametr, 22 mm xarici diametr, 7 mm qalınlıq; skeyt podşipniki kimi tanınır) və ya fırlanan masa podşipniki yükü daşıyır, servo yalnız döndərir.
- Oynaqları iki tərəfdən dəstəklə: Servo oynağı horn tərəfdən tutarkən qarşı tərəfə M3 bolt və kontr-qayka ilə pim qoy. Beləliklə servonun valı əyilmə yükü almır və dişlilər daha uzun ömürlü olur.
- Metal horn istifadə et: MG996R üçün 25 dişli (25T) metal yumru horn tax və hornu ortadakı vint ilə vala bərkit. Plastik hornlar ağır oynaqlarda sürüşür və dişini itirir.
- Qısqac barmaqlarına rezin əlavə et: Barmaq uclarına nazik rezin zolaq yapışdırmaq əşyanı daha az sıxma qüvvəsi ilə sürüşmədən tutmağa kömək edir.
Servo seçimi: SG90, MG90S, yoxsa MG996R?
| Model | Tork | Sürət (60° üçün) | Çəki | Dişli | Kilidlənmə cərəyanı | Robot qoldakı yeri |
|---|---|---|---|---|---|---|
| SG90 | 1,8 kg·cm (4,8 V) | 0,10 san (4,8 V) | 9 g | Plastik | Təxminən 0,6–0,75 A | Qısqac, yüngül bilək, kiçik 4 oxlu qol |
| MG90S | 1,8 kg·cm (4,8 V), 2,2 kg·cm (6 V) | 0,10 san (4,8 V) | 13,4 q | Metal | Təxminən 0,7–1 A | Bilək, bilək fırlanması, qısqac |
| MG996R | 9,4 kg·cm (4,8 V), 11 kg·cm (6 V) | 0,17 san (4,8 V) | 55 g | Metal | 2,5 A (6 V) | Baza, çiyin, dirsək |
| DS3218 | 19 kg·cm (5 V), 21,5 kg·cm (6,8 V) | 0,16 san (5 V) | 60 g | Metal | Təxminən 2–3 A | Uzun və ya ağır qolların çiyni |
Cədvəldəki tork dəyəri kilidlənmə (stall) torkudur: servonun valını dayandırmazdan əvvəl verə bildiyi ən böyük qüvvədir, fasiləsiz işləyə biləcəyi dəyər deyil. Servo bu həddə yaxınlaşdıqca çəkdiyi cərəyan kilidlənmə cərəyanına qalxır, qızır və titrəməyə başlayır. Praktik qayda budur: oynaqda ehtiyac duyduğun tork servonun kilidlənmə torkunun ən çoxu yarısı olmalıdır. Gərginlik də vacibdir: MG996R 4,8 V-da 9,4 kg·cm, 6 V-da 11 kg·cm verir; yəni eyni servo yalnız qida gərginliyi ilə təxminən 17% güclənir. Buna görə MG996R-li qollarda 5 V əvəzinə 6 V qidalandırma məntiqlidir, amma SG90 və MG90S üçün 6 V yuxarı hədddir. MG996R-in qoşulması və limitləri üçün MG996R servo mühərrik yazısına da baxa bilərsən.

Tork hesabı: çiyin servosu bu qolu qaldıra bilərmi?
Servonun qaldırmalı olduğu tork, oynaqdan sonra gələn hər hissənin kütləsi ilə oynaq oxuna olan üfüqi məsafəsinin hasillərinin cəmidir: Tork (kg·cm) = Σ kütlə (kg) × məsafə (sm). Ən pis hal qolun tam üfüqi uzandığı andır, çünki bütün məsafələr ən böyük qiymətini alır; şaquli duran qolda bu qaldıraç qolu demək olar ki, sıfıra enir. Nəticəni nyuton metrə çevirmək üçün 0,098-ə vur (1 kg·cm ≈ 0,098 N·m). Nümunə olaraq çiyin–dirsək arası 12 sm, dirsək–bilək arası 12 sm, bilək ilə qısqac ucu arası 6 sm olan və dirsəyində MG996R olan masaüstü qolun çiyin yükünü hesablayaq; qısqac 50 qramlıq əşya tutur:
| Hissə | Kütlə | Çiyin oxuna məsafə | Tork |
|---|---|---|---|
| Üst qol hissələri (MDF və boltlar) | 40 g | 6 sm (ağırlıq mərkəzi) | 0,04 × 6 = 0,24 kg·cm |
| Dirsək servosu (MG996R) | 55 g | 12 cm | 0,055 × 12 = 0,66 kg·cm |
| Ön qol hissələri | 30 g | 18 cm | 0,03 × 18 = 0,54 kg·cm |
| Bilək servosu + qısqac (MG90S, SG90 və hissələr) | 50 g | 25 cm | 0,05 × 25 = 1,25 kg·cm |
| Tutulan əşya | 50 g | 30 cm | 0,05 × 30 = 1,50 kg·cm |
| Cəmi | 225 g | — | 4,19 kg·cm (≈ 0,41 N·m) |
Bu qol çiyində tərpənmədən dayananda 4,19 kg·cm tələb edir. Sürətlənmə və əyləcləmənin gətirdiyi əlavə yükü qarşılamaq və servonu kilidlənmə həddindən uzaq saxlamaq üçün bu dəyəri 2-yə vur: 8,4 kg·cm. Deməli, çiyin üçün ən azı bir MG996R lazımdır (4,8 V-da 9,4 kg·cm, 6 V-da 11 kg·cm); SG90 və ya MG90S-in 1,8–2,2 kg·cm-lik torku bu qolu yerindən belə tərpədə bilməz. Eyni hesabı dirsək üçün etsən, ön qol (0,03 × 6), bilək ilə qısqac (0,05 × 13) və əşya (0,05 × 18) cəmi 1,73 kg·cm, ehtiyat payı ilə 3,5 kg·cm edir; dirsək də MG996R tələb edir. Biləkdə yalnız qısqac və əşya qaldığı üçün yük təxminən 0,4 kg·cm-dir və MG90S rahat kifayət edir. Bu hesab qolun daşıya biləcəyi ən ağır əşyanı da deyir: əşyanın kütləsini artırıb cəmi yenidən hesabla və servonun yarım torkunu keçmə.
Qida mənbəyi: servolar niyə Arduino-dan qidalanmır?
Robot qol layihələrindəki problemlərin böyük hissəsi qidalandırmadan çıxır. MG996R hərəkət edərkən 0,5–0,9 A, çətinlik çəkəndə 2,5 A-ya qədər cərəyan çəkir; kiçik SG90 belə kilidlənəndə 0,6 A-dan çox çəkə bilər. Arduino Uno USB-dən qidalananda 5V pinindən ala biləcəyin ümumi cərəyan USB-nin həddi olan təxminən 500 mA-dır və bunun bir hissəsini platanın özü sərf edir. Üç böyük servo eyni anda işə düşəndə gərginlik bir anda düşür, mikrokontroller resetlənir və qol başlanğıc pozisiyasına atılır. Həll servoları ayrı 5–6 V mənbədən qidalandırmaq və bütün GND-ləri birləşdirməkdir; Arduino-nu USB-dən və ya öz adapterindən qidalandırmağa davam edə bilərsən. Mənbə seçimləri üçün Arduino qida təchizatı yazısına, batareya ilə işləyən qolun nə qədər dayanacağını təxmin etmək üçün isə batareya ömrü hesablama alətinə baxa bilərsən.
| Qol tipi | Təxmini cərəyan | Tövsiyə olunan mənbə |
|---|---|---|
| 4 ədəd SG90 və ya MG90S-li kiçik qol | Hərəkət edərkən 0,5–1 A, pik 2–3 A | 5 V 3 A adapter və ya LM2596 modulu (ən çoxu 3 A, radiatorsuz təxminən 2 A) |
| 3 MG996R + 3 MG90S-li 6 servolu qol | Hərəkət edərkən 2–3 A, hamısı çətinlik çəkəndə 8–10 A | 5–6 V, ən azı 5 A açarlayıcı adapter (rahat istifadə üçün 10 A) |
| Portativ qol | Qol tipinə görə | 2S LiPo (7,4 V) + 6 V-a tənzimlənmiş, 5 A və daha böyük endirici modul (UBEC) |
| Çəkinilməli mənbələr | — | 9 V-luq düzbucaqlı batareya (cərəyan verə bilmir), Arduino-nun 5V pini, MG996R-li qolda 4 ədəd AA qələvi batareya |
4 oxlu qol üçün dövrə qoşulması
Aşağıdakı cədvəl potensiometrli 4 oxlu qolun Arduino Uno və Raspberry Pi Pico ilə qoşulmasıdır; bu yazıdakı kodlar bu pinlərə görə yazılıb. Uno-da Servo kitabxanası istənilən rəqəmsal pindən servo sürə bilər, lakin kitabxana Timer1-dən istifadə etdiyi üçün servo qoşulu olanda 9 və 10 nömrəli pinlərdə analogWrite işləmir. Platanın pin yerləşməsini Pinout alətində görə bilərsən.
| Qoşulma | Arduino Uno | Raspberry Pi Pico |
|---|---|---|
| Baza servosu siqnal (narıncı naqil) | D3 | GP10 |
| Çiyin servosu siqnal | D5 | GP11 |
| Dirsək servosu siqnal | D6 | GP12 |
| Qısqac servosu siqnal | D9 | GP13 |
| Pot 1–3 orta ayaq (baza, çiyin, dirsək) | A0, A1, A2 | GP26, GP27, GP28 |
| Pot 4 orta ayaq (qısqac) | A3 | Yoxdur; qısqac GP14-dəki düymə ilə |
| Potun kənar ayaqları | 5V və GND | 3V3 və GND |
| Qeyd və oynat düymələri (digər ucu GND-yə) | D7 və D8 | — |
| Servo qırmızı naqil (+) | Xarici 5–6 V artı | Xarici 5–6 V artı |
| Servo qəhvəyi naqil (−) | Xarici mənbənin mənfisi + Arduino GND | Xarici mənbənin mənfisi + Pico GND |

Montajdan əvvəl kalibrləmə: servoları ortala
- Hornları taxmazdan əvvəl aşağıdakı kodu yüklə; dörd servo da ardıcıllıqla 90 dərəcəyə gedir və orada gözləyir.
- Qolu neytral pozisiyada saxla (məsələn, üst qol şaquli, ön qol üfüqi, qısqac yarıaçıq), hornları bu pozisiyaya ən yaxın dişə tax və ortadakı vint ilə bərkit.
- Koddakı CENTER_ONLY dəyərini false et, TEST ilə bir oynaq seç və A0-dakı potensiometri yavaşca çevir.
- Serial Monitor-da bucağı izlə; oynağın heç nəyə dəymədən və naqilləri dartmadan gedə bildiyi ən kiçik və ən böyük bucağı qeyd et.
- Qısqacın bağlı bucağını barmaqların bir-birinə yenicə toxunduğu an kimi müəyyən et; daha çox sıxmağa çalışan servo dayanmadan çətinlik çəkir və qızır.
- Tapdığın dəyərləri sonrakı kodlardakı MIN_A və MAX_A massivlərinə yaz.
1#include <Servo.h>
2
3const byte SERVO_PIN[4] = {3, 5, 6, 9}; // taban, omuz, dirsek, kıskaç / base, shoulder, elbow, gripper
4const byte TEST = 1; // denenecek servo (0–3) / servo under test (0–3)
5const bool CENTER_ONLY = true; // true: hepsi 90°'de bekler / true: all wait at 90°
6
7Servo servo[4];
8
9void setup() {
10 Serial.begin(9600);
11 for (byte i = 0; i < 4; i++) {
12 servo[i].write(90); // önce açıyı ver / set the angle first
13 servo[i].attach(SERVO_PIN[i]); // sonra bağla: zıplamaz / then attach: no jump
14 delay(300); // akım darbelerini ayır / spread the current surges
15 }
16}
17
18void loop() {
19 if (CENTER_ONLY) return; // korna takarken burada kal / stay here while fitting horns
20 int angle = map(analogRead(A0), 0, 1023, 0, 180); // A0'daki pot / pot on A0
21 servo[TEST].write(angle);
22 Serial.print(F("Servo "));
23 Serial.print(TEST);
24 Serial.print(F(" aci / angle: "));
25 Serial.println(angle); // sınırları buradan oku / read the limits here
26 delay(50);
27}Kodda kiçik, lakin vacib bir detal var: servo.write(90) komandası attach() çağırışından əvvəl verildiyi üçün servo ilk impulsda birbaşa istənilən bucağı alır. Sıra tərs olarsa, kitabxana əvvəlcə standart 1500 µs-lik impulsu (təxminən 90°) göndərir; başlanğıc bucağın 90-dan fərqlidirsə, qol açılışda əvvəlcə ortaya, sonra hədəfə atılır. Servoları aralarında 300 ms gözləyərək tək-tək başlatmaq açılışdakı ümumi cərəyan zərbəsini də bölür.
Potensiometrlərlə robot qolun idarəsi
Ən sezgisel idarə üsulu hər oynaq üçün bir potensiometr istifadə etməkdir: pot valı hansı bucaqdadırsa, oynaq da o bucağa gedir, yəni mövqe idarəsi edirsən. Potları qolun kiçik maketinə (eyni nisbətlərdə karton və ya 3D çap) yerləşdirsən, maketi əllə oynadanda böyük qol hərəkəti bir-bir təkrar edir. Analoq oxunuşlar isə təbiəti etibarilə bir neçə pillə yırğalanır və bu yırğalanma servoda titrəmə kimi görünür; kodda bunun üçün iki tədbir var.
1#include <Servo.h>
2
3const byte SERVO_PIN[4] = {3, 5, 6, 9}; // taban, omuz, dirsek, kıskaç / base, shoulder, elbow, gripper
4const byte POT_PIN[4] = {A0, A1, A2, A3}; // her eklem için bir pot / one pot per joint
5const byte MIN_A[4] = {0, 15, 20, 40}; // kalibrasyonda bulduğun alt sınırlar / lower limits from calibration
6const byte MAX_A[4] = {180, 165, 160, 110}; // üst sınırlar / upper limits
7
8Servo servo[4];
9float smooth[4]; // süzülmüş pot değeri / filtered pot value
10int lastAngle[4]; // son yazılan açı / last written angle
11
12void setup() {
13 for (byte i = 0; i < 4; i++) {
14 smooth[i] = analogRead(POT_PIN[i]);
15 lastAngle[i] = map((int)smooth[i], 0, 1023, MIN_A[i], MAX_A[i]);
16 servo[i].write(lastAngle[i]); // önce açı, sonra attach / angle first, then attach
17 servo[i].attach(SERVO_PIN[i]);
18 delay(300); // servolar sırayla uyansın / wake the servos one by one
19 }
20}
21
22void loop() {
23 for (byte i = 0; i < 4; i++) {
24 smooth[i] += (analogRead(POT_PIN[i]) - smooth[i]) * 0.2; // yumuşatma filtresi / low-pass filter
25 int angle = map((int)smooth[i], 0, 1023, MIN_A[i], MAX_A[i]);
26 if (abs(angle - lastAngle[i]) >= 2) { // ölü bant: küçük gürültüyü yok say / deadband: ignore small noise
27 servo[i].write(angle);
28 lastAngle[i] = angle;
29 }
30 }
31 delay(15);
32}smooth massivi sadə alçaq keçirən filtrdir: hər dövrdə yeni oxunuşun yalnız 20%-i əlavə olunur, beləliklə ani sıçrayışlar yumşalır, amma qol yenə də sürətlə reaksiya verir. 0.2 əvəzinə 0.1 yazsan, hərəkət daha yumşaq, lakin daha gecikmiş olar. İkinci tədbir ölü zonadır: yeni bucaq sonuncu yazılan bucaqdan ən azı 2 dərəcə fərqli deyilsə, servoya komanda göndərilmir və dayanan qoldakı titrəmə kəsilir. map() pot diapazonunu birbaşa hər oynağın təhlükəsiz hədlərinə çevirdiyi üçün pot sonuna qədər çevrilsə də oynaq mexaniki həddə dayanmır.
Hərəkətləri yadda saxlama və təkrar oynatma
Robot qolu həqiqətən robot edən xüsusiyyət, göstərdiyin hərəkəti özbaşına təkrarlamasıdır. Üsul sadədir: qolu potlarla bir pozisiyaya gətirib qeyd düyməsinə basırsan və Arduino dörd oynağın bucağını saxlayır. Bir neçə pozisiya yazdıqdan sonra oynat düyməsinə basanda qol pozisiyaları ardıcıllıqla, aralarındakı keçidi yumşaldaraq təkrar edir. Pozisiyalar Arduino Uno-nun 1024 baytlıq EEPROM yaddaşına yazıldığı üçün platanı söndürüb yandıranda da silinmir; hər pozisiya 4 bayt tutduğundan 100 pozisiyalıq qeyd yalnız 401 bayt yer tutur.
1#include <Servo.h>
2#include <EEPROM.h>
3
4const byte SERVO_PIN[4] = {3, 5, 6, 9}; // taban, omuz, dirsek, kıskaç / base, shoulder, elbow, gripper
5const byte POT_PIN[4] = {A0, A1, A2, A3};
6const byte MIN_A[4] = {0, 15, 20, 40}; // güvenli sınırlar / safe limits
7const byte MAX_A[4] = {180, 165, 160, 110};
8const byte BTN_REC = 7, BTN_PLAY = 8, LED = 13; // butonların diğer ucu GND'de / buttons go to GND
9const byte MAX_STEPS = 100; // 100 adım x 4 bayt = 400 bayt / 100 steps x 4 bytes
10
11Servo servo[4];
12float smooth[4]; // süzülmüş pot değeri / filtered pot value
13byte pos[4]; // servoların şu anki açısı / current servo angles
14byte stepCount; // kayıtlı adım sayısı / number of saved steps
15
16bool pressed(byte pin) { // basılıyken true / true while pressed
17 return digitalRead(pin) == LOW;
18}
19
20byte potAngle(byte i) {
21 smooth[i] += (analogRead(POT_PIN[i]) - smooth[i]) * 0.2; // yumuşatma / smoothing
22 return map((int)smooth[i], 0, 1023, MIN_A[i], MAX_A[i]);
23}
24
25void blink(byte n) {
26 for (byte k = 0; k < n; k++) {
27 digitalWrite(LED, HIGH); delay(80);
28 digitalWrite(LED, LOW); delay(80);
29 }
30}
31
32// Tüm eklemleri aynı anda hedefe götürür / moves all joints to the target together
33void moveTo(const byte target[4], byte msPerDegree) {
34 byte start[4];
35 int steps = 0;
36 for (byte i = 0; i < 4; i++) {
37 start[i] = pos[i];
38 int d = abs((int)target[i] - (int)start[i]);
39 if (d > steps) steps = d; // en uzun hareket / longest move
40 }
41 for (int s = 1; s <= steps; s++) {
42 for (byte i = 0; i < 4; i++) {
43 pos[i] = start[i] + (long)((int)target[i] - (int)start[i]) * s / steps; // ara açı / in-between angle
44 servo[i].write(pos[i]);
45 }
46 delay(msPerDegree);
47 }
48}
49
50void saveStep() {
51 if (stepCount >= MAX_STEPS) { blink(3); return; } // hafıza dolu / memory full
52 for (byte i = 0; i < 4; i++) EEPROM.update(1 + stepCount * 4 + i, pos[i]);
53 stepCount++;
54 EEPROM.update(0, stepCount); // 0. bayt adım sayısını tutar / byte 0 holds the step count
55 blink(1);
56}
57
58void playBack() {
59 byte target[4];
60 for (byte s = 0; s < stepCount; s++) {
61 for (byte i = 0; i < 4; i++) target[i] = EEPROM.read(1 + s * 4 + i);
62 moveTo(target, 12); // derece başına 12 ms / 12 ms per degree
63 delay(400); // her pozda kısa bekleme / short pause at each pose
64 if (pressed(BTN_PLAY)) break; // oynatırken basınca durur / press again to stop
65 }
66}
67
68void syncToPots() { // potların konumuna yumuşakça dön / ease back to the pots
69 byte target[4];
70 for (byte i = 0; i < 4; i++) {
71 smooth[i] = analogRead(POT_PIN[i]);
72 target[i] = map((int)smooth[i], 0, 1023, MIN_A[i], MAX_A[i]);
73 }
74 moveTo(target, 12);
75}
76
77void setup() {
78 pinMode(BTN_REC, INPUT_PULLUP);
79 pinMode(BTN_PLAY, INPUT_PULLUP);
80 pinMode(LED, OUTPUT);
81 stepCount = EEPROM.read(0);
82 if (stepCount > MAX_STEPS) stepCount = 0; // boş EEPROM 255 okur / a blank EEPROM reads 255
83 for (byte i = 0; i < 4; i++) {
84 smooth[i] = analogRead(POT_PIN[i]);
85 pos[i] = potAngle(i);
86 servo[i].write(pos[i]); // önce açı, sonra attach / angle first, then attach
87 servo[i].attach(SERVO_PIN[i]);
88 delay(300);
89 }
90}
91
92void loop() {
93 // Kayıt: kısa bas = pozu kaydet, 2 sn basılı tut = hepsini sil / Record: short press = save pose, hold 2 s = erase all
94 if (pressed(BTN_REC)) {
95 unsigned long t0 = millis();
96 while (pressed(BTN_REC) && millis() - t0 < 2000) {}
97 if (millis() - t0 >= 2000) {
98 stepCount = 0;
99 EEPROM.update(0, 0);
100 blink(5);
101 } else {
102 saveStep();
103 }
104 while (pressed(BTN_REC)) {} // bırakılmasını bekle / wait for release
105 delay(50); // buton arkı / debounce
106 }
107
108 // Oynat: kaydedilen pozları sırayla tekrarla / play: repeat the saved poses in order
109 if (pressed(BTN_PLAY) && stepCount > 0) {
110 while (pressed(BTN_PLAY)) {}
111 delay(50);
112 digitalWrite(LED, HIGH);
113 playBack();
114 while (pressed(BTN_PLAY)) {}
115 syncToPots();
116 digitalWrite(LED, LOW);
117 }
118
119 // Normal mod: kolu potlarla sür / normal mode: drive the arm with the pots
120 for (byte i = 0; i < 4; i++) {
121 byte a = potAngle(i);
122 if (abs((int)a - (int)pos[i]) >= 2) {
123 pos[i] = a;
124 servo[i].write(a);
125 }
126 }
127 delay(15);
128}| Əməliyyat | Nə edirsən? | Qol nə edir? |
|---|---|---|
| Pozisiyanı yadda saxlama | Qeyd düyməsinə (D7) qısa bas | LED bir dəfə yanıb-sönür, pozisiya EEPROM-a yazılır |
| Qeydləri silmə | Qeyd düyməsini 2 saniyə basılı saxla | LED beş dəfə yanıb-sönür, addım sayı sıfırlanır |
| Oynatma | Oynat düyməsinə (D8) bas və burax | LED yanır, pozisiyalar ardıcıllıqla və yumşaq keçidlə təkrarlanır |
| Oynatmanı dayandırma | Oynatma zamanı oynat düyməsini basılı saxla | Qol cari pozisiyanı bitirir və dayanır |
| Normal rejimə qayıtma | Oynatma bitəndə heç nə etmə | Qol yavaşca potların göstərdiyi mövqeyə qayıdır, LED sönür |
moveTo() funksiyası kodun ürəyidir: ən uzun yol gedəcək oynağı tapır, hərəkəti o qədər addıma bölür və hər addımda bütün oynaqları mütənasib şəkildə irəli aparır. Beləliklə oynaqlar hədəfə eyni anda çatır və qol oynaqlarını tək-tək tərpədən robot kimi deyil, axıcı hərəkətlə gedir. Hər dərəcə üçün 12 ms, 90 dərəcəlik hərəkətin təxminən 1,1 saniyə çəkməsi deməkdir. Daha sürətli təkrar üçün bu dəyəri azalda bilərsən, amma MG996R yüksüz olanda belə 60 dərəcəni 0,17 saniyədə, yəni dərəcə başına təxminən 3 ms-də dönür; bunun altına enərsən, servolar komandalara çatmır və hərəkət sarsıntılı olur.
PCA9685 servo sürücü: 6 servo və titrəməsiz siqnal
Servo sayı 5–6-ya çatanda və ya Bluetooth kimi əlavə modullar qoşanda PCA9685 modulu işini çox asanlaşdırır. Bu modul 16 kanallı, 12 bit ayırdetməli PWM generatorudur; Arduino ilə yalnız iki naqillə, I2C üzərindən danışır və servo impulslarını öz saatı ilə, prosessordan asılı olmadan yaradır. Standart ünvanı 0x40-dır; modulun üzərindəki A0–A5 lehim körpüləri ilə ünvanı dəyişərək 62 modula, yəni 992 servoya qədər çata bilərsən. 50 Hz-də 20 ms-lik period 4096 hissəyə bölündüyü üçün bir addım təxminən 4,9 µs-dir; 544–2400 µs aralığı təxminən 380 addım edir, bu da yarım dərəcəyə yaxın ayırdetmə deməkdir.
| PCA9685 pini | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| GND | GND | GND | GND |
| VCC (yalnız çipin qidası) | 5V | 3V3 | 3V3 |
| SDA | A4 | GPIO 21 | GP4 |
| SCL | A5 | GPIO 22 | GP5 |
| V+ klemmi (servo qidası) | Xarici 5–6 V | Xarici 5–6 V | Xarici 5–6 V |
| OE | Boş burax | Boş burax | Boş burax |
| Servo konnektorları 0–5 | Baza, çiyin, dirsək, bilək, bilək fırlanması, qısqac | Eyni ardıcıllıq | Eyni ardıcıllıq |
Coystiklə robot qolun idarəsi
Coystik potensiometrdən fərqli işləyir: buraxılanda ortaya qayıdır. Bucağı birbaşa coystikin mövqeyinə bağlasan, buraxdığın an oynaq 90 dərəcəyə atılır. Düzgün üsul sürət idarəsidir: coystiki nə qədər itələsən oynaq o qədər sürətli dönür, buraxanda olduğu yerdə qalır. Aşağıdakı kodda iki coystik dörd oynağı sürür (sol coystik baza və çiyin, sağ coystik dirsək və bilək); sol coystikin düyməsi qısqacı açıb-bağlayır, sağdakı isə qolu başlanğıc pozisiyaya aparır. Sol coystikin VRx və VRy çıxışlarını A0 və A1-ə, sağ coystikin VRy və VRx çıxışlarını A2 və A3-ə, SW pinlərini D2 və D4-ə qoş; coystikləri Arduino-nun 5V pinindən qidalandıra bilərsən. Kodu kompilyasiya etmək üçün Library Manager-dən Adafruit PWM Servo Driver Library kitabxanasını quraşdır və Adafruit BusIO asılılığını da qəbul et.

1#include <Wire.h>
2#include <Adafruit_PWMServoDriver.h>
3
4Adafruit_PWMServoDriver pca = Adafruit_PWMServoDriver(0x40); // varsayılan adres / default address
5
6// Kanal: 0 taban, 1 omuz, 2 dirsek, 3 bilek, 4 bilek dönüşü, 5 kıskaç / Channel: 0 base, 1 shoulder, 2 elbow, 3 wrist, 4 wrist roll, 5 gripper
7const byte N = 6;
8const float MIN_A[N] = {0, 15, 20, 10, 0, 40}; // güvenli sınırlar / safe limits
9const float MAX_A[N] = {180, 165, 160, 170, 180, 110};
10const float HOME[N] = {90, 90, 90, 90, 90, 40}; // başlangıç pozu, kıskaç açık / home pose, gripper open
11const byte JOY[4] = {A0, A1, A2, A3}; // J1 X, J1 Y, J2 Y, J2 X → kanal / channel 0, 1, 2, 3
12const int8_t DIR[4] = {1, -1, 1, 1}; // ters giden ekseni -1 yap / set -1 to invert an axis
13const byte BTN_GRIP = 2, BTN_HOME = 4; // joystick SW pinleri / joystick SW pins
14const float MAX_SPEED = 90; // en yüksek hız, derece/sn / top speed, degrees/s
15const float DT = 0.02; // 20 ms döngü / 20 ms loop
16const int DEADZONE = 60; // ortadaki ölü bölge / dead zone around center
17
18float target[N], current[N];
19bool gripClosed = false;
20
21void writeServo(byte ch, float a) {
22 // Servo.h ile aynı 544–2400 µs aralığı / same 544–2400 µs range as Servo.h
23 pca.writeMicroseconds(ch, (uint16_t)(544 + a * (2400 - 544) / 180.0));
24}
25
26bool newPress(byte pin, byte k) { // her basışta bir kez true / true once per press
27 static bool prev[2] = {HIGH, HIGH};
28 bool now = digitalRead(pin);
29 bool edge = (prev[k] == HIGH && now == LOW);
30 prev[k] = now;
31 return edge;
32}
33
34void setup() {
35 pinMode(BTN_GRIP, INPUT_PULLUP);
36 pinMode(BTN_HOME, INPUT_PULLUP);
37 pca.begin();
38 pca.setOscillatorFrequency(27000000); // çoğu modülde ~27 MHz / ~27 MHz on most boards
39 pca.setPWMFreq(50); // servolar için 50 Hz / 50 Hz for servos
40 Wire.setClock(400000); // hızlı I2C / fast I2C
41 for (byte i = 0; i < N; i++) {
42 target[i] = current[i] = HOME[i];
43 writeServo(i, HOME[i]);
44 delay(300); // servolar sırayla uyansın / wake servos one by one
45 }
46}
47
48void loop() {
49 static unsigned long last = 0;
50 if (millis() - last < 20) return; // 50 Hz güncelleme / 50 Hz update
51 last = millis();
52
53 // Joystick hızı belirler, konumu değil / the joystick sets speed, not position
54 for (byte i = 0; i < 4; i++) {
55 int v = analogRead(JOY[i]) - 512;
56 if (abs(v) > DEADZONE) {
57 target[i] += DIR[i] * (v / 512.0) * MAX_SPEED * DT;
58 target[i] = constrain(target[i], MIN_A[i], MAX_A[i]);
59 }
60 }
61 if (newPress(BTN_GRIP, 0)) { // kıskaç aç/kapa / toggle gripper
62 gripClosed = !gripClosed;
63 target[5] = gripClosed ? MAX_A[5] : MIN_A[5];
64 }
65 if (newPress(BTN_HOME, 1)) { // başlangıç pozuna dön / go to home pose
66 for (byte i = 0; i < N; i++) target[i] = HOME[i];
67 gripClosed = false;
68 }
69
70 // Her eklem hedefe hız sınırıyla gider / each joint follows its target with a speed limit
71 for (byte i = 0; i < N; i++) {
72 float d = constrain(target[i] - current[i], -MAX_SPEED * DT, MAX_SPEED * DT);
73 if (d != 0) {
74 current[i] += d;
75 writeServo(i, current[i]);
76 }
77 }
78}DEADZONE coystik ortada olanda oxunan 490–530 kimi kiçik sapmaların qolu öz-özünə sürüşdürməsinin qarşısını alır. MAX_SPEED coystik sonuna qədər itələnəndə sürəti dərəcə/saniyə ilə müəyyən edir; 90 dərəcə/saniyə ilk sınaqlar üçün təhlükəsizdir. Bir oynaq coystikin əksinə gedirsə, naqilləri dəyişmə, DIR massivindəki müvafiq dəyəri -1 et. Kod hər oynaq üçün bir hədəf (target) və bir faktiki mövqe (current) saxlayır; faktiki mövqe hədəfə sürət limiti ilə yaxınlaşdığı üçün başlanğıc pozisiyası düyməsinə basılanda belə qol sıçramadan, axıcı şəkildə dönür. Bilək fırlanması bu kodda 90 dərəcədə sabit qalır; onu Bluetooth bölməsindəki R komandası ilə idarə edə bilərsən. Gözləmədən işləyən bu zamanlama üsulunun təfərrüatı millis() və delay() yazısındadır.
Telefondan Bluetooth idarəsi (HC-05)
HC-05 modulu telefonla Arduino arasında simsiz serial xətt qurur. Modulun TXD pini Arduino-nun D10-una, RXD pini isə gərginlik bölücü üzərindən D11-ə qoşulur: D11 → 1 kΩ → RXD → 2 kΩ → GND. Bölücü Arduino-nun 5 V-luq siqnalını HC-05-in gözlədiyi təxminən 3,3 V-a endirir. Modulun standart məlumat sürəti 9600 baud, cütləşdirmə şifrəsi adətən 1234-dür. Telefon sadə mətn komandaları göndərir: bir hərf oynağı seçir, ardınca gələn rəqəm bucağı verir, sətir sonu ya da nöqtəli vergül komandanı bitirir.

| Komanda | Mənası | Nümunə |
|---|---|---|
| B + bucaq | Baza | B90 |
| S + bucaq | Çiyin | S120 |
| E + bucaq | Dirsək | E45 |
| W + bucaq | Bilək (yuxarı-aşağı) | W100 |
| R + bucaq | Bilək fırlanması | R0 |
| G + bucaq | Qısqac | G110 (bağla), G40 (aç) |
| H | Başlanğıc pozisiyaya qayıt | H |
| K / P / X / C | Pozisiyanı yadda saxla / dövrlə oynat / dayandır / qeydləri sil | K |
1#include <Wire.h>
2#include <SoftwareSerial.h>
3#include <Adafruit_PWMServoDriver.h>
4
5SoftwareSerial bt(10, 11); // D10 ← HC-05 TXD, D11 → bölücü / divider → HC-05 RXD
6Adafruit_PWMServoDriver pca = Adafruit_PWMServoDriver(0x40);
7
8const byte N = 6;
9const char NAME[N] = {'B', 'S', 'E', 'W', 'R', 'G'}; // taban, omuz, dirsek, bilek, dönüş, kıskaç / base, shoulder, elbow, wrist, roll, gripper
10const byte MIN_A[N] = {0, 15, 20, 10, 0, 40}; // güvenli sınırlar / safe limits
11const byte MAX_A[N] = {180, 165, 160, 170, 180, 110};
12const byte HOME[N] = {90, 90, 90, 90, 90, 40};
13const byte MAX_POSES = 30;
14const float SPEED = 1.5; // 20 ms'de en fazla 1,5° (75°/sn) / max 1.5° per 20 ms (75°/s)
15
16float current[N];
17byte target[N];
18byte poses[MAX_POSES][N]; // kaydedilen pozlar (RAM) / recorded poses (RAM)
19byte poseCount = 0, playIndex = 0;
20bool playing = false;
21char buf[12];
22byte len = 0;
23
24void writeServo(byte ch, float a) {
25 pca.writeMicroseconds(ch, (uint16_t)(544 + a * (2400 - 544) / 180.0)); // 544–2400 µs
26}
27
28void handle(char *cmd) { // ör. / e.g. "S120", "H", "K", "P"
29 char c = toupper(cmd[0]);
30 if (c == 'H') { // başlangıç pozu / home pose
31 for (byte i = 0; i < N; i++) target[i] = HOME[i];
32 playing = false;
33 } else if (c == 'K') { // pozu kaydet / save pose
34 if (poseCount < MAX_POSES) {
35 for (byte i = 0; i < N; i++) poses[poseCount][i] = target[i];
36 poseCount++;
37 }
38 bt.print(F("Poz / pose: "));
39 bt.println(poseCount);
40 } else if (c == 'P') { // döngüyle oynat / play in a loop
41 if (poseCount > 0) { playing = true; playIndex = 0; }
42 } else if (c == 'X') { // durdur / stop
43 playing = false;
44 } else if (c == 'C') { // kayıtları sil / clear poses
45 poseCount = 0;
46 playing = false;
47 } else {
48 for (byte i = 0; i < N; i++) {
49 if (c == NAME[i]) {
50 target[i] = constrain(atoi(cmd + 1), MIN_A[i], MAX_A[i]);
51 playing = false; // elle komut oynatmayı keser / a manual command stops playback
52 }
53 }
54 }
55}
56
57bool arrived() {
58 for (byte i = 0; i < N; i++)
59 if (fabs(target[i] - current[i]) > 0.5) return false;
60 return true;
61}
62
63void setup() {
64 bt.begin(9600); // HC-05 varsayılan hızı / HC-05 default baud
65 pca.begin();
66 pca.setOscillatorFrequency(27000000);
67 pca.setPWMFreq(50);
68 for (byte i = 0; i < N; i++) {
69 target[i] = HOME[i];
70 current[i] = HOME[i];
71 writeServo(i, HOME[i]);
72 delay(300); // servolar sırayla uyansın / wake servos one by one
73 }
74}
75
76void loop() {
77 // Komutları satır satır topla / collect commands line by line
78 while (bt.available()) {
79 char ch = bt.read();
80 if (ch == '\n' || ch == '\r' || ch == ';') {
81 if (len > 0) { buf[len] = '\0'; handle(buf); len = 0; }
82 } else if (len < sizeof(buf) - 1) {
83 buf[len++] = ch;
84 }
85 }
86
87 static unsigned long last = 0, arrivedAt = 0;
88 if (millis() - last < 20) return; // 50 Hz güncelleme / 50 Hz update
89 last = millis();
90
91 if (playing) {
92 if (!arrived()) arrivedAt = millis(); // hareket sürüyor / still moving
93 else if (millis() - arrivedAt > 300) { // her pozda 300 ms bekle / hold each pose 300 ms
94 for (byte i = 0; i < N; i++) target[i] = poses[playIndex][i];
95 playIndex = (playIndex + 1) % poseCount; // sona gelince başa dön / wrap around
96 arrivedAt = millis();
97 }
98 }
99
100 for (byte i = 0; i < N; i++) {
101 float d = constrain(target[i] - current[i], -SPEED, SPEED); // hız sınırı / speed limit
102 if (d != 0) {
103 current[i] += d;
104 writeServo(i, current[i]);
105 }
106 }
107}Bu kodda servolar birbaşa Arduino-ya deyil, PCA9685-ə qoşulub və bu şüurlu seçimdir. SoftwareSerial hər baytı qəbul edərkən kəsmələri təxminən 1 ms söndürür; servolar Servo kitabxanası ilə Arduino pinlərindən sürülsəydi, bu zaman impuls müddətləri uzanar və qol hər komandada səyrərdi. PCA9685 impulsları özü yaratdığı üçün Bluetooth trafiki nə qədər sıx olsa da siqnal titrəmir. Qeyd və oynatma da artıq telefondan edilir: qolu sürüşdürücülərlə bir pozisiyaya gətirib K göndərirsən, bir neçə pozisiyadan sonra P ilə qol bu pozisiyaları dövr şəklində təkrarlayır, X ilə dayanır. Pozisiyalar bu versiyada RAM-da saxlanır və plata söndükdə silinir; daimi olmalarını istəsən, əvvəlki koddakı EEPROM üsulunu əlavə edə bilərsən.
ESP32 ilə simsiz robot qol
ESP32-nin içində klassik Bluetooth olduğu üçün HC-05-ə ehtiyac qalmır: BluetoothSerial kitabxanası ilə plata telefonda "BlueGrays-RobotKol" adı ilə görünür və eyni komandaları başa düşür. PCA9685-i GPIO 21 (SDA) və GPIO 22 (SCL) pinlərinə qoş, VCC-ni 3V3-dən qidalandır; servo siqnalları 3,3 V səviyyəsində çıxır və servoların böyük əksəriyyəti bunu problemsiz qəbul edir. BluetoothSerial yalnız klassik ESP32-də (ESP32-WROOM-32, DevKit) işləyir; ESP32-S2, S3 və C3 klassik Bluetooth-u dəstəkləmir.
1#include <Wire.h>
2#include <BluetoothSerial.h>
3#include <Adafruit_PWMServoDriver.h>
4
5BluetoothSerial bt; // klasik Bluetooth SPP / classic Bluetooth SPP
6Adafruit_PWMServoDriver pca = Adafruit_PWMServoDriver(0x40);
7
8const int N = 6;
9const char NAME[N] = {'B', 'S', 'E', 'W', 'R', 'G'}; // taban, omuz, dirsek, bilek, dönüş, kıskaç / base, shoulder, elbow, wrist, roll, gripper
10const int MIN_A[N] = {0, 15, 20, 10, 0, 40};
11const int MAX_A[N] = {180, 165, 160, 170, 180, 110};
12const int HOME[N] = {90, 90, 90, 90, 90, 40};
13float current[N], target[N];
14String line;
15
16void writeServo(int ch, float a) {
17 pca.writeMicroseconds(ch, (uint16_t)(544 + a * (2400 - 544) / 180.0)); // 544–2400 µs
18}
19
20void handle(String cmd) { // ör. / e.g. "E45", "H"
21 cmd.trim();
22 if (cmd.length() == 0) return;
23 char c = toupper(cmd[0]);
24 if (c == 'H') {
25 for (int i = 0; i < N; i++) target[i] = HOME[i];
26 return;
27 }
28 int value = cmd.substring(1).toInt();
29 for (int i = 0; i < N; i++)
30 if (c == NAME[i]) target[i] = constrain(value, MIN_A[i], MAX_A[i]);
31}
32
33void setup() {
34 Serial.begin(115200);
35 bt.begin("BlueGrays-RobotKol"); // telefonda görünen ad / name shown on the phone
36 Wire.begin(21, 22); // SDA = GPIO 21, SCL = GPIO 22
37 pca.begin();
38 pca.setOscillatorFrequency(27000000);
39 pca.setPWMFreq(50);
40 for (int i = 0; i < N; i++) {
41 current[i] = target[i] = HOME[i];
42 writeServo(i, HOME[i]);
43 delay(300);
44 }
45 Serial.println("Bluetooth hazir / ready");
46}
47
48void loop() {
49 while (bt.available()) {
50 char ch = bt.read();
51 if (ch == '\n' || ch == ';') { handle(line); line = ""; }
52 else if (line.length() < 12) line += ch;
53 }
54
55 static unsigned long last = 0;
56 if (millis() - last < 20) return; // 50 Hz güncelleme / 50 Hz update
57 last = millis();
58 for (int i = 0; i < N; i++) {
59 float d = constrain(target[i] - current[i], -1.5f, 1.5f); // yumuşak hareket / smooth motion
60 if (d != 0) {
61 current[i] += d;
62 writeServo(i, current[i]);
63 }
64 }
65}Raspberry Pi Pico (MicroPython) ilə robot qol
Raspberry Pi Pico-da servo sürmək üçün əlavə kitabxana lazım deyil: PWM-i 50 Hz-ə tənzimləyib impuls enini duty_ns() ilə nanosaniyə ilə verirsən. Pico-nun 16 PWM kanalı olduğu üçün 6 servonu birbaşa sürə bilər; eyni dilimi (slice) paylaşan pin cütlərinin tezliyi ortaqdır, amma bütün servolar 50 Hz istifadə etdiyi üçün bu problem yaratmır. Məhdudiyyət analoq tərəfdədir: Pico-da istifadə oluna bilən yalnız üç ADC pini (GP26, GP27, GP28) var. Buna görə aşağıdakı kodda üç oynaq potla sürülür, qısqac isə GP14-dəki düymə ilə açılıb-bağlanır. Pico 3,3 V ilə işlədiyi üçün potları 3V3-ə qoş; servoları yenə xarici 5 V mənbədən qidalandır.
1from machine import Pin, PWM, ADC
2import time
3
4# Servo pinleri: taban, omuz, dirsek, kıskaç / servo pins: base, shoulder, elbow, gripper
5servos = [PWM(Pin(p)) for p in (10, 11, 12, 13)]
6for s in servos:
7 s.freq(50) # 50 Hz servo sinyali / 50 Hz servo signal
8
9pots = [ADC(26), ADC(27), ADC(28)] # Pico'da 3 ADC pini var / the Pico has 3 ADC pins
10button = Pin(14, Pin.IN, Pin.PULL_UP) # kıskaç butonu GND'ye / gripper button to GND
11
12MIN_A = (0, 15, 20, 40) # güvenli sınırlar / safe limits
13MAX_A = (180, 165, 160, 110)
14
15def write(i, angle):
16 angle = max(MIN_A[i], min(MAX_A[i], angle))
17 servos[i].duty_ns(544000 + int(angle * 10311)) # 544–2400 µs aralığı / 544–2400 µs range
18
19smooth = [p.read_u16() for p in pots]
20grip_closed = False
21last_btn = 1
22write(3, MIN_A[3]) # kıskaç açık başlar / gripper starts open
23
24while True:
25 for i in range(3):
26 smooth[i] += (pots[i].read_u16() - smooth[i]) * 0.2 # yumuşatma / smoothing
27 write(i, MIN_A[i] + (MAX_A[i] - MIN_A[i]) * smooth[i] / 65535)
28 b = button.value()
29 if b == 0 and last_btn == 1: # yeni basış / new press
30 grip_closed = not grip_closed
31 write(3, MAX_A[3] if grip_closed else MIN_A[3])
32 last_btn = b
33 time.sleep_ms(20) # 50 Hz döngü / 50 Hz loopBir addım irəli: tərs kinematika
İndiyə qədər hər oynağın bucağını tək-tək verdik; buna düz kinematika deyilir. Tərs kinematika əksini edir: qısqacın getməsini istədiyin nöqtəni (x, y) verirsən, kod lazım olan oynaq bucaqlarını hesablayır. Çiyin–dirsək uzunluğu L1, dirsək–bilək uzunluğu L2 olan iki hissəli qolda əvvəlcə D = (x² + y² − L1² − L2²) / (2·L1·L2) tapılır. Dirsək bucağı θ2 = acos(D), çiyin bucağı θ1 = atan2(y, x) + atan2(L2·sin θ2, L1 + L2·cos θ2) olur (dirsək yuxarıda həlli). Məsələn, L1 = L2 = 12 sm olanda çiyinin 15 sm qarşısındakı və 5 sm yuxarısındakı nöqtə üçün D ≈ −0,13, θ2 ≈ 97,6° və θ1 ≈ 67,2° çıxır: üst qol üfüqdən 67 dərəcə yuxarı baxır, ön qol isə üst qola nisbətən 97,6 dərəcə aşağı bükülür. D-nin mütləq qiyməti 1-dən böyükdürsə, nöqtə qolun çatma zonasından kənardadır. Baza bucağı hədəfin yuxarıdan görünüşdəki mövqeyindən ayrıca hesablanır. Hesablanmış bucaqları servo bucağına çevirəndə hər servonun taxılma istiqamətini və orta nöqtəsini nəzərə almalısan.
Titrəmə və resetlənmə: tez-tez rast gəlinən xətalar və həlləri
| Əlamət | Mümkün səbəb | Həll |
|---|---|---|
| Qol dayananda servolar titrəyir, vızıldayır | Pot oxunuşlarındakı küy ya da zəif qidalandırma | Yumşaltma filtri və 2°-lik ölü zona əlavə et, xarici mənbə və 1000 µF kondensator istifadə et |
| Qol hərəkət edəndə Arduino resetlənir, HC-05 əlaqəsi qopur | Servoların işə düşmə cərəyanı gərginliyi aşağı salır | Servoları ayrı 5–6 V mənbədən qidalandır, GND-ləri birləşdir, servoları açılışda ardıcıllıqla başlat |
| Bluetooth komandası gələndə servolar səyrir | SoftwareSerial kəsmələri Servo kitabxanasının impulslarını pozur | Servoları PCA9685-ə köçür ya da ESP32-nin daxili Bluetooth-undan istifadə et |
| Açılışda qol sürətlə bir yerə atılır | Servolar son mövqelərini bilmir, ilk komandada tam sürətlə gedir | Qolu söndürməzdən əvvəl başlanğıc pozisiyaya gətir, write() komandasını attach()-dan əvvəl ver |
| Çiyin qolu qaldıra bilmir ya da yavaşca çökür | Tork çatmır | Tork hesabını et; MG996R, daha qısa qol, əks çəki ya da yay istifadə et |
| Bir oynaq uçda ilişib qızır | Servo mexaniki həddə dirənir | Kalibrləmədə tapdığın MIN_A və MAX_A hədlərini koda yaz |
| Qısqac əşyanı tutarkən servo qızır | Qısqac bağlanmağa çalışmağa davam edir, servo kilidli qalır | Bağlı bucağı əşyaya yenicə toxunduğu dəyərə tənzimlə, barmaqlara rezin əlavə et |
| PCA9685 qoşuludur, amma servolar heç dönmür | V+ klemminə qida verilməyib ya da GND ümumi deyil | V+ girişinə 5–6 V ver, I2C ünvanını (0x40) yoxla |
| Oynaq yük altında sürüşür | Plastik horn dişi soyub ya da ortadakı vint taxılmayıb | Metal horn istifadə et, hornu ortadakı vint ilə vala bərkit |
Robot qolla layihə ideyaları
- Rəngə görə ayıran qol: TCS3200 rəng sensoru ilə kubların rəngini oxu, qol hər rəngi öz qutusuna qoysun.
- Əl hərəkəti ilə idarə: Əlcəyə taxılan MPU6050 ilə biləyini əyəndə robot qol da eyni istiqamətə əyilsin.
- Simsiz pult: İki coystiki ayrı Arduino-ya qoş və komandaları nRF24L01 ilə göndər; telefona ehtiyac duymayan uzaqdan idarəetmə pultu əldə edirsən.
- Brauzerdən idarə: ESP32 ilə veb səhifədə sürüşdürücülər yarat və qolu eyni Wi-Fi şəbəkəsindəki hər cihazdan idarə et; ESP32 WebSocket gecikməni minimuma endirir.
- Lentdən götürmə: Step mühərriki ilə kiçik konveyer lenti düzəlt; TCRT5000 əşyanı görəndə qol onu lentdən götürsün.
- Müsabiqə və məktəb layihəsi: Qeyd et-oynat xüsusiyyətli qol, elmi layihə ideyaları arasında mexanikanı, elektronikanı və proqramı birlikdə göstərən güclü seçimdir.
Arduino robot qol; mexaniki dizaynı, tork hesabını, qida idarəsini və yumşaq hərəkət kodlaşdırmasını eyni anda öyrədən, zəhmət verdikcə böyüyən layihədir. 4 servolu, potensiometrli qolla başla, qeyd et-oynat xüsusiyyətini əlavə et, sonra PCA9685 və Bluetooth ilə 6 servoya çıx. BlueGrays tətbiqində potensiometr və coystiklə servo idarəsi, telefondan Bluetooth idarəsi və 32 servolu xoreoqrafiya kimi layihələri dövrə sxemləri və addım-addım kodları ilə tapa, qolunun hər oynağını əvvəlcə tək-tək sına bilərsən.
Tez-tez verilən suallar
Arduino robot qol üçün hansı servo mühərrikdən istifadə etməli?
Baza, çiyin və dirsək kimi yük daşıyan oynaqlar üçün metal dişli və 9–11 kg·cm torklu MG996R yaxşı seçimdir. Bilək və qısqac kimi yüngül oynaqlarda MG90S və ya SG90 kifayətdir. Yalnız SG90-larla qurulan kiçik qollar qısa və yüngül saxlanılsa işləyir, amma ancaq bir neçə on qramlıq əşyaları qaldıra bilir.
Robot qol üçün neçə amperlik adapter lazımdır?
4 ədəd SG90 və ya MG90S istifadə edən kiçik qol üçün 5 V 3 A adapter kifayətdir. 3 MG996R və 3 kiçik servodan ibarət 6 servolu qolda ən azı 5 A, rahat istifadə üçün 10 A-lik 5–6 V açarlayıcı adapter tövsiyə olunur. Adapterin mənfisini Arduino-nun GND-sinə qoşmağı unutma.
Arduino-ya neçə servo mühərrik qoşmaq olar?
Servo kitabxanası Arduino Uno-da 12, Mega-da 48 servoya qədər sürə bilər. Əsas limit isə cərəyandır; servoların hamısı xarici mənbədən qidalanmalıdır. Bir PCA9685 modulu yalnız iki I2C pini istifadə edərək 16 servo sürür və 62 modula qədər zəncirlənə bilər.
Robot qolun servoları niyə titrəyir?
Ən çox rast gəlinən səbəblər qida mənbəyinin zəifliyi, ümumi GND-nin olmaması və potensiometr oxunuşlarındakı küydür. Xarici mənbə və servo xəttinə 1000 µF kondensator istifadə et, kodda yumşaltma filtri və ölü zona tətbiq et. SoftwareSerial ilə Servo kitabxanası birlikdə istifadə olunursa, servoları PCA9685-ə köçürmək titrəməni tamamilə kəsir.
SG90 servolu robot qol nə qədər çəki qaldırır?
SG90-ın kilidlənmə torku təxminən 1,8 kg·cm-dir; təhlükəsiz istifadə üçün bunun yarısını, yəni 0,9 kg·cm-i hesaba qat. Qolun və servoların öz çəkisi də bu büdcədən sərf olunduğu üçün 15 sm civarında SG90-lı qol praktikada yalnız 20–30 qramlıq yüngül əşyaları, məsələn, şüşə qapağını ya da kiçik köpük kubu daşıya bilər.
Robot qolu telefondan necə idarə etmək olar?
Arduino-ya HC-05 Bluetooth modulu qoşulur və telefondakı Bluetooth serial terminal ya da sürüşdürücülü idarəetmə tətbiqi "S120" kimi mətn komandaları göndərir. ESP32 istifadə edirsənsə, daxili Bluetooth sayəsində əlavə modul lazım olmur. HC-05 iPhone ilə işləmədiyindən iPhone üçün BLE dəstəkli modul ya da ESP32 BLE lazımdır.
Bu yazıdan sonra edə biləcəyin layihələr
Bütün layihələrə bax
Potensiometrlə servo mühərrikdən istifadə
Potensiometrin düyməsini çevirdikcə servo mühərrikin qolu da onunla birlikdə dönür; düymənin bir ucu sıfır dərəcəyə, o biri ucu yarım dövrəyə uyğundur.

Coystiklə servo idarəsi
Coystik çubuğu ilə iki mühərriki idarə et, sanki təhlükəsizlik kamerasını çevirirsən.

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.

ESP32 servo mühərrik (potensiometrlə idarə)
Bu layihədə potensiometrlə SG90 servo mühərrikini idarə edirik. Potensiometrdən oxunan analoq dəyəri 0-180 dərəcə aralığına map-ləyərək servo bucağını tənzimləyirik. ESP32Servo kitabxanası ESP32-nin çıxış verə bilən uyğun GPIO-larında servo siqnalı yaradır; bu layihədə GPIO 18 istifadə olunur. Bu, robot qollar, kamera gimbal-ları və avtomatik qapı mexanizmləri üçün əsas idarəetmə üsuludur.

Bluetooth ilə telefondan LED yandırma
Telefonundan otaqdakı işıqları yandırıb söndürməyin kiçik bir sınağı. Bluetooth modulu telefondan gələn hərfləri Arduino-ya ötürür; bir hərf qırmızı LED-i, başqa hərf yaşıl LED-i yandırır, eyni…

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 çevrə xoreoqrafiyası — 32 servo ilə animasiyalı naxışlar
Arduino Mega üzərində çevrə şəklində düzülmüş 32 servo mühərriklə işləyən vizual animasiya layihəsi. Servolar tək massivdə idarə olunur, Mega-nın 22–53 nömrəli pinlərinə qoşulur və dörd hərəkət ardıcıllığı nümayiş etdirir: təsadüfi bucaqlarla xaotik titrəmə, sinxron süpürmə, çevrə boyunca fırlanan dalğa və sağa-sola yırğalanan kompas əqrəbi.
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ç

