7 практических проектов с температурными датчиками Arduino: обзор

#include <Wire.h>
#include <Adafruit_BME280.h>
#include <LiquidCrystal_I2C.h>

Adafruit_BME280 bme;
LiquidCrystal_I2C lcd(0x27, 16, 2);

void setup() {
Serial.begin(9600);
lcd.init();
lcd.backlight();

if (!bme.begin(0x76)) {
lcd.print("BME280 error!");
while (1);
}
}

void loop() {
float temperature = bme.readTemperature();
float humidity = bme.readHumidity();
float pressure = bme.readPressure() / 100.0F;

lcd.clear();
lcd.setCursor(0, 0);
lcd.print("Temp: ");
lcd.print(temperature, 1);
lcd.print(" C");

lcd.setCursor(0, 1);
lcd.print("Hum: ");
lcd.print(humidity, 1);
lcd.print("% ");
lcd.print(pressure, 0);
lcd.print("hPa");

delay(5000);
}

#include <OneWire.h>
#include <DallasTemperature.h>
#include <LiquidCrystal_I2C.h>

#define ONE_WIRE_BUS 2 // Пин подключения датчика DS18B20
#define RELAY_PIN 7 // Пин управления реле
#define BUTTON_UP 3 // Кнопка увеличения температуры
#define BUTTON_DOWN 4 // Кнопка уменьшения температуры

OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);
LiquidCrystal_I2C lcd(0x27, 16, 2);

float setTemp = 22.0; // Заданная температура
float currentTemp = 0.0; // Текущая температура
float hysteresis = 0.5; // Гистерезис

void setup() {
pinMode(RELAY_PIN, OUTPUT);
pinMode(BUTTON_UP, INPUT_PULLUP);
pinMode(BUTTON_DOWN, INPUT_PULLUP);

digitalWrite(RELAY_PIN, LOW);

lcd.init();
lcd.backlight();
sensors.begin();

lcd.print("Smart Thermostat");
delay(2000);
lcd.clear();
}

void loop() {
// Считываем температуру
sensors.requestTemperatures();
currentTemp = sensors.getTempCByIndex(0);

// Проверяем кнопки регулировки
if (digitalRead(BUTTON_UP) == LOW) {
setTemp += 0.5;
delay(200);
}

if (digitalRead(BUTTON_DOWN) == LOW) {
setTemp -= 0.5;
delay(200);
}

// Управление реле с гистерезисом
if (currentTemp < (setTemp – hysteresis)) {
digitalWrite(RELAY_PIN, HIGH); // Включаем обогреватель
} else if (currentTemp > (setTemp + hysteresis)) {
digitalWrite(RELAY_PIN, LOW); // Выключаем обогреватель
}

// Обновляем дисплей
lcd.clear();
lcd.setCursor(0, 0);
lcd.print("Current: ");
lcd.print(currentTemp, 1);
lcd.print(" C");

lcd.setCursor(0, 1);
lcd.print("Set: ");
lcd.print(setTemp, 1);
lcd.print(" C ");

// Показываем статус обогревателя
if (digitalRead(RELAY_PIN) == HIGH) {
lcd.print("ON");
} else {
lcd.print("OFF");
}

delay(1000);
}

#include <OneWire.h>
#include <DallasTemperature.h>
#include <ESP8266WiFi.h>
#include <ESP8266HTTPClient.h>
#include <LiquidCrystal_I2C.h>

#define ONE_WIRE_BUS 2 // Пин подключения датчиков DS18B20
#define ALARM_PIN 7 // Пин для сирены

const char* ssid = "YourWiFiName";
const char* password = "YourWiFiPassword";
const char* serverUrl = "http://your-server.com/api/temperature";

OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);
LiquidCrystal_I2C lcd(0x27, 16, 2);

const int sensorCount = 3; // Количество датчиков
float temperatures[sensorCount];
String sensorNames[sensorCount] = {"Rack1", "Rack2", "Room"};
float maxTemp[sensorCount] = {32.0, 32.0, 28.0}; // Критические значения

unsigned long lastCheckTime = 0;
const long checkInterval = 30000; // Интервал проверки (30 секунд)

void setup() {
Serial.begin(115200);
pinMode(ALARM_PIN, OUTPUT);
digitalWrite(ALARM_PIN, LOW);

lcd.init();
lcd.backlight();
lcd.print("Server Room");
lcd.setCursor(0, 1);
lcd.print("Temp Monitor");

sensors.begin();

// Подключаемся к WiFi
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("\nWiFi connected");

delay(2000);
lcd.clear();
}

void loop() {
unsigned long currentMillis = millis();

if (currentMillis – lastCheckTime >= checkInterval) {
lastCheckTime = currentMillis;

// Запрашиваем температуру со всех датчиков
sensors.requestTemperatures();

bool alarmCondition = false;
String dataToSend = "{\"sensors\":[";

for (int i = 0; i < sensorCount; i++) {
temperatures[i] = sensors.getTempCByIndex(i);

// Проверяем на превышение порога
if (temperatures[i] > maxTemp[i]) {
alarmCondition = true;
}

// Формируем JSON для отправки
dataToSend += "{\"name\":\"" + sensorNames[i] + "\",\"temp\":" + String(temperatures[i], 1) + "}";
if (i < sensorCount – 1) dataToSend += ",";

// Выводим на LCD поочередно
if (i < 2) { // На экран помещается информация о двух датчиках
lcd.setCursor(0, i);
lcd.print(sensorNames[i] + ": ");
lcd.print(temperatures[i], 1);
lcd.print("C");
if (temperatures[i] > maxTemp[i]) lcd.print(" !");
}
}
dataToSend += "]}";

// Активируем тревогу при превышении
if (alarmCondition) {
digitalWrite(ALARM_PIN, HIGH);
delay(500);
digitalWrite(ALARM_PIN, LOW);
}

// Отправляем данные на сервер
if (WiFi.status() == WL_CONNECTED) {
HTTPClient http;
http.begin(serverUrl);
http.addHeader("Content-Type", "application/json");
int httpCode = http.POST(dataToSend);

if (httpCode > 0) {
String response = http.getString();
Serial.println(httpCode);
Serial.println(response);
} else {
Serial.println("Error on HTTP request");
}
http.end();
}
}

// Проверяем тревожное состояние каждый цикл
bool currentAlarm = false;
for (int i = 0; i < sensorCount; i++) {
if (temperatures[i] > maxTemp[i]) {
currentAlarm = true;
}
}

if (currentAlarm) {
// Мигаем подсветкой дисплея для привлечения внимания
if ((millis() / 500) % 2 == 0) {
lcd.backlight();
} else {
lcd.noBacklight();
}
} else {
lcd.backlight();
}

delay(100);
}

#include <DHT.h>
#include <Servo.h>
#include <LiquidCrystal_I2C.h>
#include <RTClib.h>

#define DHT_PIN_1 2 // Первый датчик DHT22
#define DHT_PIN_2 3 // Второй датчик DHT22
#define DHT_TYPE DHT22

#define HEATER_PIN 7 // Реле обогревателя
#define FAN_PIN 8 // Реле вентилятора
#define WINDOW_SERVO 9 // Сервопривод форточки

// Параметры микроклимата
float minTemp = 18.0; // Минимальная допустимая температура
float maxTemp = 28.0; // Максимальная допустимая температура
float maxHumidity = 80.0; // Максимальная допустимая влажность

DHT dht1(DHT_PIN_1, DHT_TYPE);
DHT dht2(DHT_PIN_2, DHT_TYPE);
Servo windowServo;
LiquidCrystal_I2C lcd(0x27, 16, 2);
RTC_DS3231 rtc;

int windowPosition = 0; // Текущее положение форточки (0-180)

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

dht1.begin();
dht2.begin();

pinMode(HEATER_PIN, OUTPUT);
pinMode(FAN_PIN, OUTPUT);

digitalWrite(HEATER_PIN, LOW); // Выключаем обогреватель
digitalWrite(FAN_PIN, LOW); // Выключаем вентилятор

windowServo.attach(WINDOW_SERVO);
windowServo.write(windowPosition);

lcd.init();
lcd.backlight();
lcd.print("Greenhouse");
lcd.setCursor(0, 1);
lcd.print("Control System");

if (!rtc.begin()) {
lcd.clear();
lcd.print("RTC Error!");
while(1);
}

// Устанавливаем время, если RTC был сброшен
if (rtc.lostPower()) {
rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
}

delay(2000);
lcd.clear();
}

void loop() {
// Считываем данные с датчиков
float temp1 = dht1.readTemperature();
float hum1 = dht1.readHumidity();
float temp2 = dht2.readTemperature();
float hum2 = dht2.readHumidity();

// Проверяем на ошибки считывания
if (isnan(temp1) || isnan(hum1)) {
Serial.println("Sensor 1 error!");
temp1 = 0;
hum1 = 0;
}

if (isnan(temp2) || isnan(hum2)) {
Serial.println("Sensor 2 error!");
temp2 = 0;
hum2 = 0;
}

// Вычисляем средние значения
float avgTemp = (temp1 + temp2) / 2;
float avgHum = (hum1 + hum2) / 2;

// Получаем текущее время
DateTime now = rtc.now();
bool isDayTime = (now.hour() >= 7 && now.hour() < 20); // Определяем день/ночь

// Корректируем целевую температуру в зависимости от времени суток
float targetMinTemp = isDayTime ? minTemp : (minTemp – 3.0); // Ночью допускаем более низкую температуру
float targetMaxTemp = isDayTime ? maxTemp : (maxTemp – 3.0);

// Логика управления обогревом
if (avgTemp < targetMinTemp) {
digitalWrite(HEATER_PIN, HIGH); // Включаем обогреватель
} else if (avgTemp > (targetMinTemp + 1.5)) {
digitalWrite(HEATER_PIN, LOW); // Выключаем обогреватель с гистерезисом
}

// Логика управления вентиляцией
bool needVentilation = (avgTemp > targetMaxTemp) || (avgHum > maxHumidity);

if (needVentilation) {
// Сначала пробуем проветрить через форточку
if (windowPosition < 180) {
windowPosition += 10;
if (windowPosition > 180) windowPosition = 180;
windowServo.write(windowPosition);
} 
// Если форточки недостаточно, включаем вентилятор
else {
digitalWrite(FAN_PIN, HIGH);
}
} else {
// Если вентиляция не требуется, закрываем форточку и выключаем вентилятор
if (avgTemp < (targetMaxTemp – 2.0) && avgHum < (maxHumidity – 5.0)) {
digitalWrite(FAN_PIN, LOW);

if (windowPosition > 0) {
windowPosition -= 10;
if (windowPosition < 0) windowPosition = 0;
windowServo.write(windowPosition);
}
}
}

// Выводим информацию на дисплей
lcd.clear();
lcd.setCursor(0, 0);
lcd.print("T:");
lcd.print(avgTemp, 1);
lcd.print("C H:");
lcd.print(avgHum, 0);
lcd.print("%");

lcd.setCursor(0, 1);
lcd.print("H:");
if (digitalRead(HEATER_PIN)) lcd.print("ON"); else lcd.print("OFF");
lcd.print(" F:");
if (digitalRead(FAN_PIN)) lcd.print("ON"); else lcd.print("OFF");
lcd.print(" W:");
lcd.print(map(windowPosition, 0, 180, 0, 100));
lcd.print("%");

delay(5000); // Опрос каждые 5 секунд
}

#include <OneWire.h>
#include <DallasTemperature.h>
#include <SPI.h>
#include <SD.h>
#include <Wire.h>
#include <RTClib.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#define ONE_WIRE_BUS 2 // Пин датчика DS18B20
#define CHIP_SELECT 10 // Пин CS для модуля SD-карты
#define BUTTON_MODE 3 // Кнопка переключения режимов
#define BUTTON_ACTION 4 // Кнопка действия
#define SCREEN_WIDTH 128 // Ширина OLED дисплея
#define SCREEN_HEIGHT 64 // Высота OLED дисплея
#define OLED_RESET -1 // Пин сброса дисплея (не используется)

OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);
RTC_DS3231 rtc;
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

// Параметры записи данных
unsigned long loggingInterval = 60000; // Интервал записи (1 минута)
unsigned long lastLogTime = 0;
bool loggingEnabled = false;
String logFileName = "";

// Параметры интерфейса
int currentMode = 0; // 0 – просмотр, 1 – настройка, 2 – логирование
String modes[] = {"View", "Setup", "Logging"};

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

// Настройка кнопок
pinMode(BUTTON_MODE, INPUT_PULLUP);
pinMode(BUTTON_ACTION, INPUT_PULLUP);

// Инициализация дисплея
if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
Serial.println(F("SSD1306 allocation failed"));
while(1);
}

display.clearDisplay();
display.setTextSize(1);
display.setTextColor(WHITE);
display.setCursor(0, 0);
display.println("Temperature Logger");
display.display();
delay(2000);

// Инициализация датчика температуры
sensors.begin();

// Инициализация RTC
if (!rtc.begin()) {
display.clearDisplay();
display.setCursor(0, 0);
display.println("RTC failed!");
display.display();
while(1);
}

if (rtc.lostPower()) {
rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
}

// Инициализация SD-карты
display.clearDisplay();
display.setCursor(0, 0);
display.println("Initializing SD card...");
display.display();

if (!SD.begin(CHIP_SELECT)) {
display.clearDisplay();
display.setCursor(0, 0);
display.println("SD card failed!");
display.display();
delay(2000);
} else {
display.clearDisplay();
display.setCursor(0, 0);
display.println("SD card initialized.");
display.display();
delay(1000);
}

// Создаем имя файла на основе текущей даты
DateTime now = rtc.now();
logFileName = String(now.year()) + 
String(now.month() < 10 ? "0" : "") + String(now.month()) +
String(now.day() < 10 ? "0" : "") + String(now.day()) + ".csv";

// Проверяем, существует ли файл, если нет – создаем с заголовками
if (!SD.exists(logFileName)) {
File dataFile = SD.open(logFileName, FILE_WRITE);
if (dataFile) {
dataFile.println("Date,Time,Temperature (C)");
dataFile.close();
}
}
}

void loop() {
// Обработка нажатия кнопок
if (digitalRead(BUTTON_MODE) == LOW) {
delay(50); // Дребезг контактов
if (digitalRead(BUTTON_MODE) == LOW) {
currentMode = (currentMode + 1) % 3;
delay(300);
}
}

// Получаем текущую температуру
sensors.requestTemperatures();
float tempC = sensors.getTempCByIndex(0);

// Обновляем дисплей в зависимости от режима
display.clearDisplay();
display.setCursor(0, 0);
display.println("Mode: " + modes[currentMode]);
display.println("-----------------");

DateTime now = rtc.now();

if (currentMode == 0) { // Режим просмотра
display.setCursor(0, 16);
display.println("Date: " + 
String(now.year()) + "/" + 
String(now.month() < 10 ? "0" : "") + String(now.month()) + "/" + 
String(now.day() < 10 ? "0" : "") + String(now.day()));

display.println("Time: " + 
String(now.hour() < 10 ? "0" : "") + String(now.hour()) + ":" + 
String(now.minute() < 10 ? "0" : "") + String(now.minute()) + ":" + 
String(now.second() < 10 ? "0" : "") + String(now.second()));

display.println();
display.setTextSize(2);
display.print(tempC);
display.println(" C");
display.setTextSize(1);
} 
else if (currentMode == 1) { // Режим настройки
display.setCursor(0, 16);
display.println("Logging interval:");
display.print(loggingInterval / 1000);
display.println(" seconds");
display.println();
display.println("Press ACTION to");
display.println("change interval");

if (digitalRead(BUTTON_ACTION) == LOW) {
delay(50);
if (digitalRead(BUTTON_ACTION) == LOW) {
// Меняем интервал записи
if (loggingInterval == 60000) loggingInterval = 300000; // 5 минут
else if (loggingInterval == 300000) loggingInterval = 600000; // 10 минут
else if (loggingInterval == 600000) loggingInterval = 1800000; // 30 минут
else if (loggingInterval == 1800000) loggingInterval = 3600000; // 1 час
else if (loggingInterval == 3600000) loggingInterval = 60000; // 1 минута

delay(300);
}
}
} 
else if (currentMode == 2) { // Режим логирования
display.setCursor(0, 16);
if (loggingEnabled) {
display.println("Logging ACTIVE");
display.println("File: " + logFileName);
display.println("Interval: " + String(loggingInterval / 1000) + " s");
display.println();
display.println("Press ACTION to stop");
} else {
display.println("Logging INACTIVE");
display.println("File: " + logFileName);
display.println("Interval: " + String(loggingInterval / 1000) + " s");
display.println();
display.println("Press ACTION to start");
}

if (digitalRead(BUTTON_ACTION) == LOW) {
delay(50);
if (digitalRead(BUTTON_ACTION) == LOW) {
loggingEnabled = !loggingEnabled;
lastLogTime = millis(); // Сбрасываем таймер при включении/выключении
delay(300);
}
}

// Записываем данные по таймеру, если логирование включено
if (loggingEnabled && (millis() – lastLogTime >= loggingInterval)) {
lastLogTime = millis();

String dataString = 
String(now.year()) + "/" + 
String(now.month() < 10 ? "0" : "") + String(now.month()) + "/" + 
String(now.day() < 10 ? "0" : "") + String(now.day()) + "," +
String(now.hour() < 10 ? "0" : "") + String(now.hour()) + ":" + 
String(now.minute() < 10 ? "0" : "") + String(now.minute()) + ":" + 
String(now.second() < 10 ? "0" : "") + String(now.second()) + "," +
String(tempC);

File dataFile = SD.open(logFileName, FILE_WRITE);
if (dataFile) {
dataFile.println(dataString);
dataFile.close();

// Моргаем дисплеем для индикации записи
display.invertDisplay(true);
delay(100);
display.invertDisplay(false);
}
}
}

display.display();
delay(100);
}