Ursprungligen tillverkades termostaten helt enkelt som en termometer för att kontrollera temperaturen utanför fönstret. Sedan, under frost, började potatiserna frysa under jord och funktionalitet lades till för att kontrollera mikroklimatet. Passdata för kopplingsreläet - 250V och 10A (2,5kW). Eftersom värmen i undergrunden inte behövs räcker tio per kilowatt.
Nödvändiga material och verktyg:skovårdslåda
-USB-laddning för telefonen (valfri, minst 0,7A)
-
Arduino-Pro-Mini
-2-radig 8-teckenvisning (WH0802A-NGA-CT är mer kompakt)
Kodare med en knapp (kan köpas i valfri radiomagasin, knappen kan inte vara inbyggd)
-sköld med ett 5V-relä (jag köpte ett gäng kinesiska reläer utan optisk isolering på en gång, så jag behövde ytterligare en Optocoupler PC817 och ett 470 Ohm-motstånd. Om du har optisk isolering på typskylten kan du ansluta typskylten direkt till arduino-porten)
USB-kontakt
-2 3-meters USB-förlängningskabel (en för nätsladden, till den andra lödar vi DS1820)
- DS1820 (med valfri bokstav)
lödkolv
-pistolen
Typskylt FTDI232
Steg 1: Först och främst måste vi blinka arduino, eftersom jag har en Pro Mini (den går utan en USB-RS232-omvandlare), jag behöver löd en linjal med stift till arduino. Från sidan där DTR, TXD, RXD, VCC, GND, GND härleds. Nu ansluter vi FTDI232 DTR till DTR, VCC till VCC, GND till GND, TXD till RXD, RXD till TXD. Kör arduino IDE, ladda ner skissen och blixt den (skiss i slutet).
Steg 2: Nu ska vi ta hand om skrovet. Vi rivar bort svampen vid "FUKS", avfettar allt väl, den djupa delen av lådan kan passeras med en trasig trasa (något skulle klistra bättre). Markera hålet för kodaren, USB-anslutningen (modern) och skärmen själv. Limma reläet på lådans lock. Vi måste försöka placera reläet längre från processorn och ordna komponenterna så att locket stängs senare (det finns gott om utrymme).
Steg 3: Nu tar vi USB-förlängningskabeln, stänger av kontakten (moder). Vi klippte av den klippta änden, borrar ett hål för kabeln i kroppen, sätter in den och limmar nyckeln med en pistol. Plus, kabeln har röd, minus svart (jag kontrollerar det bara), plus pluss för kontakten, minus minus (jag ger inte uttaget på kontakten - det finns på Internet). Mellan anslutningens plus och 2 medium (jag har dem anslutna) måste ett 4.7kOhm-motstånd lödas.
Steg 4: Vi tar 2 USB-förlängningskablar, klipp av kontakten (mamma), klipp av kabeln. Bara i fallet kommer vi att kontrollera om vi alla lödde rätt. Vi ansluter strömkabeln med USB-laddning och till nätverket, stickar den klippta kabeln i USB-kontakten, tittar på testaren + på röd - på svart. Vi drar ut kabeln och lödar DS1820: - till 1, + till 3 de återstående 2 ledningarna till 2. Jag täcker sedan epoxiföreningen (för reparation av tankar, radiatorer) och lämnar lite av sensorhuset utåt, så att det skulle bli en snabbare reaktion på temperaturförändringar.Tja, vi gör installationen enligt kretsschemat (vi kopplar reläplattans kraft och jord till de gemensamma + respektive - kretsarna).
Steg 5: Alla kretskomponenter är anslutna. Vi ansluter vår sensor (utan den kommer skärmen att förbli svart), tillämpar ström. I den första raden - temperaturen, i 2 om “*” är på - är reläet på, nej - av. Låt oss nu försöka ställa in reläomkopplingsgränserna. Tryck på kodaraxeln (eller din knapp) så visas gränsvärdet vid vilket reläet slås på genom att rotera axeln - värdet ökar eller minskar. Genom att klicka på axeln igen - får vi den övre gränsen (reläet kommer att stängas av), ställa in värdet och tryck igen. Enheten övervakar temperaturen, gränsvärdet bibehålls när strömmen stängs av. Det är allt.
#include
#include
#include
#definiera BUTTON_1_PIN 10 // utgångsnumret för knapp 1 är 12
OneWire ds (12); // på stift 10 (ett 4.7K-motstånd är nödvändigt)
// initiera biblioteket med siffrorna på gränssnittsstiften
Liquid Crystal lcd (3, 2, 4, 5, 6, 7);
osignerad långströmstid;
const int pin_A = 8; // stift 12
const int pin_B = 9; // stift 11
osignerad char enc_A;
unsign char char__;
osignerad char enc_A_prev = 0;
flottör n_pr = 24,1;
flottör b_pr = 26,2;
booleska pris = falsk;
klass Knapp {
allmänheten:
Knapp (byte-pin, byte-tidButton); // konstruktörbeskrivning
booleska flaggan; // flaggknappen är nu tryckt
boolesk flaggaKlicka; // flaggknappen trycktes (klicka)
void scanState (); // metod för att kontrollera signaltillståndet
void setPinTime (byte pin, byte timeButton); // metod för inställning av utgångsnummer och bekräftelsetid (nummer)
private:
byte _buttonCount; // bekräftelsesteller för stabilt tillstånd
byte _timeButton; // bekräftelsestid för knappen
byte _pin; // stiftnummer
};
Knappknapp1 (BUTTON_1_PIN, 30);
void knopka () {
lcd.clear ();
lcd.setCursor (1,0);
lcd.print (n_pr);
// button1.scanState ();
medan (button1.flagClick == falskt) {
enc_A = digitalRead (pin_A);
enc_B = digitalRead (pin_B);
om ((! enc_A) && (enc_A_prev)) {
if (enc_B) {
n_pr = n_pr-0,1;
} annat {
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 = falsk;
lcd.clear ();
lcd.setCursor (1,0);
lcd.print (b_pr);
medan (button1.flagClick == falskt) {
enc_A = digitalRead (pin_A);
enc_B = digitalRead (pin_B);
om ((! enc_A) && (enc_A_prev)) {
if (enc_B) {
b_pr = b_pr-0,1;
} annat {
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 = falsk;
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);
fördröjning (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 närvarande = 0;
byte typ_s;
byte-data [12];
byte addr [8];
float celsius;
if (! ds.search (addr)) {
ds.reset_search ();
fördröjning (250);
återvända;
}
if (OneWire :: crc8 (addr, 7)! = addr [7]) {
återvända;
}
// den första ROM-byten anger vilket chip
switch (addr [0]) {
fall 0x10:
typ_s = 1;
break;
fall 0x28:
typ_s = 0;
break;
fall 0x22:
typ_s = 0;
break;
standard:
återvända;
}
ds.reset ();
ds.select (addr);
ds.skriv (0x44, 1); // starta omvandling, med parasitström på i slutet
enc_A = digitalRead (pin_A);
enc_A_prev = enc_A;
strömtid = millis ();
medan ((millis () - nuvarande tid) <2000) {
button1.scanState ();
if (button1.flagClick == true) {
// det fanns ett knappklick
button1.flagClick = falsk; // återställ klickattribut
knopka ();
}
}
// fördröjning (1000); // Kanske räcker 750 ms, kanske inte
// vi kanske gör en ds.depower () här, men återställningen kommer att ta hand om det.
närvarande = ds.reset ();
ds.select (addr);
ds.skriv (0xBE); // Läs Scratchpad
för (i = 0; i <9; i ++) {// vi behöver 9 byte
data [i] = ds.read ();
}
// Konvertera data till faktisk temperatur
// eftersom resultatet är ett 16 bitars signerat heltal, borde det
// lagras i en typ "int16_t", som alltid är 16 bitar
// även när den är kompilerad på en 32-bitars processor.
int16_t raw = (data [1] << 8) | data [0];
if (typ_s) {
rå = rå << 3; // 9 bitars upplösning standard
if (data [7] == 0x10) {
// "count rest" ger full 12-bitars upplösning
raw = (raw & 0xFFF0) + 12 - data [6];
}
} annat {
byte cfg = (data [4] & 0x60);
// vid lägre res är de låga bitarna odefinierade, så låt oss noll dem
if (cfg == 0x00) raw = raw & ~ 7; // 9 bitars upplösning, 93,75 ms
annars om (cfg == 0x20) raw = raw & ~ 3; // 10 bitars res, 187,5 ms
annars om (cfg == 0x40) raw = raw & ~ 1; // 11 bitars res, 375 ms
// // standard är 12 bitars upplösning, konverteringstid på 750 ms
}
celsius = (flyta) rå / 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, LÅG);
priz = falsk;
}
}
}
// Knapptillståndskontrollmetod
// flagPress = sant - klickat
// flagPress = falsk - tryckt
// flagClick = true - klickades (klicka)
void Button :: scanState () {
if (flagPress == (! digitalRead (_pin))) {
// signaltillståndet förblir detsamma
_buttonCount = 0; // återställa signalstatusräknaren
}
annars {
// signaltillståndet har ändrats
_buttonCount ++; // +1 till räknaren för signalstatus
if (_buttonCount> = _timeButton) {
// signaltillståndet ändrade inte den angivna tiden
// signaltillståndet har blivit stabilt
flagPress =! flagPress; // invers av statusindikatorn
_buttonCount = 0; // återställa signalstatusräknaren
if (flagPress == true) flagga Klicka = true; // tecken på klicka på klicka
}
}
}
// metod för att ställa in utgångsnummer och bekräftelsetid
void Button :: setPinTime (byte pin, byte timeButton) {
_pin = stift;
_timeButton = timeButton;
pinMode (_pin, INPUT_PULLUP); // definiera utgången som ingång
}
// beskrivning av konstruktören för klassen knapp
Knapp :: Knapp (byte pin, byte timeButton) {
_pin = stift;
_timeButton = timeButton;
pinMode (_pin, INPUT_PULLUP); // definiera utgången som ingång
}
