Sonoff Pow (ESP8266-based) per monitoraggio consumi - EnergeticAmbiente.it

annuncio

Comprimi
Ancora nessun annuncio.

Sonoff Pow (ESP8266-based) per monitoraggio consumi

Comprimi
X
 
  • Filtro
  • Ora
  • Visualizza
Elimina tutto
nuovi messaggi

  • Sonoff Pow (ESP8266-based) per monitoraggio consumi

    La Itead se n'è uscita con un nuovo gioiellino per smanettoni , il Sonoff Pow, che integra:
    - programmabilità arduino
    - wifi
    - relè
    - misuratore consumi elettrici
    - 16A supportati (=tutto l'impianto di casa)

    Fornisce sia l'assorbimento istantaneo in watt che grafici.

    Schema elettrico:



    Adesso me lo studio un po' e vi faccio sapere... :-)
    Batterie, DoD e profondità di scarica: *** Scaricare le batterie solo fino a metà prima di ricaricarle. *** Al piombo da 60 km: usata 20 km per volta durerà 60.000 km, 60 km per volta ne durerà 12.000. *** Al litio da 60 km: usata 20 km per volta durerà 120.000 km, 60 km per volta durerà 60.000 km.
    -- Jumpjack --

  • #2
    Componenti presenti:
    IW700 - PWM controller
    25q80bvsig - Memoria flash 8 Mbit (1 MByte)
    HK3ff - relè
    Leggo che l'HLW8012 è responsabile delle misurazioni.

    Immagini HD dell'interno:
    Sopra
    Sotto

    Quella "R001" con tolleranza 1% collegata all'uscita del relè potrebbe essere lo shunt che misura la corrente, ma devo studiarmi lo schema elettrico...
    Ultima modifica di jumpjack; 05-11-2016, 16:00.
    Batterie, DoD e profondità di scarica: *** Scaricare le batterie solo fino a metà prima di ricaricarle. *** Al piombo da 60 km: usata 20 km per volta durerà 60.000 km, 60 km per volta ne durerà 12.000. *** Al litio da 60 km: usata 20 km per volta durerà 120.000 km, 60 km per volta durerà 60.000 km.
    -- Jumpjack --

    Commenta


    • #3
      Originariamente inviato da jumpjack Visualizza il messaggio
      Fornisce sia l'assorbimento istantaneo in watt che grafici.
      Che vorrebbe dire grafici ? che ha già capacità logger e memorizzazione dati ?
      AUTO BANNATO

      Commenta


      • #4
        Originariamente inviato da jumpjack Visualizza il messaggio
        Quella "R001" con tolleranza 1% collegata all'uscita del relè potrebbe essere lo shunt che misura la corrente, ma devo studiarmi lo schema elettrico...
        Certo che lo è. Il chip hlw8012 poi ricava i valore di corrente e di tensione essendo collegato anche al neutro tramite quella lunga serie di resistori 474 (470k) come in questo schema

        Commenta


        • #5
          va bene anche un nuovo thread così la ricerca è più veloce, aspettiamo buone nuove e visto che tu jumpjack se anche un'esperto di batterie litio che ne pensi di un sonoff con INA129 che quando rientri in garage ti dice la carica della macchina ( o moto) elettrica e eventualmente un altro spegne il carica batteria quando raggiunge un determinato voltaggio? ovviamente ci vorrebbe quello a 12V che mi sembra essere in produzione.

          E' fattibile?
          5.76 kW 24 IBC SOLAR Tilt 19°, Azimut+54° S-SO, Power-One 6 kW , 2 boiler 0-1200W in serie, controllo domotico , SDM220Modbus x monitoraggio consumi con MeterN, 7 split a PDC, http://pvoutput.org/list.jsp?userid=8660 Aderite al Team di monitoraggio denominato EnergeticAmbiente su Pvoutput.org , così sapremo ogni giorno quanta energia pulita hanno prodotto gli amici del forum. Questo il link del Team ​https://pvoutput.org/listteam.jsp?tid=1115

          Commenta


          • #6
            Thread sul Pow:
            Support for "Sonoff Pow" (from ITead) with Power Consumption Measurement? - Let's Control It

            Si parla addirittura di possibile contributo della Itead.cc per fornire un firmware alternativo, o quantomeno info su come leggere l'HLW8012.
            Batterie, DoD e profondità di scarica: *** Scaricare le batterie solo fino a metà prima di ricaricarle. *** Al piombo da 60 km: usata 20 km per volta durerà 60.000 km, 60 km per volta ne durerà 12.000. *** Al litio da 60 km: usata 20 km per volta durerà 120.000 km, 60 km per volta durerà 60.000 km.
            -- Jumpjack --

            Commenta


            • #7
              Funzionamento dell'HLW8012:
              Smart Life WiFi Smart Plugs - tgmaxx

              A quanto pare il Sonoff Pow non è l'unico misuratore di corrente basato su questo chip.

              Forum su hacking del Pow:
              Sonoff POW and Sonoff TH16 WiFi Relays Review – Part 1: The Hardware

              Schema funzionale dell'HLW8012:
              Clicca sull'immagine per ingrandirla. 

Nome:   HLW8012 Block Diagram.png 
Visite: 1 
Dimensione: 18.9 KB 
ID: 1958212


              Firmware sperimentale per Sonoff Pow (non testato):
              Home * arendst/Sonoff-MQTT-OTA-Arduino Wiki * GitHub
              Sonoff-MQTT-OTA-Arduino/user_config.h at master * arendst/Sonoff-MQTT-OTA-Arduino * GitHub


              Definizioni nel suddetto FW:
              #define HLW_SEL 5 // GPIO 05 = HLW8012 Sel input (Sonoff Pow)
              #define HLW_CF1 13 // GPIO 13 = HLW8012 CF1 voltage / current (Sonoff Pow)
              #define HLW_CF 14 // GPIO 14 = HLW8012 CF power (Sonoff Pow)
              Batterie, DoD e profondità di scarica: *** Scaricare le batterie solo fino a metà prima di ricaricarle. *** Al piombo da 60 km: usata 20 km per volta durerà 60.000 km, 60 km per volta ne durerà 12.000. *** Al litio da 60 km: usata 20 km per volta durerà 120.000 km, 60 km per volta durerà 60.000 km.
              -- Jumpjack --

              Commenta


              • #8
                Originariamente inviato da dolam Visualizza il messaggio
                va bene anche un nuovo thread così la ricerca è più veloce, aspettiamo buone nuove e visto che tu jumpjack se anche un'esperto di batterie litio che ne pensi di un sonoff con INA129 che quando rientri in garage ti dice la carica della macchina ( o moto) elettrica e eventualmente un altro spegne il carica batteria quando raggiunge un determinato voltaggio? ovviamente ci vorrebbe quello a 12V che mi sembra essere in produzione.

                E' fattibile?
                L'ho comprato proprio per questo. :-)
                Anzi, per l'esattezza per sapere lo stato del caricabatterie prima ancora di uscire di casa... ma bisogna vedere che portata ha il wifi.
                Però non ho capito cosa c'entra l'INA129 e perchè parli di UN ALTRO sonoff: il Pow ha tutto quello che serve per leggere la corrente assorbita, scriverla su un sito e accendere/spegnere il caricabatterie.
                Batterie, DoD e profondità di scarica: *** Scaricare le batterie solo fino a metà prima di ricaricarle. *** Al piombo da 60 km: usata 20 km per volta durerà 60.000 km, 60 km per volta ne durerà 12.000. *** Al litio da 60 km: usata 20 km per volta durerà 120.000 km, 60 km per volta durerà 60.000 km.
                -- Jumpjack --

                Commenta


                • #9
                  Parlo di INA 219
                  Spedizione gratuita deriva Dello Zero corrente CJMCU 219 INA219 interfaccia I2C Bi direzionale/modulo sensore di monitoraggio della potenza in Zero CJMCU-219 modulo e un'interfaccia I2C con una deriva, bi-direzionale corrente/power monitor circuito integrato da Circuiti integrati su AliExpress.com | Gruppo Alibaba
                  perchè il sonoff normale e modificato, con questo potrebbe leggere direttamente il voltaggio della batteria, se in garage arriva il segnale wi fi e a me arriva, quando rientro e collego il carica batteria ho da subito l'andamento della carica ( che potrei vedere su meterN) e arrivato alla carica completa domoticz potrebbe spegnere direttamente il sonoff Pow che nel contempo ha misurato tutta l'energia assorbita. E' fattibile?

                  Chiaramente occorrono due sonoff, quello "piccolo" modificato resta perennemente attaccato alla batteria dell'auto/moto che viene letta dall'INA219 e il sonoff Pow sulla presa della ricarica.



                  sul sito Itead dicono che non è disponibile e forse erano meglio i morsetti con la vite del sonoff quelle minuscole levette non so se sono proprio adatte.
                  Ultima modifica di dolam; 06-11-2016, 11:37. Motivo: inversione 219
                  5.76 kW 24 IBC SOLAR Tilt 19°, Azimut+54° S-SO, Power-One 6 kW , 2 boiler 0-1200W in serie, controllo domotico , SDM220Modbus x monitoraggio consumi con MeterN, 7 split a PDC, http://pvoutput.org/list.jsp?userid=8660 Aderite al Team di monitoraggio denominato EnergeticAmbiente su Pvoutput.org , così sapremo ogni giorno quanta energia pulita hanno prodotto gli amici del forum. Questo il link del Team ​https://pvoutput.org/listteam.jsp?tid=1115

                  Commenta


                  • #10
                    Per misurare una tensione dc dovrebbero bastare un paio di resistenze opportune come per arduino. Aggiungiamoci un fusibile per sicurezza.
                    L'ESP8266 ha un ingresso ADC con Vmax di 1V ESP8266 ADC - Analog Sensors - 5
                    Non ti serve un sonoff da attaccare alla batteria, basta una schedina esp8266 e un regolatore dc/dc per alimentarlo. Prendi la schedina giusta e avrà il pin ADC riportato su pcb.
                    Ultima modifica di Ospite; 05-11-2016, 19:08.

                    Commenta


                    • #11
                      Al momento non conosco molto I2C, non so quali pin usa e se sono liberi sul Pow. Magari è proprio così che è collegato l'HLW8012? Se è così, non c'è problema perchè l'I2C supporta dispositivi multipli, se non sbaglio, ognuno con un suo indirizzo.
                      Cmq invece di "invadere" la batteria basta vedere se il caricabatterie sta assorbendo pochi mA o qualche A, per capire se la batteria è carica o no.

                      Ma qualcuno ha capito se il Pow invia anche i dati in rete, o se si possono leggere solo dal cell? I grafici si possono esportare?
                      Batterie, DoD e profondità di scarica: *** Scaricare le batterie solo fino a metà prima di ricaricarle. *** Al piombo da 60 km: usata 20 km per volta durerà 60.000 km, 60 km per volta ne durerà 12.000. *** Al litio da 60 km: usata 20 km per volta durerà 120.000 km, 60 km per volta durerà 60.000 km.
                      -- Jumpjack --

                      Commenta


                      • #12
                        Originariamente inviato da Dumah Brazorf Visualizza il messaggio
                        Non ti serve un sonoff da attaccare alla batteria, basta una schedina esp8266 e un regolatore dc/dc per alimentarlo. Prendi la schedina giusta e avrà il pin ADC riportato su pcb.
                        Il sonoff è utile per dare un po' di intelligenza al caricabatterie, per esempio per farlo spegnere comunque dopo TOT ore anche se la batteria non è carica (cioè è guasta...), e ovviamente per consultare da remoto lo stato del CB.
                        Batterie, DoD e profondità di scarica: *** Scaricare le batterie solo fino a metà prima di ricaricarle. *** Al piombo da 60 km: usata 20 km per volta durerà 60.000 km, 60 km per volta ne durerà 12.000. *** Al litio da 60 km: usata 20 km per volta durerà 120.000 km, 60 km per volta durerà 60.000 km.
                        -- Jumpjack --

                        Commenta


                        • #13
                          Trovato tutorial su MQTT, di cui al momento non so assolutamente niente, se non che è alla base dei firmware alternativi per Sonoff...

                          MQTT Essentials Part 1: Introducing MQTT (solo chiacchiere...)
                          MQTT Essentials Part 2: Publish & Subscribe (definizioni)
                          MQTT Essentials: Client, Broker and Connection Establishment (meccanismo)
                          MQTT Essentials Part 4: MQTT Publish, Subscribe & Unsubscribe
                          MQTT Essentials Part 5: MQTT Topics & Best Practices

                          Quello che vorrei capire è come appoggiarmi a un MIO server invece che a qualunque altro... sennò a che serve cambiare firmware?!?


                          Struttura funzionale del protocollo MQTT:
                          Clicca sull'immagine per ingrandirla. 

Nome:   pub-sub-mqtt-1024x588.png 
Visite: 1 
Dimensione: 270.6 KB 
ID: 1958217

                          Cioè invece di usare il classico sistema client/server per comunicare, si usa un sistema a stella: il "server" qui è chiamato "broker", e a lui fanno capo sia i sensori ("publisher"), che i "client" ("subscribers"); in teoria i sensori inviano dati al server e i client li leggono, ma la cosa interessante qui è che un dispositivo può agire sia come "publisher", cioè inviare dati che verranno letti da altri, che come "subscriber", leggendo dal server/broker i dati pubblicati da altri.

                          I dati vengono pubblicati in forma di messaggi, organizzati per "topic" (argomento); i client/subscriber si "sottoscrivono" ("subscribe") ai topic che gli interessano; sì, è come se il broker fosse un forum e i vari client fossero utenti che sottoscrivono le varie discussioni. :-)
                          (In realtà le discussioni di un forum si chiamerebbero "thread", ognuno incentrato su un "topic" (argomento), ma vabbè, si sa che i due concetti sono spesso confusi tra loro...)


                          Meccanismo:
                          Un subscriber invia al broker il messaggio CONNECT, che purtroppo a quanto pare è un messaggio binario e molto complicato da implementare a mano:
                          Clicca sull'immagine per ingrandirla. 

Nome:   connect.png 
Visite: 1 
Dimensione: 19.7 KB 
ID: 1958218

                          Quindi toccherà trovare librerie/sorgenti già pronti da caricare sul proprio sito web (pensavo bastasse scriver qualche riga di PHP...)
                          Ultima modifica di jumpjack; 06-11-2016, 10:18.
                          Batterie, DoD e profondità di scarica: *** Scaricare le batterie solo fino a metà prima di ricaricarle. *** Al piombo da 60 km: usata 20 km per volta durerà 60.000 km, 60 km per volta ne durerà 12.000. *** Al litio da 60 km: usata 20 km per volta durerà 120.000 km, 60 km per volta durerà 60.000 km.
                          -- Jumpjack --

                          Commenta


                          • #14
                            ciao

                            questo è il risultato di un INA219 connesso su un sonoff e collegato ad una mini isola che alimenta il router, switch, ap e raspberry

                            Clicca sull'immagine per ingrandirla. 

Nome:   Cattura3.PNG 
Visite: 1 
Dimensione: 55.0 KB 
ID: 1958219Clicca sull'immagine per ingrandirla. 

Nome:   Cattura2.PNG 
Visite: 1 
Dimensione: 66.9 KB 
ID: 1958220Clicca sull'immagine per ingrandirla. 

Nome:   Cattura.PNG 
Visite: 1 
Dimensione: 48.1 KB 
ID: 1958221

                            il sonoff accende l'alimentatore/caricatore dalle 8:30 alle 18:30 (funzione timer di domoticz) ed in caso di abbassamento oltre 12,2 v accende automaticamente l'alimentatore

                            se, come si dice nel forum di espeasy, itead collaborerà per lo sviluppo di un plugin per espeasy sicuramente sarà possibile leggere in rete i valori tramite domoticz.

                            ciao
                            località Frosinone; inclinazione 30^; direzione sud;
                            13 pannelli schott solar da 230w; inverter Power-One PVI-OutD 3.0
                            Solar logger RASPBERRY-PI3
                            23Solar feed PVout - MeterN - DOMOTICZ

                            Commenta


                            • #15
                              Ah, intanto ho rielaborato lo schema elettrico tirandone fuori uno più umanamente comprensibile...
                              Clicca sull'immagine per ingrandirla. 

Nome:   SonoffPow-ann.png 
Visite: 1 
Dimensione: 149.5 KB 
ID: 1958222
                              Batterie, DoD e profondità di scarica: *** Scaricare le batterie solo fino a metà prima di ricaricarle. *** Al piombo da 60 km: usata 20 km per volta durerà 60.000 km, 60 km per volta ne durerà 12.000. *** Al litio da 60 km: usata 20 km per volta durerà 120.000 km, 60 km per volta durerà 60.000 km.
                              -- Jumpjack --

                              Commenta


                              • #16
                                Per avere un mqtt server usa mosquitto che puoi installare tranquillamente accanto a domoticz (o Openhab) sul Raspberry Pi. È buono perché puoi anche organizzare uno storage dati con la funzione persistence e inoltre è più leggero di http.

                                Inoltre non sei vincolato al gestore domotico (domoticz o openhab) e puoi crearti anche app personalizzate.

                                Per es: mqtt è utilizzato da Facebook per i messaggi testuali perché è leggero e supporta anche la crittografia.

                                Inviato dal mio GT-I9300 utilizzando Tapatalk
                                Nuovo sito che incoraggia la produzione e la vendita del biodiesel in italia
                                Eccolo qua!
                                Perche biodiesel?
                                La titolazione

                                Commenta


                                • #17
                                  No, la Raspberry non c'entra niente: io vorrei che il mio ESP scrivesse dati su un MIO server da dove posso leggerli anche quando sono fuori casa!
                                  Per essere più preciso, vorrei installare un broker MQTT su Altervista.
                                  Non so se basta copiare un file PHP sul server, o se devo anche abilitare mySQL, o altre cose, boh, devo studiare ancora un po'...
                                  Batterie, DoD e profondità di scarica: *** Scaricare le batterie solo fino a metà prima di ricaricarle. *** Al piombo da 60 km: usata 20 km per volta durerà 60.000 km, 60 km per volta ne durerà 12.000. *** Al litio da 60 km: usata 20 km per volta durerà 120.000 km, 60 km per volta durerà 60.000 km.
                                  -- Jumpjack --

                                  Commenta


                                  • #18
                                    Fai troppe cose complicate. Basta mettere il server mqtt su raspberry pi e lo apri all'esterno.

                                    Inviato dal mio GT-I9300 utilizzando Tapatalk
                                    Nuovo sito che incoraggia la produzione e la vendita del biodiesel in italia
                                    Eccolo qua!
                                    Perche biodiesel?
                                    La titolazione

                                    Commenta


                                    • #19
                                      io faccio le cose complicate? Dovrei aggiungere un microcontrollore esterno con wifi a... un microcontrollore con wifi?!? Cioè spendere 40 euro quando posso spenderne 8???
                                      Batterie, DoD e profondità di scarica: *** Scaricare le batterie solo fino a metà prima di ricaricarle. *** Al piombo da 60 km: usata 20 km per volta durerà 60.000 km, 60 km per volta ne durerà 12.000. *** Al litio da 60 km: usata 20 km per volta durerà 120.000 km, 60 km per volta durerà 60.000 km.
                                      -- Jumpjack --

                                      Commenta


                                      • #20
                                        Se ti interessa c'è anche l' Orange Pi al posto del Rasp , che costa sui 12€
                                        AUTO BANNATO

                                        Commenta


                                        • #21
                                          Se hai un raspberry pi che usi con 123solar puoi benissimo mettere mosquitto. Puoi usare anche un raspi zero se non lo hai. Tanto non occupa tanta memoria.

                                          Certo che se si potrebbe fare, installando mosquitto su un server gratuito di altervista, avrei un server mqtt esterno alla mia rete più sicuro ma starei attento alla latenza. Perciò per la domotica preferisco avere il server interno in lan con la gigabit (anche se il raspberry è da 100 MB).

                                          Inviato dal mio GT-I9300 utilizzando Tapatalk
                                          Nuovo sito che incoraggia la produzione e la vendita del biodiesel in italia
                                          Eccolo qua!
                                          Perche biodiesel?
                                          La titolazione

                                          Commenta


                                          • #22
                                            Scusate , ma ESP non potrebbe mandare direttamente al server Emoncms on line ,per esempio ?
                                            AUTO BANNATO

                                            Commenta


                                            • #23
                                              Si lo puoi fare ma c'è chi non usa emoncms e si collega direttamente a domoticz o openhab o vuole avere una cosa personalizzata.

                                              Inviato dal mio GT-I9300 utilizzando Tapatalk
                                              Nuovo sito che incoraggia la produzione e la vendita del biodiesel in italia
                                              Eccolo qua!
                                              Perche biodiesel?
                                              La titolazione

                                              Commenta


                                              • #24
                                                Mi sa che forse non avete colto del tutto la potenzialità del Sonoff e dell'ESP8266...
                                                Ieri sono riuscito a scrivere per il generico ESP8266 uno sketch Arduino che, collegandosi a un mio script PHP carciato su altervista, "deduce" il proprio IP esterno, che lo script PHP poi scrive anche su un file su altervista.
                                                Questo vuol dire che posso scrivere una pagina su altervista (quindi con IP fisso e persino un nome di dominio) da cui comandare e/o leggere l'ESP.... e quindi ovviamente anche un Sonoff opportunamente riprogrammato.
                                                Senza bisogno di nessun'altro aggeggio esterno; l'ESP (e il Sonoff) è completamente autonomo!

                                                Basta infatti impostare sul mio router un "ponte" (*) tra l'IP locale dell'ESP/Sonoff, per cui collegandomi al mio router tramite ip esterno xxx.yyy.zzz.kkk:8266/accendi otterrò che
                                                la stringa "accendi" venga inviata al mio IP locale 192.168.1.128 alla porta 80, dove è in ascolto l'ESP/Sonoff.
                                                Ora, se l'IP xxx.yyy.zzz.kkk viene memorizzato costantemente su un file su www.mysonoff.altervista.org dall'ESP stesso, significa che posso creare una pagina www.mysonoff.altervista.org/comandaSonoff.html
                                                che comanda e legge il mio sonoff.

                                                (*) Tecnicamente si chiama "port redirection"; internamente l'ESP è in ascolto all'indirizzo 192.168.1.128:80 ma esternamente il mondo vede solo il mio router all'indirizzo xxx.yyy.zzz.kkk:hhhhh , dove hhhhh può essere
                                                un numero qualunque tra 0 e 65535.
                                                Batterie, DoD e profondità di scarica: *** Scaricare le batterie solo fino a metà prima di ricaricarle. *** Al piombo da 60 km: usata 20 km per volta durerà 60.000 km, 60 km per volta ne durerà 12.000. *** Al litio da 60 km: usata 20 km per volta durerà 120.000 km, 60 km per volta durerà 60.000 km.
                                                -- Jumpjack --

                                                Commenta


                                                • #25
                                                  Ehm si e nel passaggio tra il premere il pulsante e accendere la luce passano 3 secondi.

                                                  Inviato dal mio GT-I9300 utilizzando Tapatalk
                                                  Nuovo sito che incoraggia la produzione e la vendita del biodiesel in italia
                                                  Eccolo qua!
                                                  Perche biodiesel?
                                                  La titolazione

                                                  Commenta


                                                  • #26
                                                    La cosa più importante nella domotica da tenere sempre ben presente è L'AFFIDABILITÀ e la VELOCITÀ di risposta.

                                                    Sono anch'io un sostenitore dei sistemi in locale e via cavo
                                                    .... anche se l'esp mi intriga parecchio ..... ma sempre e solo con una gestione in locale.


                                                    Il Sonoff POW è comunque un oggettino davvero interessante e che apre a delle notevoli possibilità, integrando in un solo apparecchio la lettura dei consumi e la possibilità di comando.

                                                    Sono in attesa che mi arrivi a giorni .....
                                                    Monitoraggio energetico con Raspberry – 123Solar e MeterN
                                                    Monitoraggio energetico con Raspberry – Guida all’installazione e configurazione - IMPULSI
                                                    Monitoraggio energetico con Raspberry e contatori EASTRON SDM120modbus e/o SDM220modbus

                                                    Commenta


                                                    • #27
                                                      Concordo con flane : il controllo e gestione (se esistono dei comandi importanti) vanno fatti in locale ,nemmeno nel Rasp ma proprio dentro ESP (una volta c'era arduino sulla cui affidabilità non ci piove io lo uso da un decennio come gestore pannello solare e caldaia in campagna ma in locale) ; poi i dati di logger possono essere mandati in qualunque posto ; impensabile (se era questa l'intenzione) di mandare un comando a un sito remoto e da qui riaccendermi qualcosa ... ok invece modificare i parametri con cui funziona il programma in locale.....
                                                      AUTO BANNATO

                                                      Commenta


                                                      • #28
                                                        Originariamente inviato da tony995 Visualizza il messaggio
                                                        Ehm si e nel passaggio tra il premere il pulsante e accendere la luce passano 3 secondi.
                                                        E allora? Parlo di controllo quando sono FUORI casa.
                                                        Quando sono dentro casa, mi collego al sonoff direttamente col cell , no?
                                                        Batterie, DoD e profondità di scarica: *** Scaricare le batterie solo fino a metà prima di ricaricarle. *** Al piombo da 60 km: usata 20 km per volta durerà 60.000 km, 60 km per volta ne durerà 12.000. *** Al litio da 60 km: usata 20 km per volta durerà 120.000 km, 60 km per volta durerà 60.000 km.
                                                        -- Jumpjack --

                                                        Commenta


                                                        • #29
                                                          No non è proprio così.
                                                          Con il firmware moddato che andrai a mettere perderai la possibilità di usare l'app e cmq l'app si basa su AWS (Amazon Web Services) per il cloud, praticamente la stessa cosa che vuoi fare te.

                                                          Se vuoi creare qualcosa di più evoluto e open la mia configurazione è la seguente:
                                                          - Raspberry Pi 2 con 123solar e mosquitto (broker mqtt).
                                                          - Raspberry Pi 3 con Openhab.
                                                          - Sonoff classici.
                                                          - Altri sensori.
                                                          - Controller da muro per scenari.
                                                          - Modem configurato per ottenere connessioni dall'esterno tramite una porta opportunamente aperta.

                                                          Io con questo ci faccio la domotica di tutta casa mia e gestisco l'autoconsumo del mio impianto fv e gestisco riscaldamento e acs.

                                                          Se sono in casa con lo smartphone ho la massima velocità sia in wifi che in lan dal raspberry server (il 3). Poi posso accedere dall'esterno sia con mqtt e un app appositamente fatta o tramite openhab oppure anche in cloud con la gestione cloud di openhab (non la uso ma è una sincronizzazione server casa-server cloud di openhab mentre con il modem aperto mi connetto direttamente al server di casa).

                                                          Inviato dal mio GT-I9300 utilizzando Tapatalk
                                                          Nuovo sito che incoraggia la produzione e la vendita del biodiesel in italia
                                                          Eccolo qua!
                                                          Perche biodiesel?
                                                          La titolazione

                                                          Commenta


                                                          • #30
                                                            Originariamente inviato da tony995 Visualizza il messaggio
                                                            No non è proprio così.
                                                            Con il firmware moddato che andrai a mettere perderai la possibilità di usare l'app
                                                            Ah, ma io non parlo di usare un firmware esistente, ma di scrivermene uno tutto mio... :-) Certo per il Pow non sarà facile, con la faccenda di leggere il chip che legge i consumi... ma quella parte di codice posso sempre scopiazzarla! :-)
                                                            L'obiettivo sarebbe di usare sempre e solo server mio e risorse mie, senza condividere i fatti miei con chicchessia! :-)


                                                            Al momento sono arrivato a questo:

                                                            Sketch di esempio che attende la pressione di un tasto su pagina web per avviare/fermare lampeggio LED.
                                                            Pagina PHP che legge e memorizza l'IP dell'ESP8266.
                                                            Pagina PHP che crea dinamicamente la pagina coi pulsanti di controllo.

                                                            codice:
                                                            /* ESP8266 Webserver
                                                               Based on ESP8266Webserver, DHTexample, and BlinkWithoutDelay (thank you)
                                                            */
                                                            #include <ESP8266WiFi.h>
                                                            #include <WiFiClient.h>
                                                            #include <ESP8266WebServer.h>
                                                            
                                                            const char* ssid     = "wireless";
                                                            const char* password = "testami1";
                                                            const char* host = "programmi.net23.net";
                                                            const int httpPort = 80; // POrta dell IP interno, da impostare sul router
                                                            // La porta dell'IP esterno è invece impostata nella pagina web di controllo dell'ESP.
                                                            
                                                            // Millisecondi di delay per l'aggiornamento dell'IP; usare pochi secondi
                                                            // per il debug, ma qualche minuto nel caso reale.
                                                            int IP_REFRESH_DELAY = 1000; 
                                                            
                                                            // Use WiFiClient class to create TCP connections
                                                            WiFiClient client;
                                                              
                                                            int LED_STATUS= LOW;
                                                            int LED=0;
                                                            boolean BLINK_LED = false;
                                                             
                                                            ESP8266WebServer server(80);
                                                            
                                                            String webString="";     // String to display
                                                            // Generally, you should use "unsigned long" for variables that hold time
                                                            unsigned long previousMillis = 0;        // will store last temp was read
                                                            
                                                            void handle_root() {
                                                              server.send(200, "text/plain", "Huzza ESP8266 web server by Jumpjack - test");
                                                              delay(100);
                                                            }
                                                            
                                                            void setup(void)
                                                            {
                                                              pinMode(0,OUTPUT);
                                                              // You can open the Arduino IDE Serial Monitor window to see what the code is doing
                                                              Serial.begin(115200);  // Serial connection from ESP-01 via 3.3v console cable
                                                            
                                                            // config static IP
                                                              IPAddress ip(192, 168, 1, 229); 
                                                              IPAddress gateway(192, 168, 1, 1); // set gateway to match your network
                                                              Serial.print(F("Setting static ip to : "));
                                                              Serial.println(ip);
                                                              IPAddress subnet(255, 255, 255, 0); // set subnet mask to match your network
                                                              WiFi.config(ip, gateway, subnet);
                                                            
                                                             
                                                              // Connect to WiFi network
                                                              WiFi.begin(ssid, password);
                                                              Serial.print("\n\r \n\rWorking to connect");
                                                             
                                                              // Wait for connection
                                                              while (WiFi.status() != WL_CONNECTED) {
                                                                delay(500);
                                                                Serial.print(".");
                                                              }
                                                              Serial.println("");
                                                              Serial.println("Initialising server at address ");
                                                              Serial.println(WiFi.localIP());
                                                              Serial.print(" on network '");
                                                              Serial.println(ssid);
                                                              Serial.print("'");
                                                            
                                                              /////// Webserver commands handler ///////////
                                                              server.on("/", handle_root);
                                                            
                                                              server.on("/test", [](){  // if you add this subdirectory to your webserver call, you get text below :)
                                                                webString="Funziona! :-)";  
                                                                server.send(200, "text/plain", webString);            // send to someones browser when asked
                                                              });
                                                             
                                                              server.on("/blinkon", [](){  // if you add this subdirectory to your webserver call, you get text below :)
                                                                BLINK_LED = true;
                                                                webString="Avviato lampeggio LED...";
                                                                server.send(200, "text/plain", webString);               // send to someones browser when asked
                                                              });
                                                            
                                                              server.on("/blinkoff", [](){  // if you add this subdirectory to your webserver call, you get text below :)
                                                                BLINK_LED = false;
                                                                webString="Lampeggio LED arrestato";
                                                                server.send(200, "text/plain", webString);               // send to someones browser when asked
                                                              });
                                                            
                                                              server.begin();
                                                              Serial.println("HTTP server started");
                                                            
                                                              //////////////////////////////////////
                                                            }
                                                            
                                                            void loop(void)
                                                            {
                                                              server.handleClient();
                                                            
                                                              ///// Il codice che segue ha solo scopo dimostrativo: fa lampeggiare
                                                              ///// il led sulla board, ma nel farlo rallenta l'esecuzione di ben un 
                                                              ///// secondo per ogni lampeggio. In un codice "reale" eventuali operazioni
                                                              ///// cicliche andrebbero eseguite in modo asincrono (tramite Timer?).
                                                              
                                                              if (BLINK_LED) {
                                                                if (LED_STATUS == HIGH) {
                                                                  LED_STATUS = LOW;
                                                                  delay(500);
                                                                } else {
                                                                  LED_STATUS = HIGH;
                                                                  delay(500);      
                                                                }
                                                              } else {
                                                                  LED_STATUS = LOW;    
                                                              }
                                                              digitalWrite(LED,LED_STATUS);
                                                            
                                                              refreshIP();
                                                              delay(IP_REFRESH_DELAY);
                                                            }
                                                            
                                                            
                                                            void refreshIP() {
                                                              String result = "";
                                                              Serial.println("Refreshing IP: ");
                                                            
                                                              Serial.println("Reconnecting to PHP page...");
                                                              if (!client.connect(host, httpPort)) {
                                                                Serial.println("connection failed");
                                                                return;
                                                              }
                                                              Serial.print("Ok, connected to '");
                                                              Serial.print(host);
                                                              Serial.println("'.");
                                                              
                                                              // We now create a URI for the request
                                                              String url = "/ip.html";
                                                              Serial.print("Requesting URL: ");
                                                              Serial.println(url);
                                                              
                                                              // This will send the request to the server
                                                              client.print(String("GET ") + url + " HTTP/1.1\r\n" +
                                                                           "Host: " + host + "\r\n" + 
                                                                           "Connection: open\r\n\r\n");
                                                              delay(500);
                                                              
                                                              // Read all the lines of the reply from server and print them to Serial
                                                              while(client.available()){
                                                                String line = client.readStringUntil('\r');
                                                                result = result + line;
                                                              }
                                                              
                                                              Serial.println(result);
                                                              Serial.println("closing connection");
                                                            }



                                                            codice:
                                                            (html)
                                                            (body)
                                                            STARTphp
                                                            $filename= "ipmemo.html";
                                                            $somecontent = $_SERVER["REMOTE_ADDR"]; // Legge IP esterno dell'ESP8266.
                                                            
                                                            // Verifica che il file esista e sia riscrivibile
                                                            if (is_writable($filename)) {
                                                                if (!$handle = fopen($filename, 'w')) {
                                                                     echo "Non si riesce ad aprire il file ($filename)";
                                                                     exit;
                                                                }
                                                            
                                                                // Scrive IP dell'ESP8266 nel file aperto.
                                                                if (fwrite($handle, $somecontent) === FALSE) {
                                                                    echo "Non si riesce a scrivere nel file ($filename)";
                                                                    exit;
                                                                }
                                                            
                                                                echo "Riuscito, scritto ($somecontent) nel file ($filename)";
                                                                fclose($handle);
                                                            } else {
                                                                echo "Il file $filename non &grave; accessibile";
                                                            }
                                                            
                                                            ENDPHP
                                                            (/body)
                                                            (/html)

                                                            codice:
                                                            (html)
                                                            (head)
                                                            
                                                            STARTPHP
                                                            /////// Legge IP dal file:
                                                            $filename = "ipmemo.html";
                                                            if (!$handle = fopen($filename, 'r')) {
                                                                 echo "Non si riesce ad aprire il file ($filename)";
                                                                 exit;
                                                            }
                                                            $ESP8266_IP = fgets($handle);
                                                            fclose($handle);
                                                            /////////
                                                            
                                                            
                                                            $ESP8266_PORT = "8266"; // Porta usata per IP esterno, da impostare sul router nel port redirect
                                                            
                                                            
                                                            /// Crea pagina di controllo:
                                                            
                                                            // Script javascript:
                                                            $myScript = "";
                                                            $myScript = $myScript . "<script>";
                                                            $myScript = $myScript . "function accendi() {\n";
                                                            $myScript = $myScript . '   window.open("HTTP://' . $ESP8266_IP . ":" . $ESP8266_PORT . '/blinkon","COMMAND_WINDOW");';
                                                            $myScript = $myScript . "\n";
                                                            $myScript = $myScript . "}\n";
                                                            $myScript = $myScript . "\n";
                                                            
                                                            $myScript = $myScript . "function spegni() {\n";
                                                            $myScript = $myScript . '   window.open("HTTP://' . $ESP8266_IP . ":" . $ESP8266_PORT . '/blinkoff","COMMAND_WINDOW");';
                                                            $myScript = $myScript . "\n";
                                                            $myScript = $myScript . "}\n";
                                                            $myScript = $myScript . "</script>\n";
                                                            
                                                            
                                                            echo $myScript;
                                                            echo "</head><body>\n";
                                                            echo "Ip dell'ESP8266: '" . $ESP8266_IP . "'<br>\n\n";
                                                            echo '(input type="submit" value="ON" id="accendi" name="accendi" onclick="accendi();")(br)';
                                                            echo '(input type="submit" value="OFF" id="spegni" name="spegni" onclick="spegni();")(br)';
                                                            
                                                            
                                                            echo '(/body)(/html)';
                                                            
                                                            ENDPHP
                                                            Ultima modifica di jumpjack; 07-11-2016, 20:31.
                                                            Batterie, DoD e profondità di scarica: *** Scaricare le batterie solo fino a metà prima di ricaricarle. *** Al piombo da 60 km: usata 20 km per volta durerà 60.000 km, 60 km per volta ne durerà 12.000. *** Al litio da 60 km: usata 20 km per volta durerà 120.000 km, 60 km per volta durerà 60.000 km.
                                                            -- Jumpjack --

                                                            Commenta

                                                            Attendi un attimo...
                                                            X