Continuiamo a sviluppare la nostra stazione meteorologica.

Prima di passare all’aggiornamento, voglio fare un po’ di chiarezza.

Uno dei nostri colleghi mi ha scritto chiedendomi perché è stato introdotto il timer watchdog?

Il timer di watchdog è attivo in caso di emergenza. Come dimostra la pratica, l'ENC28J60 non gestisce più di (a meno che la memoria non fallisca) 4 connessioni simultanee. Considerando quante connessioni di servizio si verificano costantemente per mantenere il funzionamento della rete stessa e il traffico appena lasciato creato da tutti i tipi di giocattoli domestici (ad esempio, televisori moderni, scansiona gli host disponibili sulla rete e le loro porte aperte) il design entra semplicemente in uno stato di torpore. ENC28J60 non può funzionare in modo indipendente con protocolli di rete e tutto è implementato nelle biblioteche. Forse sono proprio loro.
Controllato tutte le librerie disponibili e diversi moduli(improvvisamente matrimonio), ma da raggiungere funzionamento stabile Non ho potuto farlo per molto tempo. Termine massimo erano circa 3-4 settimane.
Ecco perché il “cane” gira lì e, se succede qualcosa, tira il controller. Dopodiché il problema è scomparso.
Inoltre non nego che sia possibile nel mio rete di casa ci sono alcune sfumature o problemi. Ma poiché ho avuto un problema, anche un'altra persona potrebbe averlo. Finora ho trovato solo questa soluzione.
Per quanto ne so, i chip Wiznet (W5100 e versioni successive) non ce l'hanno, o semplicemente non avevano un bell'aspetto.

Passiamo all'aggiornamento

Ancora più importante, ci stiamo allontanando dal chip ENC28J60 e vai a W5100. Ho provato a implementare tutto sul vecchio chip, ma la memoria del microcontrollore non è sufficiente a causa delle librerie molto grandi ENC28J60. Quando si utilizza un nuovo chip, standard biblioteche dallo sviluppatore e tutte le modifiche apportate, rimane ancora di più 20% memoria libera microcontrollore ATMega328. E questi sono nuovi panini!

In questa versione (chiamiamola la seconda) è possibile trasmettere letture dai sensori tramite comunicazone wireless utilizzando la frequenza 433 MHz. Ho preso i moduli stessi dai cinesi, i contrassegni XY-MK-5V. Vorrei sottolineare che la qualità della trasmissione è lungi dall'essere perfetta. Possibile perdita di segnale, rumore, incapacità di farlo trasmissione simultanea eccetera. Ma il loro prezzo (meno di 1 dollaro a set) compensa queste carenze. Ti svelo un segreto per cui questi moduli (i più economici) si trovano in molte stazioni meteorologiche di marca uso domestico. Wow, inaspettato?

Cominciamo con la stazione base

Ci stiamo trasferendo a Arduino UNO E Scudo Ethernet(prima versione) basata su chip W5100. Questo è un panino ed è inutile descriverlo. Descriverò solo gli ulteriori contatti coinvolti per i moduli XY-MK-5V.

Il modulo trasmettitore utilizza energia 5 V, TERRA(dove saremmo senza madre) e D2 pin sul controller. Modifica il contatto D2 (DATI) puoi usare la funzione vw_set_tx_pin dalla libreria VW.

A differenza dello schizzo precedente, questo ne prevede due librerie aggiuntive:

#includere #includere

Lo schizzo stesso

Testo nascosto

#includere #includere #includere #includere #includere #includere #includere #includere #define DHTTYPE DHT22 #define DHTPIN 5 DHT dht(DHTPIN, DHTTYPE); byte mac = (0x54, 0x34, 0x31, 0x31, 0x31, 0x31); char server = "narodmon.ru"; porta intera = 8283; Indirizzo IP ip(192,168,0,201); Client client Ethernet; BMP085 dps = BMP085(); lungo Temperatura = 0, Pressione = 0; float H, dP, dPt; intervallo bool = vero; EasyTransferVirtualWire ET; struct SEND_DATA_STRUCTURE( byte ID; // ID dispositivo int Temperatura; // Temperatura float Pressione; // Pressione float Umidità; // Umidità float dewPoint; // Punto di rugiada/gelo ); Trasmissione SEND_DATA_STRUCTURE; void setup() ( // Inizializza il timer Watchdog wdt_disable(); delay(8000); wdt_enable(WDTO_8S); // Inizializza la console Serial.begin(9600); // Inizializza il sensore DHT dht.begin(); / / Inizializzazione del modulo a 433 MHz ET.begin(details(broadcast)); vw_set_ptt_inverted(true); vw_set_tx_pin(2); if (Ethernet.begin(mac) == 0) Ethernet.begin(mac, ip); 1-Wire Wire.begin(); // Inizializzazione BMP180 con regolazione dell'altezza // dps.init (MODE_STANDARD, 3200, true // Inizializza BMP180 dps.init(); // Invia i primi dati immediatamente dopo l'accensione del dispositivo send_info(true) // funzione dewPoint NOAA / / riferimento (1) : http://wahiduddin.net/calc/density_algorithms.htm // riferimento (2) : http: //www.colorado.edu/geography/weather_station/Geog_site/about.htm doppio punto di rugiada(doppio centigrado, doppia umidità) ( // (1) Pressione di vapore di saturazione = ESGG(T) doppio RAPPORTO = 373,15 / (273,15 + centigradi) ; doppio RHS = -7.90298 * (RAPPORTO - 1); RHS += 5.02808 * log10(RAPPORTO); RHS += -1.3816e-7 * (pow(10, (11.344 * (1 - 1/RAPPORTO))) - 1) ; RHS += 8.1328e-3 * (pow(10, (-3.49149 * (RAPPORTO - 1))) - 1) ; RHS += log10(1013.246); // il fattore -3 serve per regolare le unità: pressione di vapore SVP * umidità doppia VP = pow(10, RHS - 3) * umidità; // (2) PUNTO DI RUGIADA = F(pressione di vapore) doppia T = log(VP/0,61078); // temp var return (241.88 * T) / (17.558 - T); ) void send_info(bool eth) ( bool fail = true; while(fail) ( // Proviamo a leggere i dati dal sensore di umidità DHT finché non otteniamo // un risultato. Nel 90% dei casi tutto funziona bene, ma abbiamo bisogno 100 % if((H = dht.readHumidity()) >= 0) ( // Ottiene umidità e temperatura dal sensore BMP180 dps.getPressure(&Pressure); dps.getTemperature(&Temperature); // Calcola il punto di rugiada se la temperatura esterna è superiore a 0 gradi Celsius // e si prevede un risultato superiore a 0, altrimenti output 0. Ciò è necessario // per non trarre in inganno durante la stagione invernale. // dP = Temperatura>0?((dPt=Puntorugiada(Temperatura*0.1, H))<0?0:dPt):0; dP = dewPoint(Temperature*0.1, H); // Отправляем данные в эфир 433 мГц broadcast.ID = 1; broadcast.Temperature = floor(Temperature*0.1); broadcast.Pressure = floor(Pressure/133.3*10)/10; broadcast.Humidity = floor(H*10)/10; broadcast.dewPoint = floor(dP*10)/10; ET.sendData(); delay(250); if(eth) { // Подключаемся к серверу "Народный мониторинг" if(client.connect(server, port)) { // Начинаем передачу данных // адрес_устройства_в_проекте, имя_устройства, GPS широта, GPS долгота client.print(F("#fe-31-31-0e-5a-3b#Arduino Uno#71.344699#27.200014\n")); // Температура client.print(F("#T0#")); client.print(Temperature*0.1); client.print(F("#Температура\n")); // Давление client.print("#P1#"); client.print(Pressure/133.3); client.print(F("#Давление\n")); // Влажность client.print("#H1#"); client.print(H); client.print(F("#Влажность\n")); // Точка росы\инея client.print("#T1#"); client.print(dP); client.print((dP <= 0)? F("#Точка инея\n"):F("#Точка росы\n")); //client.print(F("#Точка росы\n")); // Отправляем конец телеграммы client.print("##"); // Даем время отработать Ethernet модулю и разрываем соединение delay(250); client.stop(); } } // Останавливаем цикл, если передача завершена fail = !fail; break; } delay(250); } } void loop() { // Каждые 4 секунды сбрасываем сторожевой таймер микроконтроллера // Каждые 6 минут отправляем данные на "Народный мониторинг" // Каждые 30 секунд отсылаем данные в эфир 433 if(!(millis()%1000)) wdt_reset(); if(!(millis()%360000)) send_info(true); if(!(millis()%30000)) send_info(false); }

Ai moduli stessi deve essere aggiunta un'antenna. Per 433 MHzÈ sufficiente un normale filo di rame lungo 17 cm. Senza un'antenna, puoi dimenticarti del normale funzionamento.

Passiamo alla parte più importante di questo aggiornamento: la stazione wireless locale

Per implementarlo (sul ginocchio) ho utilizzato un analogo Arduino NANO(sulla base ATMega328) E TFT visualizzare su un chip ST7735S con permesso 128×160

Testo nascosto

Visualizzazione della piedinatura -> controller

============================ LED | SCK 3,3 V | SCK (13) SDA | MOSI(11)A0 | CC (9) RESET | RST(8)CS | CS (10) GND | GND VCC | 5V ============================

Il modulo ricevitore si collega solo come un trasmettitore DATI appuntare D7.

Un paio di foto di come appare:

Testo nascosto

Schizzo del ricevitore

Testo nascosto

#includere #includere #includere #includere intero x, y; int w = 128, h = 160; dimensione intera; // 433 EasyTransferVirtualWire ET; struct SEND_DATA_STRUCTURE( byte ID; // ID dispositivo int Temperatura; // Temperatura float Pressione; // Pressione float Umidità; // Umidità float dewPoint; // Punto di rugiada/gelo ); Trasmissione SEND_DATA_STRUCTURE; int Log_Temperatura = -1; float Log_Pressione = -1; float Log_Umidità = -1; float Log_puntorugiada = -1; // TFT #define cs 10 #define dc 9 #define rst 8 char Temperatura, pressione, umidità, punto di rugiada; Informazioni sulla stringa; TFT Schermo TFT = TFT(cs, dc, rst); void setup())( Serial.begin(9600); // Inizializzazione del modulo 433 MHz ET.begin(details(broadcast)); vw_set_ptt_inverted(true); vw_set_rx_pin(7); vw_setup(2000); vw_rx_start(); // Inizializzazione e configurazione iniziale della visualizzazione TFTscreen.begin(); TFTscreen.setRotation(2); TFTscreen. background(0, 0, 0) // Disegna elementi statici // 1. Vieni a trovarci TFTscreen.stroke(255, 255). , 255); TFTscreen.setTextSize(1); TFTscreen.text(" ", 10, 10); // 2. Descrizione delle letture dei sensori TFTscreen.text("mmHg", w/2+5, 80); "%", con 2+5, 100); TFTscreen.text("C", con 2+5, 120); broadcast.Temperatura = 0; broadcast.Humidity = 0 .TFTPrint(); ; ) void loop())( if(ET.receiveData())( if(broadcast.ID == 1) TFTPrint(); /* Serial.println(broadcast.Temperature); Serial. println(broadcast.Pressure); Serial.println(broadcast.dewPoint); */ ) modifiche void (int size, int y, bool up, bool clear = false) ( if(clear) TFTscreen.stroke(0, 0, 0); else ( cambia(dimensione, x, y, !su, true); TFTscreen.stroke((su)?0:255, 0, (su)?255:0); ) if((dimensione%2) == 0 ) dimensione++; while(dimensione > 0) ( TFTscreen.line(x, y, x+(dimensione--), y); ++x, (su)?--y:++y, --size; ) /* while( dimensione > 0) ( TFTscreen.line(x, y, (su)?x+dimensione-1:x, (su)?y:y+dimensione-1); ++x, ++y, --dimensione; ) */ ) int x_center(int w, int lunghezza, int dimensione) ( return floor((w-lunghezza*(dimensione*5)+dimensione*2)/2); ) int x_alignment_right(int w, int lunghezza, int dimensione) ( return ceil(w-length*(dimensione*5)+dimensione*2); ) void TFTPrint() ( dimensione = 3; // ================= ================================================== === =============== // Visualizza letture della temperatura // ============== =========== ========================================== ==== if(broadcast. Temperatura != Log_Temperatura) ( TFTscreen.setTextSize(size); // Sovrascrivi i dati obsoleti String info = String(Log_Temperature); info.concat(" C"); if(Log_Temperature > 0) info = "+"+info; info .toCharArray(Temperatura, info.length()+1); TFTscreen.stroke(0, 0, 0), dimensione), 35 // Visualizza le informazioni sulle nuove letture = String(broadcast. Temperatura); = Log_dewPoint) ( TFTscreen.setTextSize(size); // Sovrascrivi i dati obsoleti info = String(Log_dewPoint); info.toCharArray(dewPoint, info.length()); TFTscreen.stroke(0, 0, 0); TFTscreen.text (dewPoint, x_alignment_right(w/2-5, info.length(), size), 120); // Genera nuove letture info = String(broadcast.dewPoint info.toCharArray(dewPoint, info.length()); TFTscreen.stroke(255, 255, 255); TFTscreen.text(dewPoint, x_alignment_right(w/2-5, info.length(), size), 120); modifiche(10, 106, 125, (broadcast.dewPoint > Log_dewPoint)?true:false); ) else (changes(10, 106, 125, true, true); changes(10, 106, 125, false, true); ) // Aggiorna i valori nei log per i successivi confronto delle letture Log_Temperature = broadcast.Temperature; Log_Pressure = broadcast.Pressure; Log_Umidità = broadcast.Umidità; Log_puntorugiada = broadcast.puntorugiada; )

Le letture sono visualizzate in modo abbastanza compatto, ma come dimostra la pratica (e il consiglio dei miei compagni) - "gusto e colore, anche la moglie non è un'amica". Ho ascoltato molti consigli e suggerimenti, ma si contraddicono a vicenda. Pertanto, fallo secondo i tuoi gusti.

Mi è sembrato che il design sia la parte del progetto che occupa la maggior parte del tempo!

Testo nascosto

Alcuni dati sono fabbricati per riflettere alcuni elementi di progettazione.

Gli artefatti sul display sono polvere e altro sporco che si è accumulato nel corso del tempo in cui il display è rimasto... da qualche parte lì,... beh, lì, non ricordo dove l'ho preso! Lasciami in pace!

Lo schizzo ha funzioni di posizionamento. Sono piuttosto primitivi, ma ti permettono di ottenere determinati effetti.

1. x_centro
2. x_allineamento_destra

Il primo centra il testo e il secondo lo allinea al lato destro della zona specificata. Tutti i calcoli vengono effettuati in relazione alle dimensioni dato testo, in base all'espressione 1 dimensione = 1PX x 1PX segmento di carattere.

Il display visualizza anche elementi corrispondenti ad un aumento o diminuzione di un particolare valore di lettura. Sono visualizzati sotto forma di triangoli. Ma nel codice funzione i cambiamenti Esiste una visualizzazione alternativa sotto forma di triangoli ruotati di 45 gradi. Se le letture aumentano l'elemento è rosso, altrimenti blu.

A proposito, il colore e l'ombra della temperatura principale cambiano a seconda della temperatura stessa. Una decisione piuttosto controversa, ma secondo me visivamente confortevole. Ho lottato per un po' e ho capito che i valori nella funzione colpo, oggetto Display TFT, sono elencati nell'ordine sbagliato. BGR posto RGB. Questo è un errore dello sviluppatore oppure non capisco qualcosa.

PS: Tutto è abbastanza interessante, ma secondo me merita ulteriori sviluppi. Questo è quello che faremo tra qualche tempo.

Recentemente un mio collega ha organizzato una piccola mostra scientifica.
Il mio insegnante mi ha chiesto di presentare un progetto di elettronica agli studenti del college. Avevo due giorni per inventare qualcosa di interessante e abbastanza semplice.

Dato che le condizioni meteorologiche qui sono piuttosto variabili e la temperatura oscilla tra 30 e 40°C, ho deciso di creare una stazione meteorologica domestica.

Quali sono le funzioni di una stazione meteo domestica?
Stazione meteorologica su Arduino con display: un dispositivo che raccoglie dati su tempo e condizioni ambiente utilizzando molti sensori.

Solitamente si tratta dei seguenti sensori:

• vento
• umidità
• piovere
• temperatura
• pressione
• altezza

Il mio obiettivo è creare una stazione meteorologica desktop portatile con le mie mani.

Dovrebbe essere in grado di determinare i seguenti parametri:

• temperatura
• umidità
• pressione
• altezza

Passaggio 1: acquistare i componenti necessari

• DHT22, sensore di temperatura e umidità.
• BMP180, sensore di pressione.
• Saldare
• Connettore di uscita a fila singola da 40

Attrezzatura di cui avrai bisogno:

• Saldatore
• Pinze per naselli
• Fili

Passaggio 2: sensore di temperatura e umidità DHT22

Per misurare la temperatura vengono utilizzati diversi sensori. DHT22, DHT11, SHT1x sono popolari

Spiegherò in cosa differiscono l'uno dall'altro e perché ho utilizzato DHT22.

Utilizza il sensore AM2302 segnale digitale. Questo sensore funziona sistema unico codifica e tecnologia dei sensori, quindi i suoi dati sono affidabili. Il suo elemento sensore è collegato a un computer a chip singolo da 8 bit.

Ogni sensore di questo modello è compensato in temperatura e calibrato con precisione; il coefficiente di calibrazione si trova in una memoria programmabile una sola volta (memoria OTP). Durante la lettura delle letture, il sensore richiamerà il coefficiente dalla memoria.

Piccole dimensioni, basso consumo energetico, lunga distanza Gli ingranaggi (100 m) consentono all'AM2302 di adattarsi a quasi tutte le applicazioni e 4 uscite di fila rendono l'installazione molto semplice.

Diamo un'occhiata ai pro e ai contro dei tre modelli di sensori.

DHT11

Pro: nessuna saldatura richiesta, il più economico dei tre modelli, veloce segnale stabile, portata superiore a 20 m, forte interferenza.
Contro: Biblioteca! Non sono disponibili opzioni di risoluzione, l'errore di misurazione della temperatura è di +/- 2°C, l'errore di misurazione del livello di umidità relativa è di +/- 5%, intervallo inadeguato di temperature misurate (0-50°C).
Campi di applicazione: giardinaggio, agricoltura.

DHT22

Pro: non richiede saldature, basso costo, curve morbide, piccoli errori di misurazione, ampio campo di misura, portata superiore a 20 m, forte interferenza.
Contro: la sensibilità potrebbe essere maggiore, rilevamento lento dei cambiamenti di temperatura, richiede una libreria.
Ambiti di applicazione: studi ambientali.

SHT1x

Pro: non richiede saldature, curve morbide, piccoli errori di misurazione, risposta rapida, basso consumo energetico, modalità automatica sonno, elevata stabilità e coerenza dei dati.
Contro: due interfaccia digitale, errore nella misurazione dei livelli di umidità, intervallo di temperatura misurata 0-50°C, libreria necessaria.
Aree di applicazione: funzionamento in ambienti difficili e in installazioni a lungo termine. Tutti e tre i sensori sono relativamente economici.

Composto

• Vcc – 5 V o 3,3 V
• Terra - con Terra
• Dati – al secondo pin Arduino

Passaggio 3: sensore di pressione BMP180

BMP180 – sensore barometrico pressione atmosferica con interfaccia I2C.
I sensori di pressione barometrica misurano il valore assoluto dell'aria ambiente. Questo indicatore dipende dallo specifico condizioni meteo e dall'altitudine sul livello del mare.

Il modulo BMP180 aveva uno stabilizzatore da 3,3 V 662 kOhm, che io, per mia stupidità, ho fatto esplodere accidentalmente. Ho dovuto instradare l'alimentatore direttamente al chip.

A causa della mancanza di uno stabilizzatore, sono limitato nella scelta della fonte di alimentazione: una tensione superiore a 3,3 V distruggerà il sensore.
Altri modelli potrebbero non avere uno stabilizzatore, assicurati di verificarne la presenza.

Schema di collegamento del sensore e del bus I2C con Arduino (nano o uno)

• SDA-A4
• SCL-A5
• VCC-3,3 V
• TERRA-TERRA

Parliamo un po' della pressione e della sua relazione con la temperatura e l'altitudine.

La pressione atmosferica in qualsiasi punto non è costante. Interazione complessa tra la rotazione della Terra e l'inclinazione dell'asse terrestre, porta alla comparsa di molte aree di alta e bassa pressione, che a loro volta portano a cambiamenti giornalieri delle condizioni meteorologiche. Osservando i cambiamenti di pressione è possibile effettuare previsioni meteorologiche a breve termine.

Ad esempio, un calo di pressione significa solitamente tempo piovoso o l'avvicinarsi di un temporale (avvicinamento alla zona di bassa pressione, ciclone). L'aumento della pressione di solito significa tempo asciutto e sereno (un'area che passa sopra di te alta pressione, anticiclone).

Anche la pressione atmosferica cambia con l'altitudine. La pressione assoluta al campo base dell'Everest (5400 m sopra il livello del mare) è inferiore alla pressione assoluta a Delhi (216 m sopra il livello del mare).

Poiché le letture della pressione assoluta variano in ciascuna località, faremo riferimento alla pressione relativa o alla pressione al livello del mare.

Misurazione dell'altezza

La pressione media al livello del mare è 1013,25 GPa (o millibar). Se ti alzi al di sopra dell'atmosfera, questo valore scende a zero. La curva di questa caduta è abbastanza chiara, quindi puoi calcolare tu stesso l'altezza sul livello del mare utilizzando la seguente equazione: alti=44330*

Se prendi la pressione a livello del mare di 1013,25 GPa come p0, la soluzione dell'equazione è tua altitudine attuale sopra il livello del mare.

Misure precauzionali

Ricordare che il sensore BMP180 necessita dell'accesso all'atmosfera circostante per poter leggere la pressione dell'aria, non posizionare il sensore in un alloggiamento chiuso. Piccolo sfogo sarà abbastanza. Ma non lasciarlo troppo aperto: il vento confonderà le letture della pressione e dell'altitudine. Considera la protezione dal vento.

Proteggere dal calore. La misurazione della pressione richiede letture accurate della temperatura. Cercare di proteggere il sensore dagli sbalzi di temperatura e non lasciarlo vicino a fonti di alte temperature.

Proteggere dall'umidità. Il sensore BMP180 è sensibile ai livelli di umidità, cercare di evitare che eventuale acqua entri nel sensore.

Non accecare il sensore. Ciò che era inaspettato era la sensibilità del silicone del sensore alla luce, che poteva raggiungerlo attraverso un foro nel coperchio del chip. Per il massimo misurazioni precise Cercare di proteggere il sensore dalla luce ambientale.

Passaggio 4: assemblaggio del dispositivo

Installazione di connettori a fila singola per Arduino Nano. In realtà, li abbiamo ridotti a la giusta dimensione e li ho levigati un po' in modo che sembrassero come se fossero lì. Quindi li saldiamo. Successivamente installiamo connettori a fila singola per il sensore DHT22.

Installiamo una resistenza da 10kOhm dall'uscita dati a terra (Gnd). Saldiamo tutto.
Quindi installiamo esattamente allo stesso modo il connettore a fila singola per il sensore BMP180, fornendo alimentazione a 3,3 V. Colleghiamo tutto al bus I2C.

Infine, colleghiamo il display LCD allo stesso bus I2C del sensore BMP180.
(Ho intenzione di collegare in seguito un modulo RTC (orologio in tempo reale) al quarto connettore in modo che il dispositivo mostri anche l'ora).

Passaggio 5: codifica

Scarica librerie

Per installare le librerie su Arduino, seguire il collegamento

#includere
#include #include #include "DHT.h" #include

SFE_BMP180 pressione;

#define ALTITUDINE 20.56 #define I2C_ADDR 0x27 //<<- Add your address here. #define Rs_pin 0 #define Rw_pin 1 #define En_pin 2 #define BACKLIGHT_PIN 3 #define D4_pin 4 #define D5_pin 5 #define D6_pin 6 #define D7_pin 7

#define DHTPIN 2 // a quale pin digitale siamo connessi

// Decommenta qualunque tipo tu stia utilizzando! //#define DHTTYPE DHT11 // DHT 11 #define DHTTYPE DHT22 // DHT 22 (AM2302), AM2321 DHT dht(DHTPIN, DHTTYPE); LiquidCrystal_I2C lcd(I2C_ADDR,En_pin,Rw_pin, Pin_Rs,pin_D4,pin_D5,pin_D6,pin_D7 float t1,t2);

void setup() ( Serial.begin(9600); lcd.begin(16,2); //<<-- our LCD is a 20x4, change for your LCD if needed // LCD Backlight ON lcd.setBacklightPin(BACKLIGHT_PIN,POSITIVE); lcd.setBacklight(HIGH); lcd.home (); // go home on LCD lcd.print("Weather Station"); delay(5000); dht.begin(); pressure.begin(); } void loop() { char status; double T,P,p0,a; status = pressure.startTemperature(); if (status != 0) { delay(status);

stato = pressione.getTemperatura(T); if (stato != 0) ( Serial.print("1"); lcd.clear(); lcd.setCursor(0,0); lcd.print("Temperatura barometrica: "); lcd.setCursor(0,1 ); lcd.stampa(T,2); lcd.stampa(" grado C ");

stato = pressione.startPressure(3); if (status != 0) ( // Attendi il completamento della misurazione: delay(status);

stato = pressione.getPressione(P,T); if (stato!= 0) (lcd.clear(); lcd.setCursor(0,0); lcd.print("pressione assoluta: "); lcd.setCursor(0,1); lcd.print(P,2 ;lcd.print("mb"); ritardo(3000);

p0 = pressione.livello del mare(P,ALTITUDINE); // siamo a 1655 metri (Boulder, CO)

a = pressione.altitudine(P,p0); lcd.clear(); lcd.setCursor(0,0); lcd.print("Altitudine: "); lcd.setCursore(0,1); lcd.print(a,0); lcd.print("metri"); ritardo(3000); ) ) ) ) float h = dht.readHumidity(); // Legge la temperatura in gradi Celsius (impostazione predefinita) float t = dht.readTemperature(); t2=t; lcd.clear(); lcd.setCursor(0,0); // vai all'inizio della 2a riga lcd.print("Umidità: "); lcd.setCursor(0,1);lcd.print(h); lcd.print("%"); ritardo(3000); lcd.clear(); lcd.setCursor(0,0); // vai all'inizio della seconda riga lcd.print("DHT Tempurature: "); lcd.setCursore(0,1); lcd.print(t); lcd.print(" grado C "); ritardo(3000); lcd.clear(); lcd.setCursor(0,0); // vai all'inizio della seconda riga lcd.print("Tempuratura media: "); lcd.setCursore(0,1); lcd.print((t1+t2)/2); lcd.print(" grado C "); ritardo(3000); )

Ho usato la versione 1.6.5 di Arduino, il codice si adatta perfettamente e potrebbe adattarsi anche a quelle successive. Se per qualche motivo il codice non è adatto, utilizzare la versione 1.6.5 come base.

Un giorno, mentre passeggiavo per la città, vidi che aveva aperto un nuovo negozio di elettronica radiofonica. Entrando ho trovato un gran numero di Shield per Arduino perché... Avevo a casa un Arduino Uno e un Arduino Nano e mi è venuta subito l'idea di giocare con i trasmettitori di segnale a distanza. Ho deciso di acquistare il trasmettitore e il ricevitore più economici a 433 MHz:

Trasmettitore di segnale.

Ricevitore di segnale.

Dopo aver registrato un semplice schizzo di trasmissione dati (un esempio tratto da qui), si è scoperto che i dispositivi di trasmissione possono essere abbastanza adatti per trasmettere dati semplici, come temperatura, umidità.

Il trasmettitore ha le seguenti caratteristiche:
1. Modello: MX-FS-03V
2. Portata (a seconda della presenza di oggetti bloccanti): 20-200 metri
3. Tensione operativa: 3,5 -12 V
4. Dimensioni del modulo: 19 * 19 mm
5. Modulazione del segnale: AM
6. Potenza del trasmettitore: 10 mW
7. Frequenza: 433 MHz
8. Lunghezza richiesta dell'antenna esterna: 25 cm
9. Facile da collegare (solo tre fili): DATI; VCC; Terra.

Caratteristiche del modulo ricevente:
1. Tensione operativa: CC 5 V
2. Corrente: 4 mA
3. Frequenza operativa: 433,92 MHz
4. Sensibilità: - 105 dB
5. Dimensioni del modulo: 30 * 14 * 7 mm
6. Antenna esterna richiesta: 32 cm.

Internet afferma che il raggio di trasmissione delle informazioni a 2Kb/sec può raggiungere fino a 150 m. Non l'ho controllato personalmente, ma in un bilocale è accettato ovunque.

Hardware per stazione meteo domestica

Dopo diversi esperimenti, ho deciso di collegare un sensore di temperatura, umidità e trasmettitore ad Arduino Nano.

Il sensore di temperatura DS18D20 è collegato ad Arduino come segue:

1) GND al meno del microcontrollore.
2) DQ tramite una resistenza di pull-up a terra e al pin D2 di Arduino
3) Vdd a +5V.

Il modulo trasmettitore MX-FS - 03V è alimentato a 5 Volt, l'uscita dati (ADATA) è collegata al pin D13.

Ho collegato un display LCD e un barometro BMP085 ad Arduino Uno.

Schema di collegamento ad Arduino Uno

Il ricevitore del segnale è collegato al pin D10.

Modulo BMP085 - sensore digitale di pressione atmosferica. Il sensore consente di misurare temperatura, pressione e altitudine sul livello del mare. Interfaccia di connessione: I2C. Tensione di alimentazione del sensore 1,8-3,6 V

Il modulo si collega ad Arduino allo stesso modo degli altri dispositivi I2C:

• VCC-VCC (3,3 V);
• TERRA-TERRA;
• SCL - al pin analogico 5;
• SDA - al pin analogico 4.

• Costo molto basso
• Alimentazione e I/O 3-5 V
• Determinazione dell'umidità 20-80% con precisione del 5%.
• Rilevamento della temperatura 0-50 gradi. con una precisione del 2%.
• Frequenza di polling non superiore a 1 Hz (non più di una volta ogni 1 secondo)
• Dimensioni 15,5 mm x 12 mm x 5,5 mm
• 4 pin con spaziatura tra i pin 0,1".

DHT ha 4 pin:

1. Vcc (alimentazione 3-5V)
2. Uscita dati: uscita dati
3. Non usato
4. Generale

Si collega al D8 di Arduino.

Parte software di una stazione meteorologica domestica

Il modulo trasmittente misura e trasmette la temperatura ogni 10 minuti.

Di seguito il programma:

/* Sketch versione 1.0 Invia la temperatura ogni 10 minuti. */ #include #include #include #define ONE_WIRE_BUS 2 //Pin per collegare il sensore Dallas OneWire oneWire(ONE_WIRE_BUS); Sensori di temperatura Dallas (&oneWire); Indirizzo dispositivo all'interno del termometro; void setup(void) ( //Serial.begin(9600); vw_set_ptt_inverted(true); // Necessario per DR3100 vw_setup(2000); // Imposta la velocità di trasmissione (bit/s) sensori.begin(); if (! sensori .getAddress(insideThermometer, 0)); printAddress(insideThermometer); sensori.setResolution(insideThermometer, 9); void printTemperature(DeviceAddress deviceAddress) ( float tempC = sensors.getTempC(deviceAddress); //Serial.print("Temp C : "); //Serial.println(tempC); //Formazione dei dati per l'invio int numero = tempC; char simbolo = "c"; //Simbolo di servizio per determinare che si tratta di un sensore String strMsg = "z"; strMsg += simbolo; strMsg += " "; strMsg += " "; strMsg.toCharArray(msg, 255); / Attendi il completamento del trasferimento void loop(void) ( for (int j=0 ; J<= 6; j++) { sensors.requestTemperatures(); printTemperature(insideThermometer); delay(600000); } } //Определение адреса void printAddress(DeviceAddress deviceAddress) { for (uint8_t i = 0; i < 8; i++) { if (deviceAddress[i] < 16); //Serial.print("0"); //Serial.print(deviceAddress[i], HEX); } }

Il dispositivo ricevente riceve i dati, misura la pressione e la temperatura nella stanza e li trasmette al display.

#include #include LiquidCrystal lcd(12, 10, 5, 4, 3, 2); #include sensore dht11; #define DHT11PIN 8 #include #include BMP085 dps = BMP085(); lungo Temperatura = 0, Pressione = 0, Altitudine = 0; void setup() ( Serial.begin(9600); vw_set_ptt_inverted(true); // Necessario per DR3100 vw_setup(2000); // Imposta la velocità di ricezione vw_rx_start(); // Avvia il monitoraggio della trasmissione lcd.begin(16, 2) ; Wire.begin(); ritardo(1000); //lcd.setCursor(14,0); //lcd.write(0)); loop() ( uint8_t buf; // Buffer per il messaggio uint8_t buflen = VW_MAX_MESSAGE_LEN ; // Lunghezza del buffer if (vw_get_message(buf, &buflen)) // Se il messaggio viene ricevuto ( // Inizia l'analisi int i; // Se il messaggio non è indirizzato a noi, esci if (buf != "z") ( return; ) char command = buf; // Il comando è all'indice 2 // Il parametro numerico inizia all'indice 4 i = 4; // Poiché la trasmissione è carattere per carattere, è necessario convertire il set di caratteri in un numero while (buf[i] != " ") ( numero *= 10; numero += buf[i] - "0"; i++; ) dps.getPressure(&Pressure); getTemperatura(&Temperatura); //Serial.print(comando); lcd.print("T="); lcd.setCursor(2,0); lcd.print(numero); lcd.setCursor(5,0); lcd.print("P="); lcd.print(Pressione/133,3); lcd.print("mmH"); lcd.setCursore(0,1); lcd.print("T="); lcd.print(Temperatura*0.1); lcd.print("H="); lcd.print(sensore.umidità); lcd.casa(); //ritardo(2000); int chk = sensore.read(DHT11PIN); switch (chk) ( case DHTLIB_OK: //Serial.println("OK"); break; case DHTLIB_ERROR_CHECKSUM: //Serial.println("Errore checksum"); break; case DHTLIB_ERROR_TIMEOUT: //Serial.println("Time out errore"); break; default: //Serial.println("Errore sconosciuto"); break; ) ) )

PS In futuro ho intenzione di aggiungere quanto segue:
- sensore di umidità al trasmettitore, rielaborare l'algoritmo di trasmissione dei dati
- sensore per la misurazione della velocità e della direzione del vento.
- aggiungi un altro display al dispositivo ricevente.
- trasferire il ricevitore e il trasmettitore su un microcontrollore separato.

Di seguito una foto di quanto accaduto:

Elenco dei radioelementi

Designazione	Tipo	Denominazione	Quantità	Nota	Negozio	Il mio blocco note
	Parte trasmittente.
	Scheda Arduino	Arduino Nano 3.0	1			Al blocco note
	termometro	DS18B20	1			Al blocco note
	Resistore	220 Ohm	1			Al blocco note
	Modulo trasmettitore	MX-FS-03V (433 MHz)	1			Al blocco note
	Parte ricevente radio.
	Scheda Arduino	ArduinoUno	1			Al blocco note
	Resistenza trimmer		1			Al blocco note
	Resistore

Come base viene preso il progetto della stazione meteorologica tratto dal libro di V. Petin "Progetti utilizzando il controller Arduino", 2a edizione (progetto 5, appendice 2). Utilizzato Arduino IDE 1.8.5 su Windows 10.
È stato generato un errore durante l'esecuzione dello schizzo

In Internet si possono scaricare librerie per Arduino che hanno gli stessi nomi ma contenuti diversi. Lo schizzo potrebbe non funzionare se stai utilizzando la libreria sbagliata. A quanto pare mi sono imbattuto nelle librerie sbagliate. Ho aggiunto al progetto un sensore BMP180 per misurare la pressione atmosferica e ho rielaborato lo schizzo.

Schema di collegamento

Scansione degli indirizzi

Innanzitutto, collega il sensore BMP180 e l'indicatore LCD1602 ad Arduino. Compila lo schizzo dello scanner I2C ed eseguilo per determinare gli indirizzi dei dispositivi sul bus I2C.

Ogni 5 secondi il programma esegue la scansione dei dispositivi e rilascia gli indirizzi sulla porta COM. Ho trovato due dispositivi con indirizzi 0x3F e 0x77. BMP180 per impostazione predefinita ha l'indirizzo 0x77, il che significa che l'indicatore LCD ha l'indirizzo 0x3F.
In alcuni circuiti del libro i collegamenti tra i segnali SDA e SCL sulla scheda Arduino sono confusi. Dovrebbe essere: SDA - in A4, SCL - in A5. Se il modulo BMP180 ha cinque pin, al pin VIN vengono forniti +5 Volt.

Schema elettrico

Ora assemblare completamente il circuito. Ho utilizzato un LED RGB a catodo comune montato sulla scheda insieme a resistori da 150 ohm. Il catodo comune è collegato al pin GND, i restanti pin sono collegati secondo lo schema. Non è necessario apportare modifiche allo schizzo, poiché la luminosità dei LED cambia secondo una legge ciclica.
Lo schema mostra il collegamento di un LED RGB con anodo comune, come nel libro.
Se sullo schermo LCD1602 non sono visibili caratteri, ruotare il controllo della luminosità. La retroilluminazione dell'indicatore consuma molta corrente, quindi utilizzare un alimentatore con una corrente di almeno 2 A. Ho utilizzato un hub USB con un alimentatore esterno da 2 A.
Il circuito utilizzava una campana piezoelettrica ZP-22. La resistenza collegata al campanello è di 100 ohm. La frequenza del suono può essere modificata nel programma. Ho scelto una frequenza di 1000 Hz. Se trovi un cicalino con una frequenza sonora fissa, puoi accenderlo e spegnerlo semplicemente applicando e rimuovendo la tensione, come un normale LED. All'avvio dello schizzo viene emesso un breve segnale acustico. È possibile abilitare la segnalazione periodica mentre il programma è in esecuzione rimuovendo il commento dalla riga //bzz(100); nello schizzo.
Nel progetto ho utilizzato un sensore DHT11 sotto forma di modulo con una resistenza da 4,7 kOhm già montata. La resistenza può variare da 4,7 a 10 kOhm.
Collegare il pin Vcc del modulo orologio DS1302 al bus +5 Volt. In questo modo ridurrai il consumo della batteria, essenzialmente funzionerà solo quando l'Arduino è spento.

Programma (schizzo)

La libreria bmp085 viene utilizzata per la manutenzione del BMP180. Il valore della pressione dipende dall'altitudine della zona. Per il corretto valore della pressione atmosferica è necessario selezionare l'altitudine. Per fare ciò, modifica la riga dps.init(MODE_STANDARD, 10000, true); La mia altezza è di 100 m (10000 cm). Il frammento del calcolo della pressione è tratto dall'esempio BMP085_test2.ino della libreria bmp085.

Schizzo meteo_P

#includere
#includere
#includere
#include "DHT.h"
#includere
BMP085 dps = BMP085();
lungo Pressione = 0, Altitudine = 0;
tempo lungo senza segno1 = 0;

#definire il PIN DHTP 10
#define DHTTYPE 11 // 11 - DHT11, 22 - DHT22
DHT dht(DHTPIN, TIPO DHT);

intero kCePin = 4; // RST DS1302
int kIoPin = 3; // Dati DS1302
int kSclkPin = 2; //CLK DS1302
DS1302 rtc(kCePin, kIoPin, kSclkPin);

int REDpin = 9;
int VERDEpin = 6;
int BLUpin = 11;

LiquidCrystal_I2C lcd(0x3f, 16, 2); // inserisci il tuo indirizzo 0x20...0xff indirizzo
memTime lungo senza segno;
int bzzPin = 8;

void HumTempRead() (
float ronzio = dht.readHumidity();
float temp = dht.readTemperature();
if (isnan(ronzio) || isnan(temp)) (
Serial.println("Impossibile leggere dal sensore DHT!");
lcd.setCursore(0, 1);
lcd.print("H=--% T=---");
lcd.setCursore(11, 1);
lcd.print((carattere)223);
lcd.setCursore(12, 1);
lcd.print("C ");
) altro (
lcd.setCursore(0, 1);
lcd.print("H=");
lcd.setCursore(2, 1);
lcd.print(ronzio);
lcd.setCursore(4, 1);
lcd.print("% T="+");
lcd.setCursore(9, 1);
lcd.print(temp);
lcd.setCursore(11, 1);
lcd.print((carattere)223);
lcd.setCursore(12, 1);
lcd.print("C ") ;
}
}

void setup_bzz() (
pinMode(bzzPin, USCITA);
}

void bzz(int _bzzTime) (
tono(bzzPin, 1000, _bzzTime); // frequenza 1000 Hz
}

configurazione nulla() (
Serial.begin(9600);
Filo.begin();
ritardo(1000);

dps.init(MODE_STANDARD, 10000, vero); // 100 metri (altezza sul livello del mare in cm)

dht.begin();
setup_bzz();
bzz(100);

LCD.init();
lcd.retroilluminazione();
lcd.casa();
// lcd.setCursor(0, 0);

rtc.halt(falso);
rtc.writeProtect(falso);

//rtc.setDOW(VENERDI); // Imposta il giorno della settimana su VENERDI imposta il giorno della settimana
//rtc.setTime(4, 58, 0); // Imposta l'ora su 12:00:00 (formato 24 ore)
//rtc.setData(6, 8, 2010); // Imposta la data al 6 agosto 2010 imposta la data (giorno, mese, anno)
}

lcd.setCursore(8, 0);
lcd.print(rtc.getTimeStr());

if ((millis() - memTime > 2000) o (millis()< memTime)) { // DHT11/22 1 time each 2 seconds
HumTempRead();
memTime = millis();
}
ritardo(100);

if (((millis() - tempo1) / 1000.0) >= 1.0) (
dps.calcTrueTemperature();
tempo1 = milli();
}
dps.getPressione(&Pressione);
Serial.print(" Pressione(Pa):");
Serial.println(Pressione);

lungo p2;
intero pi greco;
p2 = (Pressione / 133,3224); // Pa in mmHg.
pi = tronca(p2); // scartando la parte frazionaria del numero

lcd.setCursore(0, 0);
lcd.print("P=");
lcd.setCursore(2, 0);
lcd.print(pi); // uscita bancomat. pressione sul display LCD
lcd.setCursore(5, 0);
lcd.print("mm");
// ritardo(3000);
//bzz(100); // rimuovi il commento se vuoi ascoltare i segnali
{
for (int valore = 0 ; valore<= 255; value += 1) {
analogWrite(REDpin, valore);
analogWrite(GREENpin, 255 - valore);
analogWrite(BLUEpin, 255);
ritardo(5);
}

for (int valore = 0; valore<= 255; value += 1) {
analogWrite(REDpin, 255);
analogWrite(GREENpin, valore);
analogWrite(BLUEpin, 255 - valore);
ritardo(5);
}

for (int valore = 0; valore<= 255; value += 1) {
analogWrite(REDpin, 255 - valore);
analogWrite(GREENpin, 255);
analogWrite(pinBLU, valore);
ritardo(5);
}
}
}

Nel Catalogo file è possibile scaricare lo schizzo e le librerie utilizzate nel progetto.

Importa le librerie LiquidCrystal_I2C.zip, bmp085.zip, DS1302.zip e DHT.zip dall'archivio scaricato nell'IDE di Arduino. Vai al menù Schizzo Collega la libreria Aggiungi libreria .ZIP... e nella finestra seleziona l'archivio zip della libreria.
Carica lo schizzo meteo_P. Sostituisci l'indirizzo LCD1602 nello schizzo con il valore ottenuto scansionando il bus I2C. Compila ed esegui lo schizzo.
Se lo schizzo funziona, apri il monitor della porta e visualizza i messaggi visualizzati. Regolare l'altezza nell'istruzione dps.init(MODE_STANDARD, 10000 , true); per ottenere valori di pressione reali.
Imposta l'orologio. Decommentare la riga //rtc.setTime(4, 58, 0); e tra parentesi indicare l'ora corrente (ore, minuti e secondi separati da virgole) e ricaricare lo schizzo nel controller. Dopo aver impostato il tempo, commenta nuovamente questa riga ed esegui nuovamente lo schizzo.
Se l'illuminazione notturna ti infastidisce, puoi regolarla modificando la lunghezza del ritardo nei cicli for alla fine dello schizzo. Con ritardo(2); il ciclo dura 2-3 secondi, con ritardo(5); — da 4 a 5 secondi, con ritardo(30); - fino a 15-16 secondi. Le informazioni sull'indicatore verranno aggiornate con lo stesso intervallo.
Quando si utilizza la stazione meteorologica in modo autonomo, ad es. senza collegarsi alla porta USB del computer, commentare le righe dello sketch con la scritta Serial... per disabilitare l'output delle informazioni sul monitor della porta COM.

PS. Nello schizzo del libro e negli esempi per la libreria DHT è indicata la linea di definizione #definire DHTTYPE DHT11. Lo schizzo si avvia, ma si blocca dopo alcune ore. L'orologio si ferma, il display non cambia. Nel monitor della porta viene visualizzato un messaggio vago, che contiene un collegamento a dht.
In questa riga ho rimosso le lettere DHT, cioè fatto #definire DHTTYPE 11. Successivamente, lo schizzo ha iniziato a funzionare stabilmente.

Articolo aggiornato il 25 giugno 2018

Risorse utilizzate
1. Petin V.A. Progetti che utilizzano il controller Arduino (Elettronica) 2a edizione, San Pietroburgo. BHV-Pietroburgo, 2015 464 pag.
2. Petin V. A., Binyakovsky A. A. Enciclopedia pratica di Arduino. - M., DMK Press, 2017. - 152 pag.
3. http://arduinolearning.com/code/i2c-scanner.php
4. http://arduino.ru/forum/programmirovanie/ds1302lcd1602
5. http://robotehnika18.rf/how-to-connect-lcd-1602-to-arduino-via-i2c/
6. esempio BMP085_test2.ino dalla libreria bmp085.zip
7. http://proginfo.ru/round/
8. http://homes-smart.ru/index.php?id=14&Itemid=149&option=com_content&view=article
9. http://iarduino.ru/lib/datasheet%20bmp180.pdf
10.http://it-donnet.ru/hd44780_dht11_arduino/

Ho testato singole parti del sistema su Arduino UNO. Quelli. Ho collegato il modulo ESP a uno e l'ho studiato, scollegato, quindi collegato nRF24, ecc. Per l'implementazione finale del sensore finestra, ho scelto Arduino Pro Mini perché è la miniatura più vicina a Uno.

Anche in termini di consumo energetico, Arduino Pro Mini ha un bell'aspetto:

• non esiste un convertitore USB-TTL, che di per sé "mangia" molto,
• Il LED è collegato tramite una resistenza da 10k.

Per il risparmio energetico avanzato è stato previsto:

• rimuovi il LED - indicatore di alimentazione sull'Arduino Pro Mini (me ne sono pentito, non ho danneggiato la scheda)
• oppure utilizzare un assieme “nudo” su un microprocessore Atmel ATmega328 (non utilizzato)
• utilizzare la libreria Low Power o JeeLib.

Tra le librerie ho scelto Low Power Library, è semplice e contiene solo ciò che serve.

Per l'unità centrale, poiché era previsto il collegamento ad essa di numerose periferiche, è stata scelta la scheda Arduino Mega. Inoltre, è completamente compatibile con UNO e ha più memoria. Guardando al futuro, dirò che questa scelta era completamente giustificata.

Puoi acquistare un Arduino Mega per circa $ 8.

Potenza e consumo energetico

Ora parliamo di potenza e consumo energetico.

Arduino Pro Mini è disponibile in due tipi:

• per tensione di alimentazione 5V e frequenza 16MHz
• per una tensione di alimentazione di 3,3 V e una frequenza di 8 MHz.

Poiché il modulo radio nRF24L01+ richiede 3,3 V per l'alimentazione e qui la velocità non è importante, acquistate un Arduino Pro Mini con 8 MHz e 3,3 V.

In questo caso, il range di tensione di alimentazione di Arduino Pro Mini è:

• 3,35-12 V per il modello 3,3 V
• 5-12V per il modello 5V.

Avevo già un Arduino Pro Mini a 5V, ecco perché l'ho utilizzato. Puoi acquistare un Arduino Pro Mini per circa $ 4.

L'unità centrale verrà alimentata da una rete a 220 V tramite un piccolo alimentatore che fornisce un'uscita di 12 V, 450 mA, 5 W. Così per 5 dollari. C'è anche un pin 5V separato.

E se ciò non bastasse, puoi installare qualcosa di più potente. In altre parole, risparmiare energia per l’unità centrale non ha molto senso. Ma per un sensore wireless remoto, il risparmio energetico è la parte più importante. Ma non vorrei nemmeno perdere la funzionalità.

Pertanto, Arduino Pro Mini e il modulo radio nRF24 saranno alimentati da un gruppo di 4 batterie Ni-Mh.

E ricorda capacità massima di una batteria moderna circa 2500-2700mAh, qualsiasi cosa in più è o un espediente di marketing (Ansmann 2850) o un inganno (UltraFire 3500).

Non utilizzo batterie agli ioni di litio per diversi motivi:

• molto costoso
• quando la temperatura ambiente scende sotto gli 0°C la potenza della batteria agli ioni di litio scende al 40-50%
• quelli economici sono prodotti senza protezione e non sono sicuri (durante un cortocircuito o una scarica possono esplodere e bruciare, vedere un sacco di video su YouTube)
• invecchiano, anche se non vengono utilizzate (ma lo stesso vale per tutti gli elementi chimici), dopo 2 anni la batteria agli ioni di litio perde circa il 20% della sua capacità.

Per il prototipo è del tutto possibile cavarsela con batterie Ni-MH AA o AAA di alta qualità. Inoltre, non abbiamo bisogno di grandi correnti. L'unico svantaggio delle batterie Ni-MH è il lungo tempo di ricarica.

Schema generale della stazione meteorologica

Riassumiamo. Ecco uno schema generale di come funziona il tutto.

Continua.

Tag: aggiungi tag