Anfänglich wurde der Thermostat einfach als Thermometer hergestellt, um die Temperatur außerhalb des Fensters zu steuern. Während des Frosts begannen die Kartoffeln unter der Erde zu gefrieren, und es wurde eine Funktionalität hinzugefügt, um das Mikroklima zu kontrollieren. Passdaten des Schaltrelais - 250V und 10A (2,5kW). Da die Wärme im Untergrund nicht benötigt wird, reichen zehn pro Kilowatt aus.
Notwendige Materialien und Werkzeuge:Schuhpflegebox
-USB-Aufladung für das Telefon (beliebig, mindestens 0,7 A)
-
Arduino-Pro-Mini
8-stellige Anzeige mit 2 Zeilen (WH0802A-NGA-CT ist kompakter)
Encoder mit einem Knopf (kann in jedem Radiomagazin gekauft werden, der Knopf kann nicht eingebaut werden)
-Schild mit einem 5-V-Relais (Ich habe ein paar chinesische Relais ohne optische Isolation auf einmal gekauft, daher brauchte ich einen weiteren Optokoppler PC817 und einen 470-Ohm-Widerstand. Wenn Sie eine optische Isolation auf dem Typenschild haben, können Sie das Typenschild direkt an den Arduino-Port anschließen.)
USB-Anschluss
-2 3 Meter langes USB-Verlängerungskabel (eines für das Netzkabel, zum zweiten löten wir den DS1820)
- DS1820 (mit einem beliebigen Buchstaben)
Lötkolben
-klebepistole
Typenschild FTDI232
Schritt 1: Zuerst müssen wir das Arduino flashen, da ich einen Pro Mini habe (er geht ohne USB-RS232-Konverter), muss ich ein Lineal mit Stiften an das Arduino löten. Von der Seite, auf der DTR, TXD, RXD, VCC, GND, GND abgeleitet sind. Jetzt verbinden wir FTDI232 DTR mit DTR, VCC mit VCC, GND mit GND, TXD mit RXD, RXD mit TXD. Führen Sie die Arduino IDE aus, laden Sie die Skizze herunter und flashen Sie sie (Skizze am Ende).
Schritt 2: Nun kümmern wir uns um den Rumpf. Wir reißen den Schwamm an den „FUKS“ ab, entfetten alles gut, der tiefe Teil der Schachtel kann mit einem Schmirgelleinen passiert werden (etwas würde fester kleben). Markieren Sie das Loch für den Encoder, den USB-Anschluss (Mutter) und das Display selbst. Kleben Sie das Relais auf den Gehäusedeckel. Wir müssen versuchen, das Relais weiter vom Prozessor entfernt zu platzieren und die Komponenten so anzuordnen, dass sich der Deckel später schließt (es gibt viel Platz).
Schritt 3: Jetzt nehmen wir das USB-Verlängerungskabel und schneiden die Anschlussbuchse (Mutter) ab. Wir schneiden das abgeschnittene Ende ab, bohren ein Loch für das Kabel in den Körper, führen es ein und kleben den Schlüssel mit einer Pistole. Außerdem hat das Kabel rot, minus schwarz (ich überprüfe es nur), plus das Plus des Steckers, minus das Minus (ich gebe die Pinbelegung des Steckers nicht an - es ist im Internet). Zwischen dem Plus des Steckers und 2 Medien (ich habe sie angeschlossen) muss ein 4,7 kOhm Widerstand gelötet werden.
Schritt 4: Wir nehmen 2 USB-Verlängerungskabel, schneiden den Stecker (Mutter) ab und schneiden das Kabel ab. Für alle Fälle prüfen wir, ob wir alle richtig gelötet haben. Wir verbinden das Stromkabel mit USB-Aufladung und mit dem Netzwerk, stecken das abgeschnittene Kabel in den USB-Anschluss, schauen auf den Tester + auf rot - auf schwarz. Wir ziehen das Kabel heraus und löten den DS1820: - auf 1, + auf 3 die restlichen 2 Drähte auf 2. Ich beschichte dann die Epoxidverbindung (um die Tanks und Kühler zu reparieren) und lasse ein wenig vom Sensorgehäuse nach außen, damit schneller auf Temperaturänderungen reagiert wird.Nun, wir machen die Installation gemäß dem Schaltplan (wir verbinden die Leistung und Masse der Relaisplatte mit den gemeinsamen + bzw. - Schaltkreisen).
Schritt 5: Alle Schaltungskomponenten sind angeschlossen. Wir schließen unseren Sensor an (ohne ihn bleibt das Display schwarz) und schalten ihn ein. In der ersten Zeile - dem Temperaturwert, in 2, wenn „*“ eingeschaltet ist - ist das Relais eingeschaltet, nein - aus. Versuchen wir nun, die Grenzwerte für das Relaisschalten festzulegen. Drücken Sie die Geberwelle (oder Ihre Taste). Der Grenzwert wird angezeigt, bei dem sich das Relais durch Drehen der Welle einschaltet. Der Wert erhöht oder verringert sich. Durch erneutes Klicken auf die Welle erhalten wir die Obergrenze (das Relais schaltet sich aus), stellen den Wert ein und drücken erneut. Das Gerät überwacht die Temperatur, der Wert der Grenzwerte bleibt beim Ausschalten erhalten. Das ist alles.
#include
#include
#include
#define BUTTON_1_PIN 10 // Die Ausgangsnummer von Taste 1 ist 12
OneWire ds (12); // an Pin 10 (ein 4,7K Widerstand ist notwendig)
// initialisiere die Bibliothek mit den Nummern der Interface Pins
Flüssigkristall-LCD (3, 2, 4, 5, 6, 7);
unsigned long currentTime;
const int pin_A = 8; // Pin 12
const int pin_B = 9; // Pin 11
unsigned char enc_A;
unsigned char enc_B;
vorzeichenloses Zeichen enc_A_prev = 0;
float n_pr = 24,1;
float b_pr = 26,2;
Boolescher Preis = falsch;
Klasse Button {
Öffentlichkeit:
Button (Byte Pin, Byte TimeButton); // Konstruktorbeschreibung
boolean flagPress; // Flag-Taste wird jetzt gedrückt
boolean flagClick; // Flag-Taste wurde gedrückt (Klick)
void scanState (); // Methode zur Überprüfung des Signalzustands
void setPinTime (Byte Pin, Byte TimeButton); // Methode zum Einstellen der Ausgangsnummer und der Bestätigungszeit (Nummer)
privat:
Byte _buttonCount; // Bestätigungszähler für den stabilen Zustand
Byte _timeButton; // Bestätigungszeit für den Schaltflächenstatus
Byte _pin; // PIN-Nummer
};
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;
} else {
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;
} else {
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);
Verzögerung (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 vorhanden = 0;
Byte type_s;
Byte-Daten [12];
Byte-Adresse [8];
Float Celsius;
if (! ds.search (addr)) {
ds.reset_search ();
Verzögerung (250);
zurück
}}
if (OneWire :: crc8 (addr, 7)! = addr [7]) {
zurück
}}
// Das erste ROM-Byte gibt an, welcher Chip
switch (addr [0]) {
Fall 0x10:
type_s = 1;
Pause;
Fall 0x28:
type_s = 0;
Pause;
Fall 0x22:
type_s = 0;
Pause;
Standard:
zurück
}}
ds.reset ();
ds.select (addr);
ds.write (0x44, 1); // Konvertierung starten, am Ende mit eingeschaltetem Parasiten
enc_A = digitalRead (pin_A);
enc_A_prev = enc_A;
currentTime = millis ();
while ((millis () - currentTime) <2000) {
button1.scanState ();
if (button1.flagClick == true) {
// Es gab einen Knopfklick
button1.flagClick = false; // Klickattribut zurücksetzen
knopka ();
}}
}}
// delay (1000); // vielleicht sind 750ms genug, vielleicht auch nicht
// Wir könnten hier ein ds.depower () machen, aber das Zurücksetzen wird sich darum kümmern.
present = ds.reset ();
ds.select (addr);
ds.write (0xBE); // Scratchpad lesen
für (i = 0; i <9; i ++) {// benötigen wir 9 Bytes
Daten [i] = ds.read ();
}}
// Konvertiere die Daten in die tatsächliche Temperatur
// Da das Ergebnis eine 16-Bit-Ganzzahl mit Vorzeichen ist, sollte dies der Fall sein
// in einem "int16_t" -Typ gespeichert werden, der immer 16 Bit beträgt
// auch wenn auf einem 32-Bit-Prozessor kompiliert.
int16_t raw = (Daten [1] << 8) | Daten [0];
if (type_s) {
roh = roh << 3; // 9 Bit Standardauflösung
if (data [7] == 0x10) {
// "Anzahl bleibt" ergibt die volle 12-Bit-Auflösung
raw = (raw & 0xFFF0) + 12 - Daten [6];
}}
} else {
Byte cfg = (Daten [4] & 0x60);
// Bei niedrigerer Auflösung sind die niedrigen Bits undefiniert, also lasst sie uns auf Null setzen
if (cfg == 0x00) raw = raw & ~ 7; // 9 Bit Auflösung, 93,75 ms
sonst wenn (cfg == 0x20) raw = raw & ~ 3; // 10 Bit res, 187,5 ms
sonst wenn (cfg == 0x40) raw = raw & ~ 1; // 11 Bit res, 375 ms
//// Standard ist 12 Bit Auflösung, 750 ms Konvertierungszeit
}}
celsius = (float) raw / 16,0;
lcd.clear ();
lcd.setCursor (1,0);
lcd.print (celsius);
if (Preis) {
lcd.setCursor (0,1);
lcd.print ('*');
}}
if (n_pr! = b_pr) {
if (celsius b_pr) {
digitalWrite (11, LOW);
Preis = falsch;
}}
}}
}}
// Methode zur Überprüfung des Schaltflächenstatus
// flagPress = true - geklickt
// flagPress = false - gedrückt
// flagClick = true - wurde angeklickt (click)
void Button :: scanState () {
if (flagPress == (! digitalRead (_pin))) {
// Signalzustand bleibt gleich
_buttonCount = 0; // Signalstatuszähler zurücksetzen
}}
sonst {
// Signalstatus hat sich geändert
_buttonCount ++; // +1 zum Signalzustandszähler
if (_buttonCount> = _timeButton) {
// Der Signalstatus hat die angegebene Zeit nicht geändert
// Signalzustand ist stabil geworden
flagPress =! flagPress; // Umkehrung der Statusanzeige
_buttonCount = 0; // Signalstatuszähler zurücksetzen
if (flagPress == true) flagClick = true; // Zeichen von Klick auf Klick
}}
}}
}}
// Methode zum Einstellen der Ausgabenummer und der Bestätigungszeit
void Button :: setPinTime (Byte Pin, Byte TimeButton) {
_pin = pin;
_timeButton = timeButton;
pinMode (_pin, INPUT_PULLUP); // definiere die Ausgabe als Eingabe
}}
// Beschreibung des Konstruktors der Button-Klasse
Button :: Button (Byte Pin, Byte TimeButton) {
_pin = pin;
_timeButton = timeButton;
pinMode (_pin, INPUT_PULLUP); // definiere die Ausgabe als Eingabe
}}
