Функция map() в Arduino: использование, примеры и constrain()
Как пользоваться функцией map() в Arduino? Синтаксис, ловушка целочисленного деления, ограничение с constrain(), примеры от потенциометра к сервоприводу и ШИМ, ESP32 и Pico.
Функция Arduino map() — встроенная команда, которая пропорционально переводит значение из одного числового диапазона в другой. Когда нужно превратить показание потенциометра 0–1023 в 0–180 градусов для сервопривода, в значение ШИМ 0–255 для яркости светодиода или в 0–100% для вывода на дисплей, она справляется одной строкой. Проще говоря, map() — это переводчик линеек, который подгоняет имеющуюся шкалу под нужную.
Но map() не так безобидна, как кажется: она работает только с целыми числами, отбрасывает дробную часть и не ограничивает результат целевым диапазоном. В этой статье пошагово разобраны формула функции, сюрпризы целочисленного деления, безопасное использование вместе с constrain(), реальные примеры от потенциометра к сервоприводу и от датчика к ШИМ, а также то, как та же задача решается на 12-битном АЦП ESP32 и на Raspberry Pi Pico с MicroPython.

Что такое map() в Arduino и как она работает?
map() задаёт линейную пропорцию между двумя диапазонами. Она определяет, в каком месте своего диапазона (в процентах) находится входное значение, а затем вычисляет число, стоящее в том же месте целевого диапазона. Определение в ядре Arduino занимает одну строку: (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min. Все параметры и возвращаемое значение имеют тип long, то есть на Uno это 32-битное целое со знаком. Синтаксис: map(значение, входМин, входМакс, выходМин, выходМакс), и для работы с ней не нужно подключать никаких библиотек.
| Параметр | Значение | Пример: потенциометр → сервопривод |
|---|---|---|
| value (x) | Значение, которое нужно перевести | Результат analogRead(A0) |
| fromLow (in_min) | Нижняя граница входного диапазона | 0 |
| fromHigh (in_max) | Верхняя граница входного диапазона | 1023 |
| toLow (out_min) | Нижняя граница выходного диапазона | 0 |
| toHigh (out_max) | Верхняя граница выходного диапазона | 180 |
| Возвращаемое значение | Соответствие в целевом диапазоне (long) | Угол от 0 до 180 |
Посчитаем на примере: когда потенциометр стоит точно посередине, analogRead() возвращает примерно 512. Для map(512, 0, 1023, 0, 180) сначала находится 512 - 0 = 512, это значение умножается на 180 - 0 = 180, и получается 92160. Затем оно делится на 1023: 92160 / 1023 = 90,09. Поскольку целочисленное деление отбрасывает дробную часть, результат — 90 градусов; в конце прибавляется нижняя граница выхода, то есть 0. Если поменять выходные границы местами, направление тоже меняется: map(x, 0, 1023, 255, 0) даёт значение, которое уменьшается по мере поворота потенциометра. Отрицательные диапазоны тоже работают без проблем: ось джойстика можно превратить в скорость мотора вперёд-назад с помощью map(x, 0, 1023, -255, 255). Таблица ниже собирает самые частые преобразования.
| Задача | Код | Примечание |
|---|---|---|
| Потенциометр → угол сервопривода | map(x, 0, 1023, 0, 180) (угол) | Для Servo.write() |
| Потенциометр → ШИМ | map(x, 0, 1023, 0, 255) (ШИМ) | Для analogWrite(); x / 4 даёт более равномерное распределение |
| Аналоговое показание → проценты | map(x, 0, 1023, 0, 100) (проценты) | Чтобы показать проценты на дисплее |
| Джойстик → скорость и направление мотора | map(x, 0, 1023, -255, 255) (скорость со знаком) | Знак задаёт направление, модуль — скорость |
| Обратное направление (темно → ярко) | map(x, 0, 1023, 255, 0) (обратная шкала) | Поменяй выходные границы местами |
| 12-битный АЦП ESP32 → ШИМ | map(x, 0, 4095, 0, 255) (12 бит → 8 бит) | На ESP32 analogRead() возвращает 0–4095 |
Ограничение целочисленного деления: почему map() не даёт дробных чисел?
Поскольку деление внутри map() выполняется над целыми числами, результат всегда усекается в сторону нуля: дробная часть не округляется, а просто отбрасывается. В узком целевом диапазоне это особенно заметно. Например, если записать map(x, 0, 1023, 0, 10), чтобы превратить потенциометр в индикатор уровня 0–10, получится такая таблица:
| Вход (x) | Точное соотношение | Результат map() |
|---|---|---|
| 0 | 0,000 | 0 |
| 102 | 0,997 | 0 |
| 103 | 1,007 | 1 |
| 512 | 5,005 | 5 |
| 1022 | 9,990 | 9 |
| 1023 | 10,000 | 10 |
Главная проблема в таблице такая: результат 0 дают 103 разных входных значения (0–102), а верхнее значение 10 — только один вход, 1023. Если не довернуть потенциометр до упора, индикатор никогда не дойдёт до 10. Для равномерного распределения можно увеличить обе верхние границы на единицу и записать map(x, 0, 1024, 0, 11): тогда каждому выходному значению соответствует примерно 93 входных, а результат по-прежнему остаётся в пределах 0–10. Второе ограничение — переполнение: если промежуточное произведение (x - in_min) * (out_max - out_min) превышает предел 32-битного long, то есть примерно 2,1 млрд, результат портится. Большие диапазоны вроде map(50000, 0, 100000, 0, 100000) на Uno дают промежуточное произведение в 5 млрд и неверный результат. Третье ограничение — потребность в дробях: если записать map(x, 0, 1023, 0, 5), чтобы перевести аналоговое показание в напряжение 0–5 V, получатся только результаты 0, 1, 2, 3, 4 и 5. В таком случае стоит написать свою функцию map с плавающей точкой по той же формуле:
1// Ondalikli map fonksiyonu / Floating-point map function
2float mapFloat(float x, float inMin, float inMax, float outMin, float outMax) {
3 return (x - inMin) * (outMax - outMin) / (inMax - inMin) + outMin;
4}
5
6void setup() {
7 Serial.begin(9600);
8}
9
10void loop() {
11 int raw = analogRead(A0); // 0-1023 ham deger / raw value
12 float volt = mapFloat(raw, 0, 1023, 0.0, 5.0); // 0.00-5.00 V
13 long milliVolt = map(raw, 0, 1023, 0, 5000); // tamsayi mV / integer mV
14 int percent = map(raw, 0, 1023, 0, 100); // tamsayi yuzde / integer percent
15
16 Serial.print(F("Ham / Raw: "));
17 Serial.print(raw);
18 Serial.print(F(" V: "));
19 Serial.print(volt, 2);
20 Serial.print(F(" mV: "));
21 Serial.print(milliVolt);
22 Serial.print(F(" %: "));
23 Serial.println(percent);
24 delay(500);
25}Использование вместе с constrain
map() не считает целевой диапазон границей, она лишь вычисляет пропорцию. Если вход выходит за ожидаемый диапазон, выход тоже выходит за пределы. Допустим, измерения показали, что фоторезистор (LDR) на самом деле выдаёт значения от 200 до 900, и в коде записано map(x, 200, 900, 0, 255). Когда мощный фонарик поднимает значение до 980, результат равен (980 - 200) * 255 / 700 = 284; если в очень тёмной комнате значение падает до 150, получится -18. На Uno analogWrite() по-разному трактует значения больше 255 в зависимости от пина: например, на пине 6 число 284 обрезается до 8 бит и превращается в 28, то есть почти погасший светодиод. Решение — функция constrain(значение, мин, макс): она зажимает значение в заданных границах. Есть два правильных порядка: ограничить вход до map(), то есть map(constrain(x, 200, 900), 200, 900, 0, 255), или ограничить результат после map(), то есть constrain(map(x, 200, 900, 0, 255), 0, 255). Оба варианта не дают выйти за 0–255; при калибровке датчика ограничение входа читается проще.
Таблица подключения: Arduino Uno, ESP32 и Pico
| Подключение | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Крайние выводы потенциометра | 5V и GND | 3V3 и GND | 3V3 и GND |
| Средний вывод потенциометра | A0 | GPIO 34 | GP26 (ADC0) |
| Средняя точка делителя LDR + 10 kΩ | A1 | GPIO 35 | GP27 (ADC1) |
| Светодиод (с резистором 220 Ω) | D6 (ШИМ) | GPIO 25 | GP15 |
| Сигнал сервопривода (оранжевый провод) | D9 | GPIO 13 | GP16 |
| Диапазон показаний АЦП | 10 бит (0–1023) | 12 бит (0–4095) | read_u16(): 0–65535 |
Пошагово: управляем углом сервопривода потенциометром
- Подключи два крайних вывода потенциометра на 10 kΩ к пинам 5V и GND платы Arduino, а средний вывод — к A0.
- Подключи коричневый провод сервопривода SG90 к GND, красный — к 5V, а оранжевый сигнальный — к D9.
- Проверь, что библиотека Servo установлена: она идёт вместе с Arduino IDE, так что скачивать ничего не нужно.
- Загрузи код ниже в плату и открой монитор порта на скорости 9600 бод.
- Поворачивая потенциометр, понаблюдай, как на экране вместе меняются «сырое» значение и угол, а сервопривод поворачивается от 0 до 180 градусов.
- Если сервопривод в крайних точках напрягается и жужжит, сузь выход map() до диапазона вроде 10–170.
1#include <Servo.h>
2
3const int POT_PIN = A0; // potansiyometre orta ucu / potentiometer wiper
4const int SERVO_PIN = 9; // servo sinyal pini / servo signal pin
5
6Servo servo;
7
8void setup() {
9 servo.attach(SERVO_PIN);
10 Serial.begin(9600);
11}
12
13void loop() {
14 int raw = analogRead(POT_PIN); // 0-1023 ham deger / raw value
15 int angle = map(raw, 0, 1023, 0, 180); // dereceye cevir / convert to degrees
16 angle = constrain(angle, 0, 180); // guvenlik siniri / safety limit
17 servo.write(angle);
18
19 Serial.print(F("Ham / Raw: "));
20 Serial.print(raw);
21 Serial.print(F(" Aci / Angle: "));
22 Serial.println(angle);
23 delay(20); // servoya zaman tani / give the servo time
24}В коде analogRead() возвращает 10-битное значение, map() переводит его в градусы, а constrain() гарантирует, что даже если позже изменить диапазон, на сервопривод не уйдёт угол вне 0–180. Поскольку АЦП Uno слегка шумит, значение может гулять между 511, 512 и 513, даже если не трогать потенциометр, и из-за этого сервопривод дрожит. Усреднение нескольких показаний или вызов servo.write() только при изменении угла больше чем на 2 градуса в основном решают проблему. Подробности — в статьях о дрожании сервопривода и фильтрации данных датчиков. Если интересно, как устроен сервопривод, хорошее начало — статья Что такое сервопривод?.
От датчика к ШИМ: автоматическая яркость светодиода с LDR
map() подходит не только для потенциометров, а для любого аналогового датчика. В этом примере один вывод фоторезистора (LDR) подключён к 5V, а другой — к A1; между A1 и GND стоит резистор 10 kΩ. При таком подключении с ростом освещённости сопротивление LDR падает, а напряжение на A1 растёт. Сначала запиши значения, которые показывает монитор порта в тёмной комнате и при ярком свете, например 150 и 850. Эти два числа — твои границы калибровки. Код делает светодиод ярче по мере того, как темнеет, поэтому выходной диапазон записан наоборот: от 255 до 0. Как работает LDR, рассказано в статье Датчик освещённости LDR, а основы ШИМ — в статье Что такое ШИМ?.
1const int LDR_PIN = A1; // LDR + 10k bolucu / LDR + 10k divider
2const int LED_PIN = 6; // PWM pini / PWM pin
3const int DARK = 150; // karanlikta olculen / measured in the dark
4const int BRIGHT = 850; // aydinlikta olculen / measured in bright light
5
6void setup() {
7 pinMode(LED_PIN, OUTPUT);
8 Serial.begin(9600);
9}
10
11void loop() {
12 int raw = analogRead(LDR_PIN);
13 int limited = constrain(raw, DARK, BRIGHT); // once sinirla / limit first
14 int pwm = map(limited, DARK, BRIGHT, 255, 0); // karanlik = parlak / dark = bright
15 analogWrite(LED_PIN, pwm);
16
17 Serial.print(raw);
18 Serial.print(F(" -> "));
19 Serial.println(pwm);
20 delay(100);
21}map() на ESP32: 12-битный АЦП и ШИМ через LEDC
На ESP32 map() работает так же, меняется только входной диапазон. АЦП ESP32 по умолчанию имеет разрешение 12 бит, поэтому analogRead() возвращает 0–4095, а не 0–1023. Если в коде, перенесённом с Uno, оставить map(x, 0, 1023, ...), весь выходной диапазон израсходуется уже на первой четверти хода потенциометра, а на остальной части значения вылезут за пределы вплоть до четырёхкратного целевого диапазона. Поэтому на ESP32 записывай вход как 0–4095 или переходи на 10 бит с помощью analogReadResolution(10). Для ШИМ ESP32 использует блок LEDC: в ядре Arduino 3.x появилась ledcAttach(пин, частота, разрешение), а в 2.x используются канальные ledcSetup() и ledcAttachPin(). Код ниже компилируется в обеих версиях. Поскольку пины ADC2 нельзя читать при включённом Wi-Fi, потенциометр подключаем к GPIO 34, который относится к ADC1. Если нужно управлять сервоприводом на ESP32, можно применить ту же логику с библиотекой ESP32Servo и строкой map(x, 0, 4095, 0, 180).
1const int POT_PIN = 34; // ADC1 pini, yalniz giris / ADC1 pin, input only
2const int LED_PIN = 25; // PWM cikisi / PWM output
3const int PWM_FREQ = 5000; // 5 kHz
4const int PWM_RES = 8; // 8 bit: 0-255
5
6#if ESP_ARDUINO_VERSION_MAJOR < 3
7const int PWM_CH = 0; // 2.x icin LEDC kanali / LEDC channel for 2.x
8#endif
9
10void setup() {
11 Serial.begin(115200);
12 analogReadResolution(12); // 0-4095
13#if ESP_ARDUINO_VERSION_MAJOR >= 3
14 ledcAttach(LED_PIN, PWM_FREQ, PWM_RES);
15#else
16 ledcSetup(PWM_CH, PWM_FREQ, PWM_RES);
17 ledcAttachPin(LED_PIN, PWM_CH);
18#endif
19}
20
21void loop() {
22 int raw = analogRead(POT_PIN); // 0-4095
23 int duty = map(raw, 0, 4095, 0, 255); // 12 bit -> 8 bit
24 duty = constrain(duty, 0, 255);
25#if ESP_ARDUINO_VERSION_MAJOR >= 3
26 ledcWrite(LED_PIN, duty); // 3.x: pin numarasi / pin number
27#else
28 ledcWrite(PWM_CH, duty); // 2.x: kanal numarasi / channel number
29#endif
30 Serial.printf("%d -> %d\n", raw, duty);
31 delay(20);
32}У АЦП ESP32 есть особенность, о которой стоит знать: на краях диапазона он нелинеен. При настройке ослабления по умолчанию напряжения ниже примерно 0,1 V читаются как 0, а начиная примерно с 3,1 V значение упирается в 4095; между ними измерение слегка изогнуто. Поэтому 4095 может появиться ещё до того, как потенциометр довёрнут до упора, а в начале может ощущаться мёртвая зона. Практическое решение — измерить реальные минимальное и максимальное показания и использовать эти границы в map() и constrain(). Если нужно именно напряжение, функция analogReadMilliVolts(), использующая заводскую калибровку, даёт более точный результат, чем map. Об общих возможностях платы — в статье Что такое ESP32?.
Аналог map() на Raspberry Pi Pico и MicroPython
В MicroPython нет готовой map(), как в Arduino: map() в Python делает совсем другое — применяет функцию к списку. Поэтому ту же формулу пишешь вручную. На Pico ADC.read_u16() возвращает физически 12-битное измерение, масштабированное до 16 бит, в диапазоне 0–65535; PWM.duty_u16() тоже ожидает коэффициент заполнения от 0 до 65535. Поскольку целые числа в Python не ограничены по размеру, проблемы переполнения, как на Uno, здесь нет. Важное отличие: оператор // всегда округляет в сторону минус бесконечности, а map() в C++ усекает в сторону нуля, поэтому на отрицательных диапазонах между двумя языками может возникнуть разница в 1 единицу. Если нужен дробный результат, достаточно использовать / вместо //. В коде потенциометр читается с GP26, светодиод на GP15 следует за яркостью, а сервопривод на GP16 — за углом. Для светодиода ограничиваем вход диапазоном 500–65000, потому что АЦП Pico на краях редко доходит ровно до 0 и 65535. Для сервопривода 0–180 градусов при ШИМ 50 Hz у большинства SG90 соответствуют импульсу примерно 500–2500 микросекунд. Если Pico в новинку, начни со статей Что такое Raspberry Pi Pico? и Основы MicroPython.
1from machine import ADC, Pin, PWM
2import time
3
4pot = ADC(26) # GP26 = ADC0
5led = PWM(Pin(15)) # LED GP15
6led.freq(1000)
7servo = PWM(Pin(16)) # servo sinyal GP16 / servo signal GP16
8servo.freq(50) # 50 Hz = 20 ms periyot / period
9
10def map_range(x, in_min, in_max, out_min, out_max):
11 # Arduino map() karsiligi (tamsayi) / Arduino map() equivalent (integer)
12 return (x - in_min) * (out_max - out_min) // (in_max - in_min) + out_min
13
14def constrain(x, low, high):
15 # degeri sinirla / clamp the value
16 return max(low, min(x, high))
17
18while True:
19 raw = pot.read_u16() # 0-65535
20 percent = map_range(raw, 0, 65535, 0, 100) # yuzde / percent
21 duty = map_range(constrain(raw, 500, 65000), 500, 65000, 0, 65535)
22 led.duty_u16(duty) # LED parlakligi / LED brightness
23 angle = map_range(raw, 0, 65535, 0, 180) # derece / degrees
24 pulse_us = map_range(angle, 0, 180, 500, 2500) # darbe suresi / pulse width
25 servo.duty_ns(pulse_us * 1000) # mikrosaniye -> nanosaniye / us -> ns
26 print(raw, percent, angle, pulse_us)
27 time.sleep_ms(50)Идеи проектов с map()
- Индикатор уровня: переведи значение потенциометра или датчика звука в 0–8 с помощью map(x, 0, 1024, 0, 9) и покажи его на линейке из 8 светодиодов.
- Машинка с управлением джойстиком: переведи ось джойстика в диапазон от -255 до 255 и задавай направление и скорость моторов через L298N.
- Цифровой вольтметр: переведи аналоговое показание в милливольты и выведи на LCD; подробности — в статье Вольтметр на Arduino своими руками.
- Влажность почвы растения в процентах: переведи калибровочные значения «сухо» и «мокро» датчика влажности почвы в 0–100% с помощью constrain() и map().
- Инструмент, играющий от света: переведи значение LDR или расстояния в диапазон 200–2000 Hz с помощью map() и передай его в tone() как частоту.
- Бегущие огни с регулируемой скоростью: переведи положение потенциометра в задержку в миллисекундах с помощью map(x, 0, 1023, 50, 500).
Частые ошибки и их решение
| Симптом | Причина | Решение |
|---|---|---|
| Результат выходит за целевой диапазон | map() не ограничивает значение | Ограничь вход или выход с помощью constrain() |
| Дробные результаты всегда получаются целыми | Целочисленное деление отбрасывает дробную часть | Напиши mapFloat() или уменьши единицу (mV вместо V) |
| Верхнее значение никогда не достигается | Верхнее значение получается только при одном входе | Распредели равномерно через map(x, 0, 1024, 0, max + 1) |
| Бессмысленный результат на больших числах | Промежуточное произведение превышает предел 32-битного long | Уменьши диапазоны или считай через float или int64_t |
| На ESP32 значение слишком рано упирается в потолок | Код написан для 0–1023, а АЦП выдаёт 0–4095 | Сделай входной диапазон 0–4095 |
| Направление работает наоборот | Перепутаны выходные границы или подключение датчика | Поменяй местами нижнюю и верхнюю выходные границы |
| Результат постоянный и бессмысленный | in_min равен in_max, то есть деление на ноль | Проверь, что границы калибровки различаются |
Функция map() — переводчик между миром датчиков и миром выходов: помни о целочисленном делении, защищай границы с помощью constrain(), правильно укажи разрядность АЦП своей платы — и она будет работать по одной и той же логике на Uno, ESP32 и Pico. Основы потенциометра можно повторить в статье Что такое потенциометр?. В приложении BlueGrays можно пошагово, со схемами подключения и кодом, изучить проекты с map(): бегущие огни с регулируемой скоростью, измерение освещённости с LDR, управление сервоприводом потенциометром и регулировку яркости через ШИМ на ESP32.
Частые вопросы
Для чего нужна функция map() в Arduino?
map() пропорционально переводит число из одного диапазона в другой. Чаще всего её используют, чтобы превратить значение 0–1023, прочитанное через analogRead(), в 0–180 градусов для сервопривода или в значение ШИМ 0–255 для analogWrite(). Библиотека не нужна: функция встроена в ядро Arduino.
Возвращает ли map() дробные числа?
Нет. map() работает с типом long и при делении отбрасывает дробную часть; например, map(512, 0, 1023, 0, 5) даёт 2, а не 2,5. Если нужны дроби, напиши по той же формуле функцию mapFloat() с параметрами float или считай результат в более мелкой единице, например в милливольтах.
Чем map() отличается от constrain()?
map() переводит значение с одной шкалы на другую, но не ограничивает его: если вход вне диапазона, выход тоже выходит за пределы. constrain() шкалу не меняет, а только зажимает значение между заданными нижней и верхней границами. Для безопасного использования их записывают вместе: map(constrain(x, 200, 900), 200, 900, 0, 255).
Как задать угол сервопривода потенциометром?
Подключи средний вывод потенциометра к A0, а сигнальный провод сервопривода — к D9. В loop() вычисли угол строкой int angle = map(analogRead(A0), 0, 1023, 0, 180); и отправь его на сервопривод через servo.write(angle). Если сервопривод дрожит, усредняй несколько показаний или игнорируй мелкие изменения.
Работает ли map() иначе на ESP32?
Формула та же, но поскольку АЦП ESP32 12-битный, analogRead() возвращает 0–4095. Поэтому входной диапазон нужно записывать как map(x, 0, 4095, 0, 255). Так как АЦП ESP32 нелинеен на краях, лучше измерить реальные минимальное и максимальное показания и использовать их.
Есть ли в MicroPython аналог функции map() из Arduino?
Готового аналога нет: map() в Python — другая конструкция, которая применяет функцию к спискам. Достаточно написать короткую функцию по формуле (x - in_min) * (out_max - out_min) // (in_max - in_min) + out_min. Поскольку на Pico read_u16() возвращает 0–65535, входной диапазон обычно задаётся именно этими значениями.
Что собрать после прочтения
Все проекты
Бегущие огни с регулируемой скоростью
Шесть светодиодов загораются друг за другом, и кажется, что свет бежит от одного края к другому.

Светодиодный эффект Knight Rider с регулируемой скоростью
Свет бежит от одного края шести светодиодов к другому, разворачивается и бежит обратно.

Измерение освещённости с LDR
Хочешь увидеть яркость своей комнаты в виде числа? LDR — маленькая деталь, реагирующая на свет, — измеряет освещённость вокруг, а Arduino каждые полсекунды выводит значение на экран компьютера.

Управление сервоприводом потенциометром
Когда ты поворачиваешь ручку потенциометра, рычаг сервопривода поворачивается вместе с ней: одно крайнее положение ручки — ноль градусов, другое — пол-оборота.

Регулировка яркости светодиода потенциометром на ESP32 (аналог → PWM)
В этом проекте яркость светодиода плавно регулируется потенциометром. Пин АЦП ESP32 читает напряжение 0–3,3V с потенциометра, затем это значение превращается в сигнал PWM (широтно-импульсная модуляция) и подаётся на светодиод. В результате при повороте потенциометра светодиод постепенно становится ярче или тусклее. В Arduino Core 3.0+ можно сразу использовать analogWrite(); на ESP32-S2/S3 разрешение АЦП фиксировано — 12 бит.

Сервопривод на ESP32 (управление потенциометром)
В этом проекте сервопривод SG90 управляется потенциометром. Угол сервопривода задаётся сопоставлением аналогового значения потенциометра с диапазоном 0–180 градусов. Библиотека ESP32Servo формирует сигналы сервопривода на подходящих выходных пинах GPIO у ESP32; этот проект использует GPIO 18. Это базовый способ управления для роборук, подвесов камер и механизмов автоматических дверей.

Управление сервоприводом джойстиком
Управляй двумя моторами джойстиком, как будто поворачиваешь камеру наблюдения. Наклони рычажок влево или вправо, и нижний сервопривод медленно поворачивается, наклони вверх или вниз — верхний…
Другие статьи
Приложение BlueGrays
Собери эту схему шаг за шагом в телефоне
Схема подключения, код и список деталей на одном экране. 500+ проектов на Arduino, ESP32 и Pico готовы к сборке.
Наведи камеру телефона
Наведи камеру на код — откроется магазин приложений на телефоне.
или открыть магазин

