Cassetta delle lettere connessa ad energia solare: 12 passaggi (con immagini)

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:03

Per il mio secondo Ible, ti descriverò i miei lavori sulla mia cassetta delle lettere connessa.

Dopo aver letto questo Instructable (+ molti altri), e poiché la mia cassetta delle lettere non è vicino a casa mia, ho voluto ispirarmi ai lavori di Open Green Energy per collegare la mia cassetta delle lettere al mio server Domoticz.

Obiettivi

• Fatti avvisare da Telegram quando arrivano le lettere;
• Fatti avvisare da Telegram quando arriva un pacco;
• Controlla se le lettere/pacchi sono stati ritirati.

Il mio vincolo principale

La cassetta delle lettere è relativamente lontana dalla casa, ed era impossibile tirare un cavo elettrico fino ad essa per alimentare qualcosa.

Dovevo trovare un'altra soluzione: l'energia solare era una buona soluzione!

Il BOM

• Raspberry Pi (per ospitare parti MQTT e Domoticz - non descritte qui)
• Un account Bot di Telegram
• Lolin D1 mini (o Wemos…)
• Connettore per morsettiera a vite plug-in
• Scheda di ricarica della batteria al litio TP4056
• Pannello solare fotovoltaico 6V 2W
• Batteria agli ioni di litio 18650
• Portabatterie agli ioni di litio
• Circuito stampato prototipo in rame per saldatura fai-da-te PCB
• Servo analogico SG90
• 3 interruttori Reed (uno per le lettere, uno per il pacco e uno per il pagamento)
• Magneti
• Alcuni fili
• Cassa di legno: Non avendo nessuna stampante 3D, ho realizzato la mia casetta in legno per ricevere parti elettroniche…
• Cavo Ethernet di ricambio

• Scheda di sblocco del connettore Ethernet RJ45

• Saldatura J-B
• Alcuni cuscinetti a sfera
• Viti, dadi, rondelle

Passaggio 1: schema globale

I bei disegni sono sempre meglio dei lunghi discorsi;-)

Ma alcune spiegazioni su MQTT, Domoticz e Telegram sono sempre benvenute!

MQTT (Message Queuing Telemetry Transport), è un protocollo di messaggistica, utilizzato per inviare dati tra dispositivi e altri sistemi nel mondo dell'IoT (Internet delle cose).

Senza entrare troppo nei dettagli, il suo funzionamento si basa sul principio dei client che si connettono a un server. In MQTT, i client sono chiamati Subscriber o Publisher e il server è chiamato Broker.

In questo Instructable, utilizzo solo un editore, il Lolin collegato alla mia cassetta delle lettere: quando vengono rilevate lettere o pacchi tramite i contatti reed installati nella cassetta delle lettere (Fase 1 in shematic), invia un messaggio MQTT tramite WIFI al Broker (Fase 2).

La parte Broker è eseguita da Mosquitto, che è installato sul Raspberry Pi (passaggio 3).

Informazioni su Domoticz:

Come descritto nella pagina sorgente, Domoticz è un "sistema domotico", che consente di controllare vari dispositivi e ricevere input da vari protocolli: MQTT è uno dei protocolli supportati …

Non appena le informazioni lo raggiungono (Step 4), puoi definire gli eventi: Nel caso della cassetta delle lettere, ho scelto di inviare una notifica di Telegram (Step 5).

Infine, il client di Telegram è configurato sul mio telefono (e anche su quello di mia moglie! - Passaggio 6): l'obiettivo finale è raggiunto…

Fase 2: Schematica / Cablaggio

Una parola sull'analogico si legge:

Prima di tutto, ho notato dopo alcune ricerche che il Lolin mini D1 (come il vecchio Wemos), ha un partitore di tensione integrato per il pin A0 (considerando 220KΩ per R1 e 100KΩ per R2 - vedi a destra del datasheet collegato), consentendo 3,2 Volt come massima tensione di ingresso analogico.

Considerando che la tensione massima in uscita dalla batteria è 4, 2v (limitata dalla scheda di ricarica), e teoricamente, è sufficiente aggiungere un resistore esterno (in serie con R1) per aumentare il range di tensione massima in ingresso. Quindi, se aggiungi 100K in serie con R1, avrai questo risultato:

Vin * R1/(R1+R2) = Vout

4, 2 * 320 K/(320 K+100 K) = 3, 2

Nel mio circuito ho scelto di poterne regolare il valore, per questo ho preferito utilizzare un resistore regolabile nel mio circuito: forse per te sarà inutile, ma nella mia situazione ho impostato il suo valore a circa 10KΩ per avere un valore coerente in Domoticz…

Nota che il pin A0 ha una risoluzione di 10 bit: ciò significa che nel tuo schizzo, la tua lettura analogica restituirà un valore compreso tra 0 e 1024.

Poiché voglio inviare un valore percentuale a Domoticz, devo dividere il risultato della lettura analogica per 10, 24.

Passaggio 3: gestione dell'alimentazione

Ovviamente voglio che la cassetta delle lettere sia autonoma. Per raggiungere il mio obiettivo, utilizzo questi elementi:

• una batteria Li-Ion 18650 da 4000mAh;
• un pannello solare in grado di erogare 6V/2W;
• una scheda di ricarica della batteria al litio TP4056.

Per scegliere il pannello solare più adatto, ho dato un'occhiata ad alcuni esempi, tra cui questo: in questo esempio viene utilizzato un pannello solare da 5,5V / 0,66W, ed è probabilmente sufficiente allo scopo. Nel mio caso, e poiché l'ESP8266 deve rimanere acceso durante il giorno e deve essere in grado di far funzionare un servomotore per mantenere la casa rivolta verso il sole, ho scelto un modello di pannello solare più potente (6V / 2W) - Mi consente anche per anticipare periodi invernali bui e giornate nuvolose;-)

Inoltre, e per ridurre al massimo il dispendio energetico, ho selezionato i seguenti scenari:

• sapendo che il postino è passato solo tra le 7:00 e le 20:00, ESP viene messo in DeepSleep per il resto della notte;
• Il fattore non passa tra sabato mezzogiorno e lunedì mattina: anche l'ESP viene posto in modalità DeepSleep durante questo periodo.
• Per il periodo compreso tra le 7:00 e le 20:00, e per ridurre i consumi, disattivo semplicemente l'interfaccia di rete dell'ESP: la rete viene riavviata solo all'arrivo di un pacco o di una lettera, giusto il tempo di inviare le informazioni a Domoticz. Non ho bisogno di essere avvisato immediatamente ei pochi secondi aggiuntivi necessari per riavviare l'interfaccia di rete non sono dannosi!

Qualche valore sul consumo nelle diverse modalità che utilizzo per il Lolin - guarda il foglio dati, p18:

• In modalità normale (con RF funzionante), il consumo energetico può aumentare fino a 170 mA! Dato che la mia cassetta delle lettere è a circa 50 metri da casa mia (e al limite del segnale WIFI…) suppongo che la potenza utilizzata per mantenere la connessione sia al massimo…
• In modalità Modem-sleep, il consumo energetico scende a 15 mA. Ma come puoi vedere nella scheda tecnica, non ha fermato completamente il modem, poiché l'ESP sta "mantenendo una connessione Wi-Fi senza trasmissione di dati".
• In Deep-sleep, la potenza scende a 20uA.

Per essere certo che il wifi non rimanga attivo inutilmente, ho preferito disabilitarlo con i seguenti comandi. Nota le molte chiamate delay() … Senza di loro, l'ESP si blocca:

WiFi.disconnect();

ritardo(1000); WiFi.mode(WIFI_OFF); ritardo(1000); WiFi.forceSleepBegin(); ritardo(1);

Nel complesso, dopo diversi giorni di funzionamento, sembra funzionare e soprattutto caricare correttamente:

• questo mi permette di far girare il servomotore ogni ora per posizionare la casa verso il sole;
• Posso anche permettermi di riattivare l'interfaccia di rete ogni ora anche per inviare a Domoticz il livello di carica della batteria.

Passaggio 4: installazione di magneti e contatti reed

Come al solito, ho usato il mio Proxxon per modellare il posto della canna in un pezzo di legno.

Per fissare il contatto reed nel suo foro, ho usato un po' di saldatura J-B.

Per il pacco e l'uscita, un po' di nastro adesivo, un po' di seghetto, e l'obiettivo è raggiunto!

Il vantaggio della mia cassetta delle lettere è che è in metallo, il che facilita il posizionamento dei magneti in modo che interagisca correttamente con i contatti delle ance.

Passaggio 5: connettiti a My Little House

Per poter collegare e scollegare facilmente il cavo che va ai contatti reed dalla cassetta delle lettere a casa, ho scelto di utilizzare un connettore ethernet.

Puoi usare questo modello o, come me, usare un vecchio shield Arduino Ethernet che pende nei miei cassetti: non ha sofferto, è stato coraggioso davanti alla sega, la sua morte è stata rapida ^^

Solo una parola su questo shield Arduino Ethernet: non aspettarti di avere 8 driver separati… I cavi sono accoppiati da 2 all'interno dello shield… Mi ha fatto impazzire per troppo tempo!!!

Passaggio 6: in casa…

Spazio appena sufficiente per fissare il portabatteria, impostare il servo e il connettore femmina RJ45.

Passaggio 7: lascia che il giradischi…

L'obiettivo è quello di tenerlo rivolto verso il sole…

Per dare la possibilità di essere girevole, ho usato una vite lunga come asse, con alcuni dadi e due cuscinetti a sfera…

Fino ad ora, ho usato il servo SG90 (coppia: 1.8kg/cm a 4.8v).

Per girare la casa (e i suoi pochi grammi) basta. D'altra parte, non sono sicuro che i suoi ingranaggi in plastica resistano a lungo alle frequenti raffiche di vento che ci sono nella mia regione.

Ne ho ordinato un altro (coppia MG995: 9,4 kg/cm a 4,8 v), non molto costoso, ma con ingranaggi in metallo.

Sarà la prossima cosa da fare quando l'avrò ricevuto: mi affido alla mia cassetta delle lettere collegata per avvisarmi del suo arrivo!

Passaggio 8: alcuni test

Alcune note:

Questo schizzo è solo per emulare i cambi di ore durante il giorno per permettermi di controllare la posizione del servo.

• Con SG90: senza necessità extra, può funzionare con la tensione OUT proveniente dal controller della batteria.

• Ma, con MG 995:

  • L'angolo di rotazione totale non è lo stesso (più ampio): ho dovuto usare una funzione extra per ridurlo (Servo_Delta()).
  • Hai bisogno di un DC/DC Step up per fornire una tensione sufficiente al servo … per continuare …

/*

- TEST con SG90: nessun bisogno aggiuntivo, può funzionare con la tensione OUT proveniente dal controller della batteria - PER MG 995: - utilizzare la funzione Servo_Delta() … - Necessita di un DC/DC Step up per fornire una tensione sufficiente al servo … per continua: */ #include bool Logs = true; Servo mio servo; #define PIN_SERVO D2 // posizione servo per: 7h, 8h, 9h, 10h, 11h, 12h, 13h, 14h, 15h, 16h, 17h, 18h, 19h, 20h, 21h //int Arr_Servo_Pos = {177, 173, 163, 148, 133, 118, 100, 80, 61, 41, 28, 15, 2, 2, 2}; int Arr_Servo_Pos = {180, 175, 165, 150, 135, 120, 102, 82, 63, 43, 30, 15, 0, 0, 0}; int vecchio; posizione int; int io; void setup() { Serial.begin(115200); } ciclo vuoto() { for(i = 7; i <= 22; i++){ vecchio = i; if (i == 7){ if (Logs) Serial.println ("Positionne le servo pour 7 Heure"); mioservo.attach(PIN_SERVO); for(int index = Arr_Servo_Pos[(sizeof(Arr_Servo_Pos) / sizeof(Arr_Servo_Pos[0])) -1]; index 7 && i = Arr_Servo_Pos[i-7]; index--){ if (Logs) Serial.println (indice); if (Registri) Serial.print ("Valore corretto: "); if (Registri) Serial.println(Servo_Delta(index)); ritardo(200); //mioservo.write(Servo_Delta(index)); mioservo.write(indice); } ritardo(15); myservo.write(Arr_Servo_Pos[i-7]); // riscrive l'ultimo valore per evitare movimenti a scatti quando datach myservo.detach(); } } } ritardo (2000); } } int Servo_Delta(int valore){ int Temp_val; Temp_val = (valore*0.80)+9; ritorno Temp_val; }

Fase 9: La piccola casa

Come ho detto prima, non ho avuto alcuna stampante 3D. Quindi decido di usare la vecchia cassetta di verdure…

Forse non durerà a lungo, ma per allora avrei il tempo di prendere in considerazione un'altra soluzione (o un amico che possiede una stampante 3D): per proteggere il legno, ho aggiunto molta vernice ovunque…

Si vedono le "belle tende"… Ecco cosa succede quando chiedi a tua moglie di fare il lavoro ^^

Passaggio 10: lo schizzo

In corso… Ma sembra essere stabile

Sto ancora lavorando al codice: non essendo questa una versione definitiva, i vostri commenti/consigli sono ben accetti;-)

Alcune osservazioni:

• Sono molti i ritardi() nel codice: questo per evitare molti crash del Lolin, soprattutto durante l'arresto di una rete in partenza…
• Non ho trovato un modo facile e affidabile per ottenere l'azimut solare: ecco perché ho fissato il valore del servo in funzione di ciò che ho osservato … io hai un buon (e semplice) modo per ottenerlo, sono interessato! Forse una traccia da studiare qui, anche se preferisco un'API online mi da l'azimut direttamente in base alla data, all'ora, e alla posizione geografica…
• Informazioni sulla tecnica del sonno: poiché il Lolin è un processore Tensilica a 32 bit, il suo valore massimo per un numero intero senza segno a 32 bit è 4294967295 … quindi, fornisce circa 71 minuti al massimo per l'intervallo di sonno profondo. Ecco perché faccio dormire l'ESP molte volte per circa 60 minuti…

MODIFICA - 2018-10-08:

Ho scoperto che il servo ha molti movimenti a scatti, specialmente prima dell'allegato (), staccare () e ogni volta che il Lolin si sveglia da deepSleep ().

Studiando un po' di più i datasheet, mi sono reso conto di due cose:

• Sul datasheet Lolin, l'uscita D4 è già collegata al BUILTIN_LED …
• Sulla scheda tecnica ESP8266ex, apprendiamo che l'uscita D4 viene utilizzata come UART 1/U 1 TXD (trasmettitore ricevitore asincrono universale). Viene inoltre specificato che questa UART1 viene utilizzata per la stampa del log.

Leggendo queste informazioni, mi sono reso conto che l'uscita D4 non era una buona idea, soprattutto per gestire un servomotore!

Quindi, ora l'uscita utilizzata per controllare il servomotore è D2, il codice sotto è stato aggiornato di conseguenza.

//****************************************

Data creazione: 08/Data mise en prod: 08/Versione: 0.9.4 Versione IDE Arduino: 1.8.6 Velocità di caricamento: 921600 Tipo di carta dans l'IDE: "LOLIN(WEMOS) D1 R2 & mini" Carta fisica impiegato: LOLIN(WEMOS) D1 R2 & mini (https://www.amazon.fr/gp/product/B01ELFAF1S/ref=oh_aui_detailpage_o00_s00?ie=UTF8&psc=1) Pin Funzione ESP-8266 Utilizzo pin locale ------- --------------------------------------------------- ------------------------------------ TX TXD TXD RX RXD RXD A0 Ingresso analogico, ingresso max 3,3V A0 Tensione di alimentazione D0 IO GPIO16 Connecté à RST (pour le deep.sleep) D1 IO, SCL GPIO5 D2 IO, SDA GPIO4 Servomotore D3 IO, 10k Pull-up GPIO0 D4 IO, 10k pull-up, BUILTIN_LED GPIO2 D5 IO, SCK GPIO14 Reed relève D6 IO, MISO GPIO12 Reed lettre D7 IO, MOSI GPIO13 Reed colis D8 IO, 10k pull-down, SS GPIO15 G Ground GND 5V 5V – 3V3 3.3V 3.3V RST Reset RST Connecté à D0 (pour le deep.sleep) ****************************************/ #include bool Logs = true; // wifi const char* ssid = "LOL"; const char* password = "LOL"; IPAddress ip(192, 168, 000, 000); Indirizzo IP DNS(192, 168, 000, 000); IPAddress gateway(192, 168, 000, 000); Sottorete IPAddress(255, 255, 000, 000); client WiFi Client; // Servo #include #define PIN_SERVO D2 Servo myservo; // posizione servo per: 7h, 8h, 9h, 10h, 11h, 12h, 13h, 14h, 15h, 16h, 17h, 18h, 19h, 20h, 21h int Arr_Servo_Pos = {179, 175, 165, 150, 135, 120, 102, 82, 63, 43, 30, 15, 1, 1, 1}; // Reeds #define PIN_SWITCH_OUT D5 byte Old_Switch_State_OUT; byte Switch_State_OUT; #define PIN_SWITCH_IN_PARCEL D6 byte Old_Switch_State_IN_PARCEL; byte Switch_State_IN_PARCEL; #define PIN_SWITCH_IN_LETTER D7 byte Old_Switch_State_IN_LETTER; byte Switch_State_IN_LETTER; interruttore lungo senza segnoPressTime; const unsigned long DEBOUCE_TIME = 200; // Analog #define PIN_ANALOG A0 // MQTT #include const char* MQTT_Server_IP = "Il tuo indirizzo MQTT"; const int MQTT_Server_Port =; int IDX_Letter_Box =; int IDX_Parcel_Box =; int IDX_Letter_Box_Battery =; PubSubClient ClientMQTT(client); char MQTT_Message_Buff[70]; Stringa MQTT_Pub_String; // Tensione float vcc; // NTP #include time_t tnow; int Old_Time = 0; int Int_Heures = 0; int Int_Minuti = 0; int Int_Sleep_Duration = 63; void setup(){ Serial.begin(115200); rete (vero); pinMode(PIN_SWITCH_OUT, INPUT_PULLUP); Old_Switch_State_OUT = digitalRead (PIN_SWITCH_OUT); pinMode(PIN_SWITCH_IN_LETTER, INPUT_PULLUP); Old_Switch_State_IN_LETTER = digitalRead (PIN_SWITCH_IN_LETTER); pinMode(PIN_SWITCH_IN_PARCEL, INPUT_PULLUP); Old_Switch_State_IN_PARCEL = digitalRead (PIN_SWITCH_IN_PARCEL); SendBatteryLevel(); rete(falso); // NTP imposta tnow = time(nullptr); Int_Heures = String(ctime(&tnow)).substring(11, 13).toInt(); Int_Minuti = String(ctime(&tnow)).substring(14, 16).toInt(); // Deepsleep per la notte if(!((Int_Heures >= 7) && (Int_Heures <= 20))){ Serial.print("Sleep pour la nuit ("); Serial.print(Int_Sleep_Duration - Int_Minutes); Serial. println("minuti)"); sleep(Int_Sleep_Duration - Int_Minuti); } } void loop() { // NTP set tnow = time(nullptr); Int_Heures = String(ctime(&tnow)).substring(11, 13).toInt(); Int_Minuti = String(ctime(&tnow)).substring(14, 16).toInt(); //Serial.println(String(ctime(&tnow))); //Serial.println ("Heure: " + String(ctime(&tnow)).substring(11, 13)); //Serial.println (String(ctime(&tnow)).substring(11, 13).toInt()); // Gestione servo if (Old_Time != Int_Heures){ Old_Time = Int_Heures; if (Int_Heures == 7){ if (Logs) Serial.println ("Positionne le servo pour 7 Heure"); mioservo.attach(PIN_SERVO); for(int index = Arr_Servo_Pos[(sizeof(Arr_Servo_Pos) / sizeof(Arr_Servo_Pos[0])) -1]; index 7 && Int_Heures = Arr_Servo_Pos[Int_Heures-7]; index--){ if (Logs (Serial.println) indice); ritardo(200); mioservo.write(indice); } ritardo(15); myservo.write(Arr_Servo_Pos[Int_Heures-7]); // riscrive l'ultimo valore per evitare movimenti a scatti quando si stacca myservo.detach(); } rete(vero); SendBatteryLevel(); rete(falso); } } } // Deepsleep if sabato dopo le 13h if((String(ctime(&tnow)).substring(0, 3) == "Sat") && (Int_Heures >= 13)){ if (Logs) Serial.print("Sleep pour le samedi aprés midi ("); if (Logs) Serial.print(Int_Sleep_Duration - Int_Minutes); if (Logs) Serial.println(" minutes)"); sleep(Int_Sleep_Duration - Int_Minuti); } // Deepsleep if sunday if(String(ctime(&tnow)).substring(0, 3) == "Sun"){ if (Logs) Serial.print("Sleep pour le dimanche ("); if (Logs) Serial.print(Int_Sleep_Duration - Int_Minutes); if (Registri) Serial.println(" minuti)"); sleep(Int_Sleep_Duration - Int_Minuti); } // Gestione ance Switch_State_OUT = digitalRead (PIN_SWITCH_OUT); if (Switch_State_OUT != Old_Switch_State_OUT){ if (millis () - switchPressTime >= DEBOUCE_TIME){ switchPressTime = millis (); if (Switch_State_OUT == HIGH){ Serial.println ("courrier relevé !"); rete (vero); ritardo (5000); MQTT_Pubilsh(IDX_Letter_Box, 0, "0"); ritardo (5000); MQTT_Pubilsh(IDX_Parcel_Box, 0, "0"); ritardo (5000); rete(falso); } } Old_Switch_State_OUT = Switch_State_OUT; } Switch_State_IN_LETTER = digitalRead (PIN_SWITCH_IN_LETTER); if (Switch_State_IN_LETTER != Old_Switch_State_IN_LETTER){ if (millis () - switchPressTime >= DEBOUCE_TIME){ switchPressTime = millis (); if (Switch_State_IN_LETTER == HIGH){ Serial.println ("corriere arrivé!"); rete (vero); ritardo (5000); MQTT_Pubilsh(IDX_Letter_Box, 1, "Corriere"); ritardo (5000); rete(falso); } } Old_Switch_State_IN_LETTER = Switch_State_IN_LETTER; } Switch_State_IN_PARCEL = digitalRead (PIN_SWITCH_IN_PARCEL); if (Switch_State_IN_PARCEL != Old_Switch_State_IN_PARCEL){ if (millis () - switchPressTime >= DEBOUCE_TIME){ switchPressTime = millis (); if (Switch_State_IN_PARCEL == HIGH){ Serial.println ("colis arrivé !"); rete (vero); ritardo (5000); MQTT_Pubilsh(IDX_Parcel_Box, 1, "Coli"); ritardo (5000); rete(falso); } } Old_Switch_State_IN_PARCEL = Switch_State_IN_PARCEL; } } void SendBatteryLevel(){ delay(5000); vcc = analogRead(PIN_ANALOG)/10.24; if (Logs) Serial.println ("\tTension relevée: " + String(vcc, 0)); MQTT_Pubilsh(IDX_Letter_Box_Battery, 0, String(vcc, 0)); ritardo (5000); } void sleep(int Min_Duration){ ESP.deepSleep(Min_Duration * 60e6); } void network(bool UpDown){ if (UpDown){ Serial.print("Network start"); WiFi.forceSleepWake(); ritardo(1); // init WIFI WiFi.config(ip, dns, gateway, subnet); WiFi.begin(ssid, password); while (WiFi.status() != WL_CONNECTED) { ritardo(500); Serial.print("."); } ritardo(5000); Serial.println("."); Serial.print("\tConnesso - Indirizzo IP: "); Serial.println(WiFi.localIP()); // init MQTT ClientMQTT.setServer(MQTT_Server_IP, MQTT_Server_Port); // Init NTP Serial.print("\tTime Synch."); configTime(0, 0, "fr.pool.ntp.org"); setenv("TZ", "CET-1CEST, M3.5.0, M10.5.0/3", 0); while(time(nullptr) <= 1000000) { Serial.print("."); delay(100); } Serial.println("."); } else{ Serial.println("Interruzione rete."); WiFi.disconnect(); delay(1000); WiFi.mode(WIFI_OFF); delay(1000); WiFi.forceSleepBegin(); delay(1); } } void reconnect() { while (!ClientMQTT.connected()) { Serial.print(" \tTentativo di connessione MQTT…"); // Tentativo di connessione if (ClientMQTT.connect("ESP8266ClientBAL")) { Serial.println("connected"); } else { Serial.print("failed, rc="); Serial.print(ClientMQTT.state()); Serial.println("riprova tra 5 secondi"); // Attendi 5 secondi prima di riprovare delay(5000); } } } void MQTT_Pubilsh(int Int_IDX, int N_Value, String S_Value) { if (!ClientMQTT.connected()) reconnect(); vcc = analogRead(PIN_ANALOG)/10.24; Serial.println("\tSend info to MQTT …"); MQTT_Pub_String = "{ "idx\": " + String (Int_IDX) + ", \"Batteria\": " + String(vcc, 0) + ", \"nvalue\": " + N_Value + ", \"svalue \": \"" + S_Value + "\"}"; MQTT_Pub_String.toCharArray(MQTT_Message_Buff, MQTT_Pub_String.length()+1); ClientMQTT.publish("domoticz/in", MQTT_Message_Buff); ClientMQTT.disconnect(); }

Fase 11: Domotica

A Domotic:

Per uso generale:

• Crea due "fittizio (non fa nulla, usa per gli switch virtuali)":

  1. Il primo per le lettere…
  2. Il secondo per pacco…
• Per ciascuno di essi, personalizza le notifiche;
• Ovviamente, devi configurare il tuo token Tegegram.

Facoltativamente:

Puoi aggiungere un "sensore di utilità" per monitorare il livello di carica della batteria.

Suggerimenti: qui puoi trovare molte icone personalizzate gratuite…

Passaggio 12: Conclusione

Spero che questo Instructable ti aiuti:

• se creare la propria cassetta delle lettere connessa;
• o semplicemente per darti qualche idea per i tuoi progetti!

Se hai idee per miglioramenti, ti ascolto!

PS: scusa per il mio inglese, la traduzione di Google mi aiuta molto ma probabilmente non è perfetta;-)