Ардуино термометр ds18b20: схемы соединения, код проекта

Датчик температуры Arduino DS18B20

Датчик температуры в Arduino — один из самых распространенных видов сенсоров. Разработчику проектов с термометрами на Arduino доступно множество разных вариантов, отличающихся по принципу действия, точности, конструктивному исполнению.

Цифровой датчик DS18B20 является одним из наиболее популярных температурных датчиков, часто он используется в водонепроницаемом корпусе для измерения температуры воды или других жидкостей.

В этой статье вы найдете описание датчика ds18b20 на русском, мы вместе рассмотрим особенности подключения к ардуино, принцип работы датчика, описание библиотек и скетчей.

Описание датчика DS18B20 для Arduino

DS18B20 – это цифровой температурный датчик, обладающий множеством полезных функций.

По сути, DS18B20 — это целый микроконтроллер, который может хранить значение измерений, сигнализировать о выходе температуры за установленные границы (сами границы мы можем устанавливать и менять), менять точность измерений, способ взаимодействия с контроллером и многое другое. Все это в очень небольшом корпусе, который, к тому же, доступен в водонепроницаемом исполнении.

Микросхема имеет три выхода, из которых для данных используется только один, два остальных — это земля и питание. Число проводов можно сократить до двух, если использовать схему с паразитным питанием и соединить Vdd с землей. К одному проводу с данными можно подключить сразу несколько датчиков DS18B20 и в плате Ардуино будет задействован всего один пин.

Виды корпусов DS18B20

Температурный датчик DS18B20 имеет разнообразные виды корпуса. Можно выбрать один из трех — 8-Pin SO (150 mils), 8-Pin µSOP, и 3-Pin TO-92.

Последний является наиболее распространенным и изготавливается в специальном влагозащитном корпусе, так что его смело можно использовать под водой. У каждого датчика есть 3 контакта.

Для корпуса TO-92 нужно смотреть на цвет проводов: черный — земля, красный — питание и белый/желтый/синий — сигнал. В интернет-магазинах можно купить готовый модуль DS18B20.

Основные доступные виды изображены на рисунке ниже.

Где купить датчик

Естественно, что DS18B20 дешевле всего купить на Алиэкспрессе, хотя он продается и в любых специализированных российских интернет-магазинах с ардуино. Приведем несколько ссылок для примера:

Особенности цифрового датчика DS18B20

Погрешность измерения не больше 0,5 С (для температур от -10С до +85С), что позволяет точно определить значение температуры. Не требуется дополнительная калибровка.
Температурный диапазон измерений лежит в пределах от -55 С до +125 С.
Датчик питается напряжением от 3,3В до 5В.
Можно программно задать максимальную разрешающую способность до 0,0625С, наибольшее разрешение 12 бит.
Присутствует функция тревожного сигнала.
Каждое устройство обладает своим уникальным серийным кодом.
Не требуются дополнительные внешние элементы.
Можно подключить сразу до 127 датчиков к одной линии связи.
Информация передается по протоколу 1-Wire.
Для присоединения к микроконтроллеру нужны только 3 провода.
Существует так называемый режим паразитного питания – в нем происходит питание напрямую от линии связи. Для подключения в этом случае нужны только 2 провода. Важно, что в этом режиме не гарантируется корректная работа при температурах выше 100С. Режим паразитного питания удобно обычно применяется для приложений с удаленным температурным датчиком.

Память датчика состоит из двух видов: оперативной и энергонезависимой – SRAM и EEPROM.

В последнюю записываются регистры конфигурации и регистры TH, TL, которые могут использоваться как регистры общего назначения, если не используются для указания диапазона допустимых значений температуры.

Основной задачей DS18B20 является определение температуры и преобразование полученного результата в цифровой вид. Мы можем самостоятельно задать необходимое разрешение, установив количество бит точности — 9, 10, 11 и 12. В этих случаях разрешающие способности будут соответственно равны 0,5С, 0,25С, 0,125С и 0,0625С.

Во время включения питания датчик находится в состоянии покоя. Для начала измерения контроллер Ардуино выполняет команду «преобразование температуры». Полученный результат сохранится в 2 байтах регистра температуры, после чего датчик вернется в первоначальное состояние покоя.

Если схема подключена в режиме внешнего питания, микроконтроллер регулирует состояние конвертации. Во время выполнения команды линия находится в низком состоянии, после окончания программы линия переходит в высокое состояние.

Такой метод не допустим при питании от паразитной емкости, так как на шине постоянно должен сохраняться высокий уровень сигнала.

Полученные температурные измерения сохраняются в SRAM датчика. 1 и 2 байты сохраняют полученное значение температуры, 3 и 4 сохраняют пределы измерения, 5 и 6 зарезервированы, 7 и 8 используются для высокоточного определения температуры, последний 9 байт хранит устойчивый к помехам CRC код.

Подключение DS18B20 к Arduino

DS18B20 является цифровым датчиком.

Цифровые датчики передают значение измеряемой температуры в виде определенного двоичного кода, который поступает на цифровые или аналоговые пины ардуино и затем декодируется.

Коды могут быть самыми разными, ds18b20 работает по протоколу данных 1-Wire. Мы не будем вдаваться в подробности этого цифрового протокола, укажем лишь необходимый минимум для понимания принципов взаимодействия.

Обмен информацией в 1-Wire происходит благодаря следующим операциям:

Инициализация – определение последовательности сигналов, с которых начинается измерение и другие операции. Ведущее устройство подает импульс сброса, после этого датчик должен подать импульс присутствия, сообщающий о готовности к выполнению операции.
Запись данных – происходит передача байта данных в датчик.
Чтение данных – происходит прием байта из датчика.

Для работы с датчиком нам понадобится программное обеспечение:

Arduino IDE;
Библиотека OneWire, если используется несколько датчиков на шине, можно использовать библиотеку DallasTemperature. Она будет работать поверх OneWire.

Из оборудования понадобятся:

Один или несколько датчиков DS18B20;
Микроконтроллер Ардуино;
Коннекторы;
Резистор на 4,7 кОм (в случае подключения одного датчика пойдет резистор номиналом от 4 до 10K);
Монтажная плата;
USB-кабель для подключения к компьютеру.

К плате Ардуино UNO датчик подключается просто: GND с термодатчика присоединяется к GND Ардуино, Vdd подключается к 5V, Data – к любому цифровому пину.

Простейшая схема подключения цифрового датчика DS18B20 представлена на рисунке.

В режиме паразитного питания контакт Vdd с датчика подключается к GND на Ардуино – в этом случае пригодятся только два провода. Работу в паразитном режиме лучше не использовать без необходимости, так как могут ухудшиться быстродействие и стабильность.

Скетч для DS18B20

Алгоритм получения информации о температуре в скетче состоит из следующих этапов:

Определение адреса датчика, проверка его подключения.
На датчик подается команда с требованием прочитать температуру и выложить измеренное значение в регистр. Процедура происходит дольше остальных, на нее необходимо примерно 750 мс.
Подается команда на чтение информации из регистра и отправка полученного значения в «монитор порта»,
Если требуется, то производится конвертация в градусы Цельсия/Фаренгейта.

Пример простого скетча для DS18B20

Самый простой скетч для работы с цифровым датчиком выглядит следующим образом. (в скетче мы используем библиотеку OneWire, о которой поговорим подробнее чуть позже).

#include
/*
* Описание взаимодействия с цифровым датчиком ds18b20 * Подключение ds18b20 к ардуино через пин 8 */
OneWire ds(8); // Создаем объект OneWire для шины 1-Wire, с помощью которого будет осуществляться работа с датчиком void setup(){ Serial.begin(9600);
} void loop(){ // Определяем температуру от датчика DS18b20 byte data[2]; // Место для значения температуры ds.reset(); // Начинаем взаимодействие со сброса всех предыдущих команд и параметров ds.write(0xCC); // Даем датчику DS18b20 команду пропустить поиск по адресу. В нашем случае только одно устрйоство ds.write(0x44); // Даем датчику DS18b20 команду измерить температуру. Само значение температуры мы еще не получаем – датчик его положит во внутреннюю память delay(1000); // Микросхема измеряет температуру, а мы ждем. ds.reset(); // Теперь готовимся получить значение измеренной температуры ds.write(0xCC); ds.write(0xBE); // Просим передать нам значение регистров со значением температуры // Получаем и считываем ответ data[0] = ds.read(); // Читаем младший байт значения температуры data[1] = ds.read(); // А теперь старший // Формируем итоговое значение: // – сперва “склеиваем” значение, // – затем умножаем его на коэффициент, соответсвующий разрешающей способности (для 12 бит по умолчанию – это 0,0625) float temperature = ((data[1] TEMP_UPDATE_TIME) { lastUpdateTime = millis(); ds.reset(); ds.write(0xCC); ds.write(0xBE); data[0] = ds.read(); data[1] = ds.read(); // Формируем значение temperature = (data[1] > 4; }
}

Библиотека DallasTemperature и DS18b20

В своих скетчах мы можем использовать библиотеку DallasTemperature, упрощающую некоторые аспекты работы с датчиком ds18b20 по 1-Wire. Пример скетча:

#include
#include // Номер пина Arduino с подключенным датчиком
#define PIN_DS18B20 8 // Создаем объект OneWire
OneWire oneWire(PIN_DS18B20); // Создаем объект DallasTemperature для работы с сенсорами, передавая ему ссылку на объект для работы с 1-Wire.
DallasTemperature dallasSensors(&oneWire); // Специальный объект для хранения адреса устройства
DeviceAddress sensorAddress; void setup(void){ Serial.begin(9600); Serial.println(“Пример работы с датчиком температуры ds18b20 с помощью библиотеки DallasTemperature”); // Выполняем поиск устрйоств на линии Serial.print(“Ищем устройства…”); dallasSensors.begin(); Serial.print(“Найдено “); Serial.print(dallasSensors.getDeviceCount(), DEC); Serial.println(” устройств.”); // Определяем режим питания (по отдельной линии или через паразитное питание по линии данных) Serial.print(“Режим паразитного питания: “); if (dallasSensors.isParasitePowerMode()) Serial.println(“ВКЛЮЧЕН”); else Serial.println(“ВЫКЛЮЧЕН”); // Раскомментируйте, если хотите задать адрес устройства вручную //sensorAddress = { 0x28, 0x1D, 0x39, 0x31, 0x2, 0x0, 0x0, 0xF0 }; // Поиск устройства: // Ищем адрес устройства по порядку (индекс задается вторым параметром функции) if (!dallasSensors.getAddress(sensorAddress, 0)) Serial.println(“Не можем найти первое устройство”); // Второй вариант поиска с помощью библиотеки OnewWire. // Перезапускаем поиск //oneWire.reset_search(); // Находим первое устройство и запоминаем его адрес в sensorAddress //if (!oneWire.search(sensorAddress)) Serial.println(“Unable to find address for sensorAddress”); // Отображаем адрес ds18b20, который мы нашли Serial.print(“Адрес устройства: “); printAddress(sensorAddress); Serial.println(); // Устанавливаем разрешение датчика в 12 бит (мы могли бы установить другие значения, точность уменьшится, но скорость получения данных увеличится dallasSensors.setResolution(sensorAddress, 12); Serial.print(“Разрешение датчика: “); Serial.print(dallasSensors.getResolution(sensorAddress), DEC); Serial.println();
} void loop(void){ // Запрос на измерения датчиком температуры Serial.print(“Измеряем температуру…”); dallasSensors.requestTemperatures(); // Просим ds18b20 собрать данные Serial.println(“Выполнено”); // Запрос на получение сохраненного значения температуры printTemperature(sensorAddress); // Задержка для того, чтобы можно было что-то разобрать на экране delay(1000);
} // Вспомогательная функция печати значения температуры для устрйоства
void printTemperature(DeviceAddress deviceAddress){ float tempC = dallasSensors.getTempC(deviceAddress); Serial.print(“Temp C: “); Serial.println(tempC);
} // Вспомогательная функция для отображения адреса датчика ds18b20
void printAddress(DeviceAddress deviceAddress){ for (uint8_t i = 0; i < 8; i++) { if (deviceAddress[i] < 16) Serial.print("0"); Serial.print(deviceAddress[i], HEX); } }

Библиотека OneWire для работы с DS18B20

DS18B20 использует для обмена информацией с ардуино протокол 1-Wire, для которого уже написана отличная библиотека. Можно и нужно использовать ее, чтобы не реализовывать все функции вручную.

Скачать OneWire можно здесь. Для установки библиотеки скачайте архив, распакуйте в папку library вашего каталога Arduino.

Подключается библиотека с помощью команды #include<\p>

Основные команды библиотеки OneWire:

search(addressArray) – ищет температурный датчик, при нахождении в массив addressArray записывается его код, в ином случае – false.
reset_search() – производится поиск на первом приборе.
reset() – выполнение сброса шины перед тем, как связаться с устройством.
select(addressArray) – выбирается устройство после операции сброса, записывается его ROM код.
write(byte) – производится запись байта информации на устройство.
write(byte, 1) – аналогично write(byte), но в режиме паразитного питания.
read() – чтение байта информации с устройства.
crc8(dataArray, length) – вычисление CRC кода. dataArray – выбранный массив, length – длина кода.

Важно правильно настроить режим питания в скетче. Для паразитного питания в строке 65 нужно записать ds.write(0x44, 1);. Для внешнего питания в строке 65 должно быть записано ds.write(0x44).

Write позволяет передать команду на термодатчик. Основные команды, подаваемые в виде битов:

0x44 – измерить температуру, записать полученное значение в SRAM.
0x4E – запись 3 байта в третий, четвертый и пятый байты SRAM.
0xBE – последовательное считывание 9 байт SRAM.
0х48 – копирование третьего и четвертого байтов SRAM в EEPROM.
0xB8 – копирование информации из EEPROM в третий и четвертый байты SRAM.
0xB4 – возвращает тип питания (0 – паразитное, 1 – внешнее).

Подключение нескольких датчиков температуры DS18B20 к Ардуино

Все датчики DS18B20 подключаются параллельно, для них всех достаточно одного резистора. При помощи библиотеки OneWire можно одновременно считать все данные со всех датчиков. Если количество подключаемых датчиков более 10, нужно подобрать резистор с сопротивлением не более 1,6 кОм.

Также для более точного измерения температуры нужно поставить дополнительный резистор на 100…120 Ом между выходом data на плате Ардуино и data на каждом датчике.

Узнать, с какого датчика получено то или иное значение, можно с помощью уникального серийного 64-битного кода, который будет выдан в результате выполнения программы.

Для подключения температурных датчиков в нормальном режиме нужно использовать схему, представленную на рисунке.

В режиме паразитного питания схема выглядит иначе. Контакт Vdd практически не задействован, питание идет через выход data.

Выводы

Микросхема Dallas DS18B20 является очень интересным устройством. Датчики температуры и термометры, созданные на ее основе, обладают приемлемыми для большинства задач характеристиками, развитым функционалом, относительно не дороги. Особенную популярность датчик DS18B20 снискал как влагозащищенное устройство для измерения температуры жидкостей.

За дополнительные возможности приходится платить относительной сложностью работы с датчиком. Для подключения DS18B20 нам обязательно понадобится резистор с номиналом около 5К.

Для работы с датчиком в скетчах ардуино нужно установить дополнительную библиотеку и получить определенные навыки для работы с ней — там все не совсем тривиально.

Впрочем, можно купить уже готовый модуль, а для скетча в большинстве случаев хватит простых примеров, приведенных в этой статье.

Источник: https://ArduinoMaster.ru/datchiki-arduino/arduino-ds18b20/

Ардуино термометр на основе датчика температуры DS18B20

6 декабря в 14:09

Уроки / Arduino, Датчики

Один раз мы уже реализовали проект термометра на основе датчика температуры DS18B20. Сегодня мы сделаем термометр на основе этого датчика другим способом, разберемся с DS18B20 и используем несколько дополнительных библиотек.

Мы сделаем LCD-термометр или, как вариант, Serial-термометр (напечатает данные о температуре на последовательном мониторе Arduino IDE) на основе микроконтроллера Ардуино и цифрового датчика DS18B20, макетов, перемычек. Таким образом, вы сможете измерять температуру воздуха, жидкости, например, воды и температуру земли.

Информация о сенсоре DS18B20

DS18B20 – это цифровой температурный датчик с интерфейсом 1-Wire от Maxim IC. На выходе мы получаем информацию в Цельсиях с точностью от 9 до 12 бит, от -55 до 125 (+/- 0,5). Каждый датчик имеет уникальный 64-разрядный серийный номер, что позволяет использовать огромное количество датчиков на одной шине данных.

Особенности:

Для уникального интерфейса 1-Wire® требуется только один порт для связи.
Каждое устройство имеет уникальный 64-битный последовательный код, хранящийся в ПЗУ.
Многоточечная возможность упрощает использование распределенных температурных зондов.
Не требует внешних компонентов.
Может питаться от линии передачи данных.
Диапазон мощности от 3,0 до 5,5 В.
Измеряет температуру от -55°C до + 125°C (от -67 °F до + 257 °F) ± 0,5°C от -10°C до + 85°C.
Разрешение термометра выбирается пользователем от 9 до 12 бит.
Преобразует температуру в 12-битное цифровую переменную в 750 мс (макс.).
Определяемые пользователем энергонезависимые (NV) настройки сигнализации.
Команда поиска по тревоге идентифицирует и адресует устройства, температура которых находится за пределами запрограммированных пределов (состояние аварийной сигнализации).
Применяется в термостатических устройствах, промышленных системах, потребительских товарах, термометрах или в любых термических чувствительных системах.

Чтобы сделать термометр, вам понадобятся следующие детали:

Плата Arduino (UNO, DUE, Micro и т.п.);
Датчик DS18B20 (водонепроницаемый или нет);
Резистор 4.7К (в некоторых магазинах продается датчик с резистором 4,7 тыс.);
ЖК-дисплей 16×2 с шиной I2C;
Макет;
Перемычки.

Из программного обеспечения нужно иметь установленную Arduino IDE.

Библиотеки

Прежде чем вы начнете делать термометр, загрузите и распакуйте следующие библиотеки для Arduino в:

/Progam Files (x86)/Arduino/Libraries (по умолчанию):

Все библиотеки вы можете скачать по ссылкам выше или на нашем сайте в разделе Библиотеки.

Термометр через последовательный монитор

Чтобы отобразить данные на последовательном мониторе, подключите датчик DS18B20 к Arduino, используя перемычки и макет, и не забудьте подключить или припаять резистор 4.7k между контактом 2 и 3 датчика.

Затем скачайте, откройте и загрузите файл .ino, который называется – DS18B20_Serial, ниже.

Если все в порядке, вы должны увидеть измеренную температуру на серийном мониторе Arduino IDE.

Скачать DS18B20_SERIAL.

ino#include #include // Провод данных подключен к контакту 2 на Arduino #define ONE_WIRE_BUS 2 // Настройка oneWire для связи с любыми устройствами OneWire // (не только Maxim/Dallas температурные IC) OneWire oneWire(ONE_WIRE_BUS); DallasTemperature sensors(&oneWire); void setup(void) { // Старт серийного порта Serial.begin(9600); Serial.println(“Dallas Temperature IC демо”); // Запуск библиотеки sensors.begin(); } void loop(void) { // запрашиваем sensor.requestTemperatures() для получения глобальной температуры // запрос всех устройств на шине Serial.print(” Запрашиваем температуру…”); sensors.requestTemperatures(); // Отправляем команды для получения температуры Serial.println(“DONE”); Serial.print(“Температура: “); Serial.print(sensors.getTempCByIndex(0)); // Почему “byIndex”? // У вас может быть несколько IC на одной шине. // 0 относится к первой IC delay(1000); }

Термометр с ЖК-дисплеем

Если вы не хотите измерять температуру через последовательный монитор, то этот шаг для вас.

Подключите ЖК-дисплей I2C к контактам UNO:

A4 (SDA),
A5 (SCL),
к цифровому выходу 2.

Затем скачайте и загрузите файл .ino, который называется – DS18B20_I2C_LCD. Если все в порядке, вы увидите показания температуры на дисплее.

#include #include // #include #include LiquidCrystal_I2C lcd(0x27,16,2); #define ONE_WIRE_BUS 2 // Настройте oneWire для связи с любыми устройствами OneWire (а не только с микросхемами температуры Maxim / Dallas) OneWire oneWire(ONE_WIRE_BUS); DallasTemperature sensors(&oneWire); void setup() { lcd.init(); lcd.backlight(); sensors.begin(); } void loop() { sensors.requestTemperatures(); lcd.setCursor(0, 0); lcd.print(sensors.getTempCByIndex(0)); lcd.print(” *C”); delay(3000); }

На этом пока всё. Хороших вам проектов.

Источник: https://ArduinoPlus.ru/arduino-termometr-ds18b20/

Урок 26. Подключение термодатчиков DS18B20 к Ардуино. Библиотека OneWire. Точный Ардуино термометр-регистратор

В уроке узнаем, как подключать к плате Ардуино датчик температуры DS18B20, как управлять им с помощью библиотеки OneWire, разработаем точный термометр.

Предыдущий урок Список уроков Следующий урок

DS18B20 это интегральный датчик температуры с цифровым последовательным интерфейсом 1-Wire. Датчик с уникальными параметрами и функциональными возможностями. Я написал статью о нем. Сейчас я подчеркну особенности этого устройства, благодаря которым он получил такое широкое распространение. Датчику DS18B20 свойственны:

Высокая точностью измерения, погрешность не превышает 0,5 °C. Датчик откалиброван при изготовлении, дополнительной калибровки не требует.
Разрешающая способность задается программно и достигает 0,0625 °C при максимальном разрешении 12 бит.
Широкий диапазон измерения температуры -55 … + 125 °C.
Датчик осуществляет преобразование температуры в цифровой код, т.е. дополнительного АЦП не требует.
Передача информации осуществляется по последовательному протоколу 1-Wire, требуется только три провода для подключения термодатчика к микроконтроллеру.
Поддерживает режим ”паразитного питания”, в котором датчик получает питание от линии связи. В этом режиме для подключения устройства к микроконтроллеру достаточно двух проводной линии связи.
На одну линию связи может быть включено несколько датчиков.

Это главное. Различные режимы и функциональные возможности, связанные с работой нескольких устройств на одну линию, с тревожным сигналом и прочие в этой статье я не рассматриваю. В публикации делается упор на практическое использование датчика в самом распространенном режиме.

Подключение датчика DS18B20 к микроконтроллеру.

Самый распространенный вариант исполнения DS18B20 в корпусе TO-92.

Выводы на схемах подключения указаны для такого варианта. Существуют две стандартные схемы подключения DS18B20 к микроконтроллеру.

Схема питания с внешним источником.

Все просто: земля, питание, сигнал данных. Подтягивающий резистор строго необходим и устанавливается вблизи вывода микроконтроллера.

Схема в режиме ”паразитного питания” позволяет подключить термодатчик к микроконтроллеру всего двумя проводами, что особенно важно при размещении датчика на значительном расстоянии от контроллера.

В этом режиме сигнал шины данных заряжает внутренний конденсатор датчика и за счет энергии на нем происходит питание устройства при низком уровне на шине. У режима ”паразитного питания ” много особенностей. Можно почитать по ссылке. Сейчас скажу главное, что в этом режиме не гарантируется работа датчика при температуре свыше 100 °C. Надо использовать схему с внешним питанием.

Для такого случая я использую следующую схему.

Датчик работает в режиме внешнего питания, которое запасается через диод на дополнительном конденсаторе. В моих устройствах схема работает без проблем, но я не уверен, что такой вариант поддерживает библиотека OneWire. Я использовал эту схему только на PIC контроллерах с собственной библиотекой.

Обмен информацией с термодатчиком по шине интерфейса 1-Wire.

Если кто-то желает узнать подробную информацию по этому вопросу я опять дам ссылку на статью о DS18B20. Сейчас я перечислю необходимые нам операции работы с устройством:

Инициализация – последовательность импульсов, с которых начинается любая операция на шине.
Запись байта – передача байта данных в устройство DS18B20.
Чтение байта – прием данных из устройства DS18B20.

Этих трех операций достаточно для работы с термодатчиком, все они поддерживаются библиотекой OneWire.

Библиотека Ардуино OneWire для работы с интерфейсом 1-Wire.

Загрузить последнюю версию библиотеки OneWire можно по этой ссылке. Как установить ее можно посмотреть в уроке 9.

Нас интересуют следующие методы.

OneWire( uint8_t pin);

Конструктор, Pin – номер вывода, к которому подключен датчик.

OneWire sensDs (14); // датчик подключен к выводу 14

uint8_t reset(void);

Инициализация операции на шине. С этой команды должна начинаться любая операция обмена данными. Возвращает:

1 – если устройство подключено к шине (был ответный импульс присутствия);
0 – если устройство отсутствует на шине (ответного импульса не было).

void write(uint8_t v, uint8_t power = 0);

Запись байта. Передает байт в устройство на шине.

v – байт;
power – признак выбора режима питания;
- power=0 – питание от внешнего источника
- power=1 – “паразитное” питание.

uint8_t read(void);

Чтение байта – принимает байт, переданный устройством. Возвращает значение принятого байта.

Этих команд вполне достаточно, чтобы работать с датчиком DS18B20. Можно добавить методы записи и чтения блоков байтов и функцию вычисления контрольной суммы.

void write_bytes(const uint8_t *buf, uint16_t count, bool power = 0);

Запись блока байтов.

buf – указатель на массив;
count – число байтов;
power – признак выбора режима питания.

void read_bytes(uint8_t *buf, uint16_t count);

Чтение блока байтов.

buf – указатель на массив;
count – число байтов.

static uint8_t crc8(const uint8_t *addr, uint8_t len);

Функция вычисления 8ми разрядной контрольной суммы.

addr – указатель на массив данных;
len – число байтов.

Возвращает вычисленную сумму.

Последовательность операций работы с DS18B20.

Я приведу и объясню самую простую последовательность команд. Для измерения температуры необходимо выполнить следующую последовательность действий:

sensDs.reset() – Инициализация. Выполняет сброс шины, готовит ее для выполнения новой операции.
sensDs.write(0xCC, power) – Команда пропуск ROM. У нас только один датчик на шине. Поэтому нет необходимости в поиске устройства с нужным адресом. Мы эту операцию пропускаем.
sensDs.write(0x44, power) – Команда инициирует измерение температуры.
Пауза 1 сек. Ожидание на время, необходимое для выполнения датчиком преобразования температуры. Это время зависит от выбранной разрешающей способности датчика. Мы используем максимальное разрешение 12 бит. Это разрешение установлено в датчике по умолчанию. Время преобразования для него – 750 мс. Если необходима другая разрешающая способность, то ее необходимо задать дополнительными командами.
sensDs. reset() – Инициализация. Мы собираемся выполнить новую операцию на шине 1-Wire.
sensDs.write(0xCC, power) – Команда пропуск ROM.
sensDs.write(0xBE, power) – Команда чтения памяти датчика. Команда используется для чтения всех 9ти байтов памяти DS18B20.

Байт 0	Температура мл. байт
Байт 1	Температура ст. байт
Байт 2	Th регистр порога сигнализации
Байт 3	Tl регистр порога сигнализации
Байт 4	Регистр конфигурации
Байт 5	Зарезервирован
Байт 6	Зарезервирован
Байт 7	Зарезервирован
Байт 8	Циклический код CRC

read_bytes(buf, 9) – Чтение 9ти байтов данных.
crc8(addr, 8) – Вычисление контрольного кода данных.
Сравнение контрольного кода с принятым.

После этой последовательности операций значение температуры содержится в первых двух байтах массива из принятых 9ти байтов.

Отрицательная температура записывается в дополнительном коде.

Младший разряд имеет вес 0,0625 °C.

Проект Ардуино термометра с использованием датчика DS18B20.

Создадим термометр с функциями, аналогичными устройствам из урока 24 и урока 25. Использование термодатчика DS18B20 позволяет добиться:

высокой точности измерения 0,5 °C;
высокой разрешающей способности 0,0625 °C:
диапазон измерения составляет -55 … +125 °C.

Схема термометра с датчиком DS18B20.

Led индикатор подключен по привычной схеме из предыдущих уроков. Есть два варианта подключения термодатчика: с внешним питанием и ”паразитным питанием.”

На моем макете устройство выглядит так.

Резидентная программа Ардуино термометра.

Структура и большая часть программы из предыдущих уроков 24 и 25. Последовательность операций для DS18B20 подробно описаны выше. Поэтому я сразу приведу скетч программы.

// термометр, датчик DS18B20
#include
#include
#include<\p>

#define POWER_MODE 0 // режим питания, 0 – внешнее, 1 – паразитное

// тип индикатора 1; выводы разрядов 5,4,3,2; выводы сегментов 6,7,8,9,10,11,12,13
Led4Digits disp(1, 5,4,3,2, 6,7,8,9,10,11,12,13);

OneWire sensDs (14); // датчик подключен к выводу 14

byte bufData[9]; // буфер данных
float temperature; // измеренная температура

void setup() {
MsTimer2::set(2, timerInterrupt); // задаем период прерывания по таймеру 2 мс
MsTimer2::start(); // разрешаем прерывание по таймеру
Serial.begin(9600); // инициализируем порт, скорость 9600
}

void loop() {

sensDs.reset(); // сброс шины
sensDs.write(0xCC, POWER_MODE); // пропуск ROM
sensDs.write(0x44, POWER_MODE); // инициализация измерения
delay(900); // пауза 0,9 сек
sensDs.

reset(); // сброс шины
sensDs.write(0xCC, POWER_MODE); // пропуск ROM
sensDs.write(0xBE, POWER_MODE); // команда чтения памяти датчика
sensDs.

read_bytes(bufData, 9); // чтение памяти датчика, 9 байтов

if ( OneWire::crc8(bufData, 8) == bufData[8] ) { // проверка CRC
    // данные правильные
    temperature= (float)((int)bufData[0] | (((int)bufData[1]) = 0) {
      // температура положительная
      disp.print((int)(temperature * 10.

), 4, 1);
    }
    else {
      // температура отрицательная
      disp.print((int)(temperature * -1 * 10.), 3, 1);
      disp.digit[3]= 0x40; // отображается минус
    }
    disp.

digit[1] |= 0x80; // зажечь точку второго разряда

    // передача температуры на компьютер
    Serial.println(temperature);
}
else {
    // ошибка CRC, отображается —-
      disp.digit[0]= 0x40;
      disp.

digit[1]= 0x40;
      disp.digit[2]= 0x40;
      disp.digit[3]= 0x40;
}
}

//————————————– обработчик прерывания 2 мс
void timerInterrupt() {
disp.regen(); // регенерация индикатора
}

Загрузить скетч можно по этой ссылке:

Зарегистрируйтесь и оплатите. Всего 25 руб. в месяц за доступ ко всем ресурсам сайта!

Программа использует библиотеки OneWire, MsTimer2 и Led4Digits.

Не забудьте выбрать в программе режим питания датчика:

#define POWER_MODE 0 // режим питания, 0 – внешнее, 1 – паразитное

Программа верхнего уровня для Ардуино термометра-регистратора.

С этим устройством работает программа Thermometer из урока 24. В уроке можно загрузить программу, получить информацию по установке и применению программы.

Реализация измерения температуры параллельным процессом.

В проекте термометра управление термодатчиком DS18B20 происходит в основном цикле программы. Задержка 0,9 секунд реализована функцией delay(). Программа на это время зависает и никаких других действий производить не может. Хорошо, что нам в термометре больше ничего делать не надо. А если у нас сложная программа с множеством других задач.

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

// термометр, датчик DS18B20
#include
#include
#include<\p>

#define POWER_MODE 0 // режим питания, 0 – внешнее, 1 – паразитное
#define MEASURE_PERIOD 500 // время измерения, * 2 мс

// тип индикатора 1; выводы разрядов 5,4,3,2; выводы сегментов 6,7,8,9,10,11,12,13
Led4Digits disp(1, 5,4,3,2, 6,7,8,9,10,11,12,13);

OneWire sensDs (14); // датчик подключен к выводу 14

int timeCount; // счетчик времени измерения
boolean flagSensReady; // признак готовности данных с датчика
byte bufData[9]; // буфер данных
float temperature; // измеренная температура

void loop() {

if ( flagSensReady == true ) {
flagSensReady= false;
// данные готовы

   if ( OneWire::crc8(bufData, 8) == bufData[8] ) { // проверка CRC
      // данные правильные
      temperature= (float)((int)bufData[0] | (((int)bufData[1]) = 0) {
        // температура положительная
        disp.print((int)(temperature * 10.

), 4, 1);
      }
      else {
        // температура отрицательная
        disp.print((int)(temperature * -1 * 10.), 3, 1);
        disp.digit[3]= 0x40; // отображается минус
      }
      disp.

digit[1] |= 0x80; // зажечь точку второго разряда

      // передача температуры на компьютер
      Serial.println(temperature);
    }
    else {
      // ошибка CRC, отображается —-
        disp.digit[0]= 0x40;
        disp.

digit[1]= 0x40;
        disp.digit[2]= 0x40;
        disp.digit[3]= 0x40;
    }
}
}

//————————————– обработчик прерывания 2 мс
void timerInterrupt() {
disp.regen(); // регенерация индикатора

// управление датчиком DS18B20 паралллельным процессом
timeCount++; if ( timeCount >= MEASURE_PERIOD ) { timeCount=0; flagSensReady=true; }

if (timeCount == 0) sensDs.reset(); // сброс шины
if (timeCount == 1) sensDs.write(0xCC, POWER_MODE); // пропуск ROM
if (timeCount == 2) sensDs.write(0x44, POWER_MODE); // инициализация измерения

if (timeCount == 480) sensDs.reset(); // сброс шины
if (timeCount == 481) sensDs.write(0xCC, POWER_MODE); // пропуск ROM
if (timeCount == 482) sensDs.write(0xBE, POWER_MODE); // команда чтения памяти датчика

if (timeCount == 483 ) bufData[0]= sensDs.

read(); // чтение памяти датчика
if (timeCount == 484 ) bufData[1]= sensDs.read(); // чтение памяти датчика
if (timeCount == 485 ) bufData[2]= sensDs.read(); // чтение памяти датчика
if (timeCount == 486 ) bufData[3]= sensDs.read(); // чтение памяти датчика
if (timeCount == 487 ) bufData[4]= sensDs.

read(); // чтение памяти датчика
if (timeCount == 488 ) bufData[5]= sensDs.read(); // чтение памяти датчика
if (timeCount == 489 ) bufData[6]= sensDs.read(); // чтение памяти датчика
if (timeCount == 490 ) bufData[7]= sensDs.read(); // чтение памяти датчика
if (timeCount == 491 ) bufData[8]= sensDs.

read(); // чтение памяти датчика
}

После получения данных с датчика DS18B20 формируется признак о готовности данных и в основном асинхронном процессе они могут быть использованы.

В обработчике прерываний все операции с датчиком выполняются по принципу – одна операция с байтом за один цикл прерывания. Во время паузы 0,9 сек, вообще ничего не делается. Так что в основном цикле может выполняться другая задача без значительной задержки.

В следующем уроке планирую рассказать об измерении температуры в системе Ардуино с помощью термопар. Будет рабочий проект Ардуино термометра для высоких температур.

Предыдущий урок Список уроков Следующий урок

Источник: http://mypractic.ru/urok-26-podklyuchenie-termodatchikov-ds18b20-k-arduino-biblioteka-onewire-tochnyj-arduino-termometr-registrator.html

Термометр с помощью arduino и датчиков LM35 и DS18B20

Я писал недавно статью, где подключал к arduino 4-разрядный 7-сегментный индикатор hs420561k-32, тогда упоминал, что хочу сделать градусник с выводом температуры на этот индикатор, только проблема была в отсутствии датчиков.

И вот наконец-то приехала посылка с недостающими запчастями и можно продолжить проект. Температурных датчиков у меня три штуки – dht11, LM35 и DS18B20.

Но использовать буду только LM35 и DS18B20, поскольку dht11 очень неточный, в даташите написано, что отклонения от реальной температуры составляют плюс-минус два градуса, а так же он работает только с положительной температурой.

Температурный датчик LM35. Подключение к arduino

Первый датчик, который будем использовать – это LM35, использовать его очень просто, тут даже дополнительные библиотеки не требуются, достаточно подключить к нему питание и считать данные на выходе с помощью аналогового пина arduino. LM35 работает с температурами от -55 до 150 градусов Цельсия и если верить даташиту, то погрешность составляет всего плюс-минус 0,25 градуса.

Хоть датчик и обрабатывает до +150 градусов, но считать ардуиной сможем только до +110, хотя и это более чем достаточно для домашнего градусника. Поскольку этот датчик имеет высокую точность, но находится в корпусе TO92, без какой-либо дополнительной защиты, использовать его будем для измерения температуры в помещении.

Официальный мануал arduino рекомендует использовать для снятия показаний этого датчика опорное напряжение 1,1 В. Чтобы настроить arduino подобным образом достаточно использовать команду analogReference(INTERNAL) в функции setup. Далее достаточно просто, с нужным интервалом, считывать напряжение с выходной ножки(OUT) датчика.

LM35 формирует напряжение 10 милливольт на один градус, таким образом имея опорное напряжение в 1,1 В легко обработать, довольно точно, данные.

void setup() { // меняем опорное напряжение на 1.1 В, относительно которого происходят аналоговые измерения analogReference(INTERNAL); } void loop() { reading = analogRead(A0); // LM35 подключен к пину A0 temperature = (1.1 * reading * 100.0) / 1024; // получаем значение в градусах Цельсия }

Ниже на картинке показано, какая нога датчика LM35 за что отвечает.

Температурный датчик DS18B20. Подключение к arduino

Второй датчик, который будет использован – это цифровой DS18B20. Точность в этом случае не на много ниже — плюс-минус 0,5 градуса, а диапазон измерения температуры практически такой же: от -55 до +125 градусов Цельсия.

Большим преимуществом является то, что датчик находится внутри влагозащитного корпуса, а так же имеется кабель длиной 1 метр, что позволяет вынести его на улицу, когда само устройство будет находиться в помещении.

Еще из плюсов сюда можно добавить возможность подключение одновременно до 127 датчиков на один пин ардуино, только я даже предположить не могу, где это может пригодиться :).
Считывать данные с DS18B20 немного сложнее, чем с LM35, для удобства можно воспользоваться библиотекой OneWire.

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

На картинке ниже показано, как подключать датчик DS18B20. Основным моментом является то, что необходимо использовать резистор сопротивлением 4.7 кОм для соединения провода, передающего данные и плюсовым.

Проблема вывода температуры на индикаторе hs420561k-32

Пока я разбирался с каждым датчиком по отдельности, а также когда подключал к arduino 4-х разрядный 7-сегментнтый индикатор, проблем ни каких не было, все прекрасно работало. Но стоило мне собрать все в кучу, на одну макетную плату и собрать код воедино, как сразу появилась серьезная проблема.

Я писал в прошлой статье, что для одновременного вывода данных сразу на 4-х разрядах hs420561k-32 необходимо очень быстро по очереди выводить по одному разряду, тогда создается впечатление одновременного вывода четырех цифр, глаз не успевает уловить смену разрядов.

В связи с таким способом вывода возникла сложность с одновременной работой датчика DS18B20, для его опроса требуется чуть больше секунды времени – в двух участках кода используется delay, который заставляет микроконтроллер ждать, 250 и 1000 миллисекунд.

Сначала я сделал запрос к датчику раз в 30 секунд, но это не решило проблему – два раза в минуту датчик по секунде показывал непонятно что. Поэтому пришлось отказаться от delay и добавить другую аналогичную конструкцию в код, которая будет выполнять определенные куски кода с задержкой, а остальной код будет выполняться без задержек.

Многопоточности в arduino, как оказалось, нет, но есть псевдомногопоточность, добиться ее можно используя не хитрую конструкцию с таймером, который отмеряет время в миллисекундах от старта работы микроконтроллера. Пример такого кода я приведу ниже:

bool flag = false; // флаг unsigned long previousMillis = 0; // время последнего срабатывания const long interval = 1000; // интервал срабатывания кода, задержка. void setup() { // } void loop() { // получаем время в миллисекундах, которое прошло // с момента начала работы МК unsigned long currentMillis = millis(); // проверяем сколько прошло врмени if (currentMillis – previousMillis >= interval) { // если прошло нужное количество миллисекунд, // то записываем в переменную количество прошедшего времени previousMillis = currentMillis; // меняем положение флага, // это может быть вкл и выкл светодиода, например flag = !flag; } }

Что использовалось в проекте:

Скетч уличного и комнатного термометра на arduino

Все сложные моменты, с которыми возникали сложности, в процессе создания термометра я описал, теперь остается только написать скетч, его код приведен ниже, а также доступен для скачивания тут: скачать.

#include // библиотека для работы с датчиком DS18B20 OneWire ds(10); // подключаем уличный датчик к 10 пину //Пин подключен к SH_CP входу 74HC595 int clockPin = 6; //Пин подключен к ST_CP входу 74HC595 int latchPin = 7; //Пин подключен к DS входу 74HC595 int dataPin = 8; int tempHomePin = A0; // градусник в помещении // Пины разрядов цифер int pins_numbers[4] = {2, 3, 4, 5}; // Биты для отображения цифер от 0-9, минуса и символ градуса Цельсия byte numbers_array[22] = { B00111111, B00000110, B01011011, B01001111, // 0 1 2 3 B01100110, B01101101, B01111101, B00000111, // 4 5 6 7 B01111111, B01101111, B01000000, B01100011, // 8 9 – о // цифры с точкой внизу (+12 к индексу элемента) B10111111, B10000110, B11011011, B11001111, // 0 1 2 3 B11100110, B11101101, B11111101, B10000111, // 4 5 6 7 B11111111, B11101111 // 8 9 }; int cel_celsius = 0; // переменная для хранения градусов на улице float tempHome = 0; // переменная для хранения градусов в помещении const long tempInterval = 3000; // интервал запроса актуальной температуры unsigned long previousMillis = 0; // время предыдущего запроса unsigned long previousMillis_delay = 0; // хранения последней даты срабатывания, для второй задержки bool startQuery = false; // флаг, для обозначения начала запроса температуры bool firstQuery = true; // флаг первого запуска, при котором получаем температуру без задержек bool showhome = true; // флаг, который указывают какую температуру показывать – комнату или улицу int sec_show = 5000; // интервал смены отображения погоды unsigned long showhomeMillis_delay = 0; // хранения последней переключения градусников // функция для вывода чисел на индикаторе void showNumber(int numNumber, int number){ // зажигаем нужные сегменты digitalWrite(latchPin, LOW); shiftOut(dataPin, clockPin, MSBFIRST, numbers_array[number]); digitalWrite(latchPin, HIGH); // включаем нужный разряд(одну из четырех цифр) int num_razryad = pins_numbers[numNumber-1]; for(int i; i= tempInterval) || startQuery || firstQuery) { previousMillis = currentMillis; // читаем данные от датчика на улицы if ( !ds.search(addr)) { ds.reset_search(); //delay(250); return; } // если ни чего не получили или получили не понятные данные if (OneWire::crc8(addr, 7) != addr[7]) { return; } // читаем первый байт и определяем тип датчика switch (addr[0]) { case 0x10: // DS18S20 type_s = 1; break; case 0x28: // DS18B20 type_s = 0; break; case 0x22: // DS1822 type_s = 0; break; default: return; } // делаем запрос на получение данных от датчика ds.reset(); ds.select(addr); ds.write(0x44); // ждем startQuery = true; // delay(1000); if ( currentMillis – previousMillis_delay >= 1000 ) { previousMillis_delay = currentMillis; }else{ return; } startQuery = false; // и получаем ответ present = ds.reset(); ds.select(addr); ds.write(0xBE); // берем только первые 9 байт for ( i = 0; i < 9; i++) { data[i] = ds.read(); } // данные приходят в битах, переводим их в десятичное число int16_t raw = (data[1]

Источник: https://vk-book.ru/termometr-s-pomoshhyu-arduino-datchikov-lm35-ds18b20/

Белоярский. Новости, комментарии. – Подключение датчика DS18B20

После того, как мы вволю помигали диодами в прошлой статье, пора переходить к чему-нибудь более полезному в хозяйстве. Ну, например, сделать цифровой термометр, что-ли. Тем более, что с Ардуино – это совсем не так сложно, как было в “доконтроллерную эпоху”.

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

Ну, и – соответствующей подготовки радиолюбителя, который задумает все это собрать. Сейчас с этим – все гораздо проще.

Разрешите представить – цифровой датчик температуры буржуинской фирмы “Dallas semiconductor” DS18B20.

Полностью функциональное устройство для точного (до нескольких знаков после запятой) измерения температуры в диапазоне от -55 до +120 градусов Цельсия.

Кроме того – имеется даже немного “мозгов” (ячеек памяти) для запоминания чего-нибудь полезного. Но пока что мы ими пользоваться не будем. Как видно на рисунке – выпускается в нескольких вариациях.

Самая распространенная и для нас удобная – та, где написано “ТО-92”.

Датчик имеет всего 3 вывода, на два из которых подается напряжение питания 5в, а средний вывод – для передачи данных. Все управление датчиком (подача на него команд, считывание измеренной температуры) идет по единственному проводнику, поэтому вся эта технология и протокол приема-передачи называется “1-Wire” или “One-Wire”.

Чтобы не сильно загружаться теорией, примерно рассмотрим вкратце процесс измерения температуры с помощью нашего датчика.

Каждый сеанс передачи или приема данных начинается с команды инициализации. Опять же не будем вдаваться в подробности общения Ардуины с термометром, за нас это сделали посторонние люди (мысленно скажем им спасибо). Просто передадим ей одну команду – “инициализация”, и она сама разберется, что надо сделать.

Далее, после инициализации, начинаем подавать управляющие команды. Тут надо заметить, что на одном управляющем проводке, теоретически, может находиться несколько устройств семейства “1-Wire”. Причем, не только датчики температуры.

Поэтому, есть возможность обращаться к каждому из них по уникальному серийному номеру. Но, поскольку у нас на проводе единственный датчик, то ни к чему другому мы не можем обратиться в принципе. Поэтому эти прелюдии пропускаются командой (передаваемым байтом “0хСС”).

Забыл сказать – здесь и далее используется шеснадцатиричная запись двоичных чисел (байтов).

После того, как определились с адресатом – передаем команду “измерить температуру” (“0х44”). После этого нужно оставить датчик в покое примерно на 1 секунду, пока он будет делать свои дела.

За это время “ds-ка” измерит температуру и запишет результаты в два байта, которые нам нужно у нее выудить и привести к человеческому виду. Начинаем, как всегда, с инициализации сеанса связи. Потом снова передаем команду “сброс передачи адреса” (“0хСС”). И тут же следом – сообщаем, что готовы принять результат измерения: (“0хВЕ”).

После этого Ардуина получает последовательно 2 байта (или двухбайтное число – кому как нравится) с результатами. Посмотрим, что это за результаты и как нам привести их к удобоваримому виду.

Опять же, чтоб не сильно грузиться, определимся с тем, что для нас важно. А именно – в младшем и, частично, в старшем байте находится результат измерения температуры с точностью до 4-го знака после запятой (нам такая точность – излишня). Знак температуры (“+” или “-“) определяется значением старшего бита старшего байта.

Но, довольно слов – пора заняться конструированием. Схема подключения DS18B20 к Ардуине не только проста – а элементарно проста:

Выводы питания датчика подключены к соответствующим выводам Ардуины, а вывод данных – к цифровому выходу “10”. Кроме того, вывод данных подключен к шине +5 вольт через резистор 3 – 5 килоом (так называемый “подтягивающий” резистор).

Заметьте, что цифровой выход “10”, хотя он будет работать и на выход, и на вход, нам уже не придется настраивать, как в предыдущем примере со светодиодами. Разработчики библиотеки “1-Wire” заботливо освободили нас от всякой черновой работы.

Спасибо им за это!

В-общем, у меня получилось, примерно, так:

Да! Совсем забыл! Библиотека “1-Wire” не входит в базовую поставку Arduino IDE, поэтому ее нужно скачать, например, отсюда. Распакуем архив и положим папку с библиотекой в директорию libraries, которая находится в папке, где установлена Arduino IDE. При следующем запуске среды разработки – библиотека будет доступна для использования. Вот где ее можно найти:

Однако, не будем использовать скетч из “Образцов”, там сильно всего наворочено. Лучше скопируем в Arduino IDE вот такой скетч:

#include<\p>

OneWire ds(10); //

void setup(void) {
Serial.begin(9600); //настраиваем последовательный порт для вывода результатов
}

void loop() {
byte data[2];           // объявляем массив из 2-х байт
ds.reset();             // инициализируем датчик
ds.write(0xCC);         // пропускаем адресацию к конкретному датчику (у нас он один)
ds.

write(0x44);         // даем команду измерять температуру
delay(1000);           // ждем 1 секунду, пока измеряется температура

ds.reset();            // снова инициализируем датчик
ds.write(0xCC);        // снова пропускаем адресацию
ds.

write(0xBE);         // даем команду готовности считывать температуру
data[0] = ds.read();    //считываем младший
data[1] = ds.read();    // и старший байты
int Temp = (data[1] > 4;                     // к нужному виду.
Serial.

println(Temp); // выводим результат в последовательный порт.

}

Что мы тут видим… Сначала к скетчу подключается библиотека “OneWire”. Указываем, что наш датчик подключен к выводу “10” Ардуины. Затем настраивается последовательный порт для вывода результатов измерения. Все, подготовительные операции закончены, начинаем измерять.

Подготавливаем (резервируем и называем) 2 байта, куда будем записывать результат измерения температуры. Затем – подаем команды, как описывалось выше и, наконец, получаем 2 байта с нашей температурой. Затем происходит преобразование считанной информации и удаление лишних знаков после запятой с тем, чтобы получить целое значение температуры, без десятичных дробей.

Эта информация и выводится через последовательный порт. Где мы можем ее увидеть? А вот здесь:

Итак, загружаем этот скетч в Ардуину, открываем “Монитор последовательного порта” и наблюдаем каждую секунду измеренную температуру:

Ура! Заработало! Не будем вдаваться в подробности процесс преобразования полученных от датчика 2-х байт в целое число температуры, это тема для отдельной большой статьи. Скажу только, что полученное число – переменная Temp типа integer. То есть, она может принимать как положительные значения, так и отрицательные. Проверим работу нашего устройства на морозце:

Ну что же – показывает и отрицательные температуры. Даже прямо сразу со знаком. В дальнейшем, когда мы будем выводить температуру на различные индикаторы, надо будет запомнить эту особенность нашей программы. И предусмотреть дополнительно индикацию знака плюсовой температуры. Но про то – уже в следующих статьях.