Основы · 10 мин чтения

Функция 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(): показание 0–1023 переводится в угол сервопривода или значение ШИМ.

Что такое 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()
00,0000
1020,9970
1031,0071
5125,0055
10229,9909
102310,00010

Главная проблема в таблице такая: результат 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 с плавающей точкой по той же формуле:

C++ (Arduino IDE)
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}
На Uno операции с float в несколько раз медленнее целочисленных и занимают больше памяти программ. Если дроби не обязательны, используй целочисленную map(); если нужна точность, уменьши целевую единицу. Например, считай напряжение не в вольтах, а в милливольтах: map(raw, 0, 1023, 0, 5000) даёт 0–5000 mV, а самое большое промежуточное произведение (5 115 000) остаётся намного ниже предела long.

Использование вместе с 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 (AVR) constrain() — не функция, а макрос, и он вычисляет свои параметры больше одного раза. Если написать constrain(analogRead(A0), 200, 900), analogRead() может выполниться несколько раз, и сравниваемое значение может отличаться от возвращаемого. Сначала сохрани показание в переменную, а потом передай эту переменную в constrain().

Таблица подключения: Arduino Uno, ESP32 и Pico

ПодключениеArduino UnoESP32Raspberry Pi Pico
Крайние выводы потенциометра5V и GND3V3 и GND3V3 и GND
Средний вывод потенциометраA0GPIO 34GP26 (ADC0)
Средняя точка делителя LDR + 10 kΩA1GPIO 35GP27 (ADC1)
Светодиод (с резистором 220 Ω)D6 (ШИМ)GPIO 25GP15
Сигнал сервопривода (оранжевый провод)D9GPIO 13GP16
Диапазон показаний АЦП10 бит (0–1023)12 бит (0–4095)read_u16(): 0–65535
Аналоговые входы ESP32 и Pico принимают не больше 3,3 V. Если по привычке подключить крайние выводы потенциометра к пину 5V, на среднем выводе может оказаться 5 V, и вход АЦП может необратимо повредиться. На этих платах всегда питай потенциометр от пина 3V3; если используется датчик с выходом 5 V, сначала понизь уровень с помощью утилиты делителя напряжения.

Пошагово: управляем углом сервопривода потенциометром

  1. Подключи два крайних вывода потенциометра на 10 kΩ к пинам 5V и GND платы Arduino, а средний вывод — к A0.
  2. Подключи коричневый провод сервопривода SG90 к GND, красный — к 5V, а оранжевый сигнальный — к D9.
  3. Проверь, что библиотека Servo установлена: она идёт вместе с Arduino IDE, так что скачивать ничего не нужно.
  4. Загрузи код ниже в плату и открой монитор порта на скорости 9600 бод.
  5. Поворачивая потенциометр, понаблюдай, как на экране вместе меняются «сырое» значение и угол, а сервопривод поворачивается от 0 до 180 градусов.
  6. Если сервопривод в крайних точках напрягается и жужжит, сузь выход map() до диапазона вроде 10–170.
C++ (Arduino IDE)
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, а основы ШИМ — в статье Что такое ШИМ?.

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

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

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, то есть деление на нольПроверь, что границы калибровки различаются
Вместо того чтобы прописывать калибровку постоянными числами, измеряй её во время работы: в setup() несколько секунд читай датчик, запомни самое маленькое и самое большое значение, а потом используй эти переменные в map() и constrain(). Если два значения остаются равными, вернись к границам по умолчанию, чтобы не делить на ноль. Так один и тот же код сам подстраивается под разные LDR, потенциометры и условия. Основы аналогового чтения есть в статье Что такое АЦП?.

Функция 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, входной диапазон обычно задаётся именно этими значениями.

Все проекты
Бегущие огни с регулируемой скоростью
AR-7Средний

Бегущие огни с регулируемой скоростью

Шесть светодиодов загораются друг за другом, и кажется, что свет бежит от одного края к другому.

4.6(72)
148
Светодиодный эффект Knight Rider с регулируемой скоростью
AR-8Средний

Светодиодный эффект Knight Rider с регулируемой скоростью

Свет бежит от одного края шести светодиодов к другому, разворачивается и бежит обратно.

4.5(60)
124
Измерение освещённости с LDR
AR-11Новичок

Измерение освещённости с LDR

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

4.6(83)
143
Управление сервоприводом потенциометром
AR-36Новичок
Premium

Управление сервоприводом потенциометром

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

4.6(37)
53
Регулировка яркости светодиода потенциометром на ESP32 (аналог → PWM)
ES-13Средний
Premium

Регулировка яркости светодиода потенциометром на ESP32 (аналог → PWM)

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

4.5(19)
32
Сервопривод на ESP32 (управление потенциометром)
ES-16Средний
Premium

Сервопривод на ESP32 (управление потенциометром)

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

4.3(29)
42
Управление сервоприводом джойстиком
AR-60Средний
Premium

Управление сервоприводом джойстиком

Управляй двумя моторами джойстиком, как будто поворачиваешь камеру наблюдения. Наклони рычажок влево или вправо, и нижний сервопривод медленно поворачивается, наклони вверх или вниз — верхний…

4.7(42)
58