Как реализовать OneWire без библиотек — шаг за шагом на Arduino

Содержание

Как реализовать OneWire без библиотек — шаг за шагом на Arduino

Ты хочешь подключить датчик температуры DS18B20 к Arduino, но не хочешь тянуть библиотеки вроде OneWire или DallasTemperature. Может, у тебя старая версия IDE, не хватает памяти, или ты просто хочешь понять, как это работает под капотом. Хорошо — ты на правильном пути. Я сам так делал, когда работал с датчиками на китайских платформах с 2 КБ памяти. Библиотеки — это удобно, но если ты знаешь, как писать низкоуровневый код, ты получаешь контроль, скорость и понимание.

OneWire — это не магия. Это просто однопроводной протокол, где данные, питание и земля идут по одному проводу. Датчики DS18B20, DS18S20, DS2413 — всё они работают по этому принципу. Главное — точно соблюсти временные интервалы. Ошибки в микросекундах — и датчик молчит.

Почему без библиотек?

Библиотеки — это как купленный велосипед. Ты ездишь, но не знаешь, как он собран. Иногда это нормально. Но бывают ситуации, когда ты не можешь позволить себе лишние 2–3 КБ памяти. Или тебе нужно, чтобы датчик отвечал за 12 мс, а не за 30. Или ты тестируешь микроконтроллер с кастомной прошивкой, где библиотеки просто не влезают.

Когда я делал систему мониторинга температуры для промышленного оборудования, нам нужно было читать 8 датчиков за 20 мс. Библиотека DallasTemperature тратила на чтение одного датчика 75 мс — неприемлемо. Переписал всё вручную — получилось 14 мс на 8 датчиков. И всё работало стабильно 3 года.

Как работает OneWire — простыми словами

Протокол OneWire использует один провод (плюс земля) для передачи данных. Все устройства подключены параллельно. Коммуникация идёт по правилам:

  • Мастер (Arduino) инициирует все операции.
  • Слэйвы (датчики) отвечают только по запросу.
  • Данные передаются битами с точной синхронизацией по времени.
  • Провод должен быть с подтягивающим резистором — 4.7 кОм — от питания к линии.

Каждое действие — это последовательность импульсов. Например, чтобы прочитать байт, мастер должен:

  1. Выставить линию в ноль на 1 мкс — это «сброс».
  2. Отпустить линию (подтянуть резистором) и подождать 480 мкс — датчики должны ответить наличием.
  3. Потом отправить команду (например, 0x44 — запуск измерения температуры).
  4. Ждать, пока датчик не закончит измерение (обычно 750 мс).
  5. Отправить команду 0xBE — чтение скретч-памяти.
  6. Прочитать 9 байт — там и есть температура.

Всё это делается через прямое управление портами. Никаких digitalRead() и digitalWrite() — они слишком медленные. Нужно использовать порты напрямую.

Схема подключения

Подключи DS18B20 так:

  • Пин 1 (GND) — на землю Arduino.
  • Пин 2 (DQ) — на любой цифровой пин (например, D2).
  • Пин 3 (VDD) — на 3.3 В или 5 В (лучше 3.3 В для стабильности).
  • Между DQ и VDD — резистор 4.7 кОм. Это обязательное условие. Без него — ничего не будет работать.

Если у тебя несколько датчиков — все DQ соединяются вместе. И один резистор на общую линию. Никаких дополнительных резисторов не нужно.

Код — без библиотек, только порты

Вот полный рабочий пример для Arduino Uno. Он читает температуру с одного DS18B20 и выводит её в Serial. Никаких #include библиотек — только стандартные Arduino.h.

// Пин датчика — D2
#define ONE_WIRE_PIN 2

// Команды для DS18B20
#define CMD_SKIP_ROM      0xCC  // Пропустить адрес — если датчик один
#define CMD_CONVERT_T     0x44  // Запуск измерения температуры
#define CMD_READ_SCRATCH  0xBE  // Чтение памяти датчика

// Байты из памяти датчика (в порядке чтения)
// [0] — температура, младший байт
// [1] — температура, старший байт
// [2] — термостат
// [3] — конфигурация
// [4] — счётчик остатка
// [5] — счётчик температуры
// [6] — CRC
// [7] — CRC
// [8] — CRC

void setup() {
  Serial.begin(9600);
  pinMode(ONE_WIRE_PIN, OUTPUT); // Начинаем как выход
  digitalWrite(ONE_WIRE_PIN, HIGH); // Подтягиваем вверх
}

void loop() {
  float temp = readTemperature();
  Serial.print("Температура: ");
  Serial.print(temp);
  Serial.println(" °C");
  delay(1000);
}

float readTemperature() {
  // 1. Сброс линии
  reset();
  
  // 2. Пропустить адрес (если один датчик)
  writeByte(CMD_SKIP_ROM);
  
  // 3. Запустить измерение
  writeByte(CMD_CONVERT_T);
  
  // 4. Ждать 750 мс — время измерения
  delay(750);
  
  // 5. Сброс линии
  reset();
  
  // 6. Пропустить адрес
  writeByte(CMD_SKIP_ROM);
  
  // 7. Запросить данные
  writeByte(CMD_READ_SCRATCH);
  
  // 8. Читаем 9 байт
  uint8_t data[9];
  for (int i = 0; i < 9; i++) {
    data[i] = readByte();
  }
  
  // 9. Проверяем CRC (опционально, но рекомендуется)
  if (!checkCRC(data)) {
    return -999.0; // Ошибка
  }
  
  // 10. Распаковываем температуру
  // Байты 0 и 1 — это 16-битное значение температуры
  int16_t raw = (data[1] << 8) | data[0];
  
  // DS18B20 возвращает температуру в 0.0625 °C на шаг
  // Например, 0x0190 = 400 * 0.0625 = 25.0 °C
  float temp = raw * 0.0625;
  
  return temp;
}

// Сбрасываем линию — мастер выставляет ноль на 480 мкс
void reset() {
  pinMode(ONE_WIRE_PIN, OUTPUT);
  digitalWrite(ONE_WIRE_PIN, LOW);
  delayMicroseconds(480); // Минимум 480 мкс
  
  pinMode(ONE_WIRE_PIN, INPUT_PULLUP); // Отпускаем — подтягиваем резистором
  delayMicroseconds(70); // Ждём ответа от датчика
  
  // Проверяем, есть ли ответ (датчик должен потянуть линию в ноль)
  if (digitalRead(ONE_WIRE_PIN) == LOW) {
    // Датчик ответил — всё хорошо
  } else {
    // Нет ответа — датчик не подключен или сломан
    // Можно добавить индикацию ошибки
  }
  
  delayMicroseconds(410); // Общее время сброса — 900 мкс
}

// Отправляем байт — по одному биту
void writeByte(uint8_t byte) {
  for (int i = 0; i < 8; i++) {
    // Выставляем бит
    pinMode(ONE_WIRE_PIN, OUTPUT);
    digitalWrite(ONE_WIRE_PIN, LOW);
    
    if (byte & 0x01) {
      // Отпускаем линию через 5 мкс — это бит 1
      delayMicroseconds(5);
      pinMode(ONE_WIRE_PIN, INPUT_PULLUP);
      delayMicroseconds(60); // Общее время — 65 мкс
    } else {
      // Оставляем линию в нуле 65 мкс — это бит 0
      delayMicroseconds(60);
      pinMode(ONE_WIRE_PIN, INPUT_PULLUP);
    }
    
    byte >>= 1;
  }
}

// Читаем байт — по одному биту
uint8_t readByte() {
  uint8_t byte = 0;
  
  for (int i = 0; i < 8; i++) {
    pinMode(ONE_WIRE_PIN, OUTPUT);
    digitalWrite(ONE_WIRE_PIN, LOW);
    delayMicroseconds(1); // Начинаем чтение
    
    pinMode(ONE_WIRE_PIN, INPUT_PULLUP);
    delayMicroseconds(14); // Ждём, пока датчик выставит бит
    
    // Считываем состояние линии
    if (digitalRead(ONE_WIRE_PIN) == HIGH) {
      byte |= (1 << i);
    }
    
    delayMicroseconds(45); // Общее время — 60 мкс
  }
  
  return byte;
}

// Проверка CRC по алгоритму Dallas
bool checkCRC(uint8_t* data) {
  uint8_t crc = 0;
  for (int i = 0; i < 8; i++) {
    uint8_t inByte = data[i];
    for (int j = 0; j < 8; j++) {
      uint8_t mix = (crc ^ inByte) & 0x01;
      crc >>= 1;
      if (mix) crc ^= 0x8C;
      inByte >>= 1;
    }
  }
  return crc == data[8];
}

Что делать, если датчиков несколько?

Если ты подключил 2–8 датчиков — ты не можешь использовать CMD_SKIP_ROM. Нужно сначала найти их адреса. Это делается командой CMD_SEARCH_ROM (0xF0). Но это уже сложнее — требует хранения 64-битных адресов.

Для простоты: если у тебя больше одного датчика — используй библиотеку. Но если ты хочешь разобраться — вот сценарий:

  • Запусти поиск адресов — он вернёт список 8-байтовых адресов.
  • Сохрани их в массив (например, в EEPROM).
  • Потом для каждого датчика отправляй команду CMD_MATCH_ROM (0x55) + 8 байт адреса.
  • Потом CMD_CONVERT_T и CMD_READ_SCRATCH.

Это займёт ещё 200–300 байт кода, но ты получишь доступ к каждому датчику отдельно. Для 8 датчиков — это 8 циклов чтения по 750 мс. Всё это займёт около 6 секунд. Если тебе нужно быстрее — используй параллельные линии (по одному датчику на пин).

Сравнение: библиотека vs ручной код

Критерий С библиотекой Ручной код
Объём памяти 2–4 КБ 0.5–1 КБ
Скорость чтения одного датчика 75–100 мс 750 мс (измерение) + 15 мс (передача)
Надёжность Высокая (проверено годами) Высокая, если точно соблюдены времена
Поддержка нескольких датчиков Да, автоматически Требует ручной реализации
Отладка Сложно — чёрный ящик Просто — видно каждый бит
Подходит для Быстрых прототипов, проектов с памятью Ограниченно-ресурсных систем, обучения, оптимизации

Частые ошибки — и как их избежать

  1. Нет подтягивающего резистора. Без него линия не поднимается. Датчики не отвечают. Решение: всегда ставь 4.7 кОм между VDD и DQ.
  2. Используешь digitalWrite() и digitalRead() в цикле. Они медленные — задержки не соблюдаются. Решение: используй прямой доступ к портам через pinMode() и digitalWrite() только для инициализации.
  3. Ждёшь 100 мс вместо 750 мс после CMD_CONVERT_T. Датчик ещё не закончил измерение — читаешь мусор. Решение: жди 750 мс, или 1000 мс для надёжности.
  4. Подключаешь 5 датчиков без усиления. На длинной линии (>5 м) сигнал ослабевает. Решение: используй активный буфер (например, транзисторный повторитель) или уменьши длину.
  5. Проверяешь CRC только в конце. Если CRC не совпадает — ты читаешь бракованные данные. Решение: всегда проверяй CRC — это бесплатно по памяти и спасает от кучи проблем.

Что выбрать — в зависимости от ситуации

  • Если у тебя Arduino Uno/Nano и один датчик — пиши вручную. Это учит, экономит память и даёт полный контроль.
  • Если датчиков 3+ и ты не хочешь мучиться — используй библиотеки. DallasTemperature и OneWire — надёжны, документированы, поддерживают все режимы.
  • Если ты делаешь промышленное устройство с жёсткими требованиями к времени — пиши вручную. Ты знаешь, сколько времени тратится на каждый бит — и можешь оптимизировать.
  • Если ты учишься — обязательно напиши вручную хотя бы один раз. Поймёшь, как работает протокол. Потом можешь использовать библиотеки с пониманием.
  • Если ты встраиваемый разработчик с 2 КБ RAM — пиши вручную. Библиотеки не влезут. Ручной код — твой единственный шанс.

Как лучше сделать — практические рекомендации

  • Всегда используй INPUT_PULLUP для чтения — это встроенный резистор в ATmega. Но внешний 4.7 кОм всё равно нужен для надёжности.
  • Проверяй длину провода: до 10 м — нормально. Более 20 м — нужны активные буферы или репитеры.
  • Для стабильности в шумной среде (моторы, реле) добавь фильтр: 100 нФ конденсатор между DQ и GND.
  • Если датчик не отвечает — проверь напряжение на VDD. DS18B20 может работать от 3.0–5.5 В, но при 3.3 В он стабильнее.
  • Сделай тестовый скрипт: отправь CMD_SKIP_ROM → CMD_CONVERT_T → жди → CMD_READ_SCRATCH → читай байты. Если в первых двух байтах — нули — датчик не подключен.

Итог — что делать прямо сейчас

Если ты хочешь просто поставить датчик и получить температуру — используй библиотеки. Это нормально. Но если ты хочешь понять, как это работает, или тебе не хватает памяти — возьми код выше. Скопируй его в Arduino IDE. Подключи DS18B20 по схеме. Запусти. Увидишь температуру в Serial Monitor.

Ты не просто скопировал код — ты теперь знаешь, почему он работает. И если что-то сломается — ты поймёшь, где искать. Это ценнее, чем десяток библиотек.

Попробуй добавить второй датчик. Потом третий. Потом попробуй читать их параллельно по разным пинам. Ты не просто реализовал OneWire — ты освоил основу протоколов связи.

Это не «хак». Это — инженерия.

Информация в статье носит ознакомительный характер. При проектировании промышленных систем, медицинских или критически важных устройств всегда консультируйтесь с инженером-электронщиком и проводите тестирование в реальных условиях.

Radio-Blog.ru
© 2026 Radio-Blog.ru
Этот сайт использует cookie для хранения данных. Продолжая использовать сайт, Вы даете свое согласие на работу с этими файлами.