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);
}
}
public override void getAndProcessHistoryData()
{
int interval;
int countdown;
timestamp ts;
int numrecs;
cumulus.LogMessage("Reading history info");
int rec = ws2300ReadHistoryDetails(out interval, out countdown, out ts, out numrecs);
if (rec < 0)
{
cumulus.LogMessage("Failed to read history data");
}
else
{
cumulus.LogMessage("History info obtained");
datalist = new List <historyData>();
double pressureoffset = ws2300PressureOffset();
if (pressureoffset > -1000)
{
cumulus.LogMessage("Pressure offset = " + pressureoffset);
}
else
{
pressureoffset = 0;
cumulus.LogMessage("Failed to read pressure offset, using zero");
}
cumulus.LogMessage("Downloading history data");
datalist.Clear();
DateTime recordtime;// = ws2300TimestampToDateTime(ts);
if (cumulus.WS2300IgnoreStationClock)
{
// assume latest archive record is 'now'
recordtime = DateTime.Now;
}
else
{
// use time from station
recordtime = ws2300TimestampToDateTime(ts);
}
while ((numrecs > 0) && (recordtime > cumulus.LastUpdateTime))
{
int address, inhum, outhum;
double intemp, outtemp, press, raincount, windspeed, bearing, dewpoint, windchill;
if (
ws2300ReadHistoryRecord(rec, out address, out intemp, out outtemp, out press, out inhum, out outhum, out raincount, out windspeed, out bearing, out dewpoint,
out windchill) < 0)
{
cumulus.LogMessage("Error reading history record");
numrecs = 0;
datalist.Clear();
}
else
{
historyData histData = new historyData();
histData.timestamp = recordtime;
histData.interval = interval;
histData.address = address;
histData.inHum = inhum;
histData.inTemp = intemp;
histData.outHum = outhum;
histData.outTemp = outtemp;
histData.pressure = press;
histData.rainTotal = raincount;
histData.windBearing = (int)bearing;
histData.windGust = windspeed;
histData.windSpeed = windspeed;
histData.dewpoint = dewpoint;
histData.windchill = windchill;
datalist.Add(histData);
recordtime = recordtime.AddMinutes(-interval);
numrecs--;
rec--;
if (rec < 0)
{
rec = 0xAE;
}
bw.ReportProgress(datalist.Count, "collecting");
}
}
}
cumulus.LogMessage("Number of history entries = " + datalist.Count);
if (datalist.Count > 0)
{
processHistoryData();
}
//using (cumulusEntities dataContext = new cumulusEntities())
//{
// UpdateHighsAndLows(dataContext);
//}
}
