Author: Security Brother

ESP32DeltaTemp

ESP32DeltaTemp

EPS32DeltaTemp is en zelfbouwproject gebaseerd op de ESP32 van Espressif Systeem. Dit kleine IoT apparaat is goedkoop en is relatief eenvoudig te programmeren. EP32DeltaTemp is gebouwd om in en uitgaande temperatuur te meten van vloerverwarming maar kan in principe voor elke toepassing worden gebruikt waar je de temperatuur wil meten. De centrale verwarming, de kamertemperatuur, enz.

Eigenschappen

Meet de temperatuur via twee digitale sensoren en geeft deze weer op het display van de ESP32, je kunt ook een ESP32 gebruiken zonder display.  Het display kan via een aanraaktoets  worden gewisseld tussen:

  1. De ingaande en uitgaande temperatuur met een grafiek die een indicatie geeft van het verschil tussen de twee temperaturen of de wifiverbinding actief is en wanneer de temperatuur wordt uitgelezen. De temperatuur wordt met een interval van 1 seconden gemeten.
  2. Het verschilscherm geef het verschil weer tussen de twee temperaturen en wanneer de meting plaats vindt.
  3. Info scherm: geeft de softwareversie weer, de gebruikt Service Set Identifier SSID (de naam van Wifi-netwerk) en het IP-adres dat de Eps32DeltTemp gebruikt.
  4. Tot slot: het scherm kan ook op zwart worden gezet.

De informatie wordt optioneel verzonden via wifi UDP-berichten die door elke ander applicatie/programma gelezen kan worden op het lokale netwerk. Het Wifi IP-adres wordt via DHCP opgehaald iets wat de meeste thuis routers standaard doen.

Benodigde hardware

De lijst die ik hier geef werkt en ik heb geen relatie met de genoemde leveranciers.
• 1 x Heltec EPS32 met oled display (10,55): link
• 2 x DS18B20 digitale temperatuur sensor (~€ 1,00): link
• 1 x Weerstand van 4K7: (€ 1,98) link
• Behuizing (optioneel) (€ 1,86): link
• Een USB – Naar micro usb kabel voor het programmeren en of de 5V voeding.
• Een Micro USB 5V voeding van minimaal 0.7 Ampère, een Raspberry Pi voeding is uitstekend. (Ongeveer € 4)
• Experimenteer print, een paar euro bijvoorbeeld link ( ongeveer € 7).
• Iets wat als tiptoets knop kan werken. Ik gebruik een 4mm schroefje.
Totaal ongeveer: € 30 euro afhankelijk van je voorkeur.
Uiteraard een soldeerbout, soldeertin en e.d. om de boel in elkaar te zetten.

Aansluitschema

ESP32 aansluitschema

Benodigde software.

De ESP32 is eenvoudig te programmeren via de Arduino IDE als je deze nog niet hebt geïnstalleerd volg dan deze handleiding van  randomnerdtutorials.com. Deze handleiding legt tevens uit hoe je de ESP32  uitbreiding moet toevoegen die zijn standaard niet geïnstalleerd.  

De code maakt gebruik van een extra softwarebibliotheken die eenvoudig via de Arduino IDE te installeren zijn.  Deze kun je via de IDE  Sketch -> Include Libary -> Manage Libraries toevoegen.

  • OneWire
  • U8G2
  • DallasTemperature

Laad onderstaande code in de editor en pas eventueel de WIFI instellingen aan als je daar gebruik van wil maken en compileer deze door linksboven op verify te klikken.  Als dat goed gaat kun je de ESP32 aansluiten via de USB-kabel en de code uploaden naar de ESP32.   Om de code te kunnen testen moeten we de temperatuur sensors worden aangesloten zijn.  


#include <U8g2lib.h>
#include <OneWire.h>
#include <DallasTemperature.h>
#include <WiFi.h>
#include <WiFiUdp.h>

/* note, the bat(tery) led rapid blinking is a hardware "feature" of the heltec board and can not be disabled by software */

/* user setting, change these to your needs. */
/*********************************************/
/* leave SSID empty if you don't need the UDP / WIFI messages *ssid = "" */
const char *ssid                = ""; // your SSID. 
const char *pwd                 = ""; // your WPA WIFI password. 
const uint8_t udp_send_interval = 45;      // interval when an udp message will be send in 0.1 secs interval 45 = ~5 secs.
                                           // use a value between 1 and a maximum of 599.                                                       
const float temp_in_adjustmend  =  0.36;  // test en adjust these to values to compensate for differences 
const float temp_out_adjustmend =  1.4;    // in the readout of the temp sensors and general offset error.
/***************** end of user settings ******/

#define TOUCH_PIN T7                      // connected to pin 27
#define ONE_WIRE_BUS 13                   // DS18B20 on GPIO 13.
#define STR_BUF_SIZE 32                   

#define VERSION      "versie 1.0"         // Software version.
#define TEMPERATURE_PRECISION 12          // set temp precision (9-12).
#define DISPLAY_WIDTH 128
#define DISPLAY_HEIGHT 64

OneWire           oneWire(ONE_WIRE_BUS);  // setup OneWire devices.
DallasTemperature tempSensors(&oneWire);  // tempSensor data.
DeviceAddress     tempDeviceAddress;      // temp adress for devices.
WiFiUDP           udp;                    // UDP sender.

int     numberOfDevices = 0;              // number of temperature devices found.
char    strbuf[STR_BUF_SIZE];             // buffer for display and serial print.
float   temp_in;
float   temp_out;
float   temp_in_avg; 
float   temp_out_avg;
uint8_t temp_vdelta_arr_graphic[DISPLAY_WIDTH];
int     touch_value = 300;
boolean WIFIconnected = false;

U8G2_SSD1306_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ 16, /* clock=*/15, /* data=*/4);   // (rotation, [reset [, clock, data]])

// IP address to send UDP data to.
const char *udpAddress = "255.255.255.255";  // udp broadcast address for the local lan only
const int   udpPort    = 30721;              // udp port number to listen to as a client.

void setup() {
  Serial.begin(115200);

  u8g2.begin();
  u8g2.clearBuffer();
  u8g2.setFont(u8g2_font_ncenB12_tf);
  u8g2.drawStr(20,40,"ZTATZ.NL");
  u8g2.sendBuffer();
  delay(3000);
  
  // load temperature sensors.
  tempSensors.begin();
   
  // check if we can find the two temp sensors.
  u8g2.clearBuffer();
  while ( setTempPrecision() < 2 ) {
    tempSensors.begin();
    u8g2.drawStr(1,12,"wacht op");
    u8g2.drawStr(1,26,"temperatuur");
    u8g2.drawStr(1,40,"sensors.");
    u8g2.sendBuffer();
    delay(500);
  }

  // make sure we have some temperature values.
  readTemperatures();

  if ( String(ssid).length() > 0 ) {

    // try to connect to wifi.
    connectToWiFi(ssid, pwd);

    // Wait for connection
    for (uint8_t i = 0; i < 60; i++) { 
      if (WiFi.status() == WL_CONNECTED ) {
        break; // we have a network connection
      }
      u8g2.clearBuffer();
      u8g2.drawStr(1,12,"wacht op");
      u8g2.drawStr(1,27,"wifi");
      u8g2.drawStr(1,41,"verbinding.");
      String str = "seconden: " + String( i );
      str.toCharArray(strbuf, STR_BUF_SIZE);
      u8g2.drawStr(1,57,strbuf);   
      u8g2.sendBuffer(); 
      delay(1000); // try every 1 secs
    }
  }
}

void loop()
{
  static uint8_t display_select_counter = 0;
  static uint8_t pseudo_secs = 0;
  static uint8_t touch_counter = 0;
  static uint8_t udp_send_counter = 0;
  static bool    wifi_retry_is_on = false;
  
  // pseudo timer.
  pseudo_secs++; 
  if ( pseudo_secs > 599 ) {pseudo_secs = 0; } // reset secs to 0

  // read temperature values from sensors and update data buffers.
  // every second
   if ( (pseudo_secs%10 ) == 0 ) {
    readTemperatures();
    fillGraphicBufferValues();
    calcAvgTemperature( temp_in, temp_out );
    showDisplay(display_select_counter);
  }

  // Send UDP broadcast messages. 
  if (WIFIconnected) {
    udp_send_counter++;
    if ( udp_send_counter > udp_send_interval ) { 
      udpSendMessage( makeJsonMessage() );
      udp_send_counter=0;
    }
  }
  
  // touch selection.
  touch_value = touchRead(TOUCH_PIN);
 
  if (touch_value < 50 ) {
    touch_counter++;
    if ( touch_counter > 4 ) { // must held the touch contact to filter out noise.
      touch_counter = 0;
      display_select_counter++;
      if ( display_select_counter > 3 ) { display_select_counter = 0; }
      showDisplay(display_select_counter); // to get quick feedback on pressing touch "button".
    }   
  } else {
    touch_counter = 0; //reset the touch counter,
  }

  delay(100); // 0.1 sec delay.
}

void connectToWiFi(const char * ssid, const char * pwd){
  Serial.println("Connecting to WiFi network: " + String(ssid));

  // delete old config
  WiFi.disconnect(true);
  //register event handler
  WiFi.onEvent(WiFiEvent);
  
  //Initiate connection
  WiFi.begin(ssid, pwd);

}

//wifi event handler
void WiFiEvent(WiFiEvent_t event){
    Serial.print("WiFiEvent_t: ");
    Serial.println(event);
    switch(event) {
      case SYSTEM_EVENT_STA_GOT_IP:
          //When connected set 
          Serial.print("WiFi verbonden! IP address: ");
          Serial.println(WiFi.localIP());  
          //initializes the UDP state
          //This initializes the transfer buffer
          udp.begin(WiFi.localIP(),udpPort);
          WIFIconnected = true;
          break;
      case SYSTEM_EVENT_STA_DISCONNECTED:
          Serial.println("WiFi verbinding veloren.");
          WIFIconnected = false;
          WiFi.disconnect(true);
          WiFi.begin(ssid, pwd);
          break;
    }
}

// function select display mode
void showDisplay(uint8_t index) {
   switch(index) {
      case 0:
        showTempInfo();
        break; 
      case 1:
        showDeltaTempInfo();
        break; 
      case 2:
        showInitInfo();
        break;
       case 3:
        // blank screen
        u8g2.clearBuffer();
        u8g2.sendBuffer();
        break;
  }
}


// function to show temperature on display.
void showDeltaTempInfo() {
  static bool temp_icon;

  floatTempFormater(temp_in_avg - temp_out_avg).toCharArray(strbuf, STR_BUF_SIZE);
  
  u8g2.clearBuffer();
  u8g2.setFont(u8g2_font_fub30_tf);
  u8g2.drawStr(   5,  35, strbuf);
  u8g2.drawGlyph( 85, 35, 176 );
  u8g2.drawStr(   95, 35, "C" );

  u8g2.setFont(u8g2_font_ncenB18_tf);
  u8g2.drawStr( 8, 60, "verschil" );

  // activity icon toggle.
  u8g2.setFont(u8g2_font_open_iconic_gui_2x_t);
  if (temp_icon == true ) {
    u8g2.drawGlyph(112,60,66);
    temp_icon = false;
  } else {
    u8g2.drawGlyph(112,60,67);
    temp_icon = true;
  }

  u8g2.sendBuffer();
}

void showInitInfo() {

  u8g2.clearBuffer();
  u8g2.setFont(u8g2_font_courB10_tf);
  String str = VERSION;
  str.toCharArray(strbuf, STR_BUF_SIZE);
  u8g2.drawStr(1,15,strbuf);

  str = "SSID:" + String( ssid );
  str.toCharArray(strbuf, STR_BUF_SIZE);
  u8g2.drawStr(1,30,strbuf);

  str = IpAddress2String( WiFi.localIP() );
  str.toCharArray(strbuf, STR_BUF_SIZE);
  u8g2.drawStr(1,45,strbuf);

  u8g2.sendBuffer();
}

// function to show temperature on display.
void showTempInfo() {
  static bool temp_icon;
  
  u8g2.clearBuffer();
  u8g2.setFont(u8g2_font_ncenB18_tf);
  u8g2.drawStr(    0,18,"in"  );
  u8g2.drawStr(    0,40,"uit" );
  
  floatTempFormater(temp_in_avg).toCharArray(strbuf, STR_BUF_SIZE);
  u8g2.drawStr(38,18,strbuf);
  
  floatTempFormater(temp_out_avg).toCharArray(strbuf, STR_BUF_SIZE);
  u8g2.drawStr(38,40,strbuf);

  u8g2.setFont(u8g2_font_ncenB14_tf);
  u8g2.drawStr(   97,16,"C" );
  u8g2.drawStr(   97,38,"C" );
  u8g2.drawGlyph( 90,16,176 );
  u8g2.drawGlyph( 90,38,176 );
  
  for (uint8_t i=0; i <DISPLAY_WIDTH; i++ ) {
      u8g2.drawLine(i,64, i, DISPLAY_HEIGHT - temp_vdelta_arr_graphic[i] );
  }

  // activity icon toggle.
  //u8g2.setFont(u8g2_font_siji_t_6x10);
  u8g2.setFont(u8g2_font_open_iconic_all_2x_t);
  if (temp_icon == true ) {
    u8g2.drawGlyph(112,20,141);
    //u8g2.drawGlyph(111,20,57551);
    temp_icon = false;
  } else {
    //u8g2.drawGlyph(113,20,57373);
    temp_icon = true;
  }

  if (WIFIconnected) {
    u8g2.setFont(u8g2_font_open_iconic_all_2x_t);
    u8g2.drawGlyph( 112,40,247 );
  }
  
  u8g2.sendBuffer();
}


// function IPAdress conversion to string
String IpAddress2String(const IPAddress& ipAddress)
{
  return String(ipAddress[0]) + String(".") +\
  String(ipAddress[1]) + String(".") +\
  String(ipAddress[2]) + String(".") +\
  String(ipAddress[3])  ; 
}


// function to format json string.
String makeJsonMessage() {
  static unsigned int sequenceNumber;
  char  tmpbuf[8];
  
  dtostrf( temp_in, 2, 3, tmpbuf );
  String str_tmp_in = String(tmpbuf);
  dtostrf( temp_out, 2, 3, tmpbuf );
  String str_tmp_out = String(tmpbuf);

  //{ "t_in": 23.1, "t_out":45.6, "seq":65000 }
  String msg = "{\"id\":\"ztatz_dt\",\"version\":1.0,\"t_unit\":\"C\"";
  msg = msg + ",\"t_in_avg\":" +
  floatTempFormater(temp_in_avg) +
  ",\"t_out_avg\":" +
  floatTempFormater(temp_out_avg) +
   ",\"t_in\":" +
  str_tmp_in +
   ",\"t_out\":" +
  str_tmp_out +
  ",\"seq\":" + sequenceNumber +
  "}";
  
  sequenceNumber++;
  if ( sequenceNumber > 32768 ) { sequenceNumber = 0; } //wrap around to zero.
  return msg;
}

void udpSendMessage(String msg) {
   
    //alloc buffer space 
    uint8_t bufsize = msg.length()+1;
    uint8_t buffer[bufsize];
    msg.getBytes(buffer, bufsize);
   
    udp.beginPacket(udpAddress, udpPort);
    udp.write(buffer, bufsize-1); //skip trailing zero.
    udp.endPacket();
}


// function to calculate the average values, based in AVG_TEMP_ARRAY_SIZE value
void calcAvgTemperature(float in, float out) {
  #define AVG_TEMP_ARRAY_SIZE 30
  static uint8_t sample_count=0;
  static float temp_in_array[AVG_TEMP_ARRAY_SIZE];
  static float temp_out_array[AVG_TEMP_ARRAY_SIZE];
  static bool  enough_data = false; // only average value when there is enough data

  // shift array 
  for (uint8_t i = AVG_TEMP_ARRAY_SIZE-1; i > 0; i--) {
       // Serial.print  ("i = ");
       // Serial.println(i , DEC);
       temp_in_array[i]  = temp_in_array[i-1];
       temp_out_array[i] = temp_out_array[i-1];
  }
  temp_in_array[0]  = in;
  temp_out_array[0] = out;
 
  sample_count++;
  if ( sample_count == AVG_TEMP_ARRAY_SIZE ) {
      enough_data = true;
  } else {
    // we don't have enough data so just send current non average value
    temp_in_avg  = in;
    temp_out_avg = out;
  }

  if (enough_data == true ) { // ready to calc avg value
     temp_in_avg = temp_out_avg = 0;
     for (uint8_t i = 0; i < AVG_TEMP_ARRAY_SIZE; i++) {
       temp_in_avg  = temp_in_avg  + temp_in_array[i];
       temp_out_avg = temp_out_avg + temp_out_array[i];
     }
     temp_in_avg  = temp_in_avg  / AVG_TEMP_ARRAY_SIZE;
     temp_out_avg = temp_out_avg / AVG_TEMP_ARRAY_SIZE;
  } 

   /* remove comments to test and adjust offset values */
   /*
   Serial.print(" in =");
   Serial.print(in,DEC); 
   Serial.print(" out =");
   Serial.print(out ,DEC); 
   Serial.print(" delta(raw) =");
   Serial.print( floatTempFormater(out-in));
   Serial.print(" temp_in_avg =");
   Serial.print(temp_in_avg,DEC);
   Serial.print(" temp_out_avg =");
   Serial.print(temp_out_avg,DEC);
   Serial.print(" delta(avg) =");
   Serial.println(floatTempFormater(temp_out_avg - temp_in_avg));
   */
}

// function to format float type.
String floatTempFormater(float in) {
  char  tmpbuf[10];
  dtostrf( in, 2, 1, tmpbuf );
  String str = String(tmpbuf);
  
  if ( str.length() < 4) {
     str = "0"+str;
  }
  return str;
}

// function to fill buffer with offset values to draw a graph.
void fillGraphicBufferValues() {
  
  uint8_t delta_value = abs(temp_in - temp_out)* 2; //two pixels is a degree. 

  temp_vdelta_arr_graphic[0] = delta_value;
  if  ( temp_vdelta_arr_graphic[0] > 22 ) { temp_vdelta_arr_graphic[0]=22; } // cap maximum graph height. 

  for (uint8_t i=DISPLAY_WIDTH-1; i >0; i-- ) {
      temp_vdelta_arr_graphic[i] = temp_vdelta_arr_graphic[i-1];
  }
}

// function to show temperature on display.
void readTemperatures() {
  /* important add or subtract values to make sure both sensors give the right temperature.
   *  this must be done manualy once! See top of code!
   */
  tempSensors.requestTemperatures();
  temp_in  = tempSensors.getTempCByIndex(0)+ (temp_in_adjustmend);  // error offset. 
  temp_out = tempSensors.getTempCByIndex(1)+ (temp_out_adjustmend);  // error offset.
}

// function to print a device address
void printAddress(DeviceAddress deviceAddress)
{
  for (uint8_t i = 0; i < 8; i++)
  {
    if (deviceAddress[i] < 16) Serial.print("0");
    Serial.print(deviceAddress[i], HEX);
  }
}

// function to set temp device precision.
int setTempPrecision() {
  numberOfDevices = tempSensors.getDeviceCount();
  if ( numberOfDevices < 1 ) {
     Serial.println("Fout geen devices gevonden!");
     return 0;
  }
  // Loop through each device, print out address
  for(int i=0;i<numberOfDevices; i++)
  {
    // Search the wire for address
    if(tempSensors.getAddress(tempDeviceAddress, i)) {
      Serial.print("device gevonden ");
      Serial.print(i, DEC);
      Serial.print(" met adres: ");
      printAddress(tempDeviceAddress);
      Serial.println();
    
      Serial.print("Resolutie gezet op ");
      Serial.print(TEMPERATURE_PRECISION, DEC);
      Serial.println(" bits.");
    
      // set the resolution to TEMPERATURE_PRECISION bit (Each Dallas/Maxim device is capable of several different resolutions)
      tempSensors.setResolution(tempDeviceAddress, TEMPERATURE_PRECISION);
    
      Serial.print("Daadwerkelijke resolutie die gezet is : ");
      Serial.print(tempSensors.getResolution(tempDeviceAddress), DEC);
      Serial.println();
    }else{
      Serial.print("Spook device op adres ");
      Serial.print(i, DEC);
      Serial.print(" adress niet gevonden, controleer voeding en bekabeling.");
    }
  }
  return numberOfDevices;
}

Afstellen van de temperatuur sensors.

De sensors die ik gebruikt heb voor het testen wijken soms wel 1 graad Celsius of iets meer af van de werkelijkheid. Als je het belangrijk vindt dat de juiste temperatuur wordt aangeven dan kun je de sensors ijken. Dit kan via de UTP berichten of via de seriële logging van de Arduino IDE. Als je de seriële logging wil gebruiken dan moet je de commentaar karakters verwijderen.

/* remove comments to test and adjust offset values */
   /*
   Serial.print(" in =");
   Serial.print(in,DEC); 
   Serial.print(" out =");
   Serial.print(out ,DEC); 
   Serial.print(" delta(raw) =");
   Serial.print( floatTempFormater(out-in));
   Serial.print(" temp_in_avg =");
   Serial.print(temp_in_avg,DEC);
   Serial.print(" temp_out_avg =");
   Serial.print(temp_out_avg,DEC);
   Serial.print(" delta(avg) =");
   Serial.println(floatTempFormater(temp_out_avg - temp_in_avg));
   */

Met de twee variabelen temp_in_adjustmend en temp_out_adjustmend kun je de aanpassingen doorvoeren. Het is een kwestie van testen en aanpassen, testen aanpassen, enz. Het werkt het eenvoudigst als je eerst zorgt dat dezelfde waarde aangeven en daarna de waarde voor de werkelijke temperatuur aangeeft door bij beide dezelfde waarde aan te passen. Ik heb beide sensoren met duct tape bij elkaar geplaatst en in een doek gedaan tegen tocht e.d.

const float temp_in_adjustmend  =  0.36;
const float temp_out_adjustmend =  1.4;

UDP berichten

De UDP berichten zijn in JSON formaat.

{
"id":"ztatz_dt",
"version":1.0,
"t_unit":"C",
"t_in_avg":24.1,
"t_out_avg":22.0,
"t_in":24.298,
"t_out":22.150,
"seq":24464
}
  •  id: geeft de unieke naam aan van het type bericht.
  • version: versie van het bericht, in de toekomst kan het bericht uitgebreid worden.
  • t_unit: C is graden Celsius.
  • t_in_avg: de gemiddelde temperatuur in over de afgelopen 30 seconden.
  • t_out_avg: de gemiddelde temperatuur uit over de afgelopen 30 seconden.
  • t_in: de ruwe temperatuur in, wordt elke seconde gemeten.
  • t_uit: de ruwe temperatuur uit, wordt elke seconde gemeten.
  • seq: volgorde nummers van het bericht met een waarde van 1 tot 32768. Als de waarde 32769 wordt bereikt dan is het volgende nummer 1. Bij een reboot wordt altijd gestart met de waarde 1. Het doel is dat ontvangers kunnen vaststellen of ze een waarde al gehad hebben of er een gemist.

Onderstaande code geeft een simpele voorbeeld hoe je met Python de berichten kunt uitlezen.

#!/usr/bin/python

import socket
import time
import datetime

# bind all IP
HOST = '0.0.0.0' 
# Listen on Port 
PORT = 30721 
#Size of receive buffer   
BUFFER_SIZE = 1024    
# Create a TCP/IP socket
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
# Bind the socket to the host and port
s.bind((HOST, PORT))
while True:
    # Receive BUFFER_SIZE bytes data
    # data is a list with 2 elements
    # first is data
    #second is client address
    data = s.recvfrom(BUFFER_SIZE)
    if data:
        #print received data
        print( datetime.datetime.fromtimestamp(time.time()).strftime('%H:%M:%S') +' ' + str(data[0]) )
# Close connection
s.close()

P1 Monitor geschikt

In een van de volgende versies van de P1 monitor wordt de ESP32DeltaTemp ondersteund.

P1 monitor roadmap

P1 monitor roadmap

De P1 monitor roadmap geeft aan welke opties of aanpassingen op de planning staan. Het geeft tevens de mogelijkheid ideeën aan te dragen voor de volgende versies. Als je wensen of ideeën hebt dan kun aangeven via een comment op deze pagina.  Alle ideeën zijn welkom. Het kan afhankelijk van de beschikbare tijd even duren voordat geplande opties daadwerkelijk worden gerealiseerd.

Deze pagina is niet bedoeld voor bugs of andere vragen. Plaats die op de download pagina. Als je een hier bug plaatst dan wordt deze genegeerd.

In planning:

fullscreen support voor de UI, refresh button en kostenscherm update.

Te onderzoeken :

De Lijstvolgorde geeft geen prioriteit aan, maar in volgorde van verzoeken.

  • Backup naar dropbox.
  • Database export naar CSV/Excel format.
  • App voor de P1 monitor, dit wordt een IOS (Apple) versie.
  • Weer voorspelling toevoegen naast de huidige weer informatie.
  • Omnik zonnepanelen data uitlezen.
  • Watermeter uitlezen.
  • Reset / wissen van de database alsof het een nieuwe installatie is.
  • Engels als tweede taal toevoegen.
  • Een grafiek met het momentane vermogen van alle drie de fases in 1 grafiek.
  • Site responsive maken.
  • LCD scherm maken die geleverd of teruggeleverd vermogen aangeeft.
  • vergroten van het gekopieerde image naar de grootte van de sdhc card. Wordt een menu optie.
  • Export van gegevens naar Excel.
  • Optie om zelf historische gegevens toe te voegen.
  • Lange termijn overzicht van de meterstanden in plaats van het verbruik per uur,dag,maand, enz.
  • Wekelijks verbruik toe te voegen aan stroom en gas.
  • Alerting: bijvoorbeeld het ontvangen van een email als het verbruik niet 1x per b.v. 12 uur onder een in te stellen aantal Watt komt of als het verbruik per 24 uur boven een in te stellen waarde komt.
  • Progressie indicator toevoegen voor import functie.
  • Gemiddelde temperatuur in kosten overzicht tooltip toevoegen.
  • kWh levering uitschakelen in kosten overzicht tooltip.
  • Ondersteuning voor de multivallen 402 warmtemeter.
  • Serial device kunnen instellen voor het uitlezen van de P1 poort.
  • MQTT is a machine-to-machine (M2M)/”Internet of Things” connectivity protocol mogelijkheden.
  • “Dagteller” gas. Het zou handig zijn om een los tellertje te kunnen starten en stoppen. Om bijvoorbeeld bij starten van een douche beurt, of kook beurt, of gaskachel beurt, de teller te starten en er na te stoppen. Zo kan je (ongeveer) zien hoeveel 1 zo’n “beurt” aan gas kost (vermist er dan geen andere gebruikers zijn).
  • Weerlive.nl als alternatieve bron voor het weer gebruiken.
  • Direct root login verwijderen via een aparte user en via sudo.
  • Geluidstoon/piep in home screen als p1 kabel niet aangesloten zit / geen data ontvangt configureerbaar maken.
  • Docker based versie maken.
  • Mindergas.nl interface maken.
  • pvoutput.org interface maken.
  • Home pagina waarde instelbaar maken.
  • CPU temperatuur toevoegen op de info pagina.

Wordt niet verder onderzocht of uitgevoerd.

  • De P1 monitor te installeren op een bestaande Raspberry Pi 3 zoals Domoticz.
P1 monitor download

P1 monitor download

P1 monitor is op de Raspberry PI 3 gebaseerde software om je slimme meter uit te lezen. Voor een meer uitgebreide beschrijving zie hier.

Upgrade of eerst installatie.

De software verkrijgen en installatie.

De P1 monitor software wordt geleverd als Raspberry Pi 3 B SDHC image die hieronder te downloaden is. Om de het image naar een SDHC card te kopiëren is een image tool nodig als je deze niet hebt dan kun je USB Image tool downloaden. De 4GB variant is bedoeld als het 8GB image niet werkt op een andere 8GB SDHC card als je de melding krijgt dat het image niet past!  Zie hieronder hoe je dat daarna de rest van de ruimte op de card kunt gebruiken met raspi-config tool.

Mocht je een eerdere versie van de P1 monitor gebruiken exporteer dan deze data eerst!

  1. download het P1 monitor image file uit de download overzicht hieronder.
  2. pak het zip file uit en lees de bijlagen.
  3. kopieer het p1monYYYYMMDD-NN.NN-X.img file via de USB tool naar de SDHC card van minimaal 8GB  Let op! data op de card wordt overschreven en is niet meer te herstellen. (had ik gehad over de export van data).
  4. Mocht je een groter SDHC card willen gebruiken dan kan je via de raspi-config tool de gehele SDHC card gebruiken. Dit is zeker aan te bevelen om slijtage van de SDHC card te verminderen.
  5. plaats de SDHC card in de Pi.
  6. start de Pi, netwerk en P1 kabel aangesloten.
  7. Importeer de data, als je al eerdere versie hebt gebruikt.

Veel plezier met de P1 monitor en laat weten hoe het bevalt.

Problemen oplossen.

Image past niet op de SDHC card:

  1. Je kunt proberen de donor SDHC card opnieuw te formatteren met een dergelijk tool als de SD formatter.
  2. Het 4GB image is bedoeld als het 8GB image niet past op een andere 8GB SDHC card. Installeer het kleinere image op de groter SDHC card. Het ongebruikte deel van de SDHC card kun je vrijgeven via de raspi-config tool met de optie extend filesystem.

Standaard wachtwoord besturingsysteem:

  1. Het standaard account en wachtwoord om in te kunnen loggen is root met het wachtwoord  toor.
  2. Het advies dit wachtwoord na installatie aan te passen.

Juridisch spul en zo

Creative Commons-Licentie

Dit werk valt onder een Creative Commons Naamsvermelding-NietCommercieel 4.0 Internationaal-licentie.

De rechten van onderliggende softwareproducten zijn qua licentierechten niet gewijzigd Dit geldt voor bijvoorbeeld het besturingssysteem en javascript bibliotheken. De rechten van onderliggende producten gaan voor deze licentie.

DE SOFTWARE IS GELEVERD “ZOALS”, ZONDER GARANTIE VAN ENIGE SOORT, INCLUSIEF MAAR NIET BEPERKT OP DE GARANTIES VAN VERKOOPBAARHEID, GESCHIKTHEID VOOR EEN BEPAALD DOEL. IN GEEN GEVAL ZAL HET AUTEURS OF COPYRIGHT HOLDERS AANSPRAKELIJK ZIJN VOOR ENIGE EISEN, SCHADE OF ANDERE AANSPRAKELIJKHEID IN VERBAND MET DE SOFTWARE OF HET GEBRUIK VAN DE SOFTWARE.

Samengevat: gebruik is voor eigen risico.

Mocht je een eerdere versie van de P1 monitor gebruiken exporteer dan deze data eerst!

DONATIE

Africa Classis Amref Flying Doctors

Als je toch al goed bezig bent om energie te besparen en je wilt een donatie doen via een goed doel dan graag aan de Africa Classic van Amref Flying Doctors.

 

 

Als je een bijdrage wil leveren om de kosten te dekken van de website e.d. dan kan kun je hier een donatie doen.

DOWNLOAD

SDHC images

P1 monitor wordt alleen ondersteund op de Raspberry Pi 3B of Pi3 B+.

Een Pi 2 kan werken maar geen garanties.  Een Pi Zero is nooit getest. Van de Pi 1 is bekend dat deze fouten geeft en verloop van tijd stopt / crashed.

Wat is er veranderd in versie 0.9.2 (Ron)

Bug/features:

  • Tekstfout verwijderd in scherm config-ui.php
  • Main scherm, lay-out foutje veranderd bij vandaag geleverd vermogen en kleur van geleverd dal werkt weer.
  • Tooltip gaf onterecht kWh aan in plaats van kW in de twee main / home schermen.
  • CRC-controle van P1 telegrammen toegevoegd. Als in het telegram een CRC wordt gevonden (het telegram eindigt met !CD34 o.i.d) dan wordt deze gecontroleerd en bij fout het telegram genegeerd. Dit is getest met de Sagemcom /Ene5\T210-D ESMR5.0 meter 115200 8N1 snelheid. mocht er problemen optreden dan kun je de CRC-check uitschakelen in het setup menu -> P1 poort. De CRC-check is niet nodig voor meters zonder de CRC-check en kan dan worden uitgeschakeld.
  • Upgrade van fonts/icon bestanden, kleine prestatie verbeteringen doorgevoerd.Hopelijk voorkomt dit de bug dat soms het setup menu niet verschijnt. Deze bug was niet te reproduceren tijdens het testen.

Aanpassingen/ nieuwe functionaliteit:

  • Python bibliotheek PyCRC toegevoegd. Alleen interessant als je zelf de code aanpast.
  • p1mon.css aangepast, kleine verbeteringen of toevoegingen
  • Security patches tot aan 22-07-2018.

Tips:

  • Bij het installeren van een nieuw image eerst een export maken van de data zodat deze in het nieuw image ingelezen kan worden.
  • Wis je browser cache na de installatie van een nieuw image, dan weet je zeker dat je werkt met de laatste versie uit het image. In vrijwel alle gevallen zijn problemen qua lay-out met de web pagina’s te wijten aan een aanpassing van de het p1mon.css file.
  • Bij problemen met het aan de gang krijgen van WiFi als eerste de juiste SSID en password invoeren en als dit niet werkt dan via het systeem menu de p1 monitor herstarten. Dit borgt dan alle ingestelde waarden eerst naar het SDHC kaartje worden geschreven voordat de Pi reboot.

Met een zeer welgemeende dank aan Ron voor het helpen bij het testen van deze versie.

BUG: Instellingen raken verloren, wacht 15+ min  na het invoeren van wijzigingen met een reboot. doe dit ook altijd via het setup menu.  Dit is opgelost in de volgende versie.


Wat is er veranderd in versie 0.9.1 (Maja)

Bug / feature fixes:

  • Systeem configuratiescherm schoonheidsfoutje aangepast.
  • Minuten overzicht elektriciteit verbruik liet af en toe niet toe dat 24 uur werd geselecteerd.
  • In de overzichten de 7 dagen tekst omgezet naar 1 week tekst.
  • Actuele levering en verbruik bug met veel 99999999 of 000000 opgelost (hopelijk nu definitief).
  • Weer druk meting gaf soms een waarde achter de coma aan. Aangepast naar alleen gehele getallen.
  • Weer verwerkingstijdstip werd weergegeven in UTC in plaats van de de lokale tijd.
  • Kleine fouten in afhandeling van in en export opgelost.
  • Bug opgelost dat bij de eerste keer gebruik van weer informatie deze niet wordt opgeslagen.

Aanpassingen:

  • Wifi-aanpassingen worden doorgevoerd na een import.
  • M3 in teksten omgezet naar m3.
  • Upgrade van nieuw icon bibliotheek en vrijwel alle pagina’s aangepast.
  • Gas geleverd toegevoegd. Het verbruik per uur wordt berekend omdat de slimme meter laagfrequent de gas meterwaarden doorgeeft (beta test). Dit is een test de schaal verdeling is nu maximaal 1 kubieke meter. Graag feedback of deze schaal overeenkomt met je gebruik.
  • Gas geleverd max waarde instelbaar gemaakt in het display scherm.
  • In de kosten overzichten een grafiek lijn toegevoegd die de netto kosten toegevoegd. Deze geeft het verschil tussen geleverd en verbruikt aan.
  • In het home scherm kun je nu kiezen voor geleverd & verbruikt of alleen verbruik informatie.
  • Voor E-levering & E-verbruik kan nu ook 25Kw of 50Kw worden ingesteld.
  • In het informatiescherm worden nu gegevens weergegeven over het model van de Raspberry Pi en gebruikte processor (CPU).
  • De time-out van de NGINX webserver vergroot om te voorkomen dat langlopende API calls gestopt worden. Time-out staat nu op 300 seconden.
  • ApiV1p1data toegevoegd, deze bevat de meest nauwkeurig data die uit de slimme meter komt met een interval van 10 sec.
  • Het is nu mogelijk je eigen userinterface te maken, in te stellen via het setup menu en een voorbeeld demo html pagina toegevoegd.
  • De exportfunctie is aangepast zodat de bestanden uit de folder /www/custom/* mee worden genomen in de in en exportfunctie. Er kan echter geen garantie gegeven worden dat dit in alle situaties werkt. Indien er alleen files en directe folders worden gebruikt dan zou het zonder problemen moeten werken.
  • Debug export is nu beschikbaar. Het gzip bestand bevat een kopie van de gehele /p1mon file structuur. Deze dump kan worden gebruikt als er problemen optreden voor onderzoek.

Wis de CSS cache van de browser. Dit is nodig omdat de css files zijn aangepast.


Wat is er veranderd in versie 0.9.0 (Maja)

Bug / feature fixes:

  • Import van temperatuur data werkt ook als de weer API nog niet actief is.
  • Import files met [ of ] in de file naam werden niet verwerkt.
  • Internet IP adres werd niet getoond, remote API was niet meer beschikbaar, deze is aangepast.
  • Crypto test -t functie had een probleem, had geen gevolgen voor de werking.

Aanpassingen:

  • Raspbian upgrade van Weezy (Linux-4.4.21-v7+-armv7l-with-debian-7.11 ) naar Stretch (Linux- 4.14.30-v7+-armv7l-with-debian-9.4) Deze versie van Linux wordt ondersteund tot 2022.
  • Versie nummers met een nummer hoger dan 0.9.0 ondersteunen nu ook de Raspberry Pi B+ (2018 laatste model)
  • P1SerReader.py: code opgeschoond, en check gedaan of /dev/ttyUSB0 wel bestaat. Let op voor het starten moet de p1 kabel zijn aangesloten, soms gaat het goed als de p1 kabel later wordt aangesloten. Bij twijfel de kabel aansluiten en de Pi herstarten.
  • P1Watchdog.py: samba service aanpassingen /usr/sbin/service samba restart veranderd in /usr/sbin/service smbd restart (heeft te maken met de Raspbian upgrade).
  • Wifi toewijzing/selectie aangepast en verbeterd.
  • Upgrade van PHP 5 naar PHP 7.
  • Kosten scherm verhuld nu ook de kWh en m3waarde als gas of niet alle kWh waarden zijn geselecteerd.
  • Security patches tot aan 04-04-2018.

Wat is er veranderd in versie 0.8.3 (Thijs)

    • Bug fix: de tooltip werd niet correct weergegeven bij bepaalde tijdstippen. Hiermee lijkt ook het probleem met Safari browser opgelost.
    • Bug fix: bij het verbruik scherm verscheen soms 99999 in het scherm.
    • Het kostenscherm is aangepast. Het is nu mogelijk om een grenswaarde in te stellen voor de kosten zodat inzichtelijke wordt gemaakt wanneer over de zelf gekozen kosten grens wordt bereikt. De grenswaarde is instelbaar in het tarieven scherm. In de tooltip scherm van wordt nu tevens de kWh en gas waarden weergegeven.
    • Diverse pagina’s/ schermen zijn aangepast zodat de laatste versie van javascript bibliotheken worden gebruikt.
    • Optie om een aantal pagina’s full screen weer te geven. Gebruik van full screen is beperkt en moet bij het wisselen van het scherm steeds opnieuw worden ingesteld. Dit is een beperking van de javascript optie en kan niet worden aangepast. De full screen is niet beschikbaar op mobiele devices zoals iPad e.d.
    • API voor tellerstanden toegevoegd. De API apiV1countervalue geeft de meterstanden op een bepaald moment weer. De API probeert dit zo nauwkeurig als mogelijk te doen. Als de minuut waarde wordt opgegeven dan wordt deze gebruikt als deze niet beschikbaar is dan de uur waarde, dag, maand of jaar waarde. In het antwoord dat de API weergeeft wordt in het TIMESTAMP veld de gevonden timestamp gebruikt.
    • Na het updaten wordt aanbevolen de CSS cache van de browser te wissen. Dit is nodig omdat de css files zijn aangepast.
    • Security updates tot aan 16-2-2018.
    • Voor de upgrade eerste de oude data exporteren en na de upgrade weer importeren. Als je de temperatuur historie belangrijk vindt dan moet je de data een tweede keer importeren na dat de weer  instellingen zijn getest.  Dit is een bug en is gefixed in de volgende versie.

    Als de software bevalt overweeg dan een donatie om de P1 monitor te steunen.

    Wat is er veranderd in versie 0.8.2 (Thijs)

    Deze update is alleen nodig als de bugs een probleem vormen.

    • Backup account naam ondersteund nu ook _!^{}[]$+?> karakters (als je echte een funky account naam wil gebruiken).
    • Bug fixed: gas zoom bug verholpen waar bij het uitzoomen de verkeerde waarde werd weergegeven.
    • Bug fixed: Bij Gaswaarden veranderd de weergave van “uren (M3 gas)” niet als je voor de verschillende weergaven kiest (Uren, dagen, maanden). Er bleef dan uren staan. Met dank aan Mark voor het melden.
    • Bug fixed: als de weer api niet werd gebruikt dan lieten de gas schermen geen gegevens zien. Met dank aan Paul voor het melden.
    • Security updates tot aan 19-01-2018.

     

    Wat is er veranderd in versie 0.8.1 (Thijs)

    Grafiek gas vs temperatuur
    Demo van gas met temperatuur
    • Gas waarde per uur toegevoegd. De nauwkeurigheid kan tegenvallen afhankelijke hoe vaak de gas waarde aangepast/doorgeven wordt door de gas meter. De standaardwaarde is 1 maal per uur.
    • De temperatuur kan nu worden weergegeven in het gas overzicht, waar de minimale en maximale en gemiddelde temperatuur wordt weergegeven. Mits je de weer api gebruikt.
    • Export en import aangepast, de uur waarde van gas en weer informatie wordt nu meegenomen.
    • Nieuwe versie van de API apiV2usage het veld VERBR_GAS_HOUR is toegevoegd, schakel over naar deze versie. Versie V1 wordt in de toekomst verwijderd.
    • Diverse niet kritische HTML bugs verwijderd.
    • Gas schermen ajax calls aangepast om bug weg te werken.
    • Tekstfout in API help scherm aangepast die naar de verkeerde versie verwees.
    • Gas telegram prefix is nu in te stellen naar een andere dan de standaardwaarde van 1.
    • Security updates tot aan 12-01-2018.

     

    Wat is er veranderd in versie 0.8 (Thijs)

    • Bij het aanmelden van de weer API worden meer details geven bij fouten.
    • FTP back-up optie toegevoegd die met een crontab gebaseerde timer werkt. Voor details hoe crontab werkt zie https://nl.wikipedia.org/wiki/Cronjob. Je hebt uiteraard wel een FTP-server nodig voor de back-up’s. De back-up is in een hetzelfde formaat als de exportfunctie en via import kan een restore worden uitgevoerd.
    • Diverse webpagina’s aangepast zodat er geen gebruik meer gemaakt wordt van oude javascript methodes.
    • Cryptografische code aangepast die sterker is omdat de back-up data gevoelige gegevens bevat.
    • Let op bij een import zullen de wachtwoorden voor Wifi en de weer API niet meer te lezen zijn. Stel deze veilig zodat ze opnieuw in te stellen.
    • Easter egg toegevoegd 😊
    • Wifi instellingen aangepast, de selectie van de Wifi SSID’s (naam) is aangepast waardoor bugs met vergelijkbare Wifi namen wordt voorkomen.
    • In het netwerk configuratiescherm kan nu de SSID ingesteld worden los van de gevonden SSID’s.
    • Bug / feature opgelost dat als het loginscherm rechtstreeks wordt opgevraagd dat deze niet in een oneindig loop terecht komt.
    • Auto uitlog na 15 minuten in het configuratiescherm. De timeout werkte wel maar alleen na een aanpassing in het scherm.
    • Basic API V1 en V2 niet meer beschikbaar gebruik V3.
    • De CSS is aangepast. Het kan zijn dat een scherm niet goed wordt weergeven.Wis eventueel de brower cache.
    • Het opstarten van de P1 monitor neem bij een bekabelde verbinding met de Raspberry PI 3 minder dan twee minuten. Bij gebruik van WiFi kan dit aanzienlijk langer duren, tot wel 5 minuten afhankelijk van de kwaliteit van de Wifi-verbinding. Mocht er gebruik gemaakt worden van Wifi dan is het verstandig de netwerkkabel niet te gebruiken en los te nemen. Indien de keuze bestaat tussen Wifi of gebruik van de netwerkkabel dan heeft de kabel de voorkeur.
    • UI scherm layout bug opgelost met Firefox.
    • Security updates tot aan 22-12-2017 uitgevoerd.

    Belangrijk stel de wachtwoorden van de Wifi en de weer API veilig zodat je opnieuw kunt instellen. Na de import zullen oude wachtwoorden niet meer werken!

     

    Wat is er veranderd in versie 0.7.2 (Wilfried)

    • Versie 0.7.2 is gelijk aan de 0.7.1 maar lost de bug op dat 0.7.1 test data bevatte.

     

    Wat is er veranderd in versie 0.7.1 (Wilfried)

      • Bug gefixed dat het wachtwoord standaard gezet moeten worden bij eerste gebruik.
      • Seriele buffer vergroot voor meters die meer dan 35 regels per telegram aanbieden.
    • Detectie van een correct p1 bericht aangepast.
    • Basis API V3 heeft de optie om de gas waarde in m3 aan te geven in plaats van dm3.
    • API voor weer informatie toegevoegd.
    • API voor historie data toegevoegd.
    • Alle API’s hebben nu een status veld met de opties: production=ondersteund en getest, test= nog niet af kan veranderen, deprecated=wordt in de toekomst niet meer geleverd.
    • Laatste keer dat de basis API V1 en V2 nog wordt ondersteund, gebruik versie V3!
    • RAM buffer database vergroot van 75MB naar 85MB voor weer database.
    • Security updates tot aan 13-11-2017 uitgevoerd.

     

    Wat is er veranderd in versie 0.7.0 (Wilfried)

    • Configuratie scherm gewijzigd naar meerdere schermen.
    • Log bug opgelost.
    • Klok linksboven op de juiste positie gezet in de user interface.
    • Bug gefixed dat een image ouder dan 10 dagen niet goed met datum en tijd omging /etc/fake-hwclock.data wordt nu gewist voor dat de image wordt gemaakt.
    • De lege ruimte in SDHC card wordt gewist / gevuld met 0 om zo de image kleiner te kunnen maken (eenmalig actie per image build) en heeft geen effect voor de werking na download.
    • Levering en verbruik waarde elektriciteit zijn instelbaar geworden.
    • Login scherm heeft een nu een optie om naar het home scherm te gaan.
    • API kan nu worden aan of uitgezet, let op standaard staat deze nu uit dit was aan.
    • Schermen in de user interface zijn te activeren of deactiveren.
    • Weer informatie toegevoegd. Let op de weer informatie wordt alleen zichtbaar na het invoeren van een API key die gratis na aanmelden verkregen kan worden op http://openweathermap.org
    • HTML fouten verwijderd en javascript upgrades.
    • Password reset is nu mogelijk zonder reset van de Raspberry Pi en is persistent bij een reboot.
    • Wachtwoord sterkte check toegevoegd deze moet nu minimaal 1 positie lang zijn.
    • Rate limiting toegevoegd voor smart meters die sneller dan 1 maal per 10 seconden een telegram sturen.
    • V2 API geeft nu alleen gehele getallen, zonder decimalen.
    • Security updates tot met 22-10-2017.
    • Standaarde wachtwoord is: p1mon deze bij het eerste gebruik aanpassen!

     

    Wat is er veranderd in versie 0.6.3

    • Gasmeting aangepast zodat ook de meting met de telegramcodes 0-1:24.2.1 wordt verwerkt.  Tot en met versie 0.6.2 werd alleen 0-1:24.3.0 verwerkt.
    • Security updates uitgevoerd tot 26-8-2017.
    • MD5  hash: 60B1CAC7303818EE528E8CDB60408D40

     

    Wat is er veranderd in versie 0.6.2 (niet meer ondersteund):

    • Logging van gas waarde slimme meter niet gevonden verminderd naar debug level waardoor er minder naar de log files wordt geschreven.
    • Kosten tooltip aangepast waardoor alleen positieve waarden worden weergegeven en kosten of opbrengsten (geld terug 🙂 )
    • Tooltip text layout aangepast waardoor deze beter wordt weergegeven.
    • Gas geleverd tekst aangepast naar gas verbruikt (bedankt Willem).
    • Security updates uitgevoerd tot 16-8-2017.
    • MD5 hash: 5C71B10300D809BA7EB72A2D6D084C44

    Wat is er veranderd in versie 0.6.1 (niet meer ondersteund):

    • Kleine bugs zijn opgelost.
    • Het overzicht van verbruik van elektriciteit is uitbreidt met terug levering.
    • Gas meting slimme meter is toegevoegd.
    • Het voorspelingsscherm is verwijderd.
    • In het kostenoverzicht zijn de kosten voor het gebruik van gas toegevoegd.
    • In de setup kan het vastrecht en gebruikstarief van gas worden ingesteld.
    • De API is uitgebreid met de gas verbruik waarde (versie 2 van de API, versie 1 wordt nog steeds ondersteund.
    • pi, p1mon wachtwoorden zijn aangepast, het root account van de PI is te gebruiken met het wachtwoord “toor”. Advies is om deze aan te passen.  Howto.
    • File systems zijn aangepast en maken meer gebruik van ram om slijtage van de flash card te beperken.
    • Security updates uitgevoerd tot 22-07-2017.

Tools

P1 monitor voor de Orange Pi hardware

P1 monitor voor de Orange Pi hardware

nh-networks heeft een port gemaakt van de P1 monitor voor de Orange Pi hardware.  Er is een port nodig omdat de Orange Pi andere hardware gebruikt dan de Raspberry Pi.  Mocht je interesse hebben in deze variant dan kun je die bij nh-networks.nl vinden.

Ter informatie, ztatz.nl heeft geen invloed op de kwaliteit of werking van deze versie. Mocht je vragen hebben dan is het advies die aan nh-networks.nl te stellen.

P1 monitor importeren van data

P1 monitor importeren van data

Het importeren van gebruiksgegevens is (nog) geen optie van de P1 monitor.  Er zijn op dit moment twee manieren om min of meer veilig de data in de database te laden.  Beide hebben voor en nadelen afhankelijk van de situatie.  Optie een is een hack op de import en exportfunctie, optie twee is gebruik maken van een sqllite database editor.

Voordat je wijziging doorvoert is het verstandig om een export te maken en deze veilig te stellen mocht er iets mis gaan.

1:  in en export functie gebruiken. De export functie doet niet anders dan een verzameling van SQL commando’s aanmaken met alle data daarin. Als de data in het exportfile wordt aangepast dan kan de data met de import functie worden geladen.  Het is niet ingewikkeld maar het is handig als je iets enige SQL kennis hebt. Het voordeel van deze manier is dat de p1 monitor blijft draaien en dat je geen nieuwe data moet missen.  Aanpak:

  • Maak een export van uit de p1 monitor
  • Pak het export zip file uit zodat er een (onder Windows met de optie Extract All) in dit voorbeeld heet het file test.zip.
  • Open de uitgepakte folder ???\test\p1mon\export. Daar staan de volgende files in:
    • historiexxxxx (de gas en e-waarde historie)
    • finacieelxxxxx.  (de financiële gegevens)
    • 01_weer_historiexxxxx (weer historie)
    • Configuratie (configuratie, het is beter deze niet te wijzigen tenzij je weet wat je doet)
    • weerxxxxxx (huidige weer informatie)
  • Bekijk de bestanden om te zien wat je wil aanpassen, bestanden die je niet wil aanpassen kun je verwijderen.
  • In dit voorbeeld ga ik ervan uit dat je alleen historiexxxxx (de gas en e-waarde historie) wil aanpassen. Dus alle andere bestanden kunnen dan weg.
  • Open het historie bestand met een tekst editor (write, notepap++) het maakt niet uit als het maar een platte tekst editor is Word kan ook maar dan moet je het bestand opslaan als ascii tekst bestand.
  • Je mag alle regels in het bestand laten staan of alles weghalen. Het SQL commando “replace into e_history_min (TIMESTAMP….  “  Vervangt het bestaande record in de database, het kost dan alleen meer tijd bij de import.
  • In dit voorbeeld nemen we een regel en alle andere regels worden verwijderd.
  • replace into e_history_min (TIMESTAMP, VERBR_KWH_181, VERBR_KWH_182,GELVR_KWH_281, GELVR_KWH_282, VERBR_KWH_X, GELVR_KWH_X,TARIEFCODE,ACT_VERBR_KW_170,ACT_GELVR_KW_270, VERBR_GAS_2421) values (‘2018-02-21 00:02:00′,’9296.694′,’9340.233′,’664.965′,’1756.033′,’0.00300000000061′,’0.0′,’D’,’0.21′,’0.0′,’0.0′);
  • Als je in deze regel de minuut waarde wil aanpassen va 9296.694 naar 8000.00 pas dit dan aan. Dit kun je net zo lang herhalen met extra records of 1 net wat je nodige hebt.
  • Pak de folder structuur weer in (maak er een zip file van)
  • Importeer het bestand.

2:  sqlite database editor.

Met de database editor zoals (http://sqlitebrowser.org/) kun je de via een eenvoudige gebruikersinterface de database inhoud te kunnen bewerken. Echter om de data te kunnen bewerken moet de database niet door de P1 monitor worden aangepast.

  • Eerst moet de P1 monitor worden gestopt en de rechten op het database bestand worden aangepast. In dit voorbeeld wordt de historie database gebruikt.
  • Ga naar het setup menu -> bestanden -> data. Maakt het mogelijk op via samba/file share de bestanden te kopiëren naar je pc. Kopieer het bestand e_historie.db
  • Log in op de P1 montor als root (wachtwoord toor of nog beter je hebt het wachtwoord aangepast). Gebruik hiervoor putty.
  • cd /p1mon/scripts
  • ./p1mon stop (duur even)
  • cd p1mon/mnt/ramdisk
  • mv e_historie.db e_historie.db.old
  • cd /p1mon/data
  • cp e_historie.db e_historie.db.old (dit is een veiligheids kopie)
  • chmod a+rw e_historie.db (dit is nodig om als de versie van de database op je pc is aangepast weer terug te kunnen schrijven).
  • Open het e_historie.db bestand met sqlite database editor en pas dit aan zoals je wilt.
  • Kopier het het e_historie.db terug naar de p1 via samba.
  • Log in op p1 montor.
  • cd /p1mon/scripts
  • ./p1mon start
  • Nu moet alles weer werken inclusief de aanpassingen.
P1 monitor update 0.6.1 (Jilles)

P1 monitor update 0.6.1 (Jilles)

P1 monitor is op de Raspberry PI 3 gebaseerde software om je slimme meter uit te lezen. Voor een meer uitgebreide beschrijving zie hier.

Wat is er veranderd:

  • Kleine bugs zijn opgelost.
  • Het overzicht van verbruik van elektriciteit is uitbreidt met teruglevering.
  • Gas meting is toegevoegd.
  • Het voorspelingsscherm is verwijderd.
  • In het kostenoverzicht zijn de kosten voor het gebruik van gas toegevoegd.
  • In de setup kan het vastrecht en gebruikstarief van gas worden ingesteld.
  • De API is uitgebreid met de gas verbruiks waarde (versie 2 van de API, versie 1 wordt nog steeds ondersteund.
  • pi, p1mon wachtwoorden zijn aangepast, het root account van de PI is te gebruiken met het wachtwoord “toor”. Advies is om deze aan te passen.  Howto.
  • File systems zijn aangepast en maken meer gebruik van ram om slijtage van de flash card te beperken.
  • Security updates uitgevoerd tot 22-07-2017.

Upgrade of eerst installatie.

De software verkrijgen en installatie.

De P1 monitor software wordt geleverd als Raspberry Pi 3 B SDHC 8GB image. Die hieronder te downloaden is. Om de het image naar een SDHC card te kopiëren is een image tool nodig als je deze niet hebt dan kun je USB Image tool downloaden.

Mocht je een eerdere versie van de P1 monitor gebruiken exporteer dan deze data eerst!

  1. download het P1 monitor image file uit de download overzicht hieronder.
  2. pak het zip file uit en lees de leesmij.txt
  3. kopieer het p1mon_061.img file via de USB tool naar de 8GB SDHC card. Let op! data op de card wordt overschreven en is niet meer te herstellen.
  4. plaats de SDHC card in de Pi.
  5. start de Pi, netwerk en P1 kabel aangesloten.
  6. Importeer de data.

Veel plezier met de P1 monitor en laat weten hoe het bevalt.

Download de laatste versies hier

download

 

Send email secure (or not)

Send email secure (or not)

Email is send with the Simple Mail Transfer Protocol ( SMTP ). It was invented back in the day (1982) when the Internet was run by people with the best intentions and de security was not needed or perceived not necessary. When you are sending an email the text, headers, email addresses, etc. are send over the Internet in plain-text (human readable). See http://www.freesoft.org/CIE/RFC/821/31.htm for an example.

Anyone that has access to the data stream (free WiFi is not your friend) can in theory read your emails. Not a save way of using email. What we need is a solution that will hide your emails from prying eyes. Cryptography to the rescue!

Most modern email providers like Gmail support Transport Layers (TLS). TLS encrypts all the network traffic making it unintelligible. TLS email is called STARTLS and is negotiated between de mail client and mail server. Normally a user cannot choose to use STARTTLS. It the mail server (administrator) to decide how to handle the SMTP traffic. Because of the move of the Internet to encrypt everything it will be a matter of time of STARTTLS will be the normal way of sending email.

To check if an email server supports TLS (STARTTLS) you can use the TLS check script tlschk (script below) Linux script.

# tslchk -d schiphol.nl
TLS check for SMTP server for domain schiphol.nl, hang on this could take a while....
schiphol-nl.mail.protection.outlook.com. version is TLSv1.2
email4.schiphol.nl. version is not available or TLS not supported
email5.schiphol.nl. version is not available or TLS not supported
domain schiphol.nl ready.

When an TLSVx.x answer is returned STARTTLS (TLS) is supported.

#!/bin/bash
# nslookup & openssl must be installed!
OPTIND=1 # Reset in case getopts has been used previously in the shell.
DOMAINNAME=""
PRGNAME=${0##*/}

function showHelp {
	echo $PRGNAME" -d <mail domain>"
	echo "Example: "$PRGNAME" -d gmail.com "
}

while getopts "h?d:" opt; do
    case "$opt" in
    h|\?)
        showHelp
        exit 0
        ;;
    d)  
	DOMAINNAME=$OPTARG
        ;;
    esac
done

shift $((OPTIND-1))

[ "$1" = "--" ] && shift

if [ -z "${DOMAINNAME}" ]; then
	showHelp
	exit
fi

# tell what domain that will be checked
echo "TLS check for SMTP server for domain "$DOMAINNAME", hang on this could take a while...."
# find MX record, used first one that we find.
MXLIST=$(nslookup -query=mx $DOMAINNAME | grep $DOMAINNAME |cut -d ' ' -f5)

for mxrec in $MXLIST
do
	#echo "checking MX record "$mxrec
	OUTPUT=$(echo "Q"|openssl s_client  -starttls smtp  -crlf -connect $mxrec:25 2>/dev/null | tr -d ' '| grep Protocol: | cut -d ':' -f2)
	if [ -z "${OUTPUT}" ]; then
		echo $mxrec" version is not available or TLS not supported"
	else 
		echo $mxrec" version is "$OUTPUT
	fi
done
echo "domain "$DOMAINNAME" ready."

Download

[download id=”310″]

P1 monitor

P1 monitor

P1 monitor is op de Raspberry PI 3 gebaseerde software om je “slimme” meter uit te lezen. De slimme meter heeft een zogenaamde P1 poort/aansluiting waar elke 10 seconden de laatste waarden uit te lezen zijn. Als je huidige en historisch elektriciteit verbruik wil meten dan is P1 monitor de oplossing voor je. Hieronder een simpel schema hoe de P1 monitor werkt.

P1 monitor principe
P1 monitor principe

Gebruik

P1 monitor heeft een aantal schermen waar de huidige en historische waarden zijn te raadplegen en een scherm waar zaken als de tarieven elektriciteit en andere gegevens ingevoerd worden. De meeste schermen verklaren zichzelf, onderstaande afbeeldingen geven een impressie.

ACTUEEL VERBRUIK

Geeft aan welk elektrisch vermogen er wordt gebruikt (links boven), het vermogen van vandaag en de kosten. Onderin wordt het actuele verbruik van de laatste 4 uur weergegeven.

Actuele verbruik

HOME

Dit scherm geeft zowel het verbruik als het geleverd vermogen weer. Het geleverd vermogen is met name interessant voor als er zelf elektriciteit opwekt met bijvoorbeeld zonnepanelen.

Verbruik en geleverd vermogen zijn identiek qua lay-out. De meter geeft aan wat het huidige vermogen is wat wordt verbruikt of terug geleverd. Met een zon of maan symbool wordt aangeven of piek of dal tarief van de leverancier van toepassing is. Het klok en pijl omhoog symbool geven aan hoeveel en op welke moment van de dag maximaal vermogen is geleverd of verbruikt. Totaal vandaag geeft het aantal verbruikte kWh per dag en de kosten van die dag. Daaronder wordt met een grafiek met een interval van 10 sec (maximale mogelijkheid van de slimme meter) de laatste 10 minuten weergegeven.

Home pagina
Home

GRAFIEK

Dit overzicht geeft met de kleuren geel het verbruikte vermogen weer en met de kleur groen het terug geleverde vermogen. Er kan via de vooringestelde intervallen linksboven worden ingezoomd. Er kan tevens met de horizontale scrollbar een vrij in te stellen interval worden gekozen. Daarnaast kan met de optie rechtsboven gekozen worden of alleen verbruikte vermogen of geleverd vermogen worden gekozen of beide. Er kan voor minuten, uren, dagen, maanden of jaren worden gekozen. Hieronder de minuten screenshot.

Schreenshot minuten scherm.

Screenshot dagen: alle grafieken hebben een pop up als met de muis over een grafiek element wordt bewogen (zweven met de muis).

Screenshot dagen.

Screenshot: maanden, geleverd vermogen is uitgeschakeld.

Screenshot maanden
Screenshot maanden.

FINANCIEEL

De werking van de financiële overzichten is gelijk aan die van de grafieken maar geeft aan wat de kosten of opbrengsten zijn van per dag, maand of jaar.

Screenshot financieel
Screenshot financieel.

INSTELLINGEN

Met deze pagina kunnen parameters worden ingesteld voor het gebruik. De TARIEVEN ELEKTRICITEIT zijn de kWh prijzen zonder het vastrechtgedeelte van de elektriciteit. Deze kan in het vakje vastrecht worden opgevoerd.

SYSTEEM kan worden gebruikt om de P1 monitor te herstarten of te stoppen. Bij het stoppen of herstarten wordt er zeker gesteld dat alle gegevens vanuit het geheugen naar de SD-card worden geschreven. Het herstarten door de voeding uit de Raspberry Pi te halen kan ook maar kan tot data verlies leiden.

Met BESTANDEN DELEN kan toegang gekregen worden via SAMBA naar alle bestanden of alleen de databestanden. Normaal staat deze uit maar als er een back-up wil maken dan kan de optie Database worden gekozen. Als alternatief kan de exportfunctie worden gebruikt.

P1 POORT SLIMME METER: De P1 poort kan gebruik maken van andere instellingen per netbeheerder. Zie de pop-up in de user interface (UI) voor bekende waarden.

EX -/IMPORTEREN GEGEVENS met export worden alle gegevens uit de SQLite database naar SQL statements in een zip file weggeschreven. Het exporteren is primair bedoeld om de gegevens veilig te stellen als er een nieuwe versie van P1 monitor uitkomt. Importeren is bedoeld voor het inlezen en werkt alleen met een P1 monitor exportfile.

NETWERK INSTELLINGEN maakt het mogelijke Wi-FI met WPA te gebruiken het wordt echter aanbevolen een bedraad netwerk te gebruiken.

API er is een beperkte API beschikbaar die de huidige gegevens in JSON kan aanleveren voor bijvoorbeeld een domotica product als de FIBARO Home Center 2.

Screenshot instellingen
Screenshot instellingen

 

INFORMATIE

Dit scherm geeft diverse zaken weer over de werking (of als het tegen zit het niet werken) van de P1 monitor.

DATABASE: Er wordt gebruikt gemaakt van een SQLite database. Die in diverse bestanden (databases) de huidige en historische gegevens bijhoudt. De database draait in RAM omdat dit sneller is en de SDHC kaart er minder snel van slijt (lees stuk gaat). Om te voorkomen dat de gegevens verloren gaan wordt er periodiek (minimaal binnen 15 min) een kopie van de RAM-database naar de SDHC kaart geschreven. Dit gaat volledig automatisch.

P1 POORT STATUS: deze geeft aan of er gegevens uit de P1 te lezen zijn. Als erg geen gegevens kunnen worden gelezen dat wordt dit aangeven. Op PC’s wordt tevens een geluidsignaal afgegeven.

PROCESSEN: De P1 monitor heeft drie primaire programma’s draaien die zorgen dat gegevens tijdig gelezen worden, een database en een bewakingsprogramma die diverse huishoudelijke zaken uitvoert.

SYSTEEM: tijd sinds de laatste (her)start, besturingssysteem versie, de Python versie die gebruikt wordt en de versie van P1 monitor.

NETWERK: diverse zaken die netwerk gerelateerd zijn, zoals is er Internet toegang (belangrijk voor de juiste tijd) en de IP-adressen van het vaste en eventuele Wi-Fi netwerk.

SLIMME METER: hier is te zien wat de ruwe gegevens zijn uit de slimme meter (elke 10 seconden aangepast). Processor, database en geheugen belasting geven respectievelijke weer hoe druk de processor is, hoeveel ruimte de database in beslag neemt en hoeveel RAM geheugen er in gebruik is.

Screenshot informatie
Screenshot informatie

Wat heb ik nodig en wat zijn de kosten

Het goede nieuws is de P1 monitor software is gratis (zie Juridisch spul en zo).

  • Raspberry Pi 3 B Starter Kit compleet, gezien voor 59 euro, de Pi, SDHC card 8Gb, Voeding, netwerk kabel en behuizing.
  • De P1 kabel kost ongeveer 20 euro, even googelen op “p1 kabel slimme meter”.  Ik geef  de voorkeur aan kabels gebaseerd op de  FT232R chip.
  • Het spreekt vanzelf dat je een slimme meter moet hebben. Indien er nog geen slimme meter  is geplaatst kan deze worden aanvraagt bij de netbeheerder en deze wordt geplaatst voor ongeveer 70 euro (zie de website van uw netbeheerder) of even geduld  hebben en wachten tot de netbeheerder deze gratis komt plaatsen.

Juridisch spul en zo

Creative Commons-Licentie

Dit werk valt onder een Creative Commons Naamsvermelding-NietCommercieel 4.0 Internationaal-licentie.

De rechten van onderliggende softwareproducten zijn qua licentierechten niet gewijzigd Dit geldt voor bijvoorbeeld het besturingssysteem en javascript bibliotheken. De rechten van onderliggende producten gaan voor deze licentie.

DE SOFTWARE IS GELEVERD “ZOALS”, ZONDER GARANTIE VAN ENIGE SOORT, INCLUSIEF MAAR NIET BEPERKT OP DE GARANTIES VAN VERKOOPBAARHEID, GESCHIKTHEID VOOR EEN BEPAALD DOEL. IN GEEN GEVAL ZAL HET AUTEURS OF COPYRIGHT HOLDERS AANSPRAKELIJK ZIJN VOOR ENIGE EISEN, SCHADE OF ANDERE AANSPRAKELIJKHEID IN VERBAND MET DE SOFTWARE OF HET GEBRUIK VAN DE SOFTWARE.

Samengevat: gebruik is voor eigen risico.

De software verkrijgen en installatie.

De P1 monitor  software wordt geleverd als Raspberry Pi 3 B  SDHC 8GB image.  Die hieronder te downloaden is. Om de het image naar een SDHC card te kopiëren is een image tool nodig als je deze niet hebt dan kun je USB Image tool downloaden.

  1. Download het P1 monitor image file hier,
  2. Pak het zip file uit en lees de leesmij.txt
  3. kopieer het p1monYYYYMMDD.img file via de USB tool naar de lege 8GB SDHC card. Let op! data op de card wordt overschreven en is niet meer te herstellen.
  4. Sluit de Raspberry Pi aan op het netwerk via de kabel en plaatst de P1 kabel in een van de USB poorten.
  5. Sluit de RJ11 stekker aan op slimme meter (kleine stekker aan de P1 kabel)
  6. Sluit de voeding aan op de Raspberry PI. Na ongeveer 1 minuut zal de Raspberry PI gereed zijn voor gebruik. Bij gebruik van een Raspberry PI kan het starten wat langer duren.
  7. Nu komt het lastig stuk, het IP adres achterhalen van de P1 monitor. De meeste thuisnetwerken werken met het automatisch uitgeven van IP adressen. via DHCP als je toegang tot je Internet router hebt van Ziggo, Kpn dan kun je daar het adres vinden van de P1 monitor.  Als alternatief kun je zoekP1monitorW64  downloaden. Het kan zijn dat je virusscanner het bestand niet vertrouwd. Als tweede alternatief kun je een netwerkscanner tooltje voor je mobiel gebruiken als Fing – Network Tools van Domotz Ltd (Google is je vriend).
  8. Vul het IP adres is in de browser naar keuze. http://<het ipadress>

Veel plezier met de P1 monitor en laat weten hoe het bevalt.

Download de laatste versies hier

download

Certificate Authority Authorization (CAA) cometh

Certificate Authority Authorization (CAA) cometh

DNS Certification Authority Authorization (CAA) Resource Record are defined in RFC6844 since January 2013. The goal of the CAA record is to give the ability to a CA to check if the CA may issue a CA certificate.

Abstract from RFC6844

The Certification Authority Authorization (CAA) DNS Resource Record allows a DNS domain name holder to specify one or more Certification Authorities (CAs) authorized to issue certificates for that domain. CAA Resource Records allow a public Certification Authority to implement additional controls to reduce the risk of unintended certificate mis-issue.

On March 8 the CA Browser forum voted in favor of the rule that CAA RR records are mandatory for certificate authorities, effective from September 2017 all certificate authorities must implement CAA record checking.  Until  September 2017 checking and using CAA records where optional.

Ballot 187 – Make CAA Checking Mandatory

This option gives domain owners more security.  If a domain owner fails to put in CAA records any CA can issue a certificate for the domain. This is a bad thing.  Not adding a CAA record is a bad idea and not taking security responsibility.

Dns Spy logo
DNS SPY

Checking if your domain has CAA records can easily done by using dnsspy. Check google.com to see the support for the Google and Symantec CA’s.

0 issue “pki.goog”
0 issue “symantec.com”

Browser suppliers can use CAA to check the website certificate to verify the authenticity. Google planned to require Certificate transparency starting in October 2017 but has moved the compliance date to April 2018.

We’ve been making excellent progress towards our goal of robust Certificate Transparency deployment for all publicly trusted certificates — and we also have new opportunities to improve Certificate Transparency and Chrome to better serve the Internet ecosystem. I’m pleased to announce that we’ll be moving forward with our plan to require Certificate Transparency for all newly issued, publicly trusted certificates starting in April 2018.

Go ahead make the Internet a safer place and add CAA records to your DNS servers.

Python Internet availability

Python Internet availability

This Python code snippet gives you a solution when you need to check if your Python application can reach the Internet.  You can always check if an Internet website is responding with urllib.request.urlretrieve.  For instance, www.google.com.  I have found this is not always reliable or even lock up the program.

A more reliable method is pinging one or more public DNS servers.  This snippet is a Python 3 function that does just that.  The function checks at random the set of DNS servers in the ‘li’ list and return ‘1’ when a DNS server responds or ‘0’ when all  DNS severs fail.

function

import random
import os
import socket
import subprocess

def getInternetStatusByDnsServers():
    r = ‘0’
    li = ["8.8.8.8",\
    "8.8.4.4",\
    "209.244.0.3",\
    "209.244.0.4",\
    "208.67.222.222",\
    "37.235.1.174",\
    "91.239.100.100"\
    ]

    random.shuffle(li)
    for i in range(len(li)):
       try :
           hostname = li[i]
           p = subprocess.Popen(["/bin/ping", "-c1", "-W1", hostname], stdout=subprocess.PIPE).stdout.read()
           for item in str(p).split("\n"):
               if "0% packet loss" in item:
                   return ‘1’
        except Exception as inst:
            print(type(inst))
            print(inst.args)
            print(inst)
    return r