public static SYSTEM_POWER_STATUS_EX2 GetSystemPowerStatus()
{
SYSTEM_POWER_STATUS_EX2 retVal = new SYSTEM_POWER_STATUS_EX2();
int result = GetSystemPowerStatusEx2(retVal, Marshal.SizeOf(retVal), 1);
return(retVal);
}
public static Byte GetBatteryLifePercent()
{
SYSTEM_POWER_STATUS_EX2 retVal = new SYSTEM_POWER_STATUS_EX2();
int result = GetSystemPowerStatusEx2(retVal, Marshal.SizeOf(retVal), 0);
return(retVal.BatteryLifePercent);
}
public static string getBattary()
{
SYSTEM_POWER_STATUS_EX status = new SYSTEM_POWER_STATUS_EX();
SYSTEM_POWER_STATUS_EX2 status2 = new SYSTEM_POWER_STATUS_EX2();
if (GetSystemPowerStatusEx(status, false) == 1)
{
return String.Format("({0})%", status.BatteryLifePercent);
}
else return "";
}
/// <summary>
/// 获取电池电量
/// </summary>
/// <returns></returns>
public static byte GetBattery()
{
SYSTEM_POWER_STATUS_EX2 status = new SYSTEM_POWER_STATUS_EX2();
if (GetSystemPowerStatusEx2(status, (uint)Marshal.SizeOf(typeof(SYSTEM_POWER_STATUS_EX2)), true) > 0)
{
return(status.BatteryLifePercent);
}
else
{
return(0);
}
}
/// <summary>
/// Wrapper over GetSystemPowerStatusEx2
/// </summary>
/// <returns></returns>
public static int GetBatteryLifePercent2()
{
SYSTEM_POWER_STATUS_EX2 status2 = new SYSTEM_POWER_STATUS_EX2();
int percent = 0;
if (GetSystemPowerStatusEx2(status2,
(uint)Marshal.SizeOf(status2), false) ==
(uint)Marshal.SizeOf(status2))
{
percent = status2.BackupBatteryLifePercent;
}
return percent;
}
static public int GetBatteryLifePercent()
{
SYSTEM_POWER_STATUS_EX2 status = new SYSTEM_POWER_STATUS_EX2();
GetSystemPowerStatusEx2(ref status, System.Runtime.InteropServices.Marshal.SizeOf(status), 1);
if (status.ACLineStatus == 0)
{
return(status.BatteryLifePercent);
}
else
{
return(-1);
}
}
private bool updateStatus()
{
bool bRes = false;
m_SYSTEM_POWER_STATUS_EX2 = new SYSTEM_POWER_STATUS_EX2();
if (GetSystemPowerStatusEx2(m_SYSTEM_POWER_STATUS_EX2, (uint)Marshal.SizeOf(m_SYSTEM_POWER_STATUS_EX2), false) == (uint)Marshal.SizeOf(m_SYSTEM_POWER_STATUS_EX2))
{
bRes = true;
}
else
{
bRes = false;
}
return(bRes);
}
public static BatteryLevel GetSystemPowerStatus()
{
SYSTEM_POWER_STATUS_EX2 retVal = new SYSTEM_POWER_STATUS_EX2();
int result = GetSystemPowerStatusEx2(retVal, Marshal.SizeOf(retVal), 0);
switch (retVal.BatteryFlag)
{
case BatteryFlag.BATTERY_FLAG_CRITICAL:
return(BatteryLevel.Medium);
case BatteryFlag.BATTERY_FLAG_LOW:
return(BatteryLevel.High);
case BatteryFlag.BATTERY_FLAG_HIGH:
return(BatteryLevel.VeryHigh);
default:
return(BatteryLevel.Low);
}
}
public static SYSTEM_POWER_STATUS_EX2 GetBatteryAdvanced()
{
string str = "";
var v = DllImportCaller.lib.GetSystemPowerStatusExAdv7(ref str, true);
var val = v > 0; //or == 53. aka sizeof(SYSTEM_POWER_STATUS_EX2);
if (val)
{
SYSTEM_POWER_STATUS_EX2 powerStatus = new SYSTEM_POWER_STATUS_EX2();
var s = str.Split('\n');
powerStatus.ACLineStatus = (ACLineStatus)byte.Parse(s[0]);
powerStatus.BackupBatteryFlag = byte.Parse(s[1]);
powerStatus.BackupBatteryFullLifeTime = uint.Parse(s[2]);
powerStatus.BackupBatteryLifePercent = byte.Parse(s[3]);
powerStatus.BackupBatteryLifeTime = uint.Parse(s[4]);
powerStatus.BatteryFlag = byte.Parse(s[5]);
powerStatus.BatteryFullLifeTime = uint.Parse(s[6]);
powerStatus.BatteryLifePercent = byte.Parse(s[7]);
powerStatus.BatteryLifeTime = uint.Parse(s[8]);
powerStatus.BatteryVoltage = uint.Parse(s[9]);
powerStatus.BatteryCurrent = uint.Parse(s[10]);
powerStatus.BatteryAverageCurrent = uint.Parse(s[11]);
powerStatus.BatteryAverageInterval = uint.Parse(s[12]);
powerStatus.BatterymAHourConsumed = uint.Parse(s[13]);
powerStatus.BatteryTemperature = uint.Parse(s[14]);
powerStatus.BackupBatteryVoltage = uint.Parse(s[15]);
powerStatus.BatteryChemistry = (BatteryChemistry)byte.Parse(s[16]);
powerStatus.Reserved1 = byte.Parse(s[17]);
powerStatus.Reserved2 = byte.Parse(s[18]);
powerStatus.Reserved3 = byte.Parse(s[19]);
return(powerStatus);
}
return(default(SYSTEM_POWER_STATUS_EX2));
}
public static extern uint GetSystemPowerStatusEx2(ref SYSTEM_POWER_STATUS_EX2 pSystemPowerStatusEx2, int dwLen, int fUpdate);
public static extern uint GetSystemPowerStatusEx2(SYSTEM_POWER_STATUS_EX2 pSystemPowerStatusEx2, uint dwLen, [MarshalAs(UnmanagedType.Bool)]bool fUpdate);
public static extern int GetSystemPowerStatusEx2(
SYSTEM_POWER_STATUS_EX2 statusInfo,
int length,
int getLatest
);
private static extern int GetSystemPowerStatusEx2(SYSTEM_POWER_STATUS_EX2 pSystemPowerStatusEx2, [MarshalAs(UnmanagedType.U4), In] uint dwLen, [MarshalAs(UnmanagedType.Bool), In] bool fUpdate);
public static extern uint GetSystemPowerStatusEx2(SYSTEM_POWER_STATUS_EX2 pSystemPowerStatusEx2, uint dwLen, [MarshalAs(UnmanagedType.Bool)] bool fUpdate);
public static extern uint GetSystemPowerStatusEx2(SYSTEM_POWER_STATUS_EX2 lpSystemPowerStatus, uint dwLen, bool fUpdate);
public static SYSTEM_POWER_STATUS_EX2 GetBatteryAdvanced()
{
string str = "";
var v = DllImportCaller.lib.GetSystemPowerStatusExAdv7(ref str, true);
var val = v > 0; //or == 53. aka sizeof(SYSTEM_POWER_STATUS_EX2);
if (val)
{
SYSTEM_POWER_STATUS_EX2 powerStatus = new SYSTEM_POWER_STATUS_EX2();
var s = str.Split('\n');
powerStatus.ACLineStatus = (ACLineStatus)byte.Parse(s[0]);
powerStatus.BackupBatteryFlag = byte.Parse(s[1]);
powerStatus.BackupBatteryFullLifeTime = uint.Parse(s[2]);
powerStatus.BackupBatteryLifePercent = byte.Parse(s[3]);
powerStatus.BackupBatteryLifeTime = uint.Parse(s[4]);
powerStatus.BatteryFlag = byte.Parse(s[5]);
powerStatus.BatteryFullLifeTime = uint.Parse(s[6]);
powerStatus.BatteryLifePercent = byte.Parse(s[7]);
powerStatus.BatteryLifeTime = uint.Parse(s[8]);
powerStatus.BatteryVoltage = uint.Parse(s[9]);
powerStatus.BatteryCurrent = uint.Parse(s[10]);
powerStatus.BatteryAverageCurrent = uint.Parse(s[11]);
powerStatus.BatteryAverageInterval = uint.Parse(s[12]);
powerStatus.BatterymAHourConsumed = uint.Parse(s[13]);
powerStatus.BatteryTemperature = uint.Parse(s[14]);
powerStatus.BackupBatteryVoltage = uint.Parse(s[15]);
powerStatus.BatteryChemistry = (BatteryChemistry)byte.Parse(s[16]);
powerStatus.Reserved1 = byte.Parse(s[17]);
powerStatus.Reserved2 = byte.Parse(s[18]);
powerStatus.Reserved3 = byte.Parse(s[19]);
return powerStatus;
}
return default(SYSTEM_POWER_STATUS_EX2);
}
public Measurement()
{
// prepare for measuring
status = new SYSTEM_POWER_STATUS_EX2();
DataSize = (uint)Marshal.SizeOf(status);
}
public static extern int GetSystemPowerStatusEx2([Out, In] ref SYSTEM_POWER_STATUS_EX2 pSystemPowerStatusEx2, [MarshalAs(UnmanagedType.U4), In] int dwLen, [MarshalAs(UnmanagedType.Bool), In] bool fUpdate);
private void timer1_Tick(object source, EventArgs e)
{
// grab status info
SYSTEM_POWER_STATUS_EX2 status = new SYSTEM_POWER_STATUS_EX2();
uint Size = (uint)Marshal.SizeOf(status);
uint result = GetSystemPowerStatusEx2(out status,(uint)Marshal.SizeOf(status),true);
if (Size == result)
{
// display the current battery information
/*
switch (status.ACLineStatus)
{
case AC_LINE_OFFLINE:
lblACStatus.Text = "Offline";
break;
case AC_LINE_ONLINE:
lblACStatus.Text = "Online";
break;
case AC_LINE_BACKUP_POWER:
lblACStatus.Text = "Backup";
break;
case AC_LINE_UNKNOWN:
lblACStatus.Text = "Unknown";
break;
default:
lblACStatus.Text = "Undefined";
break;
}
*/
switch (status.BatteryFlag)
{
case BATTERY_FLAG_CHARGING:
lblBattStatus.Text = "Charging";
break;
case BATTERY_FLAG_CRITICAL:
lblBattStatus.Text = "Critical";
break;
case BATTERY_FLAG_HIGH:
lblBattStatus.Text = "High";
break;
case BATTERY_FLAG_LOW:
lblBattStatus.Text = "Low";
break;
case BATTERY_FLAG_NO_BATTERY:
lblBattStatus.Text = "None";
break;
case BATTERY_FLAG_UNKNOWN:
lblBattStatus.Text = "Unknown";
break;
default:
lblBattStatus.Text = "Undefined";
break;
}
if (status.BatteryLifePercent == BATTERY_PERCENTAGE_UNKNOWN)
lblBattPercent.Text = "Unknown";
else
lblBattPercent.Text = status.BatteryLifePercent.ToString();
// if battery percent is 10 percent or below do an emergency save of the current log
if (status.BatteryLifePercent <= 10)
SaveLog(source, e);
if (status.BatteryLifeTime == BATTERY_LIFE_UNKNOWN)
lblBattTime.Text = "Unknown";
else
{
// convert to h:m:s format
uint time = status.BatteryLifeTime;
uint hours = time / 3600;
time -= (hours * 3600);
uint minutes = time / 60;
time -= (minutes * 60);
uint seconds = time;
lblBattTime.Text = hours.ToString() + ":" + minutes.ToString() + ":" + seconds.ToString();
}
//lblBattTime.Text = status.BatteryLifeTime.ToString();
lblBattVoltage.Text = status.BatteryVoltage.ToString();
lblBattCurrent.Text = status.BatteryCurrent.ToString();
lblTemperature.Text = status.BatteryTemperature.ToString();
}
else
{
//lblACStatus.Text = "X";
lblTemperature.Text = "X";
lblBattStatus.Text = "X";
lblBattCurrent.Text = "X";
lblBattPercent.Text = "X";
lblBattTime.Text = "X";
lblBattVoltage.Text = "X";
}
// determine if we should add to measurement queue and/or listbox
if (KeepHistory)
{
// format the current time
string curTime = "";
if (UsingTimeStamp)
curTime = System.DateTime.Now.ToString("hh:mm:ss");
else
curTime = (GetTickCount() - StartTime).ToString();
// add measurement to listbox
if (UpdateList)
{
lstCurrentInfo.Items.Add("" + curTime + " " + lblBattCurrent.Text);
lstCurrentInfo.SelectedIndex = lstCurrentInfo.Items.Count - 1;
}
// make room if necessary and add measurement to queue
if (Measurements.Count == MaxMeasurements)
Measurements.Dequeue();
Measurement M = new Measurement();
M.Current = status.BatteryCurrent;
M.Temperature = status.BatteryTemperature;
M.Life = status.BatteryLifePercent;
Measurements.Enqueue(M);
}
// force garbage collect to prevent memory leak
System.GC.Collect();
}
private void timer1_Tick(object source, EventArgs e)
{
// grab status info
SYSTEM_POWER_STATUS_EX2 status = new SYSTEM_POWER_STATUS_EX2();
uint Size = (uint)Marshal.SizeOf(status);
uint result = GetSystemPowerStatusEx2(out status, (uint)Marshal.SizeOf(status), true);
if (Size == result)
{
// display the current battery information
/*
* switch (status.ACLineStatus)
* {
* case AC_LINE_OFFLINE:
* lblACStatus.Text = "Offline";
* break;
* case AC_LINE_ONLINE:
* lblACStatus.Text = "Online";
* break;
* case AC_LINE_BACKUP_POWER:
* lblACStatus.Text = "Backup";
* break;
* case AC_LINE_UNKNOWN:
* lblACStatus.Text = "Unknown";
* break;
* default:
* lblACStatus.Text = "Undefined";
* break;
* }
*/
switch (status.BatteryFlag)
{
case BATTERY_FLAG_CHARGING:
lblBattStatus.Text = "Charging";
break;
case BATTERY_FLAG_CRITICAL:
lblBattStatus.Text = "Critical";
break;
case BATTERY_FLAG_HIGH:
lblBattStatus.Text = "High";
break;
case BATTERY_FLAG_LOW:
lblBattStatus.Text = "Low";
break;
case BATTERY_FLAG_NO_BATTERY:
lblBattStatus.Text = "None";
break;
case BATTERY_FLAG_UNKNOWN:
lblBattStatus.Text = "Unknown";
break;
default:
lblBattStatus.Text = "Undefined";
break;
}
if (status.BatteryLifePercent == BATTERY_PERCENTAGE_UNKNOWN)
{
lblBattPercent.Text = "Unknown";
}
else
{
lblBattPercent.Text = status.BatteryLifePercent.ToString();
}
// if battery percent is 10 percent or below do an emergency save of the current log
if (status.BatteryLifePercent <= 10)
{
SaveLog(source, e);
}
if (status.BatteryLifeTime == BATTERY_LIFE_UNKNOWN)
{
lblBattTime.Text = "Unknown";
}
else
{
// convert to h:m:s format
uint time = status.BatteryLifeTime;
uint hours = time / 3600;
time -= (hours * 3600);
uint minutes = time / 60;
time -= (minutes * 60);
uint seconds = time;
lblBattTime.Text = hours.ToString() + ":" + minutes.ToString() + ":" + seconds.ToString();
}
//lblBattTime.Text = status.BatteryLifeTime.ToString();
lblBattVoltage.Text = status.BatteryVoltage.ToString();
lblBattCurrent.Text = status.BatteryCurrent.ToString();
lblTemperature.Text = status.BatteryTemperature.ToString();
}
else
{
//lblACStatus.Text = "X";
lblTemperature.Text = "X";
lblBattStatus.Text = "X";
lblBattCurrent.Text = "X";
lblBattPercent.Text = "X";
lblBattTime.Text = "X";
lblBattVoltage.Text = "X";
}
// determine if we should add to measurement queue and/or listbox
if (KeepHistory)
{
// format the current time
string curTime = "";
if (UsingTimeStamp)
{
curTime = System.DateTime.Now.ToString("hh:mm:ss");
}
else
{
curTime = (GetTickCount() - StartTime).ToString();
}
// add measurement to listbox
if (UpdateList)
{
lstCurrentInfo.Items.Add("" + curTime + " " + lblBattCurrent.Text);
lstCurrentInfo.SelectedIndex = lstCurrentInfo.Items.Count - 1;
}
// make room if necessary and add measurement to queue
if (Measurements.Count == MaxMeasurements)
{
Measurements.Dequeue();
}
Measurement M = new Measurement();
M.Current = status.BatteryCurrent;
M.Temperature = status.BatteryTemperature;
M.Life = status.BatteryLifePercent;
Measurements.Enqueue(M);
}
// force garbage collect to prevent memory leak
System.GC.Collect();
}
public static SYSTEM_POWER_STATUS_EX2 GetSystemPowerStatus()
{
SYSTEM_POWER_STATUS_EX2 retVal = new SYSTEM_POWER_STATUS_EX2();
int result = GetSystemPowerStatusEx2(retVal, Marshal.SizeOf(retVal), 1);
return retVal;
}
protected bool UpdateBattery()
{
var status = new SYSTEM_POWER_STATUS_EX2();
GetSystemPowerStatusEx2(ref status, (uint)Marshal.SizeOf(status), false);
_sbACpower = status.AcLineStatus.ToString();
_sbChargeStatus = status.BatteryFlag.ToString();
_sbLifePercent = status.BatteryLifePercent.ToString() + "%";
_sbIcons = "00.png";
var s = status.BatteryLifePercent;
if (s < 20) _sbIcons = "20.png";
if ((s > 20) && (s < 41)) _sbIcons = "40.png";
if ((s > 40) && (s < 61)) _sbIcons = "60.png";
if ((s > 60) && (s < 81)) _sbIcons = "80.png";
if ((s > 80) && (s < 101)) _sbIcons = "100.png";
return true;
}
private void GetState()
{
for (int i = 0; i < _status.Count; i++) { _status[i] = ""; }
//***********************************************************************************************
//*********************************** 1 Cellular signal strength ********************************
if (SystemState.PhoneRadioOff)
{
_status[0] = "airplane-mode.png";
}
else
{
var _si = SystemState.PhoneSignalStrength;
if ((_si >= 0) && (_si <= 10)) { _status[0] = "no-signal.png"; }
if ((_si >= 10) && (_si <= 20)) { _status[0] = "signal-very-low.png"; }
if ((_si >= 20) && (_si <= 40)) { _status[0] = "signal-low.png"; }
if ((_si >= 40) && (_si <= 60)) { _status[0] = "signal-medium.png"; }
if ((_si >= 60) && (_si <= 80)) { _status[0] = "signal-high.png"; }
if ((_si >= 80) && (_si <= 100)) { _status[0] = "signal-full.png"; }
if (SystemState.PhoneBlockedSim) { _status[0] = "sim-locked.png"; }
if (SystemState.PhoneNoService) { _status[0] = "no-data.png"; }
if (SystemState.PhoneNoSim) { _status[0] = "sim-missing.png"; }
}
//***********************************************************************************************
//*********************************** 2 Cellular data connection ********************************
if (SystemState.CellularSystemConnected1xrtt) { _status[1] = "1xrt.png"; }
if (SystemState.CellularSystemConnectedEdge) { _status[1] = "edge.png"; }
if (SystemState.CellularSystemConnectedEvdo) { _status[1] = "1xevdo.png"; }
if (SystemState.CellularSystemConnectedEvdv) { _status[1] = "evdv.png"; }
if (SystemState.CellularSystemConnectedGprs) { _status[1] = "gprs.png"; }
if (SystemState.CellularSystemConnectedHsdpa) { _status[1] = "hsdpa.png"; }
if (SystemState.CellularSystemConnectedUmts) { _status[1] = "umts.png"; }
//*********************************** 3 Call forwarding *****************************************
//***********************************************************************************************
if ((SystemState.PhoneCallForwardingOnLine1) || (SystemState.PhoneCallForwardingOnLine2)) { _status[2] = "call-forward.png"; }
//*********************************** 4 Roaming *************************************************
//***********************************************************************************************
if (SystemState.PhoneRoaming) { _status[3] = "roaming.png"; } else { _status[3] = ""; }
//*********************************** 5 Wi-Fi connection ****************************************
//***********************************************************************************************
if (SystemState.WiFiStatePowerOn)
{
_status[4] = "wifi-not-connected.png";
if (SystemState.WiFiStateConnecting) { _status[4] = "wifi-connected-full.png"; }
if (SystemState.WiFiStateConnected) { _status[4] = "internet-sharing.png"; }
}
//*********************************** 6 Bluetooth device ****************************************
//***********************************************************************************************
if (SystemState.BluetoothStatePowerOn) { _status[5] = "bluetooth.png"; } else { _status[5] = ""; }
//*********************************** 7 Phone profile *******************************************
//***********************************************************************************************
if (SystemState.PhoneProfile == "Silent") { _status[6] = "silent-mode.png"; }
if (SystemState.PhoneRingerOff) { _status[6] = "vibrate.png"; }
//*********************************** 8 Keyboard and location ***********************************
//***********************************************************************************************
//*********************************** 9 Battery *************************************************
//***********************************************************************************************
if (SystemState.PowerBatteryState == BatteryState.Charging)
{
_status[8] = "battery-charging.png";
}
else
{
SYSTEM_POWER_STATUS_EX2 Status = new SYSTEM_POWER_STATUS_EX2();
uint retBytesCount = GetSystemPowerStatusEx2(ref Status, (uint)Marshal.SizeOf(Status), false);
if ((Status.BatteryLifePercent < 0) || (Status.BatteryLifePercent > 100))
{
_status[8] = "battery-unknown-state.png";
_batteryPower = 0;
}
else
{
_status[8] = "battery-state.png";
_batteryPower = Status.BatteryLifePercent;
}
}
}
public static extern bool GetSystemPowerStatusEx2(ref SYSTEM_POWER_STATUS_EX2 pSysPS, int StructLen, bool bUpd);
public static extern int GetSystemPowerStatusEx2(
SYSTEM_POWER_STATUS_EX2 statusInfo,
int length,
int getLatest
);
public MeasureClass()
{
// prepare for measuring
status = new SYSTEM_POWER_STATUS_EX2();
DataSize = (uint)Marshal.SizeOf(status);
}
private static extern uint GetSystemPowerStatusEx2(out SYSTEM_POWER_STATUS_EX2 lpSystemPowerStatus,
uint dwLen, bool fUpdate);
void InterfaceActivityTracker()
{
int k = 0;
int[] dataSavedSeconds = new int[this._Sensors.Count];
int[] secondsCounter = new int[this._Sensors.Count];
int[] full = new int[this._Sensors.Count];
int[] partial = new int[this._Sensors.Count];
int[] empty = new int[this._Sensors.Count];
if (!Directory.Exists(this._StorageDirectory + "\\log\\"))
{
Directory.CreateDirectory(this._StorageDirectory + "\\log\\");
}
if (!Directory.Exists(this._StorageDirectory + "\\data\\summary\\"))
{
Directory.CreateDirectory(this._StorageDirectory + "\\data\\summary\\");
}
for (int i = 0; (i < this._Sensors.Count); i++)
{
dataSavedSeconds[i] = 0;
secondsCounter[i] = 0;
full[i] = 0;
partial[i] = 0;
this._Sensors[i]._ReceivedACs = 0;
this._Sensors[i]._TotalReceivedACs = 0;
this._Sensors[i]._SavedACs = 0;
this._Sensors[i]._TotalSavedACs = 0;
Core.WRITE_FULL_RECEIVED_COUNT(i, 0);
Core.WRITE_PARTIAL_RECEIVED_COUNT(i, 0);
Core.WRITE_EMPTY_RECEIVED_COUNT(i, 0);
Core.WRITE_RECEIVED_ACs(i, -1);
Core.WRITE_SAVED_ACs(i, -1);
}
while (true)
{
if (connecting)
{
SystemIdleTimerReset();
if ((this != null) && (this._Sensors.Count > 0))
{
//Check 2 things, num of connection failures
// check if data received is > 0
// if num connections >2, ready to pause
// if data received is >0, ready to pause within 2 seconds.
bool receiveFailed = true;
bool receivedFullData = true;
bool notimeoutData = true;
for (int i = 0; (i < this._Sensors.Count); i++)
{
receivedFullData &= (this._Sensors[i]._ReceivedPackets == ((WocketsDecoder)this._Decoders[i])._ExpectedBatchCount);
//halt, if either 1 successful connection was made
// or any data was received
// or 3 or more reconnections were made
if ((((RFCOMMReceiver)this._Receivers[i])._Reconnections < 3))
{
receiveFailed = false;
}
//if (((RFCOMMReceiver)this._Receivers[i])._SuccessfulConnections >= 1)
secondsCounter[i] = secondsCounter[i] + 1;
notimeoutData &= (secondsCounter[i] > 20);
}
if ((receivedFullData) || (receiveFailed) || (notimeoutData))
{
// if didnt get full data, sleep for 2 seconds
if (!receivedFullData)
{
Thread.Sleep(3000);
}
//save whatever we have so far then sleep
connecting = false;
SYSTEM_POWER_STATUS_EX2 bpower = Battery.GetSystemPowerStatus();
DateTime now = DateTime.Now;
double unixtime = WocketsTimer.GetUnixTime(now);
string currentTime = now.ToString("yyyy-MM-dd HH:mm:ss");
string log_line = ++k + "," + currentTime + "," + bpower.BatteryLifePercent + "," + bpower.BatteryVoltage + "," + bpower.BatteryCurrent + "," + bpower.BatteryTemperature;
string hourlyPath = now.ToString("yyyy-MM-dd") + "\\" + now.Hour;
DiskSpace space1 = Memory.GetDiskSpace(this._StorageDirectory);
DiskSpace space2 = Memory.GetDiskSpace("/");
int remainingStorage1 = (int)(space1.TotalNumberOfBytes / System.Math.Pow(2, 20));
int remainingStorage2 = (int)(space2.TotalNumberOfBytes / System.Math.Pow(2, 20));
string upload_log = currentTime + "," + bpower.BatteryLifePercent + "," + remainingStorage2 + "," + remainingStorage1;
for (int i = 0; (i < this._Sensors.Count); i++)
{
if ((this._Sensors[i]._ReceivedPackets > 4000) || (((WocketsDecoder)this._Decoders[i])._ExpectedBatchCount > 4000))
{
upload_log += "," + this._Sensors[i]._BatteryLevel + "," + 0 + "," + 0;
}
else
{
upload_log += "," + this._Sensors[i]._BatteryLevel + "," + ((WocketsDecoder)this._Decoders[i])._ExpectedBatchCount + "," + this._Sensors[i]._ReceivedPackets;
}
if (this._Sensors[i]._ReceivedPackets == ((WocketsDecoder)this._Decoders[i])._ExpectedBatchCount)
{
full[i] = full[i] + 1;
}
else if (this._Sensors[i]._ReceivedPackets == 0)
{
empty[i] = empty[i] + 1;
}
else
{
partial[i] = partial[i] + 1;
}
Core.WRITE_FULL_RECEIVED_COUNT(i, full[i]);
Core.WRITE_PARTIAL_RECEIVED_COUNT(i, partial[i]);
Core.WRITE_EMPTY_RECEIVED_COUNT(i, empty[i]);
Core.WRITE_RECEIVED_ACs(i, ((WocketsDecoder)this._Decoders[i])._ACIndex);
Core.WRITE_RECEIVED_COUNT(i, this._Sensors[i]._ReceivedPackets);
log_line += "," + this._Sensors[i]._ReceivedPackets + "," + ((WocketsDecoder)this._Decoders[i])._ExpectedBatchCount + "," + ((RFCOMMReceiver)this._Receivers[i])._SuccessfulConnections + "," + ((RFCOMMReceiver)this._Receivers[i])._Reconnections + "," + ((RFCOMMReceiver)this._Receivers[i])._ConnectionTime;
dataSavedSeconds[i] = 0;
countSeconds[i] = false;
secondsCounter[i] = 0;
((WocketsDecoder)this._Decoders[i])._ExpectedBatchCount = -1;
if (!Directory.Exists(this._StorageDirectory + "\\data\\summary\\" + hourlyPath))
{
Directory.CreateDirectory(this._StorageDirectory + "\\data\\summary\\" + hourlyPath);
}
TextWriter tw2 = new StreamWriter(this._StorageDirectory + "\\data\\summary\\" + hourlyPath + "\\SummaryAC-" + this._Sensors[i]._Location + "-" + i + ".csv", true);
int nextACIndex = LastACIndex[i] + 1;
if (nextACIndex == 960)
{
nextACIndex = 0;
}
int countsaved = 0;
for (int j = nextACIndex; (j != ((WocketsDecoder)this._Decoders[i])._ActivityCountIndex);)
{
DateTime ac_dt = new DateTime();
WocketsTimer.GetDateTime((long)((WocketsDecoder)this._Decoders[i])._ActivityCounts[j]._TimeStamp, out ac_dt);
string ac_currentTime = ac_dt.ToString("yyyy-MM-dd HH:mm:ss");
tw2.WriteLine(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss") + "," + j + "," + ((WocketsDecoder)this._Decoders[i])._ActivityCounts[j]._SeqNum + "," + ac_currentTime + "," + ((WocketsDecoder)this._Decoders[i])._ActivityCounts[j]._TimeStamp + "," + ((WocketsDecoder)this._Decoders[i])._ActivityCounts[j]._Count);
SynchronizedLogger.Write(i + "," + ac_currentTime + "," + ((RFCOMMReceiver)this._Receivers[i])._Address + "," + ((WocketsDecoder)this._Decoders[i])._ActivityCounts[j]._Count);
LastSeqNum[i] = ((WocketsDecoder)this._Decoders[i])._ActivityCounts[j]._SeqNum;
LastACIndex[i] = j;
countsaved++;
j++;
if (j == 960)
{
j = 0;
}
}
if (countsaved > 10)
{
Core.WRITE_SAVED_ACs(i, 10);
}
else
{
Core.WRITE_SAVED_ACs(i, countsaved);
}
tw2.Close();
}
this._Polling = false;
//shutting down BT here causes a strange delay on wakeup.
int btshutdown_counter = 0;
while (true)
{
btshutdown_counter++;
try
{
if ((Wockets.Utils.network.NetworkStacks._BluetoothStack.Dispose()) || (btshutdown_counter > 5))
{
break;
}
}
catch
{
}
SystemIdleTimerReset();
Thread.Sleep(1000);
}
SynchronizedLogger.Write(upload_log);
//TextWriter tw = new StreamWriter(this._StorageDirectory + "\\data\\log\\" + hourlyPath + "\\stats.csv", true);
//tw.Close();
Logger.Log(log_line);
SystemIdleTimerReset();
for (int i = 0; (i < this._Sensors.Count); i++)
{
try
{
this._Sensors[i].Save();
}
catch (Exception e)
{
Logger.Error("Sensor " + i + ": failed to save:" + e.Message);
}
}
Thread.Sleep(1000);
if ((bpower.BatteryCurrent < 0) && (DateTime.Now.Subtract(lastActivity).TotalSeconds > 30))
{
SetSystemPowerState(null, POWER_STATE_SUSPEND, POWER_FORCE);
}
}
}
}
Thread.Sleep(1000);
}
}
