Senzori de temperatura GSM. Termometre si alarme GSM cu senzori termici. De ce merită să cumpărați un termometru GSM și sistem de alarmă cu senzori de temperatură?

Stație meteo DIY.

Era seară, nu mai era nimic de făcut după Anul Nou. Ca de obicei, în timpul sărbătorilor de iarnă de Anul Nou vreau să-mi ocup capul și mâinile cu ceva util și creativ. În aceste sărbători de Anul Nou am decis să fac o stație meteo cu propriile mele mâini. Am început pregătirea din timp, am achiziționat și asamblat toate componentele înainte de Anul Nou și am făcut programarea principală în perioada sărbătorilor.

(Sunt o mulțime de fotografii sub tăietură!)

În primul rând, voi trece peste componente; nu voi da link-uri, deoarece produsele de pe eBay (în contul meu personal) au fost arhivate. Am cumpărat multe componente pe îndelete de pe eBay. Am încercat o licitație pentru prima dată; înainte am cumpărat întotdeauna „cumpără-l acum”. Ce pot să spun, dacă nu te grăbești să faci cumpărături, poți cumpăra unele componente mai ieftine (diferența este uneori de două ori mai mare).

Senzor de presiune VMR085
Acesta este senzorul principal. Când l-am văzut pe eBay, am știut că vreau să construiesc o stație meteo acasă.
Senzorul a sosit într-un plic obișnuit, acoperit cu folie cu bule în interior.

În interiorul plicului se afla cartea de vizită a vânzătorului și un senzor, ambalate într-o pungă antistatică și învelită într-un alt strat de folie cu bule.

Punga antistatică a fost sigilată astfel încât umiditatea din timpul zborului să nu amenințe senzorul

Scoatem senzorul. Pe o parte există o linie lipită de contacte, care au fost introduse în spumă pentru a preveni îndoirea acestora. Pe de altă parte există senzorul în sine și marcajele de contact.




Totul ar fi bine, dar marcajele de contact sunt aplicate într-o imagine în oglindă.
Senzorul este conectat prin magistrala I2C și este alimentat la 3,3 V. Adică pentru funcționarea normală aveți nevoie de 4 fire (+, -, SDA, SCL)
Puteți interoga senzorul în 2 moduri: fie prin bibliotecă, fie folosind funcții direct în schiță.
Exemplu de program:

#include

#define BMP085_ADDRESS 0x77 // adresa I2C a BMP085

Const unsigned char OSS = 0; // Setarea supraeșantionării

// Valori de calibrare
int ac1;
int ac2;
int ac3;
unsigned int ac4;
unsigned int ac5;
unsigned int ac6;
int b1;
int b2;
int mb;
int mc;
int md;

Temperatura scurta;
presiune lungă;

Void setup()
{
Serial.begin(9600);
Wire.begin();
bmp085Calibrare();
}

buclă goală ()
{
temperatura = bmp085GetTemperature(bmp085ReadUT());
presiune = bmp085GetPressure(bmp085ReadUP());
Serial.print("Temperatura: „);
Serial.print (temperatura/10,0, DEC);
Serial.println("C");
Serial.print("Presiune: „);
Serial.print(presiune/133.322, DEC);
Serial.println(“mm Hg”);
Serial.println();
întârziere (1000);
}

Void bmp085Calibrare()
{
ac1 = bmp085ReadInt(0xAA);
ac2 = bmp085ReadInt(0xAC);
ac3 = bmp085ReadInt(0xAE);
ac4 = bmp085ReadInt(0xB0);
ac5 = bmp085ReadInt(0xB2);
ac6 = bmp085ReadInt(0xB4);
b1 = bmp085ReadInt(0xB6);
b2 = bmp085ReadInt(0xB8);
mb = bmp085ReadInt(0xBA);
mc = bmp085ReadInt(0xBC);
md = bmp085ReadInt(0xBE);
}

Short bmp085GetTemperature (unsigned int ut)
{
lung x1, x2;
x1 = (((lung)ut - (lung)ac6)*(lung)ac5) >> 15;
x2 = ((lung)mc<< 11)/(x1 + md);
b5 = x1 + x2;

Întoarcere ((b5 + 8)>>4);
}

Long bmp085GetPressure (nesemnat de mult timp)
{
lung x1, x2, x3, b3, b6, p;
nesemnat lung b4, b7;
b6 = b5 - 4000;
// Calculați B3
x1 = (b2 * (b6 * b6)>>12)>>11;
x2 = (ac2 * b6)>>11;
x3 = x1 + x2;
b3 = (((((lung)ac1)*4 + x3)<>2;
// Calculați B4
x1 = (ac3 * b6)>>13;
x2 = (b1 * ((b6 * b6)>>12))>>16;
x3 = ((x1 + x2) + 2)>>2;
b4 = (ac4 * (nesemnat lung)(x3 + 32768))>>15;
b7 = ((nesemnat lung)(sus - b3) * (50000>>OSS));
dacă (b7< 0x80000000)
p = (b7<<1)/b4;
altfel
p = (b7/b4)<<1;
x1 = (p>>8) * (p>>8);
x1 = (x1 * 3038)>>16;
x2 = (-7357 * p)>>16;
p += (x1 + x2 + 3791)>>4;
întoarcere p;
}

// Citiți 1 octet din BMP085 la „adresă”
char bmp085Read (adresă caracter nesemnată)
{
date char nesemnate;

Wire.write(adresa);
Wire.endTransmission();
Wire.requestFrom(BMP085_ADDRESS, 1);
în timp ce(!Wire.available())
;
return Wire.read();
}

Int bmp085ReadInt (adresă caracter nesemnată)
{
caracter nesemnat msb, lsb;
Wire.beginTransmission(BMP085_ADDRESS);
Wire.write(adresa);
Wire.endTransmission();
Wire.requestFrom(BMP085_ADDRESS, 2);
în timp ce(Wire.available()<2)
;
msb = Wire.read();
lsb = Wire.read();
return (int) msb<<8 | lsb;
}

// Citiți valoarea temperaturii necompensate
unsigned int bmp085ReadUT()
{
unsigned int ut;
// Scrieți 0x2E în Register 0xF4
// Aceasta solicită o citire a temperaturii
Wire.beginTransmission(BMP085_ADDRESS);
Wire.write(0xF4);
Wire.write(0x2E);
Wire.endTransmission();
// Așteptați cel puțin 4,5 ms
întârziere(5);
// Citiți doi octeți din registrele 0xF6 și 0xF7
ut = bmp085ReadInt(0xF6);
return ut;
}

// Citiți valoarea presiunii necompensate
nesemnat lung bmp085ReadUP()
{
caracter nesemnat msb, lsb, xlsb;
unsigned long up = 0;
// Scrieți 0x34+(OSS<<6) into register 0xF4
// Solicitați o citire a presiunii cu setare de supraeșantionare
Wire.beginTransmission(BMP085_ADDRESS);
Wire.write(0xF4);
Wire.write(0x34 + (OSS<<6));
Wire.endTransmission();
// Așteptați conversia, timpul de întârziere depinde de OSS
întârziere (2 + (3<// Citiți registrul 0xF6 (MSB), 0xF7 (LSB) și 0xF8 (XLSB)
Wire.beginTransmission(BMP085_ADDRESS);
Wire.write(0xF6);
Wire.endTransmission();
Wire.requestFrom(BMP085_ADDRESS, 3);
// Așteptați ca datele să devină disponibile
în timp ce(Wire.available()< 3)
;
msb = Wire.read();
lsb = Wire.read();
xlsb = Wire.read();
sus = (((nesemnat lung) msb<< 16) | ((unsigned long) lsb << 8) | (unsigned long) xlsb) >> (8-OSS);
întoarce-te sus;
}

Arduino Nano v3.0
Aceasta este inima întregii stații meteo. Mai simplu spus, controlerul are dimensiuni miniaturale.
eu am cumparat
Nu voi vorbi în detaliu despre controler, deoarece acest lucru a fost deja făcut înaintea mea:


Pachetul lightake a fost prefabricat, controlerul a venit într-un pachet care conținea un cablu USB și un Arduino într-o pungă antistatică sigilată.

Pentru a estima dimensiunea, am plasat o monedă de 1 rublă lângă Arduino.

Placa de control de aproape

Cablul USB este bun, cu inel de ferita. Arduino este alimentat printr-un cablu USB. Mediul de dezvoltare poate fi descărcat (pagina de descărcare). Limbajul este asemănător „C”, nu au fost probleme cu stăpânirea lui, deoarece programez mult în el la serviciu.

ecran LCD
La serviciu am găsit în coșuri un ecran LCD 1602 compatibil. A trebuit să schimb conexiunea, deoarece nu am putut găsi o fișă de date pentru ea. Ca urmare, LCD-ul a început să funcționeze.

Dar după o scurtă perioadă de utilizare, am observat că acest ecran nu mi-a fost suficient și nu ar fi posibil să afișez mai multe date, deoarece are doar 2 rânduri a câte 16 caractere fiecare. La început pare că acești parametri sunt suficienți, dar când te apuci de programare, îți dai seama că maximul pe care îl poți strânge este de 3-4 parametri. Și dacă faci un meniu (mă gândeam să fac un meniu pe acest ecran), atunci mai rămân doar 1-2 parametri spațiu liber.
Drept urmare, am început să caut un alt ecran. La început m-am uitat cu atenție la ecranul grafic de la Nokia 3310 și am participat chiar la licitația eBay pentru a-l cumpăra, dar nu a ieșit (de care sunt foarte fericit), așa că a trebuit să renunț la acest ecran. Acum înțeleg că ar fi prea mic pentru scopurile mele, deoarece există ceva cu care să se compare.
În timp ce mă uitam la întâmplare prin scuturi pe Arduino, am dat peste un ecran grafic 12864 pe un controler ST7920. Acest ecran are dimensiunea potrivită și rezoluție bună pentru nevoile mele (128x64). Adică, puteți plasa cu ușurință 6-7 rânduri de 20 de caractere într-un font care poate fi citit în mod normal. Deoarece ecranul este grafic, pe lângă text, graficele pot fi plasate în diferite fonturi. Pe scurt, asta este exact ceea ce aveam nevoie, totul era prezent pe acest ecran, așa că nu am putut rezista și l-am comandat.
Coletul a sosit rapid și a fost ambalat standard: un plic cu folie cu bule, în interior mai era un strat de folie cu bule și un ecran într-o pungă antistatică:






Pentru a estima dimensiunea, am plasat o monedă de 1 rublă lângă LCD.




Pentru a conecta rapid ecranul la Arduino, am lipit o linie de contacte la pinii LCD. LCD-ul poate fi conectat printr-o magistrală serială sau una paralelă. Am ales prima opțiune, deoarece există deja puține contacte Arduino gratuite.
Conexiune (preluată de pe web):

- Pinul 1 (GND) este conectat la magistrala comună
- Pinul 2 (VCC) este conectat la magistrala de alimentare +5V, iar consumul de curent este relativ mic, iar afișajul poate fi alimentat de la stabilizatorul Arduino încorporat.
- Pinii 4, 5 și 6 se conectează la ieșirile digitale Arduino, formând interfața serială SPI:
pinul 4 – (RS) – corespunde liniei CS (de exemplu 7)
pinul 5 – (RW) – corespunde liniei MOSI (de exemplu 8)
pinul 6 – (E) – corespunde liniei SCK (de exemplu 3)
Numerele de contact Arduino pot fi orice, principalul lucru este să nu uitați să le indicați corect în textul programului atunci când inițializați afișajul.
- Pinul 15 (PSB) este conectat la magistrala comună.
- Contactele 19 (A) și 20 (K) sunt sursa de alimentare cu iluminare de fundal (+5V și respectiv GND). Pentru a regla luminozitatea luminii de fundal, puteți utiliza un rezistor variabil de 10 kOhm conectat între magistrala de alimentare și GND. Tensiunea de la motorul său este furnizată pinului 19 al afișajului.

Programul în sine:

#include „U8glib.h”

U8GLIB_ST7920_128X64 u8g(3, 9, 8, U8G_PIN_NONE); // SPI E = 3, RW = 9, RS = 8

// Subrutină pentru determinarea memoriei libere
int freeRam() (
extern int __heap_start, *__brkval;
în televizor;
return (int) &v - (__brkval == 0? (int) &__heap_start: (int) __brkval);
}

Void setup(void) (
u8g.setFont(u8g_font_6x10); // font
u8g.setRot180(); //Întoarce ecranul
analogWrite(6, 115); // Setați luminozitatea ecranului (anodul de iluminare de fundal la 6 pini)
}

Buclă goală (nulă) (
u8g.firstPage();
face (

u8g.setPrintPos(1, 12); // poziție
u8g.print("Bună ziua!!!"); // textul de ieșire
u8g.drawBox(0,22,128,9); // Pictează dreptunghiul în alb
u8g.setColorIndex(0); // cerneală albă, fundal negru
u8g.setPrintPos(1, 30); // poziție
u8g.print("Cuvânt..."); // textul de ieșire

U8g.setColorIndex(1); // cerneală albă, fundal negru
u8g.setPrintPos(1, 50); // poziție
u8g.print("După pornire ="); // textul de ieșire
u8g.setPrintPos(85, 50); // poziție
u8g.print(millis() / 1000); // afișează numărul de secunde după pornire
u8g.setPrintPos(1, 64); // poziție
u8g.print(freeRam()); // arată câtă memorie este ocupată
) while(u8g.nextPage());

Întârziere (200);
}

Ceas în timp real DS1307
O altă componentă pentru stația mea meteo. Acest scut implementează un ceas în timp real. Le-am comandat pe eBay. Vânzătorul a trimis eșarfa ceasului într-o cutie nerealist de mare


În interiorul cutiei erau două coli A4 cu reclamă și o batistă de ceas învelită în celofan


Aș dori să menționez că taxa nu depășește 2 ruble. monedă, iar cutia măsura 13x15x5 cm.
Placa a fost ambalată într-o pungă antistatică

Şal aproape

A trebuit să mă ocup de acest modul. În primul rând, au existat dificultăți de conectare. Și în al doilea rând, nu există cuarț pe această placă. Dacă aș fi știut că voi petrece atât de mult timp pe modul, cel mai probabil l-aș fi asamblat singur, deoarece Internetul este plin de diagrame. Cel mai simplu circuit conține 4-5 componente.
In ceea ce priveste legatura. Am găsit o bibliotecă care spunea că interfața I2C poate fi conectată nu la intrările analogice obișnuite Arduino (A4 și A5), ci la oricare dintre cele discrete. Am făcut-o așa cum a fost scris. La început nimic nu a mers, dar după un dans lung cu tamburina, ceasul a pornit. Ei bine, m-am gândit, asta e, problemele s-au terminat, dar după ce am încercat să conectez același modul la alt Arduino, dansul cu tamburina a continuat. Am petrecut mult timp căutând o soluție la această problemă și aproape peste tot a fost indicată fie o conexiune incorectă, fie absența rezistențelor pull-up pe contactele SCL și SDA. Am vrut deja să intru în placă cu un fier de lipit, dar pe un forum am dat din greșeală de un cod în care se spunea că se conectează SCL și SDA la porturile standard I2C de pe Arduino. După o conexiune standard, totul a funcționat imediat.
Acum despre cuarț. Nu știu ce fel de cuarț au pus chinezii acolo, dar ceasurile cu astfel de cuarț au fugit cu 10-11 secunde pe zi. Această eroare este de 5 minute pe lună și 1 oră pe an. Nu este nevoie de un astfel de ceas. A trebuit să intru din nou online și să caut cum să repar acest bug. Prima soluție care apare spune că trebuie să împămânți cuarțul. Am făcut-o - rezultatul a fost zero. De asemenea, am găsit undeva că trebuie să găsesc o placă de bază veche și să scot de acolo quartzul ceasului. Am făcut-o - există un rezultat. Acum ceasul fuge nu cu 10-11 secunde, ci cu 1,5 secunde pe zi. Să spunem doar că s-a îmbunătățit, dar este departe de a fi ideal. Deoarece nu mai am chef să mă joc cu un fier de lipit, s-a decis să reglez ceasul programatic, adică să reglez ceasul la valoarea necesară o dată pe zi. După 10 zile, ceasul a sunat cu cel mult o secundă. Metoda este bună, dar numai atunci când dispozitivul de sincronizare Arduino este conectat la curent, altfel ceasul funcționează pe baterie și tot fuge.
Un mic program de testare:

#include „Wire.h”
#define DS1307_I2C_ADDRESS 0x68 // SDA A4, SCL A5

Octet decToBcd (byte val)
{
return ((val/10*16) + (val%10));
}

Byte bcdToDec(byte val)
{
return ((val/16*10) + (val%16));
}

Void setDateDs1307(octet secundă, // 0-59
octet minut, // 0-59
octet oră) // 0-99
{

Wire.write(0);
Wire.write(decToBcd(secunda));
Wire.write(decToBcd(minut));
Wire.write(decToBcd(ora));
Wire.endTransmission();
}

Void getDateDs1307(octet *secundă,
octet *minut,
octet *oră)
{

Wire.beginTransmission(DS1307_I2C_ADDRESS);
Wire.write(0);
Wire.endTransmission();

Wire.requestFrom(DS1307_I2C_ADDRESS, 3);

*secunda = bcdToDec(Wire.read());
*minut = bcdToDec(Wire.read());
*ora = bcdToDec(Wire.read());
}

Void setup()
{
octet secundă, minut, oră;
Wire.begin();
Serial.begin(9600);

Al doilea = 45;
minut = 5;
ora = 16;

SetDateDs1307(secundă, minut, oră);
}

buclă goală ()
{
octet secundă, minut, oră;

GetDateDs1307(&second, &minute, &hour);
Serial.print(oră, DEC);
Serial.print(":");
Serial.print(minut, DEC);
Serial.print(":");
Serial.println(al doilea, DEC);

Întârziere (1000);
}

Senzor de temperatură și umiditate DHT11
Nu este nimic de spus despre acest senzor. Nici nu l-as folosi daca umiditatea nu ar fi necesara. Din păcate, nu i-am făcut o fotografie când l-am primit, așa că nu vor fi fotografii. Fotografiile senzorului pot fi văzute mai jos, unde l-am conectat la Arduino. Conexiunea senzorului este simplă (+, ieșire digitală, -). De obicei, senzorii sunt fabricați cu patru pini. Cu acest factor de formă, al treilea pin nu este conectat la nimic.
Puteți folosi biblioteca pentru a vă conecta la Arduino. Îl poți descărca.
Un mic program de testare cu ieșire de informații pe afișajul LCD 1602:

// include codul bibliotecii:
#include
#include

// Declara obiecte
dht11 DHT11;
LiquidCrystal lcd (12, 11, 6, 5, 4, 3);

#define DHT11PIN 7
int i;

Void setup()
{
lcd.begin(16, 2);
lcd.print("Stare: „);
i=0;
}

buclă goală ()
{
int chk = DHT11.read(DHT11PIN);
lcd.setCursor(8, 0);
comutator (chk)
{
cazul 0: lcd.print(“OK „); break;// lcd.setCursor(11, 0); lcd.print(millis()/2000); pauză;
caz -1: lcd.print(„Eroare sumă de verificare”); mErr(); pauză;
case -2: lcd.print("Eroare de expirare"); mErr(); pauză;
implicit: lcd.print ("Eroare necunoscută"); mErr(); pauză;
}
întârziere (500);
lcd.setCursor(15, 0);
comutator (i)
{
cazul 0: lcd.print("^"); lcd.setCursor(15, 1); lcd.print(" ");break;
cazul 1: lcd.print("v"); lcd.setCursor(15, 1); lcd.print(" ");break;
implicit: lcd.setCursor(15, 1); lcd.print("E"); pauză;
}
i=i+1;
dacă (i>1) i=0;
lcd.setCursor(0, 1);
lcd.print("H=");
lcd.setCursor(2, 1);
lcd.print((float)DHT11.umiditate, 0);
lcd.setCursor(4, 1);
lcd.print("%");
lcd.setCursor(8, 1);
lcd.print("T=");
lcd.setCursor(10, 1);
lcd.print((float)DHT11.temperature, 0);
lcd.setCursor(12, 1);
lcd.print("C");

Void Err ()
{
lcd.setCursor(2, 1);
lcd.print("**");
lcd.setCursor(10, 1);
lcd.print("**");
i=5;
}

Se pare că am scris despre toate componentele. Tot ce rămâne este să adunăm totul într-un singur întreg.
Hopa, aproape am uitat! Pentru a asambla dispozitivul, aveți nevoie de o husă. Am comandat și husa pe Ebay. Vânzătorul s-a dovedit a fi din Anglia. Coletul a ajuns repede, dar nu i-am făcut poze. Toate fotografiile cazului sunt mai jos.

În primul rând, am asamblat totul pe masă folosind cablaje speciale. Am scris un program de testare și l-am încărcat în controler.

De fapt, culoarea albastră a luminii de fundal este mult mai strălucitoare. Chiar și la luminozitate minimă (Bright=5), cadrul este iluminat.

Pentru a asambla totul fără fir, s-a decis să se facă o mini placă de bază, iar pe conectori au fost puse plăci și scuturi Arduino. Dacă se întâmplă ceva, acestea pot fi îndepărtate rapid și ușor. De asemenea, am decis să atașez ecranul LCD și butoanele de control la conectori, doar pentru a lipi senzorul de temperatură pe fire.
Asa a iesit esarfa

În ultima fotografie nu am spălat complet fluxul. Am lipit cauciuc poros sub scuturi de lângă conectori, astfel încât să existe măcar puțin suport. Deși, de fapt, scuturile din conectorii de pe contacte rezistă foarte bine.

Placa de baza cu scuturi instalate si placa Arduino.

Așa arată o conexiune completă la placa de bază


În loc de nasturi, am folosit un scut de casă lipit pe o placă. Am folosit ca butoane butoane de la șoareci vechi.
După cum puteți vedea, numărul de fire a scăzut.

Principala problemă a plasării în carcasă este decuparea unei caneluri netede pentru ecranul LCD. Indiferent cât de mult am încercat, tot nu a ieșit perfect. În unele locuri, golurile au fost puțin mai mari de 1 mm. Pentru ca totul să arate îngrijit, am luat un etanșant negru pentru acvariu și am umplut toate crăpăturile, în același timp am atașat ecranul de acest etanșant. După ce s-a uscat sigilantul, am tăiat excesul din exterior. În lumină puternică, etanșantul este vizibil, dar în lumină normală, totul se îmbină cu corpul.
Așa arată carcasa din interior cu un ecran LCD și o placă de bază instalate.

Așa arată din exterior în lumină puternică (scuze pentru amprentele digitale, le-am văzut când sortam fotografiile).

M-am gândit mult timp la cum să potrivesc butoanele în carcasă și, cel mai important, ce butoane să folosesc...
In magazinele de radio-electronica le-a placut butonul cu un pin lung si varfurile care se potrivesc pe acest pin. Aceste butoane sunt folosite pentru lipirea plăcii. Totul ar fi bine, dar au un minus - cursa de apăsare este foarte mică și puternică.
A trebuit să punem butoanele în două etape: prima a fost să plasăm butoanele pe tablă, a doua a fost să montam această placă pe o altă placă. Și apoi puneți toate acestea în corp pe ghidaje.

Iată cum arată o eșarfă cu nasturi:

Iată cum arată placa suport:


Aici puteți vedea ghidajele în care este introdusă placa cu butoane. Unele elemente au fost lipite pentru a da rigiditate plăcii.

Acum punem totul în corp
Fără butoane de conectare:


Cu conexiune prin buton:

Închideți carcasa și porniți-o. Totul funcționează excelent, butoanele funcționează așa cum ar trebui.

La final postez un scurt videoclip cu dispozitivul care funcționează în diferite moduri:
http://www.youtube.com/watch?v=KsiVaUWkXNA&feature=youtu.be
Pentru cei care nu văd videoclipul aici, aici este link-ul către

Este timpul să încheiem recenzia.
Voi scrie puțin despre program și apoi câteva concluzii scurte. Când am scris programul, nu credeam că voi atinge foarte repede limita de 30.720 de octeți.


A trebuit să optimizez codul. Am mutat multe bucăți de cod în subrutine. Nu m-aș fi gândit niciodată că o instrucțiune switch...case în formă compilată ocupă mai mult spațiu decât mai multe instrucțiuni if...else. Declararea corectă a variabilelor economisește și spațiu. Dacă declarați o matrice lungă, deși este destul de posibil să obțineți pe octeți, atunci depășirea memoriei ajunge la 500 de octeți, în funcție de dimensiunea matricei. Când scrii un program, nu te gândești la el și abia mai târziu, când analizezi programul, realizezi că ai greșit unele lucruri și începi să optimizezi codul. După ce s-au rezolvat problemele cu dimensiunea programului, am întâlnit o limitare a RAM. Acest lucru a fost exprimat prin faptul că programul a început să se înghețe după încărcare. A trebuit să introduc o subrutină pentru calcularea memoriei RAM liberă. Ca urmare, am fost forțat să renunț la un algoritm de prognoză meteo, deoarece trebuie să afișeze pictograme pe ecran. Algoritmul în sine funcționează, dar rezultatul pictogramelor a trebuit să fie înregistrat. Încă mai am idei despre cum să optimizez codul, dar în viitorul apropiat voi lăsa dispozitivul să funcționeze așa cum este pentru a-i evalua performanța și a identifica toate erorile.

Acum cateva concluzii
Minusuri
1) Preț. Justificarea acestui dezavantaj este că un hobby nu este niciodată ieftin.

pro
1) Funcționalitate excelentă a dispozitivului
2) Creșterea funcțiilor este limitată doar de controlerul utilizat și de propria dorință
3) Plăcerea estetică din contemplare și satisfacția morală din faptul că în sfârșit am asamblat și completat acest dispozitiv