Inizialmente, il termostato era realizzato semplicemente come un termometro per controllare la temperatura all'esterno della finestra. Quindi, durante le gelate, le patate hanno iniziato a congelare sottoterra e sono state aggiunte funzionalità per controllare il microclima. Dati del passaporto del relè di commutazione - 250 V e 10 A (2,5 kW). Poiché il calore nel sottosuolo non è necessario, è sufficiente un dieci per chilowatt.
Materiali e strumenti necessari:scatola per la cura delle scarpe
-Carica USB per il telefono (qualsiasi, almeno 0,7 A)
-
Arduino-Pro-Mini
-2 caratteri display a 8 caratteri (WH0802A-NGA-CT è più compatto)
Encoder con pulsante
-scuola con un relè 5V (ho acquistato un gruppo di relè cinesi senza isolamento ottico in una volta, quindi avevo bisogno di un altro accoppiatore ottico PC817 e una resistenza da 470 Ohm. Se si dispone di isolamento ottico sulla targhetta, è possibile collegare la targhetta direttamente alla porta Arduino)
Connettore USB
-2 Cavo prolunga USB da 3 metri (uno per il cavo di alimentazione, al secondo abbiamo saldato il DS1820)
- DS1820 (con qualsiasi lettera)
saldatore
pistola a spruzzo
Targhetta FTDI232
Passo 1: Prima di tutto, dobbiamo eseguire il flashing dell'arduino, poiché ho un Pro Mini (è privo di un convertitore USB-RS232), ho bisogno di saldare un righello con pin all'arduino. Dal lato da cui derivano DTR, TXD, RXD, VCC, GND, GND. Ora colleghiamo FTTR232 DTR a DTR, VCC a VCC, GND a GND, TXD a RXD, RXD a TXD. Esegui l'IDE arduino, scarica lo schizzo e esegui il flash (schizzo alla fine).
Step 2: Ora prendiamoci cura dello scafo. Strappiamo la spugna al "FUKS", sgrassiamo tutto bene, la parte profonda della scatola può essere passata con un panno smerigliato (qualcosa sarebbe bloccato più saldamente). Contrassegnare il foro per l'encoder, il connettore USB (madre) e il display stesso. Incollare il relè sul coperchio della scatola. Dobbiamo cercare di posizionare il relè lontano dal processore e disporre i componenti in modo che il coperchio si chiuda più tardi (c'è molto spazio).
Passaggio 3: ora prendiamo la prolunga USB, tagliamo la presa del connettore (madre). Tagliamo l'estremità tagliata, foriamo un cavo per il cavo nel corpo, lo inseriamo e incolliamo la chiave con una pistola. Inoltre, il cavo ha il rosso, meno il nero (lo controllo solo), più il plus del connettore, meno il meno (non do il pinout del connettore - è su Internet). Tra il plus del connettore e 2 medium (li ho collegati), è necessario saldare una resistenza da 4.7kOhm.
Passaggio 4: prendiamo 2 prolunghe USB, tagliamo il connettore (madre), tagliamo il cavo. Per ogni evenienza, verificheremo se tutti abbiamo saldato correttamente. Colleghiamo il cavo di alimentazione con ricarica USB e alla rete, inseriamo il cavo tagliato nel connettore USB, guardiamo il tester + su rosso - su nero. Tiriamo fuori il cavo e saldiamo il DS1820: - a 1, + a 3 i restanti 2 fili a 2. Quindi ricopro il composto epossidico (per riparare i serbatoi, i radiatori), lasciando un po 'di alloggiamento del sensore verso l'esterno, in modo che ci fosse una reazione più rapida alle variazioni di temperatura.Bene, facciamo l'installazione secondo lo schema del circuito (colleghiamo l'alimentazione e la terra della piastra del relè con i circuiti + e - comuni, rispettivamente).
Passaggio 5: tutti i componenti del circuito sono collegati. Colleghiamo il nostro sensore (senza di esso, il display rimarrà nero), applichiamo energia. Nella prima riga - il valore della temperatura, in 2 se “*” è attivo - il relè è attivo, no - spento. Ora proviamo a impostare i limiti di commutazione del relè. Premere l'albero dell'encoder (o il pulsante) per visualizzare il valore limite al quale il relè si accenderà ruotando l'albero - il valore aumenta o diminuisce. Cliccando di nuovo sull'albero - otteniamo il limite superiore (il relè si spegne), impostiamo il valore e premiamo di nuovo. Il dispositivo monitorerà la temperatura, il valore dei limiti viene mantenuto allo spegnimento. Tutto qui.
#include
#include
#include
#define BUTTON_1_PIN 10 // il numero di uscita del pulsante 1 è 12
OneWire ds (12); // sul pin 10 (è necessaria una resistenza da 4,7 K)
// inizializza la libreria con i numeri dei pin dell'interfaccia
LCD a cristalli liquidi (3, 2, 4, 5, 6, 7);
tempo corrente non firmato;
const int pin_A = 8; // pin 12
const int pin_B = 9; // pin 11
enc_A char senza segno;
unsigned char enc_B;
char senza segno enc_A_prev = 0;
float n_pr = 24.1;
float b_pr = 26.2;
booleano priz = false;
pulsante class {
pubblica:
Pulsante (pin byte, byte timeButton); // descrizione del costruttore
flag booleano; Il pulsante // flag è ora premuto
boolean flagClick; // è stato premuto il pulsante flag (clic)
void scanState (); // metodo per controllare lo stato del segnale
void setPinTime (pin byte, byte timeButton); // metodo per impostare il numero di uscita e il tempo di conferma (numero)
privato:
byte _buttonCount; // contatore di conferma dello stato stabile
byte _timeButton; // tempo di conferma dello stato del pulsante
byte _pin; // numero pin
};
Button button1 (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;
} altro {
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;
} altro {
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);
ritardo (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 presente = 0;
byte type_s;
dati byte [12];
byte addr [8];
galleggiante celsius;
if (! ds.search (addr)) {
ds.reset_search ();
ritardo (250);
tornare;
}
if (OneWire :: crc8 (addr, 7)! = addr [7]) {
tornare;
}
// il primo byte ROM indica quale chip
switch (addr [0]) {
caso 0x10:
type_s = 1;
break;
caso 0x28:
type_s = 0;
break;
caso 0x22:
type_s = 0;
break;
DEFAULT:
tornare;
}
ds.reset ();
ds.select (addr);
ds.write (0x44, 1); // avvia la conversione, con il parassita acceso alla fine
enc_A = digitalRead (pin_A);
enc_A_prev = enc_A;
currentTime = millis ();
while ((millis () - currentTime) <2000) {
button1.scanState ();
if (button1.flagClick == true) {
// c'era un clic sul pulsante
button1.flagClick = false; // ripristina l'attributo clic
knopka ();
}
}
// ritardo (1000); // forse bastano 750ms, forse no
// qui potremmo fare un ds.depower (), ma il reset ci penserà.
present = ds.reset ();
ds.select (addr);
ds.write (0xBE); // Leggi Scratchpad
per (i = 0; i <9; i ++) {// abbiamo bisogno di 9 byte
data [i] = ds.read ();
}
// Converti i dati in temperatura effettiva
// poiché il risultato è un numero intero con segno a 16 bit, dovrebbe
// essere memorizzato in un tipo "int16_t", che è sempre 16 bit
// anche se compilato su un processore a 32 bit.
int16_t raw = (data [1] << 8) | dati [0];
if (type_s) {
raw = raw << 3; // Risoluzione predefinita a 9 bit
if (data [7] == 0x10) {
// "conta restante" fornisce una risoluzione completa di 12 bit
raw = (raw & 0xFFF0) + 12 - dati [6];
}
} altro {
byte cfg = (dati [4] e 0x60);
// a una risoluzione inferiore, i bit bassi sono indefiniti, quindi azzeriamoli
if (cfg == 0x00) raw = raw & ~ 7; // Risoluzione a 9 bit, 93.75 ms
altrimenti if (cfg == 0x20) raw = raw & ~ 3; // Res 10 bit, 187,5 ms
altrimenti if (cfg == 0x40) raw = raw & ~ 1; // Res. 11 bit, 375 ms
//// il valore predefinito è risoluzione a 12 bit, tempo di conversione di 750 ms
}
celsius = (float) raw / 16.0;
lcd.clear ();
lcd.setCursor (1,0);
lcd.print (centigrado);
if (prezzo) {
lcd.setCursor (0,1);
lcd.print ('*');
}
if (n_pr! = b_pr) {
if (celsius b_pr) {
digitalWrite (11, LOW);
priz = false;
}
}
}
// metodo di controllo dello stato dei pulsanti
// flagPress = true - cliccato
// flagPress = false - premuto
// flagClick = true - è stato fatto clic (clic)
void Button :: scanState () {
if (flagPress == (! digitalRead (_pin))) {
// lo stato del segnale rimane lo stesso
_buttonCount = 0; // ripristina il contatore dello stato del segnale
}
altro {
// lo stato del segnale è cambiato
_buttonCount ++; // +1 al contatore dello stato del segnale
if (_buttonCount> = _timeButton) {
// lo stato del segnale non ha cambiato il tempo specificato
// lo stato del segnale è diventato stabile
flagPress =! flagPress; // inverso dell'indicatore di stato
_buttonCount = 0; // ripristina il contatore dello stato del segnale
if (flagPress == true) flagClick = true; // segno di clic su clic
}
}
}
// metodo per impostare il numero di uscita e il tempo di conferma
void Button :: setPinTime (pin byte, byte timeButton) {
_pin = pin;
_timeButton = timeButton;
pinMode (_pin, INPUT_PULLUP); // definisce l'output come input
}
// descrizione del costruttore della classe Button
Button :: Button (byte pin, byte timeButton) {
_pin = pin;
_timeButton = timeButton;
pinMode (_pin, INPUT_PULLUP); // definisce l'output come input
}
