Inițial, termostatul a fost făcut simplu ca termometru pentru a controla temperatura în afara ferestrei. Apoi, în timpul gerurilor, cartofii au început să înghețe în subteran și s-a adăugat funcționalitate pentru controlul microclimatului. Datele pașaportului releului de comutare - 250V și 10A (2,5kW). Deoarece căldura din subteran nu este necesară, o cantitate de zece pe kilowatt este suficientă.
Materiale și instrumente necesare:cutie de îngrijire a pantofilor
-Incarcare USB pentru telefon (oricare, cel puțin 0,7A)
-
Arduino-Pro-Mini
Afișaj cu 2 caractere cu 8 linii (WH0802A-NGA-CT este mai compact)
Encoder cu buton (poate fi achiziționat în orice radio mag, butonul nu poate fi încorporat)
-schild cu releu de 5V (am achiziționat o grămadă de relee chinezești fără izolare optică la un moment dat, așa că aveam nevoie de un alt Optocoupler PC817 și de un rezistor de 470 Ohm. Dacă aveți o izolare optică pe plăcuța de identificare, puteți conecta placa directă la portul arduino)
Conector USB
-2 cablu de extensie USB de 3 metri (unul pentru cablul de alimentare, la al doilea am vândut DS1820)
- DS1820 (cu orice literă)
fier de lipit
-arma cu clei
Placa de identificare FTDI232
Pasul 1: În primul rând, trebuie să aprindem flashul arduino, pentru că am un Pro Mini (merge fără convertor USB-RS232), trebuie să lipesc o riglă cu ace la arduino. Din partea în care derivă DTR, TXD, RXD, VCC, GND, GND. Acum conectăm DTR FTDI232 la DTR, VCC la VCC, GND la GND, TXD la RXD, RXD la TXD. Rulați IDE arduino, descărcați schița și flash-o (schiță la sfârșit).
Pasul 2: Acum să avem grijă de coca. Scoatem buretele la „FUKS”, degresăm totul bine, partea adâncă a cutiei poate fi trecută cu o cârpă smălțuită (ceva ar fi mult mai bine blocat). Marcați gaura pentru codificator, conector USB (mamă) și afișajul în sine. Lipiți releul pe capacul cutiei. Trebuie să încercăm să amplasăm releul mai departe de procesor și să aranjăm componentele astfel încât capacul să se închidă mai târziu (există mult spațiu).
Pasul 3: Acum luăm cablul de extensie USB, tăiem soclul conectorului (mama). Decupăm capătul tăiat, găurim o gaură pentru cablul din corp, îl introducem și lipim cheia cu o armă. În plus, cablul are roșu, minus negru (doar îl verific), plus plusul conectorului, minus minusul (nu dau identificarea conectorului - este pe Internet). Între plusul conectorului și 2 mediu (le-am conectat), trebuie să fie lipită o rezistență de 4,7kOhm.
Pasul 4: Luăm 2 cabluri de extensie USB, tăiem conectorul (mama), tăiem cablul. Doar în caz, vom verifica dacă toate am lipit corect. Conectăm cablul de alimentare cu încărcare USB și la rețea, lipim cablul tăiat în conectorul USB, privim testerul + pe roșu - pe negru. Scoatem cablul și lipim DS1820: - la 1, + până la 3 cele 2 fire rămase la 2. Am acoperit apoi compusul epoxidic (pentru a repara rezervoarele, caloriferele), lăsând un pic din carcasa senzorului spre exterior, astfel încât să existe o reacție mai rapidă la schimbările de temperatură.Ei bine, facem instalarea în conformitate cu diagrama circuitului (conectăm puterea și pământul plăcii releului cu circuitele comune + și respectiv).
Pasul 5: Toate componentele circuitului sunt conectate. Conectăm senzorul nostru (fără el, afișajul va rămâne negru), aplicăm putere. În prima linie - valoarea temperaturii, în 2 dacă „*” este pornit - releul este pornit, nu - oprit. Acum, să încercăm să stabilim limitele de comutare a releului. Apăsați arborele codificatorului (sau butonul dvs.) apare valoarea limită la care releul se va porni prin rotirea arborelui - valoarea crește sau scade. Dând clic din nou pe arbore - obținem limita superioară (releul se va opri), setăm valoarea și apăsăm din nou. Aparatul va monitoriza temperatura, valoarea limitelor este menținută la oprirea alimentării. Totul este.
#include
#include
#include
#define BUTTON_1_PIN 10 // numărul de ieșire al butonului 1 este 12
OneWire ds (12); // pe pinul 10 (este necesar un rezistor de 4,7 K)
// inițializează biblioteca cu numerele pinilor de interfață
Cristal lichid lcd (3, 2, 4, 5, 6, 7);
nesemnat lung curentTime;
const int pin_A = 8; // pin 12
const int pin_B = 9; // pinul 11
unsigned char enc_A;
unsigned char enc_B;
unsigned char enc_A_prev = 0;
float n_pr = 24,1;
float b_pr = 26,2;
boolean priz = fals;
buton de clasă {
publice:
Buton (pin byte, byte timeButton); // descrierea constructorului
boolean flagPress; // butonul flag este acum apăsat
steagul boolean // a fost apăsat butonul flag (click)
void scanState (); // metoda pentru verificarea stării semnalului
void setPinTime (pin byte, byte timeButton); // metoda pentru setarea numărului de ieșire și a timpului de confirmare (număr)
privat:
byte _buttonCount; // contorul de confirmare a stării stabile
byte _timeButton; // ora de confirmare a stării butonului
byte _pin; // număr pin
};
Buton buton1 (BUTTON_1_PIN, 30);
void knopka () {
lcd.clear ();
lcd.setCursor (1,0);
lcd.print (n_pr);
// butonul1.scanState ();
while (button1.flagClick == false) {
enc_A = digitalRead (pin_A);
enc_B = digitalRead (pin_B);
if ((! enc_A) && (enc_A_prev)) {
if (enc_B) {
n_pr = n_pr-0,1;
} altfel {
n_pr = n_pr + 0,1;
}
lcd.clear ();
lcd.setCursor (1,0);
lcd.print (n_pr);
}
enc_A_prev = enc_A;
button1.scanState ();
}
button1.flagClick = false;
lcd.clear ();
lcd.setCursor (1,0);
lcd.print (b_pr);
while (button1.flagClick == false) {
enc_A = digitalRead (pin_A);
enc_B = digitalRead (pin_B);
if ((! enc_A) && (enc_A_prev)) {
if (enc_B) {
b_pr = b_pr-0,1;
} altfel {
b_pr = b_pr + 0,1;
}
lcd.clear ();
lcd.setCursor (1,0);
lcd.print (b_pr);
}
enc_A_prev = enc_A;
button1.scanState ();
}
button1.flagClick = false;
if (n_pr> b_pr) {
float wr = n_pr;
n_pr = b_pr;
b_pr = wr;
}
int addr = 0;
EEPROM.write (addr, 'y');
addr = 1;
EEPROM.put (addr, n_pr);
addr + = sizeof (float);
EEPROM.put (addr, b_pr);
întârziere (300);
}
void setup (void) {
pinMode (11, OUTPUT);
pinMode (pin_A, INPUT_PULLUP);
pinMode (pin_B, INPUT_PULLUP);
lcd.begin (8,2);
int addr = 0;
char c = EEPROM.read (addr);
addr = addr + 1;
if (c == 'y') {
EEPROM.get (addr, n_pr);
addr + = sizeof (float);
EEPROM.get (addr, b_pr);
}
// Serial.begin (9600);
}
void loop (void) {
byte i;
byte prezent = 0;
tip byte_s;
date de byte [12];
byte addr [8];
plutesc celsius;
if (! ds.search (addr)) {
ds.reset_search ();
întârziere (250);
return;
}
if (OneWire :: crc8 (addr, 7)! = addr [7]) {
return;
}
// primul octet ROM indică ce cip
switch (addr [0]) {
carcasa 0x10:
tip_s = 1;
pauză;
carcasa 0x28:
tip_s = 0;
pauză;
carcasa 0x22:
tip_s = 0;
pauză;
implicit:
return;
}
resetare ();
ds.select (addr);
ds.write (0x44, 1); // începe conversia, cu pornirea parazitului la sfârșit
enc_A = digitalRead (pin_A);
enc_A_prev = enc_A;
currentTime = millis ();
while ((millis () - currentTime) <2000) {
button1.scanState ();
if (button1.flagClick == true) {
// s-a făcut clic pe buton
button1.flagClick = false; // resetează atributul clicului
knopka ();
}
}
// întârziere (1000); // poate 750ms este suficient, poate nu
// am putea face aici un ds.dower (), dar resetarea va avea grijă de el.
prezent = ds.reset ();
ds.select (addr);
ds.write (0xBE); // Citiți Scratchpad
for (i = 0; i <9; i ++) {// avem nevoie de 9 octeți
date [i] = ds.read ();
}
// Convertiți datele la temperatura reală
// deoarece rezultatul este un număr întreg semnat pe 16 biți, ar trebui
// să fie stocate la un tip "int16_t", care este întotdeauna 16 biți
// chiar și atunci când este compilat pe un procesor pe 32 de biți.
int16_t brut = (date [1] << 8) | date [0];
if (type_s) {
brut = brut << 3; // implicit rezoluție 9 biți
if (date [7] == 0x10) {
// „count rămâne” dă o rezoluție completă de 12 biți
raw = (raw & 0xFFF0) + 12 - date [6];
}
} altfel {
byte cfg = (date [4] & 0x60);
// la rezoluții inferioare, biții joși nu sunt definiți, deci să le zero
if (cfg == 0x00) raw = raw & ~ 7; // Rezoluție 9 biți, 93,75 ms
altfel daca (cfg == 0x20) brut = brut & ~ 3; // 10 bit res, 187,5 ms
else if (cfg == 0x40) raw = raw & ~ 1; // 11 bit res, 375 ms
//// implicit este rezoluția pe 12 biți, timp de conversie de 750 ms
}
celsius = (float) raw / 16,0;
lcd.clear ();
lcd.setCursor (1,0);
lcd.print (celsius);
if (priz) {
lcd.setCursor (0,1);
lcd.print ('*');
}
if (n_pr! = b_pr) {
if (celsius b_pr) {
digitalWrite (11, LOW);
priz = fals;
}
}
}
// metoda de verificare a stării butonului
// flagPress = adevărat - clic pe
// flagPress = false - apăsat
// flagClick = true - s-a dat clic (faceți clic)
butonul void :: scanState () {
if (flagPress == (! digitalRead (_pin))) {
// starea semnalului rămâne aceeași
_buttonCount = 0; // resetați contorul de stare a semnalului
}
altfel {
// starea semnalului s-a schimbat
_buttonCount ++; // +1 la contorul de stare a semnalului
if (_buttonCount> = _timeButton) {
// starea semnalului nu a modificat ora specificată
// starea semnalului a devenit stabilă
flagPress =! flagPress; // inversul indicatorului de stare
_buttonCount = 0; // resetați contorul de stare a semnalului
if (flagPress == true) flagClick = true; // semn de clic pe click
}
}
}
// metoda pentru setarea numărului de ieșire și a timpului de confirmare
butonul void :: setPinTime (pin byte, byte timeButton) {
_pin = pin;
_timeButton = buton de timp;
pinMode (_pin, INPUT_PULLUP); // definiți ieșirea ca intrare
}
// descrierea constructorului clasei Button
Button :: Button (pin byte, byte timeButton) {
_pin = pin;
_timeButton = buton de timp;
pinMode (_pin, INPUT_PULLUP); // definiți ieșirea ca intrare
}
