Простая система управления сервоприводом уровнем освещенности | Arduino

1. Цели урока

• Понять, что такое raw и почему он в диапазоне 0…1023.
• Разобраться, как работает analogRead() (АЦП) и от чего зависит результат.
• Понять, как работает map() и почему после него часто нужен constrain().
• Научиться управлять сервоприводом через Servo.attach() и Servo.write().
• Сделать управление спокойным: фильтр flt, коэффициент alpha, порог по углу.
• Уметь читать отладочный вывод в Serial.

2. Контекст: как работает “свет → угол”

LDR — это резистор, который меняет сопротивление от освещённости. Arduino не умеет измерять сопротивление напрямую, поэтому LDR подключают через делитель напряжения: два резистора последовательно между +5V и GND, а середина — на вход A0.

Дальше программа делает простую цепочку:

Напряжение на A0 → analogRead() → raw (0..1023)
raw → (сглаживание) → flt (0..1023)
flt → map() → angle (0..180)
angle → Servo.write(angle) → поворот сервы

Частая путаница

3. Переменные проекта: что означает raw, flt и другие

Словарь переменных

Как читать Serial‑лог

Мы печатаем три ключевых числа в одной строке:

raw=975 | flt=960 | angle=169

• raw может прыгать быстрее (шум, мгновенное изменение освещения).
• flt обычно меняется плавнее (это цель фильтра).
• angle — уже готовая команда сервоприводу.

Типичные ошибки

4. analogRead(): как Arduino читает LDR (raw)

Что возвращает analogRead()

analogRead(A0) измеряет напряжение на входе A0 и возвращает целое число: 0 примерно соответствует 0V, а 1023 — примерно опорному напряжению (обычно около 5V для UNO).

int raw = analogRead(A0);  // raw: 0..1023

Мини‑пример чтения A0

void setup() {
  Serial.begin(9600); // запускаем Serial один раз при старте
}

void loop() {
  int raw = analogRead(A0); // читаем АЦП
  Serial.print("raw=");
  Serial.println(raw);      // печатаем и переводим строку
  delay(200);
}

Типичные ошибки

5. map() и constrain(): как получить угол (angle)

Как работает map() (с формулой)

Функция map(x, inMin, inMax, outMin, outMax) делает линейное преобразование диапазона. То есть она “растягивает/сжимает” число x из одного диапазона в другой.

Идея такая: если x находится посередине входного диапазона, результат будет посередине выходного диапазона.

map(x, 0, 1023, 0, 180)
0    → 0
1023 → 180
примерно 512 → примерно 90

int raw = 512;
int angle = map(raw, 0, 1023, 0, 180); // angle будет около 90

Зачем нужен constrain()

Важный момент: map() не “зажимает” (не ограничивает) значения. Если x случайно станет меньше inMin или больше inMax, результат может выйти за пределы outMin…outMax.

Поэтому после map() часто добавляют constrain(value, min, max) — это “зажим” значения в диапазон.

int angle = map(flt, 0, 1023, 0, 180);
angle = constrain(angle, 0, 180); // гарантируем 0..180

Как сделать инверсию зависимости

Если вам нужно “чем светлее, тем меньше угол” (или наоборот), проще всего инвертировать значение АЦП:

int raw = analogRead(A0);
raw = 1023 - raw; // инверсия: 0↔1023

int angle = map(raw, 0, 1023, 0, 180);
angle = constrain(angle, 0, 180);

Типичные ошибки

// Плохо (пример): перепутаны диапазоны
int angle = map(raw, 0, 180, 0, 1023);

6. Servo + стабильность: attach(), write(), фильтр, abs(), delay()

Servo.attach() и Servo.write()

Библиотека Servo.h управляет сервой через объект Servo:

• sv.attach(pin) — подключить серву к конкретному пину (настроить управление).
• sv.write(angle) — отправить команду угла (обычно 0…180).

#include <Servo.h>

Servo sv;

void setup() {
  sv.attach(9);   // сигнал сервы на D9
  sv.write(90);   // поставить примерно в центр
}

void loop() {}

Что такое flt (фильтр) и alpha

Даже если освещённость меняется идеально, raw может немного “шуметь”. Чтобы серва не получала множество мелких команд, мы используем сглаживание (экспоненциальный фильтр).

// filtered — “плавная версия” raw
filtered = filtered + alpha * (raw - filtered);

• alpha — “скорость реакции”. Пример: 0.12 означает, что за один шаг фильтр делает примерно 12% “приближения к требуемому значению”.
• filtered — float, чтобы фильтр был плавным.
• flt — целое число (округление), с ним удобно делать map() и печатать в Serial.

int flt = (int)(filtered + 0.5); // округление float → int

Зачем нужны abs() и delay()

abs(x) возвращает модуль числа (абсолютное значение). Мы используем это для “мертвой зоны”: не обновлять серву, если угол изменился слишком мало.

if (abs(angle - lastAngle) >= 2) {
  sv.write(angle);
  lastAngle = angle;
}

delay(ms) останавливает программу на указанное число миллисекунд. В этом проекте мы используем delay(100), чтобы печатать в Serial не слишком часто (так лог проще читать).

Типичные ошибки

// Плохо:
int raw = analogRead(A0);
sv.write(raw);

7. Практика: задачи (с решениями)

Блок 1: raw и Serial

void setup() {
  Serial.begin(9600);
}

void loop() {
  int raw = analogRead(A0);
  Serial.print("raw=");
  Serial.println(raw);
  delay(200);
}

Блок 2: map → angle

void setup() {
  Serial.begin(9600);
}

void loop() {
  int raw = analogRead(A0);
  int angle = map(raw, 0, 1023, 0, 180);
  angle = constrain(angle, 0, 180);

  Serial.print("raw="); Serial.print(raw);
  Serial.print(" | angle="); Serial.println(angle);

  delay(200);
}

int raw = analogRead(A0);
raw = 1023 - raw;

int angle = map(raw, 0, 1023, 0, 180);
angle = constrain(angle, 0, 180);

Блок 3: фильтр и “мертвая зона”

#include <Servo.h>

// --- Настройка пинов ---
const byte PIN_LDR   = A0;  // куда подключена середина делителя с LDR
const byte PIN_SERVO = 9;   // сигнал сервопривода

Servo sv;

// --- Фильтр (сглаживание) ---
float filtered = 0.0;       // внутреннее “плавное” значение (float)
const float alpha = 0.12;   // скорость фильтра: больше → быстрее, меньше → плавнее

// --- Порог обновления угла ---
int lastAngle = -999;       // последний отправленный угол (стартовый “маркер”)

void setup() {
  Serial.begin(9600);       // включаем Serial для отладки
  sv.attach(PIN_SERVO);     // подключаем сервопривод к пину

  // Инициализируем фильтр текущим чтением, чтобы старт был “с реального значения”
  filtered = analogRead(PIN_LDR);

  Serial.println("Start: LDR -> Servo");
}

void loop() {
  // 1) Сырое чтение АЦП (0..1023)
  int raw = analogRead(PIN_LDR);

  // 2) Экспоненциальный фильтр:
  // filtered плавно “догоняет” raw
  filtered = filtered + alpha * (raw - filtered);

  // 3) Округляем float → int (это и есть наше flt)
  int flt = (int)(filtered + 0.5);

  // (Опционально) инверсия зависимости:
  // flt = 1023 - flt;

  // 4) Перевод 0..1023 в 0..180
  int angle = map(flt, 0, 1023, 0, 180);

  // 5) Ограничение угла на всякий случай
  angle = constrain(angle, 0, 180);

  // 6) “Мёртвая зона”: обновляем серву только если угол изменился заметно
  if (abs(angle - lastAngle) >= 2) {
    sv.write(angle);
    lastAngle = angle;
  }

  // 7) Отладочный вывод: видно raw / flt / angle
  Serial.print("raw=");   Serial.print(raw);
  Serial.print(" | flt=");   Serial.print(flt);
  Serial.print(" | angle="); Serial.println(angle);

  // 8) Пауза, чтобы лог был читаемым
  delay(100);
}

8. Чек‑лист самопроверки

Отметьте пункты, которые вы действительно понимаете и можете объяснить без подсказок.