Month: August 2018

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 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.

LET OP DEZE PAGINA BEVAT GEEN DOWNLOAD MEER!

Upgrade of eerst installatie.

De software verkrijgen en installatie.

De P1 monitor software wordt geleverd als Raspberry Pi 3 B SDHC image 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

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

 

BESCHRIJVING OUDE VERSIES

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 login scherm 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.

Dit is niet de laatst versie deze staat als eerste artikel op de site. Voor historische versies zie hier.


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