Chłodzenie sterowane prędkością wiatraczka! Czujnik monitoruje ciepło, a urządzenie chłodzące automatycznie dostosowuje prędkość obrotową od powolnych 30% do pełnych 100%. Kiedy temperatura zaczyna spadać, system mierzy czas stabilizacji, a po osiągnięciu równowagi wyłącza program. Na koniec prezentuje wyniki: średnią temperaturę, czas stabilizacji i różnicę od średniej – wszystko podane z błędem względnym i bezwzględnym.
1. Rezystor
2. Płytka ESP8266
3. Płytka SmartPlant
4. Wiatraczek z wejściem USB
5. Czujnik temperatury DS18B20
6. Parę kabelków do połączenia wszystkiego (najlepiej przylutowanych do płytki Smart Plant)
7. Kabel micro USB i do komputera
1. Komputer z wejściem USB oraz zainstalowanym programem 'Thonny'.
Celem projektu było stworzenie prostego systemu chłodzenia za pomocą wiatraczka, który automatycznie dostosowuje prędkość obrotów na podstawie odczytów temperatury. System został zaprojektowany w środowisku programistycznym Thonny z wykorzystaniem płytki ESP8266 oraz czujnika temperatury DS18B20. W programie zastosowano funkcję wygładzania zmian prędkości wiatraczka w celu uniknięcia gwałtownych skoków jej wartości.
Sposób działania
-
Pomiar temperatury
- System korzysta z cyfrowego czujnika temperatury DS18B20, podłączonego do wybranego pinu GPIO (w tym przypadku do 12.) płytki ESP8266.
- Temperatury są odczytywane co sekundę, a wyniki wyświetlane na ekranie i zapisywane w liście przechowującej 15 ostatnich odczytów.
-
Sterowanie wiatraczkiem
- Wiatraczek podłączony do innego pinu GPIO (tutaj Pin14.) sterowany jest sygnałem PWM. Sygnał ten reguluje prędkość obrotową urządzenia w zakresie od 30% do 100%, w zależności od zmierzonej temperatury.
- Temperatury w zakresie:
- Poniżej min_temp — Wiatraczek pracuje z minimalną prędkością 30%.
- Powyżej max_temp — Wiatraczek osiąga maksymalną prędkość 100%.
- Między min_temp a max_temp— Prędkość wiatraczka jest liniowo przeliczana na podstawie odczytanej temperatury.
-
Wygładzanie zmian prędkości
- Aby uniknąć gwałtownych zmian prędkości, zastosowano algorytm wygładzania eksponencjalnego, który stopniowo dostosowuje prędkość do docelowej wartości PWM.
-
Monitorowanie stabilizacji temperatury
- Program śledzi maksymalną osiągniętą temperaturę oraz czas, jaki upływa od jej spadku.
- Gdy 15 kolejnych odczytów temperatury ma identyczną wartość (jest to warunek stabilizacji temperatury), system zwraca następujące wartości:
- Czas stabilizacji.
- Temperatura stabilizacji.
- Średnia arytmetyczna zadeklarowanego zakresu temperatur.
- Różnica między temperaturą stabilizacji a średnią.
- Błąd względny i bezwzględny.
-
Zakończenie pracy systemu
- Po osiągnięciu stabilizacji program wyłącza wiatrak i kończy działanie.
Rozszerzenie funkcjonalności
-
Integracja z Wi-Fi
- Projekt można rozszerzyć o obsługę Wi-Fi, aby monitorować temperaturę i sterować wartościami zdalnie.
-
Przechowywanie danych
- Możliwość zapisywania danych do pliku lub przesyłania ich na serwer, co pozwoliłoby na analizę długoterminową.
-
Alarmy
- Dodanie alarmów (np. sygnał dźwiękowy lub powiadomienie) w przypadku przekroczenia dopuszczalnego zakresu temperatur albo innej dysfunkcji programu.
Przykładowy przebieg programu
- Program rozpoczyna się od inicjalizacji czujnika temperatury oraz wiatraczka.
- System odczytuje temperaturę (np. 24°C) i oblicza docelowy współczynnik PWM dla wentylatora, np. 35%. Prędkość wentylatora zaczyna się stopniowo zwiększać.
- Przy osiągnięciu temperatury maksymalnej (np. 28°C), wiatraczek pracuje na 100%. W momencie, gdy temperatura zaczyna spadać, system rejestruje najwyższą temperaturę osiągniętą w trakcie działania programu (np. 28.4°C) i rozpoczyna odliczanie czasu.
- Po stabilizacji temperatury na poziomie np. 26.2°C przez 15 odczytów, program wyświetla wyniki:
- Czas stabilizacji: 45 sekund
- Temperatura stabilizacji: 26.2°C
- Średnia zakresu: 26°C
- Różnica: 0.2°C
- Błąd względny: 0.77%
- Błąd bezwzględny: 0.2°C
- Wentylator zostaje wyłączony, a program kończy działanie.
import machine
import onewire
import ds18x20
import time
import sys
ds_pin = machine.Pin(12)
ds_sensor = ds18x20.DS18X20(onewire.OneWire(ds_pin))
fan_pin = machine.Pin(14, machine.Pin.OUT)
fan_pwm = machine.PWM(fan_pin)
fan_pwm.freq(1000)
min_temp = 26.0
max_temp = 33.0
smoothing_factor = 0.1
current_duty = 0
max_recorded_temp = None
start_time = None
temperature_readings = []
timer_active = False
def stop_fan():
fan_pwm.duty_u16(0)
fan_pwm.deinit()
fan_pin.off()
stop_fan()
roms = ds_sensor.scan()
print('Found DS devices: ', roms)
try:
while True:
ds_sensor.convert_temp()
time.sleep(1)
for rom in roms:
temp = ds_sensor.read_temp(rom)
print("Temperatura: {:.2f} °C".format(temp))
if max_recorded_temp is None or temp > max_recorded_temp:
max_recorded_temp = temp
print(f"Nowa największa temperatura: {max_recorded_temp:.2f} °C")
if max_recorded_temp is not None and temp < max_recorded_temp and not timer_active:
start_time = time.time()
timer_active = True
print(f"Osiągnięto największą dotychczas temperaturę, odliczanie się rozpoczęło")
temperature_readings.append(temp)
if len(temperature_readings) > 15:
temperature_readings.pop(0)
if timer_active and len(temperature_readings) == 15 and len(set(temperature_readings)) == 1:
czas = time.time() - start_time
temperatura_stab = temperature_readings[0]
avg_temp = (min_temp + max_temp) / 2
temp_diff = abs(temperatura_stab - avg_temp)
blad_wzgl = (temp_diff / avg_temp) * 100
print("\n--- Wyniki stabilizacji ---")
print(f"Czas stabilizacji: {czas:.2f} s")
print(f"Temperatura stabilizacji: {temperatura_stab:.2f} °C")
print(f"Średnia arytmetyczna zakresu: {avg_temp:.2f} °C")
print(f"Różnica między stabilizacją a średnią: {temp_diff:.2f} °C")
print(f"Błąd względny: {blad_wzgl:.2f} %")
print(f"Błąd bezwzględny: {temp_diff:.2f} °C")
stop_fan()
sys.exit()
if temp <= min_temp:
target_duty = 30
elif temp >= max_temp:
target_duty = 100
else:
target_duty = ((temp - min_temp) / (max_temp - min_temp)) * (100 - 30) + 30
current_duty = current_duty * (1 - smoothing_factor) + target_duty * smoothing_factor
print("Rzeczywista prędkość: {:.1f}%, Wygładzona prędkość: {:.1f}%".format(target_duty, current_duty))
fan_pwm.duty_u16(int(current_duty * 65535 / 100)) # Ustawienie PWM
time.sleep(0.5)
except KeyboardInterrupt:
print("Program zakończony ręcznie. Wyłączanie wiatraczka...")
stop_fan()