Inicialment, el termòstat es feia simplement com a termòmetre per controlar la temperatura fora de la finestra. Després, durant les gelades, les patates van començar a congelar-se sota terra i es va afegir funcionalitat per controlar el microclima. Dades del passaport del relé de commutació: 250V i 10A (2,5kW). Com que no es necessita la calor al soterrament, n'hi ha prou amb un deu per quilowatt.
Material i eines necessàries:caixa de cura de sabates
- Recàrrega del telèfon per a USB (qualsevol, com a mínim, 0,7A)
-
Arduino-Pro-Mini
Pantalla de -2 caràcters de 8 línies (WH0802A-NGA-CT és més compacte)
Codificador amb botó
-schild amb un relé de 5V (vaig comprar un munt de relés xinesos sense aïllament òptic alhora, així que necessitava un altre Optocoupler PC817 i una resistència de 470 Ohm. Si teniu un aïllament òptic a la placa identificativa, podeu connectar la placa directament al port arduino)
Connector USB
-2 cable d’extensió USB de 3 metres (un per al cable d’alimentació, al segon vam vendre el DS1820)
- DS1820 (amb qualsevol lletra)
soldadura
-pistola de cola
Placa identificativa FTDI232
Pas 1: Primer de tot, hem de fer servir l'arc arduino, ja que tinc un Pro Mini (va sense convertidor USB-RS232), necessito soldar una regla amb pins al arduino. Des del costat on es deriven DTR, TXD, RXD, VCC, GND, GND. Ara connecteu FTDI232 DTR a DTR, VCC a VCC, GND a GND, TXD a RXD, RXD a TXD. Executeu l'IDE arduino, descarregueu l'esbós i feu un flash (esbós al final).
Pas 2: Ara cuidem el casc. Esquinçem l’esponja al “FUKS”, desgreixem tot bé, es pot passar la part profunda de la caixa amb un drap esmicolat (alguna cosa s’enganxaria millor). Marqueu el forat per al codificador, connector USB (mare) i la pantalla pròpia. Pegueu el relé a la coberta de la caixa. Hem d’intentar situar el relé lluny del processador i organitzar els components perquè la tapa es tanqui més tard (hi ha molt espai).
Pas 3: Ara agafem el cable d’extensió USB, tallem la presa del connector (mare). Tallem l’extrem del tall, foradem un forat pel cable al cos, l’introduïm i enganxem la clau amb una pistola. A més, el cable té vermell, menys negre (només ho comprovo), a més de l’enllaç del connector, menys el menys (no dono la pinya del connector, sinó a Internet). Entre el plus del connector i el mitjà 2 (els tinc connectats), s’ha de soldar una resistència de 4,7kOhm.
Pas 4: Agafem 2 cables d'extensió USB, tallem el connector (mare), tallem el cable. Per si de cas, comprovarem si tots ens soldem correctament. Connectem el cable d’alimentació amb càrrega USB i a la xarxa, enganxem el cable tallat al connector USB, mirem el provador + en vermell - en negre. Traiem el cable i soldem el DS1820: - a 1, + a 3 els dos fils restants a 2. A continuació, recobrim el compost epoxi (per reparar els dipòsits, radiadors), deixant una mica de l’allotjament del sensor cap a fora, de manera que hi hauria una reacció més ràpida als canvis de temperatura.Doncs fem la instal·lació segons el diagrama del circuit (connectem la potència i la terra de la placa del relé amb els circuits comuns + i - respectivament).
Pas 5: tots els components del circuit estan connectats. Connectem el sensor (sense ell, la pantalla quedarà en negre), apliquem energia. A la primera línia - el valor de temperatura, en 2 si està "*" actiu - el relé està en marxa, no - apagat. Ara intentem establir els límits de commutació del relé. Si premeu l’eix del codificador (o el vostre botó) apareix el valor límit al qual s’activa el relé girant l’eix: el valor augmenta o disminueix. Fent clic de nou sobre l’eix: obtenim el límit superior (el relé s’apagarà), establim el valor i premem de nou. El dispositiu vigilarà la temperatura, el valor dels límits es manté quan s’apaga l’energia. Tot això.
#incloure
#include
#incloure
#define BUTTON_1_PIN 10 // el número de sortida del botó 1 és 12
OneWire ds (12); // al pin 10 (cal un resistor de 4,7 K)
// inicialitzar la biblioteca amb els números dels pins de la interfície
Cristall líquid (3, 2, 4, 5, 6, 7);
unsigned long currentTime;
const int pin_A = 8; // pin 12
const int pin_B = 9; // pin 11
char sense signar enc_A;
char sense signar enc_B;
unsigned char enc_A_prev = 0;
float n_pr = 24,1;
float b_pr = 26,2;
preu booleà = fals;
Botó de classe {
públic:
Botó (pin de byte, byte timeButton); // descripció del constructor
boolean flagPress; ara es prem el botó de marca
boolean flagClick; // es va prémer el botó de marca (feu clic)
void scanState (); // mètode per comprovar l'estat del senyal
void setPinTime (pin de byte, byte timeButton); // mètode per establir el número de sortida i el temps de confirmació (número)
privat:
byte _buttonCount; // comptador de confirmació d'estat estable
byte _timeButton; // hora de confirmació de l'estat del botó
byte _pin; // número pin
};
Botó botó1 (BUTTON_1_PIN, 30);
void knopka () {
lcd.clear ();
lcd.setCursor (1,0);
lcd.print (n_pr);
// button1.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;
} més {
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;
} més {
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);
retard (300);
}
void setup (void) {
pinMode (11, SORTIDA);
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 present = 0;
tipus de byte;
dades de bytes [12];
byte addr [8];
flotar celsius;
if (! ds.search (addr)) {
ds.reset_search ();
retard (250);
tornar
}
if (OneWire :: crc8 (addr, 7)! = addr [7]) {
tornar
}
// el primer byte ROM indica quin xip
switch (addr [0]) {
estoig 0x10:
tipus_s = 1;
trencar;
estoig 0x28:
type_s = 0;
trencar;
caixa 0x22:
type_s = 0;
trencar;
predeterminat:
tornar
}
ds.reset ();
ds.select (addr);
ds.write (0x44, 1); // iniciar la conversió, amb la presa de paràsit encesa al final
enc_A = digitalRead (pin_A);
enc_A_prev = enc_A;
currentTime = millis ();
while ((millis () - currentTime) <2000) {
button1.scanState ();
if (button1.flagClick == true) {
// hi va haver un clic de botó
button1.flagClick = false; // restablir l’atribut del clic
knopka ();
}
}
// retard (1000); // Potser 750ms és suficient, potser no
// aquí podríem fer un ds.depower (), però el restabliment tindrà cura.
present = ds.reset ();
ds.select (addr);
ds.write (0xBE); // Llegiu Scratchpad
per (i = 0; i <9; i ++) {// necessitem 9 bytes
data [i] = ds.read ();
}
// Convertiu les dades a la temperatura real
// perquè el resultat és un nombre enter signat de 16 bits, hauria de ser
// es desa en un tipus "int16_t", que sempre és de 16 bits
// fins i tot quan es compila en un processador de 32 bits.
int16_t cru = (dades [1] << 8) | dades [0];
if (type_s) {
cru = cru << 3; // Resolució predeterminada de 9 bits
if (dades [7] == 0x10) {
// "Count rest" dóna una resolució completa de 12 bits
raw = (raw & 0xFFF0) + 12 - dades [6];
}
} més {
byte cfg = (dades [4] & 0x60);
// a menys res, els bits baixos no estan definits, així que anem a zero
if (cfg == 0x00) cru = cru & ~ 7; // Resolució de 9 bits, 93,75 ms
else if (cfg == 0x20) raw = raw & ~ 3; // Res de 10 bits, 187,5 ms
else if (cfg == 0x40) raw = raw & ~ 1; // 11 bits res, 375 ms
//// El predeterminat és de 12 bits de resolució, temps de conversió de 750 ms
}
celsius = (flotador) cru / 16,0;
lcd.clear ();
lcd.setCursor (1,0);
lcd.print (celsius);
if (preu) {
lcd.setCursor (0,1);
lcd.print ('*');
}
if (n_pr! = b_pr) {
if (centígrads b_pr) {
digitalWrite (11, BAIX);
preu = fals;
}
}
}
// mètode de comprovació de l'estat del botó
// flagPress = feta clic real
// flagPress = fals: prement
// flagClick = true: es va fer clic (feu clic)
botó void :: scanState () {
if (flagPress == (! digitalRead (_pin))) {
// l’estat del senyal continua sent el mateix
_buttonCount = 0; // restablir el comptador d'estat del senyal
}
més {
// L'estat del senyal ha canviat
_buttonCount ++; // +1 al comptador d'estat del senyal
if (_buttonCount> = _timeButton) {
// l’estat del senyal no ha canviat l’hora especificada
// l’estat del senyal s’ha convertit en estable
flagPress =! flagPress; // inversa de l’indicador d’estat
_buttonCount = 0; // restablir el comptador d'estat del senyal
if (flagPress == true) flagClick = true; // signe de clic sobre clic
}
}
}
// mètode per establir el número de sortida i el temps de confirmació
botó void :: setPinTime (pin de byte, byte timeButton) {
_pin = pin;
_timeButton = botó de temps;
pinMode (_pin, INPUT_PULLUP); // definiu la sortida com a entrada
}
// descripció del constructor de la classe Button
Button :: Button (pin de byte, byte timeButton) {
_pin = pin;
_timeButton = botó de temps;
pinMode (_pin, INPUT_PULLUP); // definiu la sortida com a entrada
}
