無線通信規格920MHz帯「Wi-SUN」を活用した気象ステーションの製作【第3回】

/*
  SPRESENSE-WISUN-EVK-701
  Copyright (c) 2019 ROHM Co.,Ltd.

  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files (the "Software"), to deal
  in the Software without restriction, including without limitation the rights
  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  copies of the Software, and to permit persons to whom the Software is
  furnished to do so, subject to the following conditions:

  The above copyright notice and this permission notice shall be included in
  all copies or substantial portions of the Software.

  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  THE SOFTWARE.
*/
//Weather station main program V1.0 by M.Ayatani 2022 4/4
#include <LowPower.h>
#include <SoftwareSerial.h>
#include <Watchdog.h>
#include "bp35c0-j11.h"
#include <Adafruit_MPL3115A2.h>
#include <Adafruit_AHTX0.h>
#include <BH1750_WE.h>
#define BH1750_ADDRESS 0x23
BH1750_WE myBH1750(BH1750_ADDRESS);
// You may also pass a TwoWire object like wire2
// BH1750_WE myBH1750(&wire2, BH1750_ADDRESS);
Adafruit_MPL3115A2 baro;
Adafruit_AHTX0 aht;
//Software Serial ports
const byte rxPin = 9;
const byte txPin = 10;
// set up a new serial object
SoftwareSerial WeatherSerial (rxPin, txPin);
//
const byte BATT = A2;
unsigned long exTime;
unsigned char state = 0 ;

void setup() {
  exTime = millis();
  // Initialize LowPower library
  LowPower.begin();
  LowPower.clockMode(CLOCK_MODE_32MHz);
  //Serial mode
  Serial.begin(115200);
  Serial.print("Clock mode= ");
  Serial.println(LowPower.getClockMode());
  //Software Serial mode
  WeatherSerial.begin(9600);

  if (!baro.begin()) {
    Serial.println("Could not find sensor. Check wiring.");
    while (1);
  }
  myBH1750.init(); // sets default values: mode = CHM, measuring time factor = 1.0
  // use to set sea level pressure for current location
  // this is needed for accurate altitude measurement
  // STD SLP = 1013.26 hPa
  baro.setSeaPressure(1013.26);
  if (! aht.begin()) {
    Serial.println("Could not find AHT? Check wiring");
    while (1) delay(10);
  }
  Serial.println("AHT10 or AHT20 found");

  boolean rc = FALSE ;
  j11_init();
  rc = wait_msg();
  if (rc == TRUE) {
    state = 1 ;           //  hardware reset end
  } else {
    state = 0 ;
  }
  Watchdog.begin();
  Watchdog.start(30000);
}

void loop() {
  unsigned char msg_length = 0 ;
  boolean rc = 0 ;

#ifdef DEBUG
  Serial.print("State = ");
  Serial.println(state, DEC);
#endif

  delay(500);
  switch (state) {
    case (0):  // need hardware reset
      rc = cmd_send(CMD_RESET);
      rc = wait_msg();
      if (rc == TRUE) {
        state = 1 ;
      }
      break;
    case (1): //  init state
      Serial.println("Send CMD_INI");
      rc = cmd_send(CMD_INI);
      rc = wait_msg();
      if (rc == TRUE) {
        state = 2;
      }
      break;
    case (2): // HAN PANA setting
      rc = cmd_send(CMD_PANA_SET);
      rc = wait_msg();
      if (rc == TRUE) {
        state = 4;
      }
      break;
    case (3): // active scan
      rc = cmd_send(CMD_SCAN);
      rc = wait_msg();
      if (rc == TRUE) {
        rc = wait_msg();
        if (rc == TRUE) {
          state = 4;
        }
      }
      break;
    case (4): //  HAN act
      rc = cmd_send(CMD_HAN);
      rc = wait_msg();
      if (rc == TRUE) {
        state = 5;
      }
      break;
    case (5): // HAN PANA act
      rc = cmd_send(CMD_PANA);
      rc = wait_msg();
      if (rc == TRUE) {
        rc = wait_msg();
        if (rc == TRUE) {
          state = 7;
        }
      }
      break;
    case (6): // rcv mode change
      rc = cmd_send(CMD_CON_SET);
      rc = wait_msg();
      if (rc == TRUE) {
        state = 7;
      }
      break;
    case (7): // my_port open
      rc = cmd_send(CMD_PORTOPEN);
      rc = wait_msg();
      if (rc == TRUE) {
        state = 8;
      }
      break;
    case (8): // UDP send
      // Sensor Measurement
      float pressure = baro.getPressure();
      float altitudem = baro.getAltitude();
      float temperature = baro.getTemperature();

      Serial.println("-----------------");
      Serial.print("pressure = "); Serial.print(pressure); Serial.println(" hPa");
      Serial.print("altitude = "); Serial.print(altitudem); Serial.println(" m");
      Serial.print("MPL3115A2 temperature = "); Serial.print(temperature); Serial.println(" C");
      //Check batt level
      float batt_lvl = get_battery_level();
      Serial.print("VinPin = ");
      Serial.print(batt_lvl);
      Serial.print("V");
      Serial.println();

      sensors_event_t humidity, temp;
      aht.getEvent(&humidity, &temp);// populate temp and humidity objects with fresh data
      Serial.print("Temperature: "); Serial.print(temp.temperature); Serial.println(" degrees C");
      Serial.print("Humidity: "); Serial.print(humidity.relative_humidity); Serial.println(" % rH");
      //Check Light intensity
      float lightIntensity = myBH1750.getLux();
      Serial.print(F("Light intensity: "));
      Serial.print(lightIntensity);
      Serial.println(F(" Lux"));
      //
      //Recieve Wheather Data from Arduino Pro mini
      String incomingData2;
      WeatherSerial.print("G");
      unsigned long timeout;
      timeout = millis();
      while (WeatherSerial.available() == 0) {
        if ( millis() - timeout > 5000) {
          break;
        }
      }
      if (WeatherSerial.available() > 0) {
        incomingData2 = "Data2:" + WeatherSerial.readString();
        Serial.print("WeatherSerial Data: ");
        Serial.println(incomingData2);
      }
      char testmsg1[100];
      String te1 = String(temp.temperature, 2);
      String hu1 = String(humidity.relative_humidity, 2);
      String pa1 = String(pressure, 2);
      String hi1 = String(altitudem, 2);
      String ite1 = String(temperature, 2);
      String lu1 = String(lightIntensity, 2);
      String btv1 = String(batt_lvl, 2);
      sprintf(testmsg1, "Data1:%s,%s,%s,%s,%s,%s,%s", te1.c_str(), hu1.c_str(), pa1.c_str(), hi1.c_str(), ite1.c_str(), lu1.c_str(), btv1.c_str());
      //send 1st data
      send_data(String(testmsg1));
      rc = wait_msg();
      delay(100);
      //send 2nd data
      send_data(incomingData2);
      rc = wait_msg();
      if (rc == TRUE) {
        exTime = millis() - exTime;
        int exSec = round(exTime / 1000);
        Serial.print("exTime= ");
        Serial.println(exSec);
        Serial.print(Watchdog.timeleft());
        Serial.println("ms left for watchdog bite");
        LowPower.deepSleep(120 - exSec - 2); //deepSleep 2min
        Watchdog.kick();
      }
      break;
    default:  // error
      state = 0 ;
      break;
  }
}
//Returns the voltage of the raw pin based on the 5V rail
//This allows us to ignore what VCC might be (an Arduino plugged into USB has VCC of 4.5 to 5.2V)
//Battery level is connected to the RAW pin on Spresense and is fed through two 5% resistors:
//3.9K on the high side (R1), and 1K on the low side (R2)
float get_battery_level()
{
  float rawVoltage = analogRead(BATT);
  float operatingVoltage = 5.0;
  rawVoltage = operatingVoltage * (rawVoltage / 1024); //Convert the 0 to 1023 int to actual voltage on BATT pin
  rawVoltage *= 4.90; //(3.9k+1k)/1k - multiple BATT voltage by the voltage divider to get actual system voltage
  return (rawVoltage);
}

/*
  Weather Shield Example
  By: Nathan Seidle
  SparkFun Electronics
  Date: November 16th, 2013
  License: This code is public domain but you buy me a beer if you use this and we meet someday (Beerware license).

  Much of this is based on Mike Grusin's USB Weather Board code: https://www.sparkfun.com/products/10586

  This is a more advanced example of how to utilize every aspect of the weather shield. See the basic
  example if you're just getting started.

  This code reads all the various sensors (wind speed, direction, rain gauge, humidity, pressure, light, batt_lvl)
  and reports it over the serial comm port. This can be easily routed to a datalogger (such as OpenLog) or
  a wireless transmitter (such as Electric Imp).

  Measurements are reported once a second but windspeed and rain gauge are tied to interrupts that are
  calculated at each report.

  This example code assumes the GPS module is not used.


  Updated by Joel Bartlett
  03/02/2017
  Removed HTU21D code and replaced with Si7021

*/
// Modified for Weather station V1.0 by M.Ayatani 2022 4/4
// 
//Hardware pin definitions
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
// digital I/O pins
const byte WSPEED = 3;
const byte RAIN = 2;

// analog I/O pins
const byte WDIR = A0;
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=

//Global Variables
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
long lastSecond; //The millis counter to see when a second rolls by
unsigned int minutesSinceLastReset; //Used to reset variables after 24 hours. Imp should tell us when it's midnight, this is backup.
byte seconds; //When it hits 60, increase the current minute
byte seconds_2m; //Keeps track of the "wind speed/dir avg" over last 2 minutes array of data
byte minutes; //Keeps track of where we are in various arrays of data
byte minutes_10m; //Keeps track of where we are in wind gust/dir over last 10 minutes array of data

long lastWindCheck = 0;
volatile long lastWindIRQ = 0;
volatile byte windClicks = 0;

//We need to keep track of the following variables:
//Wind speed/dir each update (no storage)
//Wind gust/dir over the day (no storage)
//Wind speed/dir, avg over 2 minutes (store 1 per second)
//Wind gust/dir over last 10 minutes (store 1 per minute)
//Rain over the past hour (store 1 per minute)
//Total rain over date (store one per day)

byte windspdavg[120]; //120 bytes to keep track of 2 minute average
#define WIND_DIR_AVG_SIZE 120
int winddiravg[WIND_DIR_AVG_SIZE]; //120 ints to keep track of 2 minute average
float windgust_10m[10]; //10 floats to keep track of 10 minute max
int windgustdirection_10m[10]; //10 ints to keep track of 10 minute max
volatile float rainHour[60]; //60 floating numbers to keep track of 60 minutes of rain

//These are all the weather values that wunderground expects:
int winddir = 0; // [0-360 instantaneous wind direction]
float windspeedmph = 0; // [mph instantaneous wind speed]
float windgustmph = 0; // [mph current wind gust, using software specific time period]
int windgustdir = 0; // [0-360 using software specific time period]
float windspdmph_avg2m = 0; // [mph 2 minute average wind speed mph]
int winddir_avg2m = 0; // [0-360 2 minute average wind direction]
float windgustmph_10m = 0; // [mph past 10 minutes wind gust mph ]
int windgustdir_10m = 0; // [0-360 past 10 minutes wind gust direction]
float rainin = 0; // [rain inches over the past hour)] -- the accumulated rainfall in the past 60 min
volatile float dailyrainin = 0; // [rain inches so far today in local time]

// volatiles are subject to modification by IRQs
volatile unsigned long raintime, rainlast, raininterval, rain;

//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=

//Interrupt routines (these are called by the hardware interrupts, not by the main code)
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
void rainIRQ()
// Count rain gauge bucket tips as they occur
// Activated by the magnet and reed switch in the rain gauge, attached to input D2
{
  raintime = millis(); // grab current time
  raininterval = raintime - rainlast; // calculate interval between this and last event

  if (raininterval > 10) // ignore switch-bounce glitches less than 10mS after initial edge
  {
    dailyrainin += 0.011; //Each dump is 0.011" of water
    rainHour[minutes] += 0.011; //Increase this minute's amount of rain

    rainlast = raintime; // set up for next event
  }
}

void wspeedIRQ()
// Activated by the magnet in the anemometer (2 ticks per rotation), attached to input D3
{
  if (millis() - lastWindIRQ > 10) // Ignore switch-bounce glitches less than 10ms (142MPH max reading) after the reed switch closes
  {
    lastWindIRQ = millis(); //Grab the current time
    windClicks++; //There is 1.492MPH for each click per second.
  }
}

void setup()
{
  Serial.begin(9600);
  pinMode(WSPEED, INPUT_PULLUP); // input from wind meters windspeed sensor
  pinMode(RAIN, INPUT_PULLUP); // input from wind meters rain gauge sensor

  midnightReset(); //Reset rain totals

  seconds = 0;
  lastSecond = millis();

  // attach external interrupt pins to IRQ functions
  attachInterrupt(0, rainIRQ, FALLING);
  attachInterrupt(1, wspeedIRQ, FALLING);

  // turn on interrupts
  interrupts();
}

void loop()
{
  //Keep track of which minute it is
  if (millis() - lastSecond >= 1000)
  {
    lastSecond += 1000;

    //Take a speed and direction reading every second for 2 minute average
    if (++seconds_2m > 119) seconds_2m = 0;

    //Calc the wind speed and direction every second for 120 second to get 2 minute average
    //float currentSpeed = get_wind_speed();
    //windspeedmph = currentSpeed;//update global variable for windspeed when using the printWeather() function
    //float currentSpeed = random(5); //For testing
    //int currentDirection = get_wind_direction();
    windspeedmph = get_wind_speed();
    winddir = get_wind_direction();
    windspdavg[seconds_2m] = (int)windspeedmph;
    winddiravg[seconds_2m] = winddir;
    //if(seconds_2m % 10 == 0) displayArrays(); //For testing

    //Check to see if this is a gust for the minute
    if (windspeedmph > windgust_10m[minutes_10m])
    {
      windgust_10m[minutes_10m] = windspeedmph;
      windgustdirection_10m[minutes_10m] = winddir;
    }
    //Check to see if this is a gust for the day
    if (windspeedmph > windgustmph)
    {
      windgustmph = windspeedmph;
      windgustdir = winddir;
    }

    //If we roll over 60 seconds then update the arrays for rain and windgust
    if (++seconds > 59)
    {
      seconds = 0;

      if (++minutes > 59) minutes = 0;
      if (++minutes_10m > 9) minutes_10m = 0;

      rainHour[minutes] = 0; //Zero out this minute's rainfall amount
      windgust_10m[minutes_10m] = 0; //Zero out this minute's gust

      minutesSinceLastReset++; //It's been another minute since last night's midnight reset
    }

    //Report all readings every second
    calcWeather();
    //get command & send data to SPRESENSE
    if (Serial.available() > 0) {
      int incomingByte = Serial.read();
      if (incomingByte == 'G') {
        sendWeather_str();
      }
    }
  }
  //If we go for more than 24 hours without a midnight reset then force a reset
  //24 hours * 60 mins/hr = 1,440 minutes + 2 extra minutes. We hope that Imp is doing it.
  if (minutesSinceLastReset > (1440 + 2))
  {
    midnightReset(); //Reset a bunch of variables like rain and daily total rain
  }
  delay(100);
}

//When the imp tells us it's midnight, reset the total amount of rain and gusts
void midnightReset()
{
  dailyrainin = 0; //Reset daily amount of rain

  windgustmph = 0; //Zero out the windgust for the day
  windgustdir = 0; //Zero out the gust direction for the day

  minutes = 0; //Reset minute tracker
  seconds = 0;
  lastSecond = millis(); //Reset variable used to track minutes

  minutesSinceLastReset = 0; //Zero out the backup midnight reset variable
}

//Calculates each of the variables that wunderground is expecting
void calcWeather()
{
  //Calc winddir
  winddir = get_wind_direction();

  //Calc windspeed
  //windspeedmph = get_wind_speed(); //This is calculated in the main loop on line 185

  //Calc windgustmph
  //Calc windgustdir
  //These are calculated in the main loop

  //Calc windspdmph_avg2m
  float temp = 0;
  for (int i = 0 ; i < 120 ; i++)
    temp += windspdavg[i];
  temp /= 120.0;
  windspdmph_avg2m = temp;

  //Calc winddir_avg2m, Wind Direction
  //You can't just take the average. Google "mean of circular quantities" for more info
  //We will use the Mitsuta method because it doesn't require trig functions
  //And because it sounds cool.
  //Based on: http://abelian.org/vlf/bearings.html
  //Based on: http://stackoverflow.com/questions/1813483/averaging-angles-again
  long sum = winddiravg[0];
  int D = winddiravg[0];
  for (int i = 1 ; i < WIND_DIR_AVG_SIZE ; i++)
  {
    int delta = winddiravg[i] - D;

    if (delta < -180)
      D += delta + 360;
    else if (delta > 180)
      D += delta - 360;
    else
      D += delta;

    sum += D;
  }
  winddir_avg2m = sum / WIND_DIR_AVG_SIZE;
  if (winddir_avg2m >= 360) winddir_avg2m -= 360;
  if (winddir_avg2m < 0) winddir_avg2m += 360;

  //Calc windgustmph_10m
  //Calc windgustdir_10m
  //Find the largest windgust in the last 10 minutes
  windgustmph_10m = 0;
  windgustdir_10m = 0;
  //Step through the 10 minutes
  for (int i = 0; i < 10 ; i++)
  {
    if (windgust_10m[i] > windgustmph_10m)
    {
      windgustmph_10m = windgust_10m[i];
      windgustdir_10m = windgustdirection_10m[i];
    }
  }

  //Total rainfall for the day is calculated within the interrupt
  //Calculate amount of rainfall for the last 60 minutes
  rainin = 0;
  for (int i = 0 ; i < 60 ; i++)
    rainin += rainHour[i];
}

//Returns the instataneous wind speed
float get_wind_speed()
{
  float deltaTime = millis() - lastWindCheck; //750ms

  deltaTime /= 1000.0; //Covert to seconds

  float windSpeed = (float)windClicks / deltaTime; //3 / 0.750s = 4

  windClicks = 0; //Reset and start watching for new wind
  lastWindCheck = millis();

  windSpeed *= 1.492; //4 * 1.492 = 5.968MPH
  //windSpeed *= (1.492*1.610); //4 * 1.492 = 5.968MPH

  return (windSpeed);
}

//Read the wind direction sensor, return heading in degrees
int get_wind_direction()
{
  unsigned int adc;
  //adc = analogRead(WDIR); // get the current reading from the sensor
  adc = averageAnalogRead(WDIR); // get the current reading from the sensor

  // The following table is ADC readings for the wind direction sensor output, sorted from low to high.
  // Each threshold is the midpoint between adjacent headings. The output is degrees for that ADC reading.
  // Note that these are not in compass degree order! See Weather Meters datasheet for more information.

  if (adc < 380) return (113);
  if (adc < 393) return (68);
  if (adc < 414) return (90);
  if (adc < 456) return (158);
  if (adc < 508) return (135);
  if (adc < 551) return (203);
  if (adc < 615) return (180);
  if (adc < 680) return (23);
  if (adc < 746) return (45);
  if (adc < 801) return (248);
  if (adc < 833) return (225);
  if (adc < 878) return (338);
  if (adc < 913) return (0);
  if (adc < 940) return (293);
  if (adc < 967) return (315);
  if (adc < 990) return (270);
  return (-1); // error, disconnected?
}

//Takes an average of readings on a given pin
//Returns the average
int averageAnalogRead(int pinToRead)
{
  byte numberOfReadings = 8;
  unsigned int runningValue = 0;

  for(int x = 0 ; x < numberOfReadings ; x++)
    runningValue += analogRead(pinToRead);
  runningValue /= numberOfReadings;

  return(runningValue);
}
//send data to SPRESENSE
void sendWeather_str()
{
  char sendmsg[100];
  String p1 = String(winddir);
  String p2 = String(windspeedmph / 2.236936, 2);
  String p3 = String(windgustmph / 2.236936, 2);
  String p4 = String(windgustdir);
  String p5 = String(windspdmph_avg2m / 2.236936, 2);
  String p6 = String(winddir_avg2m);
  String p7 = String(windgustmph_10m / 2.236936, 2);
  String p8 = String(windgustdir_10m);
  String p9 = String(rainin * 25.4, 2);
  String p10 = String(dailyrainin * 25.4, 2);
  sprintf(sendmsg, "%s,%s,%s,%s,%s,%s,%s,%s,%s,%s", p1.c_str(), p2.c_str(), p3.c_str(), p4.c_str(), p5.c_str(), p6.c_str(), p7.c_str(), p8.c_str(), p9.c_str(), p10.c_str());
  Serial.print(String(sendmsg));
}