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

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.

SG90
SG90
MG90S
MG90S
MG996R
MG996R

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.

OynaqHərəkətiYük vəziyyətiTövsiyə olunan servo
Baza (bel)Qolu sağa-sola döndərirÇəki qaldırmır, amma bütün qolu daşıyırMG996R + podşipnik
ÇiyinQolu irəli və geri qaldırırƏn çox yüklənən oynaqMG996R və ya 20 kg·cm sinifli servo
DirsəkÖn qolu bükürOrta-yüksəkMG996R
Bilək (yuxarı-aşağı)Qısqacın bucağını tənzimləyirAş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ırSıxma qüvvəsiSG90 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 qol6 servolu qolQeyd
İdarəetmə platasıArduino Uno və ya NanoArduino Uno, Nano və ya ESP32Nano-nun əlavə A6 və A7 girişləri potların sayını artırır
Servo mühərrik4 ədəd SG90 və ya MG90S3 ədəd MG996R + 3 ədəd MG90SSeçimini aşağıdakı tork hesabı ilə yoxla
Servo sürücüLazım deyilPCA9685 16 kanallı modulI2C ilə yalnız 2 siqnal naqili
Qida mənbəyi5 V 3 A adapter5–6 V, ən azı 5 A adapterServolar Arduino-dan qidalanmır
Kondensator470–1000 µF, 16 V1000–2200 µF, 16 VServo qida xəttinə, qütbə diqqət edərək
İdarəetmə elementi4 ədəd 10 kΩ potensiometr2 ə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ətdirINPUT_PULLUP ilə əlavə rezistor lazım olmur
Mexanika3 mm MDF və ya 3D çap hissələr4 mm MDF, 3D çap və ya alüminium braket608 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ırNəmdən təsirlənir, vint dəlikləri zamanla genişlənirMeArm tipli ilk qollar, məktəb layihələri
3 mm akrilGözəl görünür, nəmdən təsirlənmirKövrəkdir; vinti sıxanda çatlaya bilərSə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ərAğır və bahalıdır, çiyinə daha çox yük düşürDaha ağır əşya qaldıracaq 6 servolu qollar
Karton, dondurma çubuğuDemək olar ki, pulsuz, sürətli prototipDavamsı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?

ModelTorkSürət (60° üçün)ÇəkiDişliKilidlənmə cərəyanıRobot qoldakı yeri
SG901,8 kg·cm (4,8 V)0,10 san (4,8 V)9 gPlastikTəxminən 0,6–0,75 AQısqac, yüngül bilək, kiçik 4 oxlu qol
MG90S1,8 kg·cm (4,8 V), 2,2 kg·cm (6 V)0,10 san (4,8 V)13,4 qMetalTəxminən 0,7–1 ABilək, bilək fırlanması, qısqac
MG996R9,4 kg·cm (4,8 V), 11 kg·cm (6 V)0,17 san (4,8 V)55 gMetal2,5 A (6 V)Baza, çiyin, dirsək
DS321819 kg·cm (5 V), 21,5 kg·cm (6,8 V)0,16 san (5 V)60 gMetalTəxminən 2–3 AUzun 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.

MG996R metal dişli servo mühərrik
MG996R: metal dişli, 6 V-da 11 kg·cm tork və 25 dişli çıxış valı; robot qolun baza, çiyin və dirsək oynaqları üçün standart seçim.

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 g6 sm (ağırlıq mərkəzi)0,04 × 6 = 0,24 kg·cm
Dirsək servosu (MG996R)55 g12 cm0,055 × 12 = 0,66 kg·cm
Ön qol hissələri30 g18 cm0,03 × 18 = 0,54 kg·cm
Bilək servosu + qısqac (MG90S, SG90 və hissələr)50 g25 cm0,05 × 25 = 1,25 kg·cm
Tutulan əşya50 g30 cm0,05 × 30 = 1,50 kg·cm
Cəmi225 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ə.

Çiyin torkunu azaltmağın üç ucuz yolu var: qolu qısaltmaq, dirsək servosunu çiyin səviyyəsinə köçürüb dirsəyi itələyici çubuqla hərəkət etdirmək və çiyinin arxasına bir əks çəki ya da qolu yuxarı çəkən yay əlavə etmək. Məsələn, çiyin oxunun 5 sm arxasına qoyulan 400 qramlıq çəki 0,4 × 5 = 2 kg·cm əks tork yaradır və yuxarıdakı qolun yükünü demək olar ki, yarıya endirir; bu halda baza podşipnikinin daşıdığı yük bir az artır.

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 tipiTəxmini cərəyanTövsiyə olunan mənbə
4 ədəd SG90 və ya MG90S-li kiçik qolHərəkət edərkən 0,5–1 A, pik 2–3 A5 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 qolHərəkət edərkən 2–3 A, hamısı çətinlik çəkəndə 8–10 A5–6 V, ən azı 5 A açarlayıcı adapter (rahat istifadə üçün 10 A)
Portativ qolQol 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
Servoları heç vaxt Arduino-nun 5V pinindən qidalandırma və xarici mənbənin mənfisini mütləq Arduino-nun GND-sinə qoş; ümumi GND yoxdursa servolar siqnalı anlamır və təsadüfi hərəkət edir. Servo qida xəttinə, servoların yaxınlığına servo başına ən azı 100 µF hesabı ilə elektrolitik kondensator qoy (6 servolu qolda 1000–2200 µF, ən azı 16 V) və uzun ayağı artıya (+) gələcək şəkildə tax; tərs taxılan elektrolitik kondensator şişib partlaya bilər. Breadboard-un qida relsləri təxminən 1 A üçün nəzərdə tutulub; MG996R-li qolda qida naqillərini birbaşa klemmə ya da PCA9685-in V+ girişinə qoş.

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şulmaArduino UnoRaspberry Pi Pico
Baza servosu siqnal (narıncı naqil)D3GP10
Çiyin servosu siqnalD5GP11
Dirsək servosu siqnalD6GP12
Qısqac servosu siqnalD9GP13
Pot 1–3 orta ayaq (baza, çiyin, dirsək)A0, A1, A2GP26, GP27, GP28
Pot 4 orta ayaq (qısqac)A3Yoxdur; qısqac GP14-dəki düymə ilə
Potun kənar ayaqları5V və GND3V3 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 GNDXarici mənbənin mənfisi + Pico GND
10 kΩ fırlanan potensiometr
10 kΩ potensiometr: kənar ayaqlar 5V və GND-yə, orta ayaq analoq girişə qoşulur; valı çevirdikcə oynaq da eyni nisbətdə dönür.

Montajdan əvvəl kalibrləmə: servoları ortala

  1. 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.
  2. 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.
  3. Koddakı CENTER_ONLY dəyərini false et, TEST ilə bir oynaq seç və A0-dakı potensiometri yavaşca çevir.
  4. 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.
  5. 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.
  6. Tapdığın dəyərləri sonrakı kodlardakı MIN_A və MAX_A massivlərinə yaz.
C++ (Arduino IDE)
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.

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

C++ (Arduino IDE)
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əliyyatNə edirsən?Qol nə edir?
Pozisiyanı yadda saxlamaQeyd düyməsinə (D7) qısa basLED 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ı saxlaLED beş dəfə yanıb-sönür, addım sayı sıfırlanır
OynatmaOynat düyməsinə (D8) bas və buraxLED yanır, pozisiyalar ardıcıllıqla və yumşaq keçidlə təkrarlanır
Oynatmanı dayandırmaOynatma zamanı oynat düyməsini basılı saxlaQol cari pozisiyanı bitirir və dayanır
Normal rejimə qayıtmaOynatma 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.

EEPROM-un hər xanası təxminən 100.000 dəfə yazıla bilər. Kod EEPROM.update() istifadə etdiyi üçün yalnız dəyəri dəyişən xanalara yazır və bu ömür praktikada heç tükənmir. Daha uzun hərəkət ardıcıllıqları üçün qeydləri SD karta yaza və ya Arduino Mega-nın 4 KB-lıq EEPROM-undan istifadə edə bilərsən.

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 piniArduino UnoESP32Raspberry Pi Pico
GNDGNDGNDGND
VCC (yalnız çipin qidası)5V3V33V3
SDAA4GPIO 21GP4
SCLA5GPIO 22GP5
V+ klemmi (servo qidası)Xarici 5–6 VXarici 5–6 VXarici 5–6 V
OEBoş buraxBoş buraxBoş burax
Servo konnektorları 0–5Baza, çiyin, dirsək, bilək, bilək fırlanması, qısqacEyni ardıcıllıqEyni ardıcıllıq
PCA9685-də iki ayrı qida var: VCC yalnız çipi qidalandırır, servolar isə klemmdəki V+ girişindən qidalanır. V+ boş qalsa, modul I2C-də görünür, amma servolar tərpənmir. Arduino Uno-da A4 və A5 I2C üçün istifadə olunduğundan PCA9685 qoşulu olanda analoq giriş kimi yalnız A0–A3 qalır; daha çox potensiometr lazımdırsa, əlavə A6 və A7 girişləri olan Arduino Nano-dan istifadə et.

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.

İki oxlu analoq coystik modulu
Coystik modulu: VRx və VRy çıxışları ortada təxminən 512 oxuyur, SW düyməsi basılanda GND-yə çəkir. İki modulla robot qolun dörd oynağını sürə bilərsən.
C++ (Arduino IDE)
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.

HC-05 Bluetooth serial modulu
HC-05: klassik Bluetooth ilə telefona qoşulan serial modul; VCC 5 V ilə qidalanır, amma RXD girişi 3,3 V səviyyəsindədir.
KomandaMənasıNümunə
B + bucaqBazaB90
S + bucaqÇiyinS120
E + bucaqDirsəkE45
W + bucaqBilək (yuxarı-aşağı)W100
R + bucaqBilək fırlanmasıR0
G + bucaqQısqacG110 (bağla), G40 (aç)
HBaşlanğıc pozisiyaya qayıtH
K / P / X / CPozisiyanı yadda saxla / dövrlə oynat / dayandır / qeydləri silK
C++ (Arduino IDE)
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.

Telefon tərəfində hazır tətbiq kifayətdir: Android-də Bluetooth serial terminal ya da sürüşdürücülü Bluetooth idarəetmə tətbiqi quraşdırıb hər sürüşdürücüyə "S" kimi prefiks və sətir sonu təyin et. Öz düymə və sürüşdürücülü interfeysini düzəltmək istəsən, MIT App Inventor ilə Bluetooth tətbiqi yazısı addım-addım izah edir. HC-05 klassik Bluetooth istifadə etdiyi üçün iPhone ilə işləmir; iPhone üçün ESP32 BLE kimi Bluetooth Low Energy istifadə edən həll lazımdır.

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.

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

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

Bir 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ətMümkün səbəbHəll
Qol dayananda servolar titrəyir, vızıldayırPot oxunuşlarındakı küy ya da zəif qidalandırmaYumş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 qopurServoların işə düşmə cərəyanı gərginliyi aşağı salırServoları 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əyrirSoftwareSerial kəsmələri Servo kitabxanasının impulslarını pozurServoları PCA9685-ə köçür ya da ESP32-nin daxili Bluetooth-undan istifadə et
Açılışda qol sürətlə bir yerə atılırServolar son mövqelərini bilmir, ilk komandada tam sürətlə gedirQolu 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ürTork çatmırTork hesabını et; MG996R, daha qısa qol, əks çəki ya da yay istifadə et
Bir oynaq uçda ilişib qızırServo mexaniki həddə dirənirKalibrləmədə tapdığın MIN_A və MAX_A hədlərini koda yaz
Qısqac əşyanı tutarkən servo qızırQısqac bağlanmağa çalışmağa davam edir, servo kilidli qalırBağlı bucağı əşyaya yenicə toxunduğu dəyərə tənzimlə, barmaqlara rezin əlavə et
PCA9685 qoşuludur, amma servolar heç dönmürV+ klemminə qida verilməyib ya da GND ümumi deyilV+ girişinə 5–6 V ver, I2C ünvanını (0x40) yoxla
Oynaq yük altında sürüşürPlastik horn dişi soyub ya da ortadakı vint taxılmayıbMetal horn istifadə et, hornu ortadakı vint ilə vala bərkit
Problemin qidadan, yoxsa koddan gəldiyini anlamağın qısa yolu: servoları qoşmadan kalibrləmə kodunu (CENTER_ONLY = false) işlət və potu çevirərkən Serial Monitor-da bucaqları izlə. Dəyərlər düzgündürsə, problem qidalandırmadadır; qol hərəkət edərkən servo xəttinin gərginliyini multimetrlə ölç, 4,5 V-un altına düşürsə, mənbə ya da naqillər kifayət etmir. Resetlənmənin bütün səbəbləri üçün Arduino niyə resetlənir? yazısına baxa bilərsən.

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.

Bütün layihələrə bax
Potensiometrlə servo mühərrikdən istifadə
AR-36Başlanğıc
Premium

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.

4.6(37)
53
Coystiklə servo idarəsi
AR-60Orta
Premium

Coystiklə servo idarəsi

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

4.7(42)
58
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
ESP32 servo mühərrik (potensiometrlə idarə)
ES-16Orta
Premium

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.

4.3(29)
42
Bluetooth ilə telefondan LED yandırma
AR-34Başlanğıc
Premium

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…

4.8(69)
91
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 çevrə xoreoqrafiyası — 32 servo ilə animasiyalı naxışlar
AR-97Qabaqcıl
Premium

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.

4.5(40)
62