Vejrstation del 3

Diagrammer og software

Diagrammerne er ret simple.

Først diagrammet over målecomputeren, der håndterer diverse følere.

Diagram over måleenhed

De to kredse til højre er diagrammet over FTDI interface, der bruges til at enten kommunikere med enheden eller reprogrammere den. Denne del har jeg to versioner af, da der opstår lidt bøvl med kommunikationen hvis der ikke laves en lille ændring. Der sker, det at DTR går lav når python eller andet software vil kommunikere med en arduino. Dette skal den iflg. rs232 protokollen, men det gør desværre at en arduino genstarter, da den ser det som om at den skal programmeres. For at undgå dette afbrydes DTR når enheden benyttes som vejrstation.
Seriel kommunikation fungerer heldigvis fint uden DTR.
Hvis der skal lægges rettelser på, skal DTR reetableres for at man kan overføre ny software.

Herunder er koden til målecomputeren.

#include <Arduino.h>
#include <dhtnew.h>

#include <Adafruit_Sensor.h>
#include <Adafruit_BMP280.h>
#include <Wire.h>
#include <Adafruit_Sensor.h>

// put function declarations here:
// 
float getTempIn(void);
float getTempOut(void);
float getPress(void);
float getOutHumid(void);
void  rainInt(void);
void  rollRain(int);
float getRain5(void);
float getRain(void);

//Constants
#define DHTPIN 5
#define RAINPIN 2

// Init temp/hum sensor
DHTNEW outdoorSensor(DHTPIN);

#define OUTTEMP_ADJUST  -1.16
#define INTEMP_ADJUST   -1.58

// Init pressure sensor
Adafruit_BMP280 bmp;

// Variable
float tryk;
float indetemp;
String cmd = "";
volatile int rain = 0;
volatile unsigned long pulseTime = millis();
volatile unsigned long lastPulseTime = pulseTime;
int rain5 = 0;
unsigned long nuTid;
unsigned long tid;
float VIPFAKTOR = 0.408;
int minRain[5] = {0, 0, 0, 0, 0};

void setup() {
  Serial.begin(9600);
	Serial.println("Klargør hardware");
  Serial.println();

  // trykmaaler
  while (!bmp.begin(0x76)) {
    Serial.println("Kunne ikke finde BMP280!!!");
    delay(5000);
  }

  bmp.setSampling(Adafruit_BMP280::MODE_NORMAL,     /* Operating Mode. */
                  Adafruit_BMP280::SAMPLING_X2,     /* Temp. oversampling */
                  Adafruit_BMP280::SAMPLING_X16,    /* Pressure oversampling */
                  Adafruit_BMP280::FILTER_X16,      /* Filtering. */
                  Adafruit_BMP280::STANDBY_MS_500);  /* Standby time. */
  Serial.println("BMP280 klar");

  // Setup interrupt for regnmåler
  pinMode(RAINPIN, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(RAINPIN), rainInt, FALLING);
  Serial.println("Interrupt klar");

  Serial.println("Vejrstation klar");
  nuTid = millis();
}

void loop() {
  // Seriel kommunikation
  // --------------------
  if ( Serial.available() ) {
    cmd = Serial.readStringUntil('\n');
  
    cmd.trim();
    if ( cmd.equalsIgnoreCase("getTempIn")) {
      //Serial.print("Inde Temperatur ");
      Serial.println(getTempIn());
    } 
    else if ( cmd.equalsIgnoreCase("getTempOut")) {
      //Serial.print("Ude Temperatur ");
      Serial.println(getTempOut());
    } 
    else if ( cmd.equalsIgnoreCase("getPress")) {
      //Serial.print("tryk ");
      Serial.println(getPress());
    } 
    else if ( cmd.equalsIgnoreCase("getOutHumidity")) {
      //Serial.print("ude luftfugtighed ");
      Serial.println(getOutHumid());
    }
    else if ( cmd.equalsIgnoreCase("getRain5")) {
      Serial.println(getRain5());
    }
    else if ( cmd.equalsIgnoreCase("getRain1")) {
      Serial.println(getRain());
    }
    else {
      //Serial.print("Ukendt kommando: ");
      Serial.println("?: " + cmd);
    }
  }

  // Regnmåler 
  // ---------
  tid = millis();
  if (tid >= nuTid + 60000) {
    rollRain(rain);
    rain = 0;
    nuTid = tid;
  }

}

float getRain5(void) {
  int i;
  int rain5 = 0;
  float mm;
  for (i=0; i<5; i++){
    rain5 += minRain[i];
    // Serial.println(minRain[i]);
  }
  mm = rain5 * VIPFAKTOR;
  return mm;
}

float getRain(void) {
  float mm;

  mm = minRain[4] * VIPFAKTOR;
  return mm;
}

void rollRain(int r1){
  int i;
  rain5 = 0;
  // sum 5 min regn
  for (i = 0; i < 5; i++) {
    rain5 += minRain[i];
  }

  // rul rain5
  for (i = 1; i < 5; i++) {
    minRain[i - 1] = minRain[i];
  }
  minRain[4] = r1;
}

void rainInt(void) {
  pulseTime = millis();
  if (pulseTime - lastPulseTime > 5000) {
    rain++;
  } else {
    rain = 0;
  }
  lastPulseTime = pulseTime;
}

float getTempIn(void){
  float indetemp;
  indetemp = bmp.readTemperature() + INTEMP_ADJUST;
  return indetemp;
}

float getTempOut(void) {
  float udeTemp;
  outdoorSensor.read();
  udeTemp = outdoorSensor.getTemperature() + OUTTEMP_ADJUST;
  return udeTemp;
}

float getOutHumid(void) {
  float hum;
  outdoorSensor.read();
  hum = outdoorSensor.getHumidity();
  return hum;
}

float getPress(void){
  tryk = bmp.readPressure()/100+4.4;
  return tryk;
}

Det enester der er lidt specielt er:
void rainInt(void) {
pulseTime = millis();
if (pulseTime – lastPulseTime > 5000) {
rain++;
} else {
rain = 0;
}
lastPulseTime = pulseTime;
}

Dette er interrupt rutinen. Den tæller op, når der kommer en puls fra regnmåleren, medmindre der er gået under 5 sekunder mellem to pulser. Dette ses som støj og der tælles ikke op.

Diagram over displayenheden

Igen et meget simpelt kredsløb. Alt kommunikation med denne enhed er via et web kald.

Herunder koden:

#include <Arduino.h>

/*


  U8G2_SSD1306_128X64_NONAME_1_4W_HW_SPI u8g2
  make -f Makefile.184.uno

   text
   8732	    					default, all active
   8500	    -232	    -2.65%		no U8G2_WITH_CLIP_WINDOW_SUPPORT
   8316	    -416	    -4.76%		no U8G2_WITH_FONT_ROTATION
   8606	    -126	    -1.44%	 	no U8G2_WITH_UNICODE
   8692	    -40	    -0.45%		no U8G2_WITH_INTERSECTION
   8328	    -404	    -4.62%	  	no U8G2_WITH_INTERSECTION  no U8G2_WITH_CLIP_WINDOW_SUPPORT
   8718	    -14	    -4.86%		no U8G2_WITH_HVLINE_SPEED_OPTIMIZATION
   8026	    -706	    -8.08%		no U8G2_WITH_FONT_ROTATION   no U8G2_WITH_INTERSECTION  no U8G2_WITH_CLIP_WINDOW_SUPPORT

   Some flags depend on each other: `U8G2_WITH_INTERSECTION` is required for `U8G2_WITH_CLIP_WINDOW_SUPPORT`, so `U8G2_WITH_INTERSECTION` is partly active as long
   as `U8G2_WITH_CLIP_WINDOW_SUPPORT` is requested.

*/

#include <Arduino.h>
#include <U8g2lib.h>
#include <WiFi.h>
#include <HTTPClient.h>
#include <Arduino_JSON.h>
#include <OneWire.h>
#include <DallasTemperature.h>

#ifdef U8X8_HAVE_HW_SPI
#include <SPI.h>
#endif
#ifdef U8X8_HAVE_HW_I2C
#include <Wire.h>
#endif

#define FALSE 1
#define TRUE 0
const int ONEWIREPIN = 4;

// init oled
//U8G2_SH1106_128X64_NONAME_F_HW_I2C oled(U8G2_R0, /* reset=*/U8X8_PIN_NONE);
//U8G2_SSD1309_128X64_NONAME2_F_HW_I2C oled(U8G2_R0, /*reset=*/U8X8_PIN_NONE);
U8G2_SSD1309_128X64_NONAME0_F_HW_I2C oled(U8G2_R0, /*reset=*/U8X8_PIN_NONE);

// init onewire og sensor
OneWire oneWire(ONEWIREPIN);
DallasTemperature indeSensor(&oneWire);

// WiFi setup
const char *ssid = "DIN_SSID";
const char *password = "SSID_PASSWORD";

// URL for vejrdata
const char *vejrDataURL = "URL_for_data";

JSONVar udeTemp = "-99.99";
JSONVar indeTemp = "-99.99";
JSONVar regn1 = "-99.99";
JSONVar regn24 = "-99.99";
JSONVar regn15 = "-99.99";
JSONVar humid = "-99.99";
JSONVar tryk = "-9999.99";
JSONVar tidString = "--";

unsigned JsonOk = FALSE;
int dispNr = 0;

unsigned long sidsteTid = millis(); // Web Refresh
unsigned long tid = 0;              // Tid nu
unsigned long dTid = millis();      // Display Refresh
const long interval = 60000;
const long webInterval = 60000;
const long dispUpdate = 5000;
unsigned int wifiOk = FALSE; // 1 = notok 0 = ok
const int cpuSpeedSaving = 80;
int strLen = 0;
int strPos = 0;
int pxStart = 0;
int nLen = 0;
int firstRead = 1;
int hour = 0;
int minUr = 0;
String vString = "";
String tekst = "";
String enhed = "";
String maalinger = "";
String sysTid = "";
float ut = 999.9;
float it = 999.9;
float r1 = 999.9;
float r15 = 999.9;
float r24 = 999.9;
float h = 999.9;
float p = 999.9;
char buffer[30];
char ur[5];

float vaerdi = 0.0;

// funtioner deklarationer
void displayRSSI(void);
String httpGETRequest(const char *serverName);
void dispData(String, JSONVar, String);
void dispBullet(int);

void setup(void)
{
  setCpuFrequencyMhz(cpuSpeedSaving);
  delay(500);
  // seriel baud rate
  Serial.begin(115200);
  // oled display
  oled.begin();
  // Temp sensor
  indeSensor.begin();

  // Wifi
  //WiFi.hostname("espWeather");
  WiFi.begin(ssid, password);

  Serial.print("CPU speed: ");
  Serial.println(getCpuFrequencyMhz());
  Serial.println("Forbinder");
  while (WiFi.status() != WL_CONNECTED)
  {
    delay(500);
    Serial.print(".");
  }
  // Set wifi sleep mode
  WiFi.setSleep(true);

  Serial.println("");
  Serial.print("Forbundet til WiFi med IP Adresse: ");
  Serial.println(WiFi.localIP());
  wifiOk = 0;
}

void loop(void)
{

  // Spørg efter data på webserver
  tid = millis();
  if (((tid - sidsteTid) > webInterval) || (firstRead == 1))
  {
    firstRead = 0;
    sidsteTid = millis();

    // Aflæs indesensor
    indeSensor.requestTemperatures();
    it = indeSensor.getTempCByIndex(0);
    Serial.printf("Inde temp: %.1f\n", it);

    // Tjek wifi
    if (WiFi.status() == WL_CONNECTED)
    {
      wifiOk = 0;
      maalinger = httpGETRequest(vejrDataURL);
      // Serial.println(maalinger);
      JSONVar vejrDataJson = JSON.parse(maalinger);
      if (JSON.typeof(vejrDataJson) == "undefined")
      {
        Serial.println("Fejl i modtagne JSON");
        JsonOk = FALSE;
      }
      else
      {
        JsonOk = TRUE;
        Serial.println(vejrDataJson);
        if (vejrDataJson.hasOwnProperty("systid"))
        {
          tidString = vejrDataJson["systid"];
          vString = JSON.stringify(tidString);
          hour = vString.substring(12, 14).toInt();
          minUr = vString.substring(15, 17).toInt();
          //Serial.println(hour);
        }
        if (vejrDataJson.hasOwnProperty("tryk"))
        {
          tryk = vejrDataJson["tryk"];
          vString = JSON.stringify(tryk);
          p = vString.toFloat();
        }
        if (vejrDataJson.hasOwnProperty("tempout"))
        {
          udeTemp = vejrDataJson["tempout"];
          vString = JSON.stringify(udeTemp);
          ut = vString.toFloat();
        }
        if (vejrDataJson.hasOwnProperty("rhout"))
        {
          humid = vejrDataJson["rhout"];
          vString = JSON.stringify(humid);
          h = vString.toFloat();
        }
        if (vejrDataJson.hasOwnProperty("r15min"))
        {
          regn15 = vejrDataJson["r15min"];
          vString = JSON.stringify(regn15);
          r15 = vString.toFloat();
        }
        if (vejrDataJson.hasOwnProperty("r1hour"))
        {
          regn1 = vejrDataJson["r1hour"];
          vString = JSON.stringify(regn1);
          r1 = vString.toFloat();
        }
        if (vejrDataJson.hasOwnProperty("r24hour"))
        {
          regn24 = vejrDataJson["r24hour"];
          vString = JSON.stringify(regn24);
          r24 = vString.toFloat();
        
        }
      }
    }
    else{
      wifiOk = 1;
    }
  }

  // Display data
  if (tid - dTid > dispUpdate)
  {
    dTid = millis();

    if (dispNr == 7)
    {
      dispNr = 0;
    }

    switch (dispNr)
    {
    case 0:
      vaerdi = ut;
      tekst = "Temp Ude i ";
      enhed = (String) char(176);
      dispNr++;
      break;

    case 1:
      vaerdi = it;
      tekst = "Temp inde i ";
      enhed = (String) char(176);
      dispNr++;
      break;

    case 2:
      vaerdi = h;
      tekst = "Luftfugtighed ";
      enhed = "%";
      dispNr++;
      break;

    case 3:
      vaerdi = p;
      tekst = "Tryk i ";
      enhed = "hPa";
      dispNr++;
      break;

    case 4:
      vaerdi = r15;
      tekst = "Regn 15 min ";
      enhed = "mm";
      dispNr++;
      break;

    case 5:
      vaerdi = r1;
      tekst = "Regn 1 t ";
      enhed = "mm";
      dispNr++;
      break;

    case 6:
      vaerdi = r24;
      tekst = "Regn 24 t ";
      enhed = "mm";
      dispNr++;
      break;

    default:
      break;
    }

    oled.clearBuffer();
    if ( hour >= 18 || hour <= 8 ) {
      oled.setContrast(1);
      Serial.printf("Lav kontrast");
    }
    else
    {
      oled.setContrast(255);
      Serial.println("Høj kontrast");
    }
    
    if (wifiOk == 1)
    {
      Serial.println("WIFI AFBRUDT");
      oled.setCursor(0, 30);
      oled.print("WiFi AFBRUDT");
    }
    
    // Skillelinie
    oled.drawHLine(0, 19, 128);
    
    // overskrift
    oled.setCursor(2, 15);
    oled.setFont(u8g2_font_t0_13b_te);
    Serial.println(tekst);
    oled.print(tekst);
    oled.printf("%s", enhed);

    // Vaerdi
    sprintf(buffer, "%.1f", vaerdi);
    strPos = 4 - (strlen(buffer) / 2);
  
    if ((strlen(buffer) % 2) == 1)
    {
      pxStart =  (strPos-1) * 17 + 8 ;
    }
    else
    {
      pxStart = strPos * 17 - 5;
    }
    oled.setCursor(pxStart, 50);
    oled.setFont(u8g2_font_timR24_tn);
    Serial.println(buffer);
    oled.print(buffer);
    
    // Ur
    oled.setCursor(2, 63);
    oled.setFont(u8g2_font_6x10_mn);
    //oled.setFont(u8g2_font_t0_13b_te);
    sprintf(ur, "%02d:%02d", hour, minUr);
    oled.print(ur);
    Serial.println(ur);

    // WIFI signal styrke
    displayRSSI();
    // display indikator
    dispBullet((dispNr-1));
    oled.sendBuffer();
  }
}

void displayRSSI(void)
{
  int rssi;

  rssi = WiFi.RSSI();
  // Serial.printf("RSSI: %d\n", rssi);

  // virkelig godt signal >= -32dBm
  if (rssi >= -48)
  {
    oled.drawHLine(119, 2, 8);
    oled.drawHLine(119, 3, 8);
  }

  // rimeligt signal >= -67dBm
  if (rssi >= -67)
  {
    oled.drawHLine(121, 6, 4);
    oled.drawHLine(121, 7, 4);
  }

  // dårligt signal >= 70dBm
  if (rssi >= -70)
  {
    oled.drawHLine(122, 10, 2);
    oled.drawHLine(122, 11, 2);
  }
  // røv signal < 70dBm
  if (rssi < -70)
  {
    oled.drawHLine(122, 10, 1);
  }
}

void dispBullet(int nr)
{
  int x = 125;
  int y;
  int i;
  int r = 2;

  for (i = 0; i <= 6; i++)
  {
    y = i * 6 + 25;
    if (i == nr)
    {
      // fyldt cirkel
      oled.drawDisc(x, y, r), U8G2_DRAW_ALL;
    }
    else
    {
      // Cirkel
      oled.drawCircle(x, y, r, U8G2_DRAW_ALL);
    }
  }
}

void dispData(String tekst, JSONVar vaerdi, String enhed)
{
  int strLen = 0;
  int strPos = 0;
  int pxStart = 0;
  String vString;

  // Ramme
  // oled.drawFrame(0, 0, 128, 64);

  // Værdi
}

String httpGETRequest(const char *serverName)
{
  WiFiClient client;
  HTTPClient http;

  // Your Domain name with URL path or IP address with path
  http.begin(client, serverName);

  // Send HTTP POST request
  int httpResponseCode = http.GET();

  String payload = "--";

  if (httpResponseCode > 0)
  {
    Serial.print("HTTP Response code: ");
    Serial.println(httpResponseCode);
    payload = http.getString();
  }
  else
  {
    Serial.print("Error code: ");
    Serial.println(httpResponseCode);
  }
  // Free resources
  http.end();

  return payload;
}

Ikke så meget hokus pokus over dette. Meget er “lånt” fra diverse tutorials deraf de engelske kommentarer.

Næste del, som kommer senere, vil kort beskrive serverdelen.