private void ProcessExtraDewPoint(NameValueCollection data, WeatherStation station)
{
for (var i = 1; i <= 10; i++)
{
if (data["temp" + i + "f"] != null && data["humidity" + i] != null)
{
var dp = MeteoLib.DewPoint(ConvertUserTempToC(station.ExtraTemp[i]), station.ExtraHum[i]);
station.ExtraDewPoint[i] = ConvertTempCToUser(dp);
}
}
}
private void ImetGetData()
{
const int TEMP1POS = 1;
const int TEMP2POS = 2;
const int RELHUMPOS = 3;
const int PRESSPOS = 4;
const int WINDPOS = 5;
const int DIRPOS = 6;
const int SUNPOS = 7;
const int RAINPOS = 8;
//const int CHECKSUMPOS = 9;
DateTime now = DateTime.Now;
int h = now.Hour;
int min = now.Minute;
if (min != previousminute)
{
previousminute = min;
if (cumulus.StationOptions.SyncTime && (h == cumulus.StationOptions.ClockSettingHour) && (min == 2))
{
// It's 0400, set the station clock
SetStationClock();
}
}
SendCommand("RDLV");
// read the response
var response = GetResponse("rdlv");
if (ValidChecksum(response) && !stop)
{
// split the data
var sl = new List <string>(Regex.Split(response, ","));
if (sl.Count != 10 && sl[0] != "rdlv")
{
cumulus.LogMessage($"RDLV: Unexpected response: {response}");
return;
}
// Parse data using decimal points rather than user's decimal separator
NumberFormatInfo provider = new NumberFormatInfo {
NumberDecimalSeparator = "."
};
double windspeed = -999;
double temp1 = -999;
int humidity = -999;
double varDbl;
int varInt;
if (!string.IsNullOrEmpty(sl[DIRPOS]) && int.TryParse(sl[DIRPOS], out varInt) &&
!string.IsNullOrEmpty(sl[WINDPOS]) && double.TryParse(sl[WINDPOS], NumberStyles.Float, provider, out varDbl))
{
windspeed = varDbl;
DoWind(ConvertWindMSToUser(windspeed), varInt, ConvertWindMSToUser(windspeed), now);
}
else
{
cumulus.LogMessage($"RDLV: Unexpected wind dir/speed format, found: {sl[DIRPOS]}/{sl[WINDPOS]}");
}
if (!string.IsNullOrEmpty(sl[TEMP1POS]) && double.TryParse(sl[TEMP1POS], NumberStyles.Float, provider, out varDbl))
{
temp1 = varDbl;
DoOutdoorTemp(ConvertTempCToUser(temp1), now);
if (windspeed > -99)
{
double windchill = MeteoLib.WindChill(temp1, windspeed * 3.6);
DoWindChill(windchill, now);
}
}
else
{
cumulus.LogMessage($"RDLV: Unexpected temperature 1 format, found: {sl[TEMP1POS]}");
}
if (!string.IsNullOrEmpty(sl[TEMP2POS])) // TEMP2 is optional
{
if (double.TryParse(sl[TEMP2POS], NumberStyles.Float, provider, out varDbl))
{
if (cumulus.StationOptions.LogExtraSensors)
{
// use second temp as Extra Temp 1
DoExtraTemp(ConvertTempCToUser(varDbl), 1);
}
else
{
// use second temp as wet bulb
DoWetBulb(ConvertTempCToUser(varDbl), now);
}
}
else
{
cumulus.LogMessage($"RDLV: Unexpected temperature 2 format, found: {sl[TEMP2POS]}");
}
}
if (!string.IsNullOrEmpty(sl[RELHUMPOS]) && double.TryParse(sl[RELHUMPOS], NumberStyles.Float, provider, out varDbl))
{
humidity = Convert.ToInt32(varDbl);
DoOutdoorHumidity(humidity, now);
}
else
{
cumulus.LogMessage($"RDLV: Unexpected humidity format, found: {sl[RELHUMPOS]}");
}
if (!string.IsNullOrEmpty(sl[PRESSPOS]) && double.TryParse(sl[PRESSPOS], NumberStyles.Float, provider, out varDbl))
{
DoPressure(ConvertPressMBToUser(varDbl), now);
UpdatePressureTrendString();
}
else
{
cumulus.LogMessage($"RDLV: Unexpected pressure format, found: {sl[PRESSPOS]}");
}
if (!string.IsNullOrEmpty(sl[RAINPOS]) && double.TryParse(sl[RAINPOS], NumberStyles.Float, provider, out varDbl))
{
DoRain(ConvertRainMMToUser(varDbl), -1, now);
}
else
{
cumulus.LogMessage($"RDLV: Unexpected rain format, found: {sl[RAINPOS]}");
}
if (!string.IsNullOrEmpty(sl[SUNPOS]) && double.TryParse(sl[SUNPOS], NumberStyles.Float, provider, out varDbl))
{
DoSunHours(varDbl);
}
else
{
cumulus.LogMessage($"RDLV: Unexpected rain format, found: {sl[RAINPOS]}");
}
if (temp1 > -999 && humidity > -999)
{
DoOutdoorDewpoint(0, now);
DoHumidex(now);
DoCloudBaseHeatIndex(now);
if (windspeed > -999)
{
DoApparentTemp(now);
DoFeelsLike(now);
}
}
DoForecast("", false);
UpdateStatusPanel(now);
UpdateMQTT();
}
else
{
cumulus.LogMessage("RDLV: Invalid checksum:");
cumulus.LogMessage(response);
}
if (!cumulus.ImetOptions.UpdateLogPointer || stop)
{
return;
}
// Keep the log pointer current, to avoid large numbers of logs
// being downloaded at next start-up
// Only do this every 30 read intervals
if (readCounter > 0)
{
readCounter--;
}
else
{
UpdateReadPointer();
readCounter = 30;
}
}
public override void getAndProcessHistoryData()
{
// Positions of fields in logger data
//const int IDPOS = 1;
//const int TYPEPOS = 2;
const int INTERVALPOS = 3;
const int TIMEPOS = 4;
const int DATEPOS = 5;
//const int TEMP1MINPOS = 6;
//const int TEMP1MAXPOS = 7;
const int TEMP1AVGPOS = 8;
//const int TEMP2MINPOS = 9;
//const int TEMP2MAXPOS = 10;
const int TEMP2AVGPOS = 11;
//const int RELHUMMINPOS = 12;
//const int RELHUMMAXPOS = 13;
const int RELHUMAVGPOS = 14;
//const int PRESSMINPOS = 15;
//const int PRESSMAXPOS = 16;
const int PRESSAVGPOS = 17;
//const int WINDMINPOS = 18;
const int WINDMAXPOS = 19;
const int WINDAVGPOS = 20;
const int DIRPOS = 21;
const int SUNPOS = 22;
const int RAINPOS = 23;
DateTime timestamp = DateTime.MinValue;
NumberFormatInfo provider = new NumberFormatInfo {
NumberDecimalSeparator = "."
};
DateTime startfrom = cumulus.LastUpdateTime;
int startindex = 0;
int year = startfrom.Year;
int month = startfrom.Month;
int day = startfrom.Day;
int hour = startfrom.Hour;
int minute = startfrom.Minute;
int sec = startfrom.Second;
cumulus.LogMessage($"Last update time = {year}/{month}/{day} {hour}:{minute}:{sec}");
int recordsdone = 0;
if (FirstRun)
{
// First time Cumulus has run, "delete" all the log entries as there may be
// vast numbers and they will take hours to download only to be discarded
//cumulus.LogMessage("First run: PRLG,32760");
// regress the pointer
//comport.Write("PRLG,32760" + sLineBreak);
// read the response
//response = GetResponse("prlg");
// Do it by updating the read pointer to match the write pointer
// The recorded value for currentWritePointer will not have been set yet
UpdateReadPointer();
}
cumulus.LogMessage("Downloading history from " + startfrom);
cumulus.LogConsoleMessage("Reading archive data from " + startfrom + " - please wait");
//RegressLogs(cumulus.LastUpdateTime);
//bool valid = false;
int numrecs = GetNumberOfLogs();
cumulus.LogMessage("Logs available = " + numrecs);
if (numrecs > 0)
{
cumulus.LogMessage("Number of history records = " + numrecs);
// get the earliest record
List <string> sl = GetArchiveRecord();
bool dataOK;
try
{
hour = Convert.ToInt32(sl[TIMEPOS].Substring(0, 2));
minute = Convert.ToInt32(sl[TIMEPOS].Substring(3, 2));
sec = Convert.ToInt32(sl[TIMEPOS].Substring(6, 2));
day = Convert.ToInt32(sl[DATEPOS].Substring(0, 2));
month = Convert.ToInt32(sl[DATEPOS].Substring(3, 2));
year = Convert.ToInt32(sl[DATEPOS].Substring(6, 4));
cumulus.LogMessage("Logger entry : Y = " + year + ", M = " + month + ", D = " + day + ", h = " + hour + ", m = " + minute + ", s = " + sec);
timestamp = new DateTime(year, month, day, hour, minute, sec, 0);
dataOK = true;
}
catch
{
cumulus.LogMessage("Error in earliest timestamp, unable to process logger data");
dataOK = false;
}
if (dataOK)
{
cumulus.LogMessage("Earliest timestamp " + timestamp);
if (timestamp < cumulus.LastUpdateTime)
{
// startindex = 1;
cumulus.LogMessage("-----Earliest timestamp is earlier than required");
cumulus.LogMessage("-----Find first entry after " + cumulus.LastUpdateTime);
startindex++; // to allow for first log already read
while ((startindex < numrecs) && (timestamp <= cumulus.LastUpdateTime))
{
// Move on to next entry
ProgressLogs();
sl = GetArchiveRecord();
try
{
hour = Convert.ToInt32(sl[TIMEPOS].Substring(0, 2));
minute = Convert.ToInt32(sl[TIMEPOS].Substring(3, 2));
sec = Convert.ToInt32(sl[TIMEPOS].Substring(6, 2));
day = Convert.ToInt32(sl[DATEPOS].Substring(0, 2));
month = Convert.ToInt32(sl[DATEPOS].Substring(3, 2));
year = Convert.ToInt32(sl[DATEPOS].Substring(6, 4));
cumulus.LogMessage("Logger entry zero: Y = " + year + ", M = " + month + ", D = " + day + ", h = " + hour + ", m = " + minute + ", s = " + sec);
timestamp = new DateTime(year, month, day, hour, minute, sec, 0);
cumulus.LogMessage("New earliest timestamp " + timestamp);
}
catch (Exception E)
{
cumulus.LogMessage("Error in timestamp, skipping entry. Error = " + E.Message);
timestamp = DateTime.MinValue;
}
startindex++;
}
}
}
if (startindex < numrecs)
{
// We still have entries to process
cumulus.LogMessage("-----Actual number of valid history records = " + (numrecs - startindex));
// Compare earliest timestamp with the update time of the today file
// and see if (they are on the same day
//int hourInc = cumulus.GetHourInc();
// set up controls for end of day roll-over
int rollHour;
if (cumulus.RolloverHour == 0)
{
rollHour = 0;
}
else if (cumulus.Use10amInSummer && (TimeZoneInfo.Local.IsDaylightSavingTime(DateTime.Now)))
{
// Locale is currently on Daylight time
rollHour = cumulus.RolloverHour + 1;
}
else
{
// Locale is currently on Standard time or unknown
rollHour = cumulus.RolloverHour;
}
// Check to see if (today"s roll-over has been done
// (we might be starting up in the roll-over hour)
int luhour = cumulus.LastUpdateTime.Hour;
var rolloverdone = luhour == rollHour;
midnightraindone = luhour == 0;
for (int i = startindex; i < numrecs; i++)
{
try
{
recordsdone++;
sl = GetArchiveRecord();
ProgressLogs();
hour = Convert.ToInt32(sl[TIMEPOS].Substring(0, 2));
minute = Convert.ToInt32(sl[TIMEPOS].Substring(3, 2));
sec = Convert.ToInt32(sl[TIMEPOS].Substring(6, 2));
day = Convert.ToInt32(sl[DATEPOS].Substring(0, 2));
month = Convert.ToInt32(sl[DATEPOS].Substring(3, 2));
year = Convert.ToInt32(sl[DATEPOS].Substring(6, 4));
timestamp = new DateTime(year, month, day, hour, minute, sec);
cumulus.LogMessage("Processing logger data entry " + i + " for " + timestamp);
int interval = (int)(Convert.ToDouble(sl[INTERVALPOS], provider) / 60);
// Check for roll-over
if (hour != rollHour)
{
rolloverdone = false;
}
if (hour != 0)
{
midnightraindone = false;
}
if (sl[RELHUMAVGPOS].Length > 0)
{
DoOutdoorHumidity((int)(Convert.ToDouble(sl[RELHUMAVGPOS], provider)), timestamp);
}
if ((sl[WINDAVGPOS].Length > 0) && (sl[WINDMAXPOS].Length > 0) && (sl[DIRPOS].Length > 0))
{
double windspeed = Convert.ToDouble(sl[WINDAVGPOS], provider);
double windgust = Convert.ToDouble(sl[WINDMAXPOS], provider);
int windbearing = Convert.ToInt32(sl[DIRPOS]);
DoWind(windgust, windbearing, windspeed, timestamp);
// add in "archivePeriod" minutes worth of wind speed to windrun
WindRunToday += ((WindAverage * WindRunHourMult[cumulus.Units.Wind] * interval) / 60.0);
DateTime windruncheckTS;
if ((hour == rollHour) && (minute == 0))
// this is the last logger entry before roll-over
// fudge the timestamp to make sure it falls in the previous day
{
windruncheckTS = timestamp.AddMinutes(-1);
}
else
{
windruncheckTS = timestamp;
}
CheckForWindrunHighLow(windruncheckTS);
// update dominant wind bearing
CalculateDominantWindBearing(Bearing, WindAverage, interval);
}
if (sl[TEMP1AVGPOS].Length > 0)
{
DoOutdoorTemp(ConvertTempCToUser(Convert.ToDouble(sl[TEMP1AVGPOS], provider)), timestamp);
// add in "archivePeriod" minutes worth of temperature to the temp samples
tempsamplestoday += interval;
TempTotalToday += (OutdoorTemperature * interval);
// update chill hours
if (OutdoorTemperature < cumulus.ChillHourThreshold)
{
// add 1 minute to chill hours
ChillHours += interval / 60.0;
}
// update heating/cooling degree days
UpdateDegreeDays(interval);
}
if (sl[TEMP2AVGPOS].Length > 0)
{
double temp2 = Convert.ToDouble(sl[TEMP2AVGPOS], provider);
// supply in CELSIUS
if (cumulus.StationOptions.LogExtraSensors)
{
DoExtraTemp(temp2, 1);
}
else
{
DoWetBulb(temp2, timestamp);
}
}
if (sl[RAINPOS].Length > 0)
{
var raintotal = Convert.ToDouble(sl[RAINPOS], provider);
double raindiff;
if (prevraintotal == -1)
{
raindiff = 0;
}
else
{
raindiff = raintotal - prevraintotal;
}
double rainrate = ConvertRainMMToUser((raindiff) * (60.0 / cumulus.logints[cumulus.DataLogInterval]));
DoRain(ConvertRainMMToUser(raintotal), rainrate, timestamp);
prevraintotal = raintotal;
}
if ((sl[WINDAVGPOS].Length > 0) && (sl[TEMP1AVGPOS].Length > 0))
{
// wind chill
double tempinC = ConvertUserTempToC(OutdoorTemperature);
double windinKPH = ConvertUserWindToKPH(WindAverage);
double value = MeteoLib.WindChill(tempinC, windinKPH);
// value is now in Celsius, convert to units in use
value = ConvertTempCToUser(value);
DoWindChill(value, timestamp);
}
if (sl[PRESSAVGPOS].Length > 0)
{
DoPressure(ConvertPressMBToUser(Convert.ToDouble(sl[PRESSAVGPOS], provider)), timestamp);
}
// Cause wind chill calc
DoWindChill(0, timestamp);
DoOutdoorDewpoint(0, timestamp);
DoApparentTemp(timestamp);
DoFeelsLike(timestamp);
DoHumidex(timestamp);
DoCloudBaseHeatIndex(timestamp);
// sunshine hours
if (sl[SUNPOS].Length > 0)
{
DoSunHours(Convert.ToDouble(sl[SUNPOS], provider));
}
cumulus.DoLogFile(timestamp, false);
cumulus.MySqlRealtimeFile(999, false, timestamp);
AddRecentDataEntry(timestamp, WindAverage, RecentMaxGust, WindLatest, Bearing, AvgBearing, OutdoorTemperature, WindChill, OutdoorDewpoint, HeatIndex,
OutdoorHumidity, Pressure, RainToday, SolarRad, UV, Raincounter, FeelsLike, Humidex, ApparentTemperature, IndoorTemperature, IndoorHumidity, CurrentSolarMax, RainRate, -1, -1);
DoTrendValues(timestamp);
if (cumulus.StationOptions.CalculatedET && timestamp.Minute == 0)
{
// Start of a new hour, and we want to calculate ET in Cumulus
CalculateEvaoptranspiration(timestamp);
}
UpdatePressureTrendString();
UpdateStatusPanel(timestamp);
// Add current data to the lists of web service updates to be done
cumulus.AddToWebServiceLists(timestamp);
if ((hour == rollHour) && !rolloverdone)
{
// do roll-over
cumulus.LogMessage("Day roll-over " + timestamp);
DayReset(timestamp);
rolloverdone = true;
}
if ((hour == 0) && !midnightraindone)
{
ResetMidnightRain(timestamp);
ResetSunshineHours(timestamp);
ResetMidnightTemperatures(timestamp);
midnightraindone = true;
}
}
catch (Exception E)
{
cumulus.LogMessage("Error in data: " + E.Message);
}
}
}
else
{
cumulus.LogMessage("No history records to process");
}
}
else
{
cumulus.LogMessage("No history records to process");
}
}
/// <summary>
/// Read current data and process it
/// </summary>
private void GetAndProcessData()
{
// Curr Reading Loc
// 0 Time Since Last Save
// 1 Hum In
// 2 Temp In
// 3 "
// 4 Hum Out
// 5 Temp Out
// 6 "
// 7 Pressure
// 8 "
// 9 Wind Speed m/s
// 10 Wind Gust m/s
// 11 Speed and Gust top nibbles (Gust top nibble)
// 12 Wind Dir
// 13 Rain counter
// 14 "
// 15 status
// 16 Solar (Lux)
// 17 "
// 18 "
// 19 UV
//var ci = new CultureInfo("en-GB");
//System.Threading.Thread.CurrentThread.CurrentCulture = ci;
var data = new byte[32];
if (cumulus.SyncFOReads && !Synchronising)
{
if ((DateTime.Now - FOSensorClockTime).TotalDays > 1)
{
// (re)synchronise data reads to try to avoid USB lockup problem
StartSynchronising();
return;
}
else
{
// Check that were not within N seconds of the station updating memory
bool sensorclockOK = ((int)(Math.Floor((DateTime.Now - FOSensorClockTime).TotalSeconds)) % 48 >= (cumulus.FOReadAvoidPeriod - 1)) &&
((int)(Math.Floor((DateTime.Now - FOSensorClockTime).TotalSeconds)) % 48 <= (47 - cumulus.FOReadAvoidPeriod));
bool stationclockOK = ((int)(Math.Floor((DateTime.Now - FOStationClockTime).TotalSeconds)) % 60 >= (cumulus.FOReadAvoidPeriod - 1)) &&
((int)(Math.Floor((DateTime.Now - FOStationClockTime).TotalSeconds)) % 60 <= (59 - cumulus.FOReadAvoidPeriod));
if (!sensorclockOK || !stationclockOK)
{
if (!sensorclockOK)
{
cumulus.LogDebugMessage("Within " + cumulus.FOReadAvoidPeriod + " seconds of sensor data change, skipping read");
}
if (!stationclockOK)
{
cumulus.LogDebugMessage("Within " + cumulus.FOReadAvoidPeriod + " seconds of station clock minute change, skipping read");
}
return;
}
}
}
// get the block of memory containing the current data location
if (cumulus.DataLogging)
{
cumulus.LogMessage("Reading first block");
}
ReadAddress(0, data);
int addr = (data[31] * 256) + data[30];
if (cumulus.DataLogging)
{
cumulus.LogMessage("First block read, addr = " + addr.ToString("X8"));
}
if (addr != prevaddr)
{
// location has changed, skip this read to give it chance to update
//cumulus.LogMessage("Location changed, skipping");
if (SynchroPhase == 2)
{
cumulus.LogDebugMessage("Address changed");
cumulus.LogDebugMessage("addr=" + addr.ToString("X4") + "previous=" + prevaddr.ToString("X4"));
FOStationClockTime = DateTime.Now;
StopSynchronising();
}
}
else
{
if (cumulus.DataLogging)
{
cumulus.LogMessage("Reading data, addr = " + addr.ToString("X8"));
}
ReadAddress(addr, data);
if (cumulus.DataLogging)
{
cumulus.LogMessage("Data read - " + BitConverter.ToString(data));
}
DateTime now = DateTime.Now;
if (Synchronising)
{
if (SynchroPhase == 1)
{
// phase 1 - sensor clock
bool datachanged = false;
// ReadCounter determines whether we actually process the data (every 10 seconds)
ReadCounter++;
if (hadfirstsyncdata)
{
for (int i = 0; i < 16; i++)
{
if (prevdata[i] != data[i])
{
datachanged = true;
}
}
if (datachanged)
{
FOSensorClockTime = DateTime.Now;
SynchroPhase = 2;
}
}
}
else
{
// Phase 2 - station clock
ReadCounter++;
}
}
hadfirstsyncdata = true;
for (int i = 0; i < 16; i++)
{
prevdata[i] = data[i];
}
if ((!Synchronising) || ((ReadCounter % 20) == 0))
{
LatestFOReading = addr.ToString("X4") + ":";
for (int i = 0; i < 16; i++)
{
LatestFOReading = LatestFOReading + " " + data[i].ToString("X2");
}
if (cumulus.DataLogging)
{
cumulus.LogMessage(LatestFOReading);
}
// Indoor Humidity ====================================================
int inhum = data[1];
if ((inhum > 100) && (inhum != 255))
{
// bad value
cumulus.LogMessage("Ignoring bad data: inhum = " + inhum);
}
else
{
// 255 is the overflow value, when RH gets below 10% - use 10%
if (inhum == 255)
{
inhum = 10;
}
if (inhum > 0)
{
DoIndoorHumidity(inhum);
}
}
// Indoor temperature ===============================================
double intemp = ((data[2]) + (data[3] & 0x7F) * 256) / 10.0f;
var sign = (byte)(data[3] & 0x80);
if (sign == 0x80)
{
intemp = -intemp;
}
if ((intemp > -50) && (intemp < 50))
{
DoIndoorTemp(ConvertTempCToUser(intemp));
}
// Pressure =========================================================
double pressure = (data[7] + (data[8] * 256)) / 10.0f + pressureOffset;
if ((pressure < cumulus.EWminpressureMB) || (pressure > cumulus.EWmaxpressureMB))
{
// bad value
cumulus.LogMessage("Ignoring bad data: pressure = " + pressure.ToString());
cumulus.LogMessage(" offset = " + EWpressureoffset.ToString());
}
else
{
if ((previouspress == 9999) || (Math.Abs(pressure - previouspress) < cumulus.EWpressurediff))
{
previouspress = pressure;
DoPressure(ConvertPressMBToUser(pressure), now);
// Get station pressure in hPa by subtracting offset and calibrating
// EWpressure offset is difference between rel and abs in hPa
// PressOffset is user calibration in user units.
pressure = pressure - pressureOffset + PressureHPa(cumulus.PressOffset);
StationPressure = ConvertPressMBToUser(pressure);
}
else
{
LogSpikeRemoval("Pressure difference greater than specified; reading ignored");
LogSpikeRemoval("Old value = " + previouspress.ToString("F1") + " New value = " + pressure.ToString("F1") + " EWpressurediff = " +
cumulus.EWpressurediff.ToString("F1"));
}
UpdatePressureTrendString();
UpdateStatusPanel(now);
DoForecast("", false);
}
var status = data[15];
if ((status & 0x40) != 0)
{
SensorContactLost = true;
cumulus.LogMessage("Sensor contact lost; ignoring outdoor data");
}
else
{
SensorContactLost = false;
// Outdoor Humidity ===================================================
int outhum = data[4];
if ((outhum > 100) && (outhum != 255))
{
// bad value
cumulus.LogMessage("Ignoring bad data: outhum = " + outhum);
}
else
{
// 255 is the overflow value, when RH gets below 10% - use 10%
if (outhum == 255)
{
outhum = 10;
}
if (outhum > 0)
{
if ((previoushum == 999) || (Math.Abs(outhum - previoushum) < cumulus.EWhumiditydiff))
{
previoushum = outhum;
DoOutdoorHumidity(outhum, now);
}
else
{
LogSpikeRemoval("Humidity difference greater than specified; reading ignored");
LogSpikeRemoval("Old value = " + previoushum + " New value = " + outhum + " EWhumiditydiff = " + cumulus.EWhumiditydiff.ToString("F1"));
}
}
}
// Wind =============================================================
double gust = (data[10] + ((data[11] & 0xF0) * 16)) / 10.0f;
double windspeed = (data[9] + ((data[11] & 0x0F) * 256)) / 10.0f;
var winddir = (int)(data[12] * 22.5f);
if ((gust > 60) || (gust < 0))
{
// bad value
cumulus.LogMessage("Ignoring bad data: gust = " + gust.ToString());
}
else if ((windspeed > 60) || (windspeed < 0))
{
// bad value
cumulus.LogMessage("Ignoring bad data: speed = " + gust.ToString());
}
else
{
if (((previousgust == 999) || (Math.Abs(gust - previousgust) < cumulus.EWgustdiff)) &&
((previouswind == 999) || (Math.Abs(windspeed - previouswind) < cumulus.EWwinddiff)))
{
previousgust = gust;
previouswind = windspeed;
DoWind(ConvertWindMSToUser(gust), winddir, ConvertWindMSToUser(windspeed), now);
}
else
{
LogSpikeRemoval("Wind or gust difference greater than specified; reading ignored");
LogSpikeRemoval("Gust: Old value = " + previousgust.ToString("F1") + " New value = " + gust.ToString("F1") + " EWgustdiff = " +
cumulus.EWgustdiff.ToString("F1"));
LogSpikeRemoval("Wind: Old value = " + previouswind.ToString("F1") + " New value = " + windspeed.ToString("F1") + " EWwinddiff = " +
cumulus.EWwinddiff.ToString("F1"));
}
}
// Outdoor Temperature ==============================================
double outtemp = ((data[5]) + (data[6] & 0x7F) * 256) / 10.0f;
sign = (byte)(data[6] & 0x80);
if (sign == 0x80)
{
outtemp = -outtemp;
}
if ((outtemp < -50) || (outtemp > 70))
{
// bad value
cumulus.LogMessage("Ignoring bad data: outtemp = " + outtemp);
}
else
{
if ((previoustemp == 999) || (Math.Abs(outtemp - previoustemp) < cumulus.EWtempdiff))
{
previoustemp = outtemp;
DoOutdoorTemp(ConvertTempCToUser(outtemp), now);
// Use current humidity for dewpoint
if (OutdoorHumidity > 0)
{
OutdoorDewpoint = ConvertTempCToUser(MeteoLib.DewPoint(ConvertUserTempToC(OutdoorTemperature), OutdoorHumidity));
CheckForDewpointHighLow(now);
}
;
// calculate wind chill
if ((outtemp > -50) || (outtemp < 70))
{
// The 'global average speed will have been determined by the call of DoWind
// so use that in the wind chill calculation
double avgspeedKPH = ConvertUserWindToKPH(WindAverage);
// windinMPH = calibwind * 2.23693629;
// calculate wind chill from calibrated C temp and calibrated win in KPH
double val = MeteoLib.WindChill(ConvertUserTempToC(OutdoorTemperature), avgspeedKPH);
DoWindChill(ConvertTempCToUser(val), now);
}
DoApparentTemp(now);
}
else
{
LogSpikeRemoval("Temp difference greater than specified; reading ignored");
LogSpikeRemoval("Old value = " + previoustemp + " New value = " + outtemp + " EWtempdiff = " + cumulus.EWtempdiff);
}
}
// Rain ============================================================
int raintot = data[13] + (data[14] * 256);
if (prevraintotal == -1)
{
// first reading
prevraintotal = raintot;
cumulus.LogMessage("Rain total count from station = " + raintot);
}
int raindiff = Math.Abs(raintot - prevraintotal);
if (raindiff > cumulus.EWMaxRainTipDiff)
{
cumulus.LogMessage("Warning: large difference in rain gauge tip count: " + raindiff);
ignoreraincount++;
if (ignoreraincount == 6)
{
cumulus.LogMessage("Six consecutive readings; accepting value. Adjusting start of day figure to compensate");
raindaystart = raindaystart + (raindiff * 0.3);
// adjust current rain total counter
Raincounter = Raincounter + (raindiff * 0.3);
cumulus.LogMessage("Setting raindaystart to " + raindaystart);
ignoreraincount = 0;
}
else
{
cumulus.LogMessage("Ignoring reading " + ignoreraincount);
}
}
else
{
ignoreraincount = 0;
}
if (ignoreraincount == 0)
{
DoRain(ConvertRainMMToUser(raintot * 0.3), -1, now);
prevraintotal = raintot;
}
// Solar/UV
if (hasSolar)
{
LightValue = (data[16] + (data[17] * 256) + (data[18] * 65536)) / 10.0;
if (LightValue < 300000)
{
DoSolarRad((int)(LightValue * cumulus.LuxToWM2), now);
}
int UVreading = data[19];
if (UVreading != 255)
{
DoUV(UVreading, now);
}
}
}
}
}
prevaddr = addr;
}
private void ImetGetData()
{
const int TEMP1POS = 1;
const int TEMP2POS = 2;
const int RELHUMPOS = 3;
const int PRESSPOS = 4;
const int WINDPOS = 5;
const int DIRPOS = 6;
const int SUNPOS = 7;
const int RAINPOS = 8;
//const int CHECKSUMPOS = 9;
DateTime now = DateTime.Now;
int h = now.Hour;
int min = now.Minute;
if (min != previousminute)
{
previousminute = min;
if (cumulus.SyncTime && (h == cumulus.ClockSettingHour) && (min == 0))
{
// It's 0400, set the station clock
SetStationClock();
}
}
comport.Write("RDLV" + sLineBreak);
// read the response
var response = getResponse("rdlv");
if (ValidChecksum(response))
{
cumulus.LogDataMessage(response);
// split the data
var sl = new List <string>(Regex.Split(response, ","));
// Parse data using decimal points rather than user's decimal separator
NumberFormatInfo provider = new NumberFormatInfo();
provider.NumberDecimalSeparator = ".";
double temp1 = 0;
double windspeed = 0;
if (!string.IsNullOrEmpty(sl[TEMP1POS]))
{
temp1 = Convert.ToDouble(sl[TEMP1POS], provider);
DoOutdoorTemp(ConvertTempCToUser(temp1), now);
}
if (!string.IsNullOrEmpty(sl[TEMP2POS]))
{
double temp2 = Convert.ToDouble(sl[TEMP2POS], provider);
if (cumulus.LogExtraSensors)
{
// use second temp as Extra Temp 1
DoExtraTemp(ConvertTempCToUser(temp2), 1);
}
else
{
// use second temp as wet bulb
DoWetBulb(ConvertTempCToUser(temp2), now);
}
}
if (!string.IsNullOrEmpty(sl[RELHUMPOS]))
{
double hum = Convert.ToDouble(sl[RELHUMPOS], provider);
DoOutdoorHumidity((int)hum, now);
}
if (!string.IsNullOrEmpty(sl[PRESSPOS]))
{
double press = Convert.ToDouble(sl[PRESSPOS], provider);
DoPressure(ConvertPressMBToUser(press), now);
}
if (!string.IsNullOrEmpty(sl[DIRPOS]) && !string.IsNullOrEmpty(sl[WINDPOS]))
{
int winddir = Convert.ToInt32(sl[DIRPOS], provider);
windspeed = Convert.ToDouble(sl[WINDPOS], provider);
DoWind(ConvertWindMSToUser(windspeed), winddir, ConvertWindMSToUser(windspeed), now);
}
if (!string.IsNullOrEmpty(sl[RAINPOS]))
{
double raintotal = Convert.ToDouble(sl[RAINPOS], provider);
DoRain(ConvertRainMMToUser(raintotal), -1, now);
}
if (!string.IsNullOrEmpty(sl[SUNPOS]))
{
double sunhours = Convert.ToDouble(sl[SUNPOS], provider);
DoSunHours(sunhours, now);
}
if (!string.IsNullOrEmpty(sl[TEMP1POS]))
{
double windchill = MeteoLib.WindChill(temp1, windspeed * 3.6);
DoWindChill(windchill, now);
}
DoApparentTemp(now);
DoForecast("", false);
UpdatePressureTrendString();
UpdateStatusPanel(now);
}
else
{
cumulus.LogMessage("Invalid checksum:");
cumulus.LogMessage(response);
}
if (cumulus.ImetUpdateLogPointer)
{
// Keep the log pointer current, to avoid large numbers of logs
// being downloaded at next startup
ProgressLogs();
}
}
private void processHistoryData()
{
int totalentries = datalist.Count;
cumulus.LogMessage("Processing history data, number of entries = " + totalentries);
int rollHour = Math.Abs(cumulus.GetHourInc());
int luhour = cumulus.LastUpdateTime.Hour;
bool rolloverdone = luhour == rollHour;
bool midnightraindone = luhour == 0;
while (datalist.Count > 0)
{
HistoryData historydata = datalist[datalist.Count - 1];
DateTime timestamp = historydata.timestamp;
cumulus.LogMessage("Processing data for " + timestamp);
int h = timestamp.Hour;
// if outside rollover hour, rollover yet to be done
if (h != rollHour)
{
rolloverdone = false;
}
// In rollover hour and rollover not yet done
if ((h == rollHour) && !rolloverdone)
{
// do rollover
cumulus.LogMessage("Day rollover " + timestamp.ToShortTimeString());
DayReset(timestamp);
rolloverdone = true;
}
// Not in midnight hour, midnight rain yet to be done
if (h != 0)
{
midnightraindone = false;
}
// In midnight hour and midnight rain (and sun) not yet done
if ((h == 0) && !midnightraindone)
{
ResetMidnightRain(timestamp);
ResetSunshineHours();
midnightraindone = true;
}
// Indoor Humidity ======================================================
if ((historydata.inHum > 100) && (historydata.inHum != 255))
{
cumulus.LogMessage("Ignoring bad data: inhum = " + historydata.inHum);
}
else if ((historydata.inHum > 0) && (historydata.inHum != 255))
{
// 255 is the overflow value, when RH gets below 10% - ignore
DoIndoorHumidity(historydata.inHum);
}
// Indoor Temperature ===================================================
if ((historydata.inTemp > -50) && (historydata.inTemp < 50))
{
DoIndoorTemp(ConvertTempCToUser(historydata.inTemp));
}
// Pressure =============================================================
if ((historydata.pressure < cumulus.EWminpressureMB) || (historydata.pressure > cumulus.EWmaxpressureMB))
{
cumulus.LogMessage("Ignoring bad data: pressure = " + historydata.pressure);
cumulus.LogMessage(" offset = " + pressureOffset);
}
else
{
DoPressure(ConvertPressMBToUser(historydata.pressure), timestamp);
}
if (historydata.SensorContactLost)
{
cumulus.LogMessage("Sensor contact lost; ignoring outdoor data");
}
else
{
// Outdoor Humidity =====================================================
if ((historydata.outHum > 100) && (historydata.outHum != 255))
{
cumulus.LogMessage("Ignoring bad data: outhum = " + historydata.outHum);
}
else if ((historydata.outHum > 0) && (historydata.outHum != 255))
{
// 255 is the overflow value, when RH gets below 10% - ignore
DoOutdoorHumidity(historydata.outHum, timestamp);
}
// Wind =================================================================
if ((historydata.windGust > 60) || (historydata.windGust < 0))
{
cumulus.LogMessage("Ignoring bad data: gust = " + historydata.windGust);
}
else if ((historydata.windSpeed > 60) || (historydata.windSpeed < 0))
{
cumulus.LogMessage("Ignoring bad data: speed = " + historydata.windSpeed);
}
{
DoWind(ConvertWindMSToUser(historydata.windGust), historydata.windBearing, ConvertWindMSToUser(historydata.windSpeed), timestamp);
}
// Outdoor Temperature ==================================================
if ((historydata.outTemp < -50) || (historydata.outTemp > 70))
{
cumulus.LogMessage("Ignoring bad data: outtemp = " + historydata.outTemp);
}
else
{
DoOutdoorTemp(ConvertTempCToUser(historydata.outTemp), timestamp);
// add in 'archivePeriod' minutes worth of temperature to the temp samples
tempsamplestoday = tempsamplestoday + historydata.interval;
TempTotalToday = TempTotalToday + (OutdoorTemperature * historydata.interval);
}
// update chill hours
if (OutdoorTemperature < cumulus.ChillHourThreshold)
{
// add 1 minute to chill hours
ChillHours = ChillHours + (historydata.interval / 60);
}
int raindiff;
if (prevraintotal == -1)
{
raindiff = 0;
}
else
{
raindiff = historydata.rainCounter - prevraintotal;
}
// record time of last rain tip, to use in
// normal running rain rate calc NB rain rate calc not currently used
if (raindiff > 0)
{
lastraintip = timestamp;
raininlasttip = raindiff;
}
else
{
lastraintip = DateTime.MinValue;
raininlasttip = 0;
}
double rainrate;
if (raindiff > 100)
{
cumulus.LogMessage("Warning: large increase in rain gauge tip count: " + raindiff);
rainrate = 0;
}
else
{
if (historydata.interval > 0)
{
rainrate = ConvertRainMMToUser((raindiff * 0.3) * (60.0 / historydata.interval));
}
else
{
rainrate = 0;
}
}
DoRain(ConvertRainMMToUser(historydata.rainCounter * 0.3), rainrate, timestamp);
prevraintotal = historydata.rainCounter;
OutdoorDewpoint = ConvertTempCToUser(MeteoLib.DewPoint(ConvertUserTempToC(OutdoorTemperature), OutdoorHumidity));
CheckForDewpointHighLow(timestamp);
// calculate wind chill
if (ConvertUserWindToMS(WindAverage) < 1.5)
{
DoWindChill(OutdoorTemperature, timestamp);
}
else
{
// calculate wind chill from calibrated C temp and calibrated win in KPH
DoWindChill(ConvertTempCToUser(MeteoLib.WindChill(ConvertUserTempToC(OutdoorTemperature), ConvertUserWindToKPH(WindAverage))), timestamp);
}
DoApparentTemp(timestamp);
if (hasSolar)
{
if (historydata.uvVal == 255)
{
// ignore
}
else if (historydata.uvVal < 0)
{
DoUV(0, timestamp);
}
else if (historydata.uvVal > 16)
{
DoUV(16, timestamp);
}
else
{
DoUV(historydata.uvVal, timestamp);
}
if ((historydata.solarVal >= 0) && (historydata.solarVal <= 300000))
{
DoSolarRad((int)Math.Floor(historydata.solarVal * cumulus.LuxToWM2), timestamp);
// add in archive period worth of sunshine, if sunny
if ((SolarRad > CurrentSolarMax * cumulus.SunThreshold / 100) && (SolarRad >= cumulus.SolarMinimum))
{
SunshineHours = SunshineHours + (historydata.interval / 60.0);
}
LightValue = historydata.solarVal;
}
}
}
// add in 'following interval' minutes worth of wind speed to windrun
cumulus.LogMessage("Windrun: " + WindAverage.ToString(cumulus.WindFormat) + cumulus.WindUnitText + " for " + historydata.followinginterval + " minutes = " +
(WindAverage * WindRunHourMult[cumulus.WindUnit] * historydata.followinginterval / 60.0).ToString(cumulus.WindRunFormat) + cumulus.WindRunUnitText);
WindRunToday += (WindAverage * WindRunHourMult[cumulus.WindUnit] * historydata.followinginterval / 60.0);
// update heating/cooling degree days
UpdateDegreeDays(historydata.interval);
// update dominant wind bearing
CalculateDominantWindBearing(Bearing, WindAverage, historydata.interval);
CheckForWindrunHighLow(timestamp);
bw.ReportProgress((totalentries - datalist.Count) * 100 / totalentries, "processing");
//UpdateDatabase(timestamp.ToUniversalTime(), historydata.interval, false);
cumulus.DoLogFile(timestamp, false);
if (cumulus.LogExtraSensors)
{
cumulus.DoExtraLogFile(timestamp);
}
AddLastHourDataEntry(timestamp, Raincounter, OutdoorTemperature);
AddGraphDataEntry(timestamp, Raincounter, RainToday, RainRate, OutdoorTemperature, OutdoorDewpoint, ApparentTemperature, WindChill, HeatIndex,
IndoorTemperature, Pressure, WindAverage, RecentMaxGust, AvgBearing, Bearing, OutdoorHumidity, IndoorHumidity, SolarRad, CurrentSolarMax, UV);
AddLast3HourDataEntry(timestamp, Pressure, OutdoorTemperature);
AddRecentDataEntry(timestamp, WindAverage, RecentMaxGust, WindLatest, Bearing, AvgBearing, OutdoorTemperature, WindChill, OutdoorDewpoint, HeatIndex,
OutdoorHumidity, Pressure, RainToday, SolarRad, UV, Raincounter);
RemoveOldLHData(timestamp);
RemoveOldL3HData(timestamp);
RemoveOldGraphData(timestamp);
DoTrendValues(timestamp);
UpdatePressureTrendString();
UpdateStatusPanel(timestamp);
cumulus.AddToWebServiceLists(timestamp);
datalist.RemoveAt(datalist.Count - 1);
}
cumulus.LogMessage("End processing history data");
}
private void ProcessHistoryData(List <Observation> datalist)
{
var totalentries = datalist.Count;
cumulus.LogMessage("Processing history data, number of entries = " + totalentries);
cumulus.LogConsoleMessage(
$"Processing history data for {totalentries} records. {DateTime.Now.ToLongTimeString()}");
var rollHour = Math.Abs(cumulus.GetHourInc());
var luhour = cumulus.LastUpdateTime.Hour;
var rolloverdone = luhour == rollHour;
var midnightraindone = luhour == 0;
var ticks = Environment.TickCount;
foreach (var historydata in datalist)
{
var timestamp = historydata.Timestamp;
cumulus.LogMessage("Processing data for " + timestamp);
var h = timestamp.Hour;
// if outside rollover hour, rollover yet to be done
if (h != rollHour)
{
rolloverdone = false;
}
// In rollover hour and rollover not yet done
if (h == rollHour && !rolloverdone)
{
// do rollover
cumulus.LogMessage("Day rollover " + timestamp.ToShortTimeString());
DayReset(timestamp);
rolloverdone = true;
}
// Not in midnight hour, midnight rain yet to be done
if (h != 0)
{
midnightraindone = false;
}
// In midnight hour and midnight rain (and sun) not yet done
if (h == 0 && !midnightraindone)
{
ResetMidnightRain(timestamp);
ResetSunshineHours();
midnightraindone = true;
}
// Pressure =============================================================
var alt = AltitudeM(cumulus.Altitude);
var seaLevel = GetSeaLevelPressure(alt, (double)historydata.StationPressure, (double)historydata.Temperature);
DoPressure(ConvertPressMBToUser(seaLevel), timestamp);
// Outdoor Humidity =====================================================
DoOutdoorHumidity((int)historydata.Humidity, timestamp);
// Wind =================================================================
DoWind(ConvertWindMSToUser((double)historydata.WindGust), historydata.WindDirection,
ConvertWindMSToUser((double)historydata.WindAverage), timestamp);
// Outdoor Temperature ==================================================
DoOutdoorTemp(ConvertTempCToUser((double)historydata.Temperature), timestamp);
// add in 'archivePeriod' minutes worth of temperature to the temp samples
tempsamplestoday += historydata.ReportInterval;
TempTotalToday += OutdoorTemperature * historydata.ReportInterval;
// update chill hours
if (OutdoorTemperature < cumulus.ChillHourThreshold)
{
// add 1 minute to chill hours
ChillHours += historydata.ReportInterval / 60.0;
}
double rainrate = (double)(ConvertRainMMToUser((double)historydata.Precipitation) *
(60d / historydata.ReportInterval));
var newRain = Raincounter + ConvertRainMMToUser((double)historydata.Precipitation);
cumulus.LogMessage(
$"TempestDoRainHist: New Precip: {historydata.Precipitation}, Type: {historydata.PrecipType}, Rate: {rainrate}, LocalDayRain: {historydata.LocalDayRain}, LocalRainChecked: {historydata.LocalRainChecked}, FinalRainChecked: {historydata.FinalRainChecked}");
DoRain(newRain, rainrate, timestamp);
cumulus.LogMessage(
$"TempestDoRainHist: Total Precip for Day: {Raincounter}");
OutdoorDewpoint =
ConvertTempCToUser(MeteoLib.DewPoint(ConvertUserTempToC(OutdoorTemperature),
OutdoorHumidity));
CheckForDewpointHighLow(timestamp);
// calculate wind chill
if (ConvertUserWindToMS(WindAverage) < 1.5)
{
DoWindChill(OutdoorTemperature, timestamp);
}
else
{
// calculate wind chill from calibrated C temp and calibrated win in KPH
DoWindChill(
ConvertTempCToUser(MeteoLib.WindChill(ConvertUserTempToC(OutdoorTemperature),
ConvertUserWindToKPH(WindAverage))), timestamp);
}
DoApparentTemp(timestamp);
DoFeelsLike(timestamp);
DoHumidex(timestamp);
DoUV((double)historydata.UV, timestamp);
DoSolarRad(historydata.SolarRadiation, timestamp);
// add in archive period worth of sunshine, if sunny
if (SolarRad > CurrentSolarMax * cumulus.SunThreshold / 100 &&
SolarRad >= cumulus.SolarMinimum)
{
SunshineHours += historydata.ReportInterval / 60.0;
}
LightValue = historydata.Illuminance;
// add in 'following interval' minutes worth of wind speed to windrun
cumulus.LogMessage("Windrun: " + WindAverage.ToString(cumulus.WindFormat) + cumulus.Units.WindText + " for " + historydata.ReportInterval + " minutes = " +
(WindAverage * WindRunHourMult[cumulus.Units.Wind] * historydata.ReportInterval / 60.0).ToString(cumulus.WindRunFormat) + cumulus.Units.WindRunText);
WindRunToday += WindAverage * WindRunHourMult[cumulus.Units.Wind] * historydata.ReportInterval / 60.0;
// update heating/cooling degree days
UpdateDegreeDays(historydata.ReportInterval);
// update dominant wind bearing
CalculateDominantWindBearing(Bearing, WindAverage, historydata.ReportInterval);
CheckForWindrunHighLow(timestamp);
bw?.ReportProgress((totalentries - datalist.Count) * 100 / totalentries, "processing");
//UpdateDatabase(timestamp.ToUniversalTime(), historydata.interval, false);
cumulus.DoLogFile(timestamp, false);
if (cumulus.StationOptions.LogExtraSensors)
{
cumulus.DoExtraLogFile(timestamp);
}
//AddRecentDataEntry(timestamp, WindAverage, RecentMaxGust, WindLatest, Bearing, AvgBearing,
// OutdoorTemperature, WindChill, OutdoorDewpoint, HeatIndex,
// OutdoorHumidity, Pressure, RainToday, SolarRad, UV, Raincounter, FeelsLike, Humidex);
AddRecentDataWithAq(timestamp, WindAverage, RecentMaxGust, WindLatest, Bearing, AvgBearing, OutdoorTemperature, WindChill, OutdoorDewpoint, HeatIndex,
OutdoorHumidity, Pressure, RainToday, SolarRad, UV, Raincounter, FeelsLike, Humidex, ApparentTemperature, IndoorTemperature, IndoorHumidity, CurrentSolarMax, RainRate);
DoTrendValues(timestamp);
UpdatePressureTrendString();
UpdateStatusPanel(timestamp);
cumulus.AddToWebServiceLists(timestamp);
}
ticks = Environment.TickCount - ticks;
var rate = ((double)totalentries / ticks) * 1000;
cumulus.LogMessage($"End processing history data. Rate: {rate:f2}/second");
cumulus.LogConsoleMessage($"Completed processing history data. {DateTime.Now.ToLongTimeString()}, Rate: {rate:f2}/second");
}
private void WeatherPacketReceived(WeatherPacket wp)
{
DateTime ts;
if (wp != null)
{
switch (wp.MsgType)
{
case WeatherPacket.MessageType.Observation:
ts = wp.Observation.Timestamp;
var userTemp = ConvertTempCToUser(Convert.ToDouble(wp.Observation.Temperature));
DoOutdoorTemp(userTemp, ts);
DoWind(ConvertWindMSToUser((double)wp.Observation.WindGust),
wp.Observation.WindDirection,
ConvertWindMSToUser((double)wp.Observation.WindAverage),
ts);
var alt = AltitudeM(cumulus.Altitude);
var seaLevel = GetSeaLevelPressure(alt, (double)wp.Observation.StationPressure,
(double)wp.Observation.Temperature);
DoPressure(ConvertPressMBToUser(seaLevel), ts);
cumulus.LogMessage(
$"TempestPressure: Station:{wp.Observation.StationPressure} mb, Sea Level:{seaLevel} mb, Altitude:{alt}");
DoSolarRad(wp.Observation.SolarRadiation, ts);
DoUV((double)wp.Observation.UV, ts);
double rainrate = (double)(ConvertRainMMToUser((double)wp.Observation.Precipitation) *
(60d / wp.Observation.ReportInterval));
var newRain = Raincounter + ConvertRainMMToUser((double)wp.Observation.Precipitation);
cumulus.LogMessage(
$"TempestDoRain: New Precip: {wp.Observation.Precipitation}, Type: {wp.Observation.PrecipType}, Rate: {rainrate}");
DoRain(newRain, rainrate, ts);
cumulus.LogMessage(
$"TempestDoRain: Total Precip for Day: {Raincounter}");
DoOutdoorHumidity((int)wp.Observation.Humidity, ts);
OutdoorDewpoint =
ConvertTempCToUser(MeteoLib.DewPoint(ConvertUserTempToC(OutdoorTemperature),
OutdoorHumidity));
CheckForDewpointHighLow(ts);
DoApparentTemp(ts);
DoFeelsLike(ts);
DoWindChill(userTemp, ts);
DoHumidex(ts);
DoPressTrend(null);
UpdateStatusPanel(ts);
UpdateMQTT();
DoForecast(string.Empty, false);
cumulus.BatteryLowAlarm.Triggered = wp.Observation.BatteryVoltage <= 2.355M;
break;
case WeatherPacket.MessageType.RapidWind:
var rw = wp.RapidWind;
DoWind(ConvertWindMSToUser((double)rw.WindSpeed),
rw.WindDirection,
ConvertWindMSToUser((double)rw.WindSpeed),
rw.Timestamp);
UpdateStatusPanel(rw.Timestamp);
break;
case WeatherPacket.MessageType.LightningStrike:
LightningTime = wp.LightningStrike.Timestamp;
LightningDistance = ConvertKmtoUserUnits(wp.LightningStrike.Distance);
LightningStrikesToday++;
cumulus.LogMessage($"Lightning Detected: {wp.LightningStrike.Timestamp} - {wp.LightningStrike.Distance} km - {LightningStrikesToday} strikes today");
break;
}
}
}
private int ws2300ReadHistoryRecord(int record, out int address, out double tempindoor, out double tempoutdoor, out double pressure, out int humindoor, out int humoutdoor,
out double raincount, out double windspeed, out double winddir, out double dewpoint, out double windchill)
{
byte[] data = new byte[20];
byte[] command = new byte[25];
int bytes = 10;
int tempint;
address = 0x6C6 + record * 19;
cumulus.LogMessage("Reading history record " + record);
if (ws2300ReadWithRetries(address, bytes, data, command) != bytes)
{
cumulus.LogMessage("Failed to read history record");
tempindoor = 0;
tempoutdoor = 0;
pressure = 0;
humindoor = 0;
humoutdoor = 0;
raincount = 0;
windspeed = 0;
winddir = 0;
dewpoint = 0;
windchill = 0;
return(-1000);
}
string msg = "History record read: ";
for (int n = 0; n < bytes; n++)
{
msg += data[n].ToString("X2");
msg += " ";
}
cumulus.LogMessage(msg);
tempint = (data[4] << 12) + (data[3] << 4) + (data[2] >> 4);
pressure = 1000 + (tempint % 10000) / 10.0;
if (pressure >= 1502.2)
{
pressure = pressure - 1000;
}
pressure = ConvertPressMBToUser(pressure);
humindoor = (int)((tempint - (tempint % 10000)) / 10000.0);
humoutdoor = (data[5] >> 4) * 10 + (data[5] & 0xF);
raincount = ConvertRainMMToUser(rainref + (((data[7] & 0xF) * 256 + data[6]) - raincountref) * 0.518);
windspeed = (data[8] * 16 + (data[7] >> 4)) / 10.0;
if (windspeed > 49.9)
{
// probably lost sensor contact
windspeed = 0;
}
// need wind in kph for chill calc
double windkmh = 3.6 * windspeed;
tempint = ((data[2] & 0xF) << 16) + (data[1] << 8) + data[0];
tempindoor = ConvertTempCToUser((tempint % 1000) / 10.0f - 30.0);
tempoutdoor = (tempint - (tempint % 1000)) / 10000.0f - 30.0;
windchill = ConvertTempCToUser(MeteoLib.WindChill(tempoutdoor, windkmh));
dewpoint = ConvertTempCToUser(MeteoLib.DewPoint(tempoutdoor, humoutdoor));
tempoutdoor = ConvertTempCToUser(tempoutdoor);
windspeed = ConvertWindMSToUser(windspeed);
winddir = (data[9] & 0xF) * 22.5;
return((++record) % 0xAF);
}
private void processHistoryData()
{
// history data is alread in correct units
int totalentries = datalist.Count;
int rollHour = Math.Abs(cumulus.GetHourInc());
int luhour = cumulus.LastUpdateTime.Hour;
bool rolloverdone = luhour == rollHour;
bool midnightraindone = luhour == 0;
double prevraintotal = -1;
double raindiff, rainrate;
double pressureoffset = ConvertPressMBToUser(ws2300PressureOffset());
while (datalist.Count > 0)
{
historyData historydata = datalist[datalist.Count - 1];
DateTime timestamp = historydata.timestamp;
cumulus.LogMessage("Processing data for " + timestamp);
// Check for rollover
int h = timestamp.Hour;
if (h != rollHour)
{
rolloverdone = false;
}
if ((h == rollHour) && !rolloverdone)
{
// do rollover
cumulus.LogMessage("WS2300: Day rollover " + timestamp);
DayReset(timestamp);
rolloverdone = true;
}
// handle rain since midnight reset
if (h != 0)
{
midnightraindone = false;
}
if ((h == 0) && !midnightraindone)
{
ResetMidnightRain(timestamp);
ResetSunshineHours();
midnightraindone = true;
}
// Humidity ====================================================================
if ((historydata.inHum > 0) && (historydata.inHum <= 100))
{
DoIndoorHumidity(historydata.inHum);
}
if ((historydata.outHum > 0) && (historydata.outHum <= 100))
{
DoOutdoorHumidity(historydata.outHum, timestamp);
}
// Wind ========================================================================
if (historydata.windSpeed < cumulus.LCMaxWind)
{
DoWind(historydata.windGust, historydata.windBearing, historydata.windSpeed, timestamp);
}
// Temperature ==================================================================
if ((historydata.outTemp > -50) && (historydata.outTemp < 50))
{
DoOutdoorTemp(historydata.outTemp, timestamp);
tempsamplestoday = tempsamplestoday + historydata.interval;
TempTotalToday = TempTotalToday + (OutdoorTemperature * historydata.interval);
if (OutdoorTemperature < cumulus.ChillHourThreshold)
// add 1 minute to chill hours
{
ChillHours += (historydata.interval / 60.0);
}
}
if ((historydata.inTemp > -50) && (historydata.inTemp < 50))
{
DoIndoorTemp(historydata.inTemp);
}
// Rain ==========================================================================
if (prevraintotal < 0)
{
raindiff = 0;
}
else
{
raindiff = historydata.rainTotal - prevraintotal;
}
if (historydata.interval > 0)
{
rainrate = (raindiff) * (60 / historydata.interval);
}
else
{
rainrate = 0;
}
cumulus.LogMessage("WS2300: History rain total = " + historydata.rainTotal);
DoRain(historydata.rainTotal, rainrate, timestamp);
prevraintotal = historydata.rainTotal;
// Dewpoint ====================================================================
if (cumulus.CalculatedDP)
{
double tempC = ConvertUserTempToC(OutdoorTemperature);
DoOutdoorDewpoint(ConvertTempCToUser(MeteoLib.DewPoint(tempC, OutdoorHumidity)), timestamp);
CheckForDewpointHighLow(timestamp);
}
else
{
if (historydata.dewpoint < ConvertUserTempToC(60))
{
DoOutdoorDewpoint(CalibrateTemp(historydata.dewpoint), timestamp);
}
}
// Windchill ==================================================================
if (cumulus.CalculatedWC)
{
if (ConvertUserWindToMS(WindAverage) < 1.5)
{
DoWindChill(OutdoorTemperature, timestamp);
}
else
{
// calculate wind chill from calibrated C temp and calibrated win in KPH
DoWindChill(ConvertTempCToUser(MeteoLib.WindChill(ConvertUserTempToC(OutdoorTemperature), ConvertUserWindToKPH(WindAverage))), timestamp);
}
}
else
{
if (historydata.windchill < ConvertTempCToUser(60))
{
DoWindChill(historydata.windchill, timestamp);
}
}
// Wind run ======================================================================
cumulus.LogMessage("Windrun: " + WindAverage.ToString(cumulus.WindFormat) + cumulus.WindUnitText + " for " + historydata.interval + " minutes = " +
(WindAverage * WindRunHourMult[cumulus.WindUnit] * historydata.interval / 60.0).ToString(cumulus.WindRunFormat) + cumulus.WindRunUnitText);
WindRunToday += (WindAverage * WindRunHourMult[cumulus.WindUnit] * historydata.interval / 60.0);
CheckForWindrunHighLow(timestamp);
// Pressure ======================================================================
double slpress = historydata.pressure + pressureoffset;
if ((slpress > ConvertPressMBToUser(900)) && (slpress < ConvertPressMBToUser(1200)))
{
DoPressure(slpress, timestamp);
}
// update heating/cooling degree days
UpdateDegreeDays(historydata.interval);
DoApparentTemp(timestamp);
CalculateDominantWindBearing(Bearing, WindAverage, historydata.interval);
bw.ReportProgress((totalentries - datalist.Count) * 100 / totalentries, "processing");
//UpdateDatabase(timestamp.ToUniversalTime(), historydata.interval, false);
cumulus.DoLogFile(timestamp, false);
if (cumulus.LogExtraSensors)
{
cumulus.DoExtraLogFile(timestamp);
}
AddLastHourDataEntry(timestamp, Raincounter, OutdoorTemperature);
AddGraphDataEntry(timestamp, Raincounter, RainToday, RainRate, OutdoorTemperature, OutdoorDewpoint, ApparentTemperature, WindChill, HeatIndex, IndoorTemperature, Pressure, WindAverage, RecentMaxGust, AvgBearing, Bearing, OutdoorHumidity, IndoorHumidity, SolarRad, CurrentSolarMax, UV);
AddLast3HourDataEntry(timestamp, Pressure, OutdoorTemperature);
AddRecentDataEntry(timestamp, WindAverage, RecentMaxGust, WindLatest, Bearing, AvgBearing, OutdoorTemperature, WindChill, OutdoorDewpoint, HeatIndex, OutdoorHumidity,
Pressure, RainToday, SolarRad, UV, Raincounter);
RemoveOldLHData(timestamp);
RemoveOldL3HData(timestamp);
RemoveOldGraphData(timestamp);
DoTrendValues(timestamp);
UpdatePressureTrendString();
UpdateStatusPanel(timestamp);
cumulus.AddToWebServiceLists(timestamp);
datalist.RemoveAt(datalist.Count - 1);
}
}