Letterbox conectado com energia solar: 12 etapas (com fotos)

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:38

No meu segundo Ible, descreverei meus trabalhos sobre minha caixa de correio conectada.

Depois de ler este Instructable (+ muitos outros), e como minha caixa de correio não está perto da minha casa, eu queria me inspirar nos trabalhos da Open Green Energy para conectar minha caixa de correio ao meu servidor Domoticz.

Metas

• Seja avisado pelo Telegram quando as cartas chegarem;
• Seja avisado pelo Telegram quando um pacote estiver chegando;
• Verifique se as cartas / encomendas foram recolhidas.

Minha principal restrição

A caixa de correio fica relativamente longe da casa e era impossível puxar um cabo elétrico até ela para alimentar qualquer coisa.

Tive que encontrar outra solução: a energia solar era uma boa solução!

O BOM

• Raspberry Pi (para hospedar partes MQTT e Domoticz - não descrito aqui)
• Uma conta do Telegram Bot
• Lolin D1 mini (ou Wemos …)
• Conector de bloco de terminais de parafuso plug-in
• TP4056 Placa de carregamento de bateria de lítio
• Painel Solar Fotovoltaico 6V 2W
• Bateria Li-Ion 18650
• Suporte de bateria Li-Ion
• Placa de circuito impresso de protótipo de solda de cobre PCB faça você mesmo
• Servo Analógico SG90
• 3 Reed Switchs (um para cartas, um para pacotes e um para checkout)
• Ímanes
• Alguns fios
• Engradado de madeira: Como não recebi nenhuma impressora 3D, criei minha própria casinha de madeira para receber peças eletrônicas…
• Cabo Ethernet sobressalente

• Placa de fuga do conector Ethernet RJ45

• Solda J-B
• Alguns rolamentos de esferas
• Parafusos, porcas, arruelas

Etapa 1: Esquema Global

Desenhos bonitos são sempre melhores do que discursos longos;-)

Mas algumas explicações sobre MQTT, Domoticz e Telegram são sempre bem-vindas!

MQTT (Message Queuing Telemetry Transport), é um protocolo de mensagens, usado para enviar dados entre dispositivos e outros sistemas no mundo da IoT (Internet das coisas).

Sem entrar em muitos detalhes, seu funcionamento é baseado no princípio de clientes se conectarem a um servidor. No MQTT, os clientes são chamados de Assinante ou Publicador e o servidor é chamado de Broker.

Neste Instructable, eu uso apenas um editor, o Lolin conectado à minha caixa de correio: quando cartas ou pacotes são detectados por meio dos contatos de palheta instalados na caixa de correio (Etapa 1 no shematic), ele envia mensagem MQTT por WIFI para o Corretor (Etapa 2)

A parte Broker é feita pelo Mosquitto, que é instalado no Raspberry Pi (Passo 3).

Sobre Domoticz:

Conforme descrito na página de origem, Domoticz é um "sistema de automação residencial", permitindo que você controle vários dispositivos e receba entrada de vários protocolos: MQTT é um dos protocolos suportados …

Assim que a informação chegar a ele (Passo 4), você pode definir eventos: No caso da caixa de correio, optei por enviar uma notificação por Telegrama (Passo 5).

Finalmente, o cliente Telegram é configurado no meu telefone (e na minha esposa também! - Etapa 6): o objetivo final foi alcançado …

Etapa 2: Shematic / Wiring

Uma palavra sobre o analógico:

Em primeiro lugar, notei após algumas pesquisas que o Lolin mini D1 (como o antigo Wemos), construiu um divisor de tensão para o pino A0 (considerando 220KΩ para R1 e 100KΩ para R2 - veja à direita do datasheet do link), permitindo 3,2 Volts como tensão de entrada analógica máxima.

Considerando que a tensão máxima de saída da bateria é 4, 2v (limitada pela placa de carregamento) e, teoricamente, você só precisa adicionar um resistor externo (em série com R1) para aumentar a faixa de tensão máxima de entrada. Então, se você adicionar 100K em série com R1, você terá este resultado:

Vin * R1 / (R1 + R2) = Vout

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

No meu circuito, optei por poder ajustar seu valor, por isso preferi usar um resistor ajustável no meu circuito: talvez seja inútil para você, mas na minha situação, configurei seu valor para cerca de 10KΩ para ter um valor coerente em Domoticz …

Observe que o pino A0 tem resolução de 10 bits: isso significa que em seu esboço, sua leitura analógica retornará um valor entre 0 e 1024.

Como desejo enviar um valor percentual ao Domoticz, preciso dividir o resultado da leitura analógica por 10, 24.

Etapa 3: gerenciamento de energia

Claro, quero que a caixa de correio seja autônoma. Para alcançar meu objetivo, uso estes elementos:

• uma bateria Li-Ion 18650 de 4000mAh;
• um painel solar que pode fornecer 6V / 2W;
• uma placa de carregamento de bateria de lítio TP4056.

Para escolher o painel solar mais adequado, dei uma olhada em alguns exemplos, inclusive este: neste exemplo, um painel solar de 5,5 V / 0,66 W é usado e provavelmente é suficiente para o propósito. No meu caso, e como o ESP8266 deve ficar LIGADO durante o dia e deve ser capaz de rodar um servo motor para manter a casa voltada para o sol, escolhi um modelo de painel solar mais potente (6V / 2W) - Também me permite para antecipar períodos escuros de inverno e dias nublados;-)

Além disso, a fim de reduzir ao máximo o gasto de energia, selecionei os seguintes cenários:

• sabendo que o carteiro passa apenas entre 7h e 20h, ESP é colocado em DeepSleep o resto da noite;
• O fator não passa entre o meio-dia de sábado e a manhã de segunda-feira: o ESP também é colocado no modo DeepSleep durante este período.
• Para o período entre 7h e 20h, e de forma a reduzir o consumo de energia, simplesmente desabilito a interface de rede do ESP: a rede é reiniciada apenas na chegada de um pacote ou de uma carta, tempo suficiente para enviar a informação para Domoticz. I não preciso ser avisado imediatamente e os poucos segundos adicionais necessários para reiniciar a interface de rede não são prejudiciais!

Algum valor sobre o consumo em diferentes modos que eu uso para o Lolin - veja a folha de dados, p18:

• No modo normal (com RF funcionando), o consumo de energia pode aumentar para 170mA! Como minha caixa de correio está a cerca de 50 metros da minha casa (e no limite do sinal WIFI …), suponho que a energia usada para manter a conexão está no máximo …
• No modo repouso do modem, o consumo de energia cai para 15 mA. Mas como você pode ver na ficha técnica, ele não parou completamente o modem, já que o ESP está "mantendo uma conexão wi-fi sem transmissão de dados".
• No sono profundo, a potência cai para 20uA.

Para ter certeza de que o wi-fi não permanece ativo desnecessariamente, preferi desativá-lo com os seguintes comandos. Observe a chamada de muitos delay () … Sem eles, o ESP falha:

WiFi.disconnect ();

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

No geral, após vários dias de operação, parece funcionar e, principalmente, carregar corretamente:

• isso me permite ligar o servomotor a cada hora para posicionar a casa em direção ao sol;
• Também posso permitir-me reativar a interface de rede a cada hora para enviar ao Domoticz o nível de carga da bateria.

Etapa 4: Instalação de ímãs e contatos de palhetas

Como de costume, usei meu Proxxon para moldar o lugar do junco em um pedaço de madeira.

Para fixar o contato da palheta em seu orifício, usei um pouco de solda J-B.

Para o pacote e a saída, um pedacinho de fita, um pedacinho de serra e o objetivo é alcançado!

A vantagem da minha caixa de correio é que ela é metálica, o que facilita o posicionamento dos ímãs para que interaja bem com os contatos das palhetas.

Etapa 5: Conecte-se à My Little House

Para poder conectar e desconectar facilmente o cabo que vai dos contatos de palheta da caixa de correio para a casa, optei por usar um conector Ethernet.

Você pode usar este modelo ou, como eu, usar um escudo Arduino Ethernet antigo que fica pendurado nas minhas gavetas: Ele não sofreu, foi valente na frente da serra, sua morte foi rápida ^^

Só uma palavra sobre este escudo Arduino Ethernet: não espere ter 8 drivers separados … Os cabos são pareados por 2 dentro do escudo … Isso me deixou louco por muito tempo !!!

Etapa 6: em casa …

Lugar suficiente para fixar o porta-bateria, configurando o servo e o conector fêmea RJ45.

Etapa 7: Let It Turntable …

O objetivo é mantê-lo voltado para o sol …

Para deixar a capacidade de girar, usei um parafuso comprido como eixo, com algumas porcas e dois rolamentos de esferas …

Até agora, usei o servo SG90 (torque: 1,8kg / cm a 4,8v).

Para virar a casa (e seus poucos gramas) basta. Por outro lado, não tenho a certeza de que as suas engrenagens de plástico resistam por muito tempo às frequentes rajadas de vento que há na minha região.

Encomendei outro (torque MG995: 9,4kg / cm a 4,8v), também não muito caro, mas com engrenagens de metal.

Será a próxima coisa a fazer quando eu recebê-lo: conto com minha caixa de correio conectada para me notificar de sua chegada!

Etapa 8: alguns testes

Algumas notas:

Este esboço é apenas para emular mudanças de horas durante o dia para me permitir controlar a posição do servo.

• Com SG90: sem necessidade de extras, pode funcionar com a tensão OUT proveniente do controlador da bateria.

• Mas, com MG 995:

  • O ângulo total de rotação não é o mesmo (mais largo): tive que usar uma função extra para reduzi-lo (Servo_Delta ()).
  • Precisa de um DC / DC Step up para fornecer tensão suficiente para o servo … para continuar …

/*

- TESTE com SG90: sem necessidade extra, pode funcionar com a tensão OUT proveniente do controlador de bateria - PARA MG 995: - use a função Servo_Delta () … - Precisa de um DC / DC Step up para fornecer tensão suficiente para o servo … para continuar: * / #include bool Logs = true; Servo myservo; # define PIN_SERVO D2 // posição do servo para: 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 old; int pos; int i; void setup () {Serial.begin (115200); } void loop () {for (i = 7; i <= 22; i ++) {old = i; if (i == 7) {if (Logs) Serial.println ("Posicione o servo para 7 heure"); myservo.attach (PIN_SERVO); for (índice interno = Arr_Servo_Pos [(sizeof (Arr_Servo_Pos) / sizeof (Arr_Servo_Pos [0])) -1]; índice 7 && i = Arr_Servo_Pos [i-7]; índice -) {if (Logs) Serial.println (índice); if (Logs) Serial.print ("Valor ajustado:"); if (Logs) Serial.println (Servo_Delta (índice)); atraso (200); //myservo.write(Servo_Delta(index)); myservo.write (índice); } atraso (15); myservo.write (Arr_Servo_Pos [i-7]); // escreva novamente o último valor para evitar movimentos bruscos quando datach myservo.detach (); }}} atraso (2000); }} int Servo_Delta (valor int) {int Temp_val; Temp_val = (valor * 0,80) +9; return Temp_val; }

Etapa 9: A casinha

Como eu disse antes, não recebi nenhuma impressora 3D. Então eu decido usar uma velha caixa de vegetais …

Talvez não dure muito tempo, mas então, eu teria tempo para pensar em outra solução (ou um amigo que possui uma impressora 3D): para proteger a madeira, coloquei muito verniz em todos os lugares…

Você pode ver as "cortinas bonitas"… É o que acontece quando você pede para sua esposa fazer o serviço ^^

Etapa 10: o esboço

Em andamento… Mas parece estável

Ainda estou trabalhando no código: como esta não é uma versão definitiva, seus comentários / conselhos são bem-vindos;-)

Algumas observações:

• Existem muitos atrasos () no código: isto é para evitar muitos travamentos do Lolin, especialmente ao parar uma rede inicial …
• Não encontrei uma maneira fácil e confiável de obter o azimute do sol: por isso fixei o valor do servo em função do que observei … Se você tem uma maneira boa (e simples) de obtê-lo, estou interessado! Talvez uma trilha para estudar aqui, mesmo que eu prefira uma API online me dá o azimute diretamente de acordo com a data, a hora e a posição geográfica …
• Sobre a técnica de sono: como o Lolin é um Processador Tensilica de 32 bits, seu valor máximo para um inteiro sem sinal de 32 bits é 4294967295 … então, dá no máximo 71 minutos para o intervalo de sono profundo. É por isso que faço dormir l'ESP muitas vezes por cerca de 60 minutos …

EDITAR - 2018-08-10:

Descobri que o servo tem muitos movimentos bruscos, principalmente antes do prender (), se desprender () e cada vez que o Lolin acorda do sono profundo ().

Enquanto estudava um pouco mais de planilhas, percebi duas coisas:

• Na folha de dados Lolin, a saída D4 já está conectada ao BUILTIN_LED…
• Na folha de dados ESP8266ex, descobrimos que a saída D4 é usada como UART 1 / U 1 TXD (Universal Asynchronous Receiver Transmitter). Também é especificado que este UART1 é usado para imprimir o registro.

Ao ler essas informações, percebi que a saída D4 não era uma boa ideia, principalmente para gerenciar um servo motor!

Portanto, agora a saída usada para controlar o servomotor é D2, o código abaixo foi atualizado de acordo.

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

Data de criação: 08 / Data mise en prod: 08 / Versão: 0.9.4 Versão IDE Arduino: 1.8.6 Velocidade de upload: 921600 Type de carte dans l'IDE: "LOLIN (WEMOS) D1 R2 & mini" Carte physique Employée: LOLIN (WEMOS) D1 R2 & mini (https://www.amazon.fr/gp/product/B01ELFAF1S/ref=oh_aui_detailpage_o00_s00?ie=UTF8&psc=1) Pin Função ESP-8266 Pin Utilization locale ------- -------------------------------------------------- ------------------------------------ TX TXD TXD RX RXD RXD A0 Entrada analógica, entrada máx. 3,3 V A0 Tension d'alimentaion D0 IO GPIO16 Connecté à RST (pour le deep.sleep) D1 IO, SCL GPIO5 D2 IO, SDA GPIO4 Servo motor 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 (para o fundo.sleep) *****************************************/ #include bool Logs = true; // wifi const char * ssid = "LOL"; const char * senha = "LOL"; IPAddress ip (192, 168, 000, 000); Endereço IP dns (192, 168, 000, 000); Gateway de endereço IP (192, 168, 000, 000); Sub-rede IPAddress (255, 255, 000, 000); Cliente WiFiClient; // Servo #include #define PIN_SERVO D2 Servo myservo; // posição do servo para: 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}; // Palhetas #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; unsigned long switchPressTime; const sem sinal longo DEBOUCE_TIME = 200; // Analog #define PIN_ANALOG A0 // MQTT #include const char * MQTT_Server_IP = "Seu endereço MQTT"; const int MQTT_Server_Port =; int IDX_Letter_Box =; int IDX_Parcel_Box =; int IDX_Letter_Box_Battery =; PubSubClient ClientMQTT (cliente); char MQTT_Message_Buff [70]; String MQTT_Pub_String; // Tension float vcc; // NTP #include time_t tnow; int Old_Time = 0; int Int_Heures = 0; int Int_Minutes = 0; int_Sleep_Duration = 63; void setup () {Serial.begin (115200); rede (verdadeiro); 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 (); rede (falso); // NTP definido tnow = time (nullptr); Int_Heures = String (ctime (& tnow)). Substring (11, 13).toInt (); Int_Minutes = String (ctime (& tnow)). Substring (14, 16).toInt (); // Dormir profundamente durante a noite if (! ((Int_Heures> = 7) && (Int_Heures <= 20))) {Serial.print ("Sleep pour la nuit ("); Serial.print (Int_Sleep_Duration - Int_Minutes); Serial. println ("minutos)"); dormir (Int_Sleep_Duration - Int_Minutes); }} void loop () {// NTP definido tnow = time (nullptr); Int_Heures = String (ctime (& tnow)). Substring (11, 13).toInt (); Int_Minutes = 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 ()); // Gerenciamento de servo if (Old_Time! = Int_Heures) {Old_Time = Int_Heures; if (Int_Heures == 7) {if (Logs) Serial.println ("Positionne le servo pour 7 Heure"); myservo.attach (PIN_SERVO); for (índice interno = Arr_Servo_Pos [(sizeof (Arr_Servo_Pos) / sizeof (Arr_Servo_Pos [0])) -1]; índice 7 && Int_Heures = Arr_Servo_Pos [Int_Heures-7]; índice -) {if (Logs) Serial.println (índice); atraso (200); myservo.write (índice); } atraso (15); myservo.write (Arr_Servo_Pos [Int_Heures-7]); // escreve novamente o último valor para evitar movimentos bruscos ao separar myservo.detach (); } rede (verdadeiro); SendBatteryLevel (); rede (falso); }}} // Dormindo profundamente se sábado depois das 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)"); dormir (Int_Sleep_Duration - Int_Minutes); } // Deepsleep if domingo 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 (Logs) Serial.println ("minutos)"); dormir (Int_Sleep_Duration - Int_Minutes); } // Gerenciamento de palhetas 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é!"); rede (verdadeiro); atraso (5000); MQTT_Pubilsh (IDX_Letter_Box, 0, "0"); atraso (5000); MQTT_Pubilsh (IDX_Parcel_Box, 0, "0"); atraso (5000); rede (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 ("courrier arrivé!"); rede (verdadeiro); atraso (5000); MQTT_Pubilsh (IDX_Letter_Box, 1, "Courrier"); atraso (5000); rede (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é!"); rede (verdadeiro); atraso (5000); MQTT_Pubilsh (IDX_Parcel_Box, 1, "Colis"); atraso (5000); rede (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)); atraso (5000); } void sleep (int Min_Duration) {ESP.deepSleep (Min_Duration * 60e6); } void network (bool UpDown) {if (UpDown) {Serial.print ("Network start"); WiFi.forceSleepWake (); atraso (1); // init WIFI WiFi.config (ip, dns, gateway, sub-rede); WiFi.begin (ssid, senha); while (WiFi.status ()! = WL_CONNECTED) {delay (500); Serial.print ("."); } atraso (5000); Serial.println ("."); Serial.print ("\ tConnected - Endereço 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); enquanto (tempo (nullptr) <= 100000) {Serial.print ("."); Atraso (100);} Serial.println (".");} Else {Serial.println ("Parada de rede."); WiFi.disconnect (); atraso (1000); WiFi.mode (WIFI_OFF); atraso (1000); WiFi.forceSleepBegin (); atraso (1);}} void reconnect () {while (! ClientMQTT.connected ()) {Serial.print (" / tTentativa de conexão MQTT… "); // Tentativa de conexão if (ClientMQTT.connect (" ESP8266ClientBAL ")) {Serial.println (" conectado ");} else {Serial.print (" falhou, rc = "); Serial.print (ClientMQTT.state ()); Serial.println ("tente novamente em 5 segundos"); // Aguarde 5 segundos antes de tentar novamente o atraso (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 ("\ tEnviar informações para MQTT…"); MQTT_Pub_String = "{" idx / ":" + String (Int_IDX) + ", \" Bateria / ":" + String (vcc, 0) + ", \" nvalor / ":" + N_Valor + ", \" svalor / ": \" "+ S_Value +" / "}"; MQTT_Pub_String.toCharArray (MQTT_Message_Buff, MQTT_Pub_String.length () + 1); ClientMQTT.publish ("domoticz / in", MQTT_Message_Buff); ClientMQTT.disconnect (); }

Etapa 11: Domoticz

Em Domoticz:

Para uso geral:

• Crie dois "Fictícios (não faz nada, usa para interruptores virtuais)":

  1. O primeiro para cartas …
  2. O segundo para pacote …
• Para cada um deles, personalize as notificações;
• Claro, você precisa configurar seu token Tegegram.

Opcionalmente:

Você pode adicionar um "Sensor de utilitário" para supervisionar o nível de carga da bateria.

Dicas: aqui você pode encontrar muitos ícones personalizados gratuitos …

Etapa 12: Conclusão

Espero que este Instructable ajude você:

• se deseja fazer sua própria caixa de correio conectada;
• ou apenas para lhe dar algumas ideias para seus projetos!

Se você tiver ideias de melhorias, estou ouvindo!

PS: desculpe pelo meu inglês, a tradução do Google me ajuda muito, mas provavelmente não é perfeita;-)