Aanvankelijk was de thermostaat gewoon gemaakt als thermometer om de temperatuur buiten het raam te regelen. Vervolgens begonnen de aardappelen tijdens de vorst ondergronds te bevriezen en werd functionaliteit toegevoegd om het microklimaat te beheersen. Paspoortgegevens van het schakelrelais - 250 V en 10 A (2,5 kW). Omdat de warmte in de ondergrond niet nodig is, is tien per kilowatt voldoende.
Benodigde materialen en gereedschappen:schoenendoos
-USB-opladen voor voor de telefoon (elk, ten minste 0,7 A)
-
Arduino-Pro-Mini
-2-regelige weergave van 8 tekens (WH0802A-NGA-CT is compacter)
Encoder met een knop (kan worden gekocht in elk radiomagazijn, de knop kan niet worden ingebouwd)
-schild met een 5V relais (ik kocht een aantal Chinese relais zonder optische isolatie in één keer, dus ik had nog een Optocoupler PC817 en een weerstand van 470 Ohm nodig. Als je optische isolatie op het naamplaatje hebt, kun je het naamplaatje rechtstreeks op de arduino-poort aansluiten)
USB-aansluiting
-2 USB-verlengkabel van 3 meter (één voor het netsnoer, tot de tweede solderen we de DS1820)
- DS1820 (met elke letter)
soldeerbout
- lijmpistool
Naamplaat FTDI232
Stap 1: Allereerst moeten we de arduino flashen, omdat ik een Pro Mini heb (deze gaat zonder een USB-RS232-converter), moet ik een liniaal met pinnen aan de arduino solderen. Vanaf de kant waar DTR, TXD, RXD, VCC, GND, GND zijn afgeleid. Verbind nu FTDI232 DTR met DTR, VCC met VCC, GND met GND, TXD met RXD, RXD met TXD. Voer de Arduino IDE uit, download de schets en flash deze (schets aan het einde).
Stap 2: Laten we nu voor de romp zorgen. We scheuren de spons af bij de "FUKS", ontvetten alles goed, het diepe gedeelte van de doos kan worden gepasseerd met een schuurlinnen (iets zit steviger vast). Markeer het gat voor de encoder, USB-connector (moeder) en het beeldscherm zelf. Lijm het relais op het deksel van de doos. We moeten proberen het relais verder van de processor te plaatsen en de componenten zo te plaatsen dat het deksel later sluit (er is voldoende ruimte).
Stap 3: Nu nemen we de USB-verlengkabel, snijden de connector (moeder) af. We snijden het afgeknipte uiteinde af, boren een gat voor de kabel in het lichaam, steken het in en lijmen de sleutel met een pistool. Bovendien heeft de kabel rood, min zwart (ik controleer het gewoon), plus de plus van de connector, min de min (ik geef niet de pinout van de connector - deze staat op internet). Tussen de plus van de connector en 2 medium (ik heb ze aangesloten), moet een weerstand van 4.7kOhm worden gesoldeerd.
Stap 4: We nemen 2 USB-verlengkabels, knippen de connector (moeder) af, knippen de kabel. Voor het geval we zullen controleren of we allemaal correct hebben gesoldeerd. We verbinden de voedingskabel met opladen via USB en op het netwerk, steken de gesneden kabel in de USB-connector, kijken naar de tester + op rood - op zwart. We trekken de kabel eruit en solderen de DS1820: - op 1, + op 3 de resterende 2 draden op 2. Ik coat vervolgens de epoxyverbinding (om de tanks, radiatoren te repareren), waarbij een klein deel van de sensorbehuizing naar buiten blijft, zodat er een snellere reactie op temperatuurveranderingen zou zijn.Welnu, we installeren de installatie volgens het schakelschema (we verbinden respectievelijk de stroom en aarde van de relaisplaat met de gemeenschappelijke + en - circuits).
Stap 5: Alle circuitcomponenten zijn aangesloten. We verbinden onze sensor (zonder deze blijft het scherm zwart), schakel stroom in. In de eerste regel - de temperatuurwaarde, in 2 als "*" aan is - is het relais aan, nee - uit. Laten we nu proberen de limieten voor het schakelen van relais in te stellen. Druk op de encoder-as (of uw knop) de grenswaarde verschijnt waarbij het relais wordt ingeschakeld door de as te draaien - de waarde neemt toe of af. Door nogmaals op de as te klikken, krijgen we de bovengrens (het relais wordt uitgeschakeld), stellen we de waarde in en drukken we opnieuw. Het apparaat bewaakt de temperatuur, de waarde van de limieten blijft behouden wanneer de stroom wordt uitgeschakeld. Dat is alles.
#include
#include
#include
#define BUTTON_1_PIN 10 // het outputnummer van knop 1 is 12
OneWire ds (12); // op pin 10 (een 4.7K weerstand is nodig)
// initialiseer de bibliotheek met de nummers van de interfacepinnen
LCD-scherm met vloeibare kristallen (3, 2, 4, 5, 6, 7);
ongetekende lange huidige tijd;
const int pin_A = 8; // pin 12
const int pin_B = 9; // pin 11
niet-ondertekende char enc_A;
niet-ondertekende char enc_B;
unsigned char enc_A_prev = 0;
zweven n_pr = 24,1;
zweven b_pr = 26,2;
boolean priz = false;
klasse Knop {
publiek:
Knop (byte pin, byte timeButton); // constructor beschrijving
boolean flagPress; // vlagknop is nu ingedrukt
boolean flagClick; // vlagknop is ingedrukt (klik)
nietig scanState (); // methode voor het controleren van de signaalstatus
leegte setPinTime (byte pin, byte timeButton); // methode voor het instellen van het uitvoernummer en de bevestigingstijd (getal)
privé:
byte _buttonCount; // stabiele staat bevestigingsteller
byte _timeButton; // bevestigingstijd voor status van knop
byte _pin; // pin nummer
};
Knop knop1 (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;
} anders {
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;
} anders {
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) {
drijven 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);
vertraging (300);
}
ongeldig setup (ongeldig) {
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);
}
leegte lus (nietig) {
byte i;
byte aanwezig = 0;
byte type_s;
bytegegevens [12];
byte addr [8];
zweven celsius;
if (! ds.search (addr)) {
ds.reset_search ();
vertraging (250);
terugkeer
}
if (OneWire :: crc8 (addr, 7)! = addr [7]) {
terugkeer
}
// de eerste ROM-byte geeft aan welke chip
schakelaar (addr [0]) {
zaak 0x10:
type_s = 1;
breken;
zaak 0x28:
type_s = 0;
breken;
zaak 0x22:
type_s = 0;
breken;
standaard:
terugkeer
}
ds.reset ();
ds.select (addr);
ds.write (0x44, 1); // start conversie, met parasiet aan het einde aan
enc_A = digitalRead (pin_A);
enc_A_prev = enc_A;
currentTime = millis ();
while ((millis () - currentTime) <2000) {
button1.scanState ();
if (button1.flagClick == true) {
// er was een klik op de knop
button1.flagClick = false; // reset klikkenmerk
knopka ();
}
}
// delay (1000); // misschien is 750ms genoeg, misschien ook niet
// we kunnen hier een ds.depower () doen, maar de reset zorgt ervoor.
aanwezig = ds.reset ();
ds.select (addr);
ds.write (0xBE); // Lees Scratchpad
voor (i = 0; i <9; i ++) {// we hebben 9 bytes nodig
gegevens [i] = ds.read ();
}
// Converteer de gegevens naar de werkelijke temperatuur
// omdat het resultaat een 16-bits geheel getal met teken is, moet dit
// worden opgeslagen in een "int16_t" -type, dat altijd 16 bits is
// zelfs wanneer gecompileerd op een 32-bits processor.
int16_t raw = (data [1] << 8) | gegevens [0];
if (type_s) {
raw = raw << 3; // 9 bit resolutie standaard
if (data [7] == 0x10) {
// "Count Rest" geeft een volledige resolutie van 12 bits
raw = (raw & 0xFFF0) + 12 - data [6];
}
} anders {
byte cfg = (data [4] & 0x60);
// bij een lagere resolutie zijn de lage bits niet gedefinieerd, dus laten we ze op nul zetten
if (cfg == 0x00) raw = raw & ~ 7; // 9 bit resolutie, 93,75 ms
anders als (cfg == 0x20) raw = raw & ~ 3; // 10 bit res, 187,5 ms
anders als (cfg == 0x40) raw = raw & ~ 1; // 11 bit res, 375 ms
//// standaard is 12 bit resolutie, 750 ms conversietijd
}
celsius = (float) raw / 16,0;
lcd.clear ();
lcd.setCursor (1,0);
lcd.print (celsius);
if (prijs) {
lcd.setCursor (0,1);
lcd.print ('*');
}
if (n_pr! = b_pr) {
if (celsius b_pr) {
digitalWrite (11, LOW);
priz = false;
}
}
}
// knop staat check methode
// flagPress = true - geklikt
// flagPress = false - ingedrukt
// flagClick = true - werd aangeklikt (klik)
ongeldige knop :: scanState () {
if (flagPress == (! digitalRead (_pin))) {
// signaalstatus blijft hetzelfde
_buttonCount = 0; // reset de signaalstatus teller
}
anders {
// signaalstatus is gewijzigd
_buttonCount ++; // +1 naar de signaalstatusteller
if (_buttonCount> = _timeButton) {
// signaalstatus heeft de opgegeven tijd niet gewijzigd
signaalstatus is stabiel geworden
flagPress =! flagPress; // inverse van de statusindicator
_buttonCount = 0; // reset de signaalstatus teller
if (flagPress == true) flagClick = true; // teken van klik op klik
}
}
}
// methode voor het instellen van het uitvoernummer en de bevestigingstijd
void Button :: setPinTime (byte pin, byte timeButton) {
_pin = pin;
_timeButton = timeButton;
pinMode (_pin, INPUT_PULLUP); // definieer de uitvoer als invoer
}
// beschrijving van de constructor van de klasse Button
Button :: Button (byte pin, byte timeButton) {
_pin = pin;
_timeButton = timeButton;
pinMode (_pin, INPUT_PULLUP); // definieer de uitvoer als invoer
}
