// Update is called once per frame
void Update()
{
if (Time.time >= timeDelay || lastStatus != SystemInfo.batteryStatus)
{
lastStatus = SystemInfo.batteryStatus;
Vector3 scale = Vector3.one;
scale.x = SystemInfo.batteryLevel;
string addIn = System.String.Empty;
switch (lastStatus)
{
case BatteryStatus.Charging: {
addIn = "+";
break;
}
case BatteryStatus.Discharging: {
addIn = "-";
break;
}
}
transform.localScale = scale;
img.color = (scale.x < .2f) ? Color.red : (scale.x < .45f) ? Color.yellow : Color.green;
string warn = (scale.x < .15f) ? "!" : System.String.Empty;
percText.text = warn + (scale.x * 100f) + "%" + addIn + warn;
timeDelay = Time.time + 10f;
}
}
static int Main()
{
BatteryStatus.CheckBatteryStatus(40, 60, 0.4f);
BatteryStatus.CheckBatteryStatus(-1, 20, 0.3f);
BatteryStatus.CheckBatteryStatus(100, -20, 0.1f);
return(0);
}
private static BatteryEntryState ToBatteryEntryState(BatteryStatus bs)
{
BatteryEntryState state = BatteryEntryState.Unknown;
switch (bs)
{
case BatteryStatus.Full:
state = BatteryEntryState.Full;
break;
case BatteryStatus.Charging:
state = BatteryEntryState.Charging;
break;
case BatteryStatus.Discharging:
state = BatteryEntryState.Discharging;
break;
case BatteryStatus.NotCharging:
state = BatteryEntryState.NotCharging;
break;
case BatteryStatus.Unknown:
state = BatteryEntryState.Unknown;
break;
}
return(state);
}
public void Initialize()
{
_batteryStatus = new BatteryStatus();
_batteryStatus.Start();
_batteryStatus.BatteryStatusUpdate += (s, bi) =>
{
this.BatteryDetails.BatteryStatus = bi.ChargeStatus;
this.BatteryDetails.ChargeDischargeRate = bi.DischargeRate;
this.BatteryDetails.DesignCapacity = bi.DesignedMaxCapacity;
this.BatteryDetails.FullCharge = bi.FullChargeCapacity;
this.BatteryDetails.RemainingCapacity = (int)bi.CurrentCapacity;
this.BatteryDetails.RemainingCapacityInPercent = bi.CurrentCapacityPercent;
this.BatteryDetails.BatteryHealthInPercent = bi.BatteryHealthPercent;
Chart.DischargeRateSeries.Values.Add(this.BatteryDetails.ChargeDischargeRate);
Chart.RemainingCapacity.Values.Add(this.BatteryDetails.RemainingCapacity);
if (Chart.DischargeRateSeries.Values.Count > 50)
{
Chart.MaxValue = Chart.DischargeRateSeries.Values.Count;
}
if (Chart.MaxValue > 200)
{
Chart.DischargeRateSeries.Values.RemoveAt(0);
Chart.RemainingCapacity.Values.RemoveAt(0);
}
};
}
protected override void Start()
{
base.Start();
HideAll();
myStatus = BatteryStatus.Normal;
//InvokeRepeating("LowBatteryUpdate", 0, 1);
}
public static string GetBatStatName(BatteryStatus status)
{
string batStatName = "";
switch (status)
{
case BatteryStatus.BAT_NO_DETECTED:
batStatName += "Bat no detected";
break;
case BatteryStatus.BAT_OK:
break;
case BatteryStatus.BAT_CHARGE_FAULT:
batStatName += "Charge Fault";
break;
case BatteryStatus.BAT_PRE_CHARGE:
batStatName += "Pre charge";
break;
case BatteryStatus.BAT_NO_CHARGER_NO_DISCHARGER:
batStatName += "No charge, No discharge";
break;
case BatteryStatus.BAT_CHARGE_DISCHARGE:
batStatName += "Discharge";
break;
case BatteryStatus.BAT_END_MEASURE_RESISTANCE:
batStatName += "Mesure resistance";
break;
case BatteryStatus.BAT_CHARGE:
batStatName += "Charging";
break;
case BatteryStatus.BAT_FULL:
batStatName += "Full";
break;
case BatteryStatus.BAT_FULL_MEASURE_RESISTANCE:
batStatName += "Full mesure resistance";
break;
case BatteryStatus.BAT_DISCHARGE:
batStatName += "Bat discharge";
break;
case BatteryStatus.BAT_END:
batStatName += "Bat end";
break;
default:
batStatName += "Code error!";
break;
}
return(batStatName);
}
public static string GetFileBatImage(BatteryStatus status)
{
string path = @"Resource\";
switch (status)
{
case BatteryStatus.BAT_CHARGE:
path += chargingBatImageName;
break;
case BatteryStatus.BAT_FULL:
path += fullBatImageName;
break;
case BatteryStatus.BAT_NO_DETECTED:
path += noBatImageName;
break;
default:
path += emtybatImageName;
break;
}
return(path);
}
public BatteryStateEventArgs(BatteryStatus status, double level, bool isCharging, TimeSpan?remainingTime)
{
Status = status;
Level = level;
IsCharging = isCharging;
RemainingTime = remainingTime;
}
public void SetBatteryStatus(BatteryStatus batteryStatus)
{
Debug.Log("SetBatteryStatus:" + batteryStatus);
CurBatteryStatus = batteryStatus;
if (batteryStatus == BatteryStatus.NoCharging)
{
//m_BaterryTarget.sprite = m_BatteryNormal;
SetBatteryPower(SvrNativeInterface.GetInstance().BatteryUtils.GetCurrentBattery());
BatteryChargeLightning.SetActive(false);
}
else
{
m_BaterryTarget.sprite = m_BatteryCharge;
BatteryChargeLightning.SetActive(true);
}
//if (batteryStatus == BatteryStatus.NoCharging)
//{
// ChargingAnimationSwitch(false);//关闭动画
// CurUsingBPs = NoChargingBPs;
// SetBatteryPower(CurBatteryPower);
//}
//else
//{
// CurUsingBPs = ChargingBPs;
// ChargingAnimationSwitch(true);
//}
}
public void Update()
{
try
{
if (!(bool)WMITool.QuerySingle("root/WMI", "BatteryStatus", "Active"))
{
Status = BatteryStatus.Unavailable;
return;
}
Status = BatteryStatus.Discharging;
if ((bool)WMITool.QuerySingle("root/WMI", "BatteryStatus", "Charging"))
{
Status = BatteryStatus.Charging;
}
}
catch (Exception)
{
Status = BatteryStatus.Unavailable;
return;
}
try
{
NominalCapacity = ((uint)WMITool.QuerySingle("root/WMI", "BatteryStaticData", "DesignedCapacity")) / 1000f;
}
catch { }
try
{
RealCapacity = ((uint)WMITool.QuerySingle("root/WMI", "BatteryFullChargedCapacity", "FullChargedCapacity")) / 1000f;
}
catch { }
try
{
CurrentCapacity = ((uint)WMITool.QuerySingle("root/WMI", "BatteryStatus", "RemainingCapacity")) / 1000f;
}
catch { }
try
{
ChargePercent = CurrentCapacity / RealCapacity * 100f;
}
catch { }
try
{
CurrentVoltage = ((uint)WMITool.QuerySingle("root/WMI", "BatteryStatus", "Voltage")) / 1000f;
}
catch { }
try
{
TimeToDischarge = TimeSpan.FromSeconds((uint)WMITool.QuerySingle("root/WMI", "BatteryRuntime", "EstimatedRuntime"));
}
catch { }
if (Status == BatteryStatus.Discharging)
{
ChargeRate = -((int)WMITool.QuerySingle("root/WMI", "BatteryStatus", "DischargeRate")) / 1000f;
}
else
{
ChargeRate = ((int)WMITool.QuerySingle("root/WMI", "BatteryStatus", "ChargeRate")) / 1000f;
}
}
private static void DetermineWorkloads()
{
BatteryStatus batteryStatus = PowerManager.BatteryStatus;
int remainingCharge = PowerManager.RemainingChargePercent;
PowerSupplyStatus powerStatus = PowerManager.PowerSupplyStatus;
PowerSourceKind powerSource = PowerManager.PowerSourceKind;
if ((powerSource == PowerSourceKind.DC &&
batteryStatus == BatteryStatus.Discharging &&
remainingCharge < 25) ||
(powerSource == PowerSourceKind.AC &&
powerStatus == PowerSupplyStatus.Inadequate))
{
// The device is not in a good battery/power state,
// so we should pause any non-critical work.
PauseNonCriticalWork();
}
else if ((batteryStatus != BatteryStatus.Discharging && remainingCharge > 75) &&
powerStatus != PowerSupplyStatus.Inadequate)
{
// The device is in good battery/power state,
// so let's kick of some high-power work.
StartPowerIntensiveWork();
}
}
/// <summary>
/// Initialize the controller subsystem
/// </summary>
/// <returns>true if initialization was sucessfull, false otherwise</returns>
public static bool InitController(CoreDispatcher uiDispatcher)
{
SystemDispatcher = uiDispatcher;
//first set the robot status
_RobotStatus = RobotStatus.Idle;
//battery
Hardware.UpdateSignalBattery();
SignalBatteryStatus = Hardware.UpdateSignalBatteryStatus();
Hardware.Signal_battery_status_indicator.UpdateRuntimeValue((int)SignalBatteryStatus);
Hardware.UpdatePowerBattery();
PowerBatteryStatus = Hardware.UpdatePowerBatteryStatus();
Hardware.Power_battery_status_indicator.UpdateRuntimeValue((int)PowerBatteryStatus);
//and start them
Hardware.Power_battery_status_indicator.Start();
Hardware.Signal_battery_status_indicator.Start();
//TODO: status indicator for what the robot control is doing
ControllerThread = new BackgroundWorker()
{
WorkerSupportsCancellation = true,
WorkerReportsProgress = true
};
ControllerThread.RunWorkerCompleted += OnControlThreadExit;
ControllerThread.ProgressChanged += ControllerLogProgress;
ControllerThread.DoWork += ControlRobotAuto;
ControllerThread.RunWorkerAsync();
return(true);
}
/// <inheritdoc />
public override void OnReceive(Context context, Intent intent)
{
if (this.Updated == null)
{
return;
}
var batteryLevel = intent.GetIntExtra(BatteryManager.ExtraLevel, -1);
var batteryScale = intent.GetIntExtra(BatteryManager.ExtraScale, -1);
var batteryStatus = intent.GetIntExtra(BatteryManager.ExtraStatus, -1);
var status = BatteryStatus.NotPresent;
switch (batteryStatus)
{
case (int)Android.OS.BatteryStatus.Charging:
status = BatteryStatus.Charging;
break;
case (int)Android.OS.BatteryStatus.Discharging:
status = BatteryStatus.Discharging;
break;
case (int)Android.OS.BatteryStatus.Full:
case (int)Android.OS.BatteryStatus.NotCharging:
status = BatteryStatus.Idle;
break;
case (int)Android.OS.BatteryStatus.Unknown:
status = BatteryStatus.NotPresent;
break;
}
var remainingChargePercent = (int)Math.Floor(batteryLevel * 100D / batteryScale);
if (status != this.previousStatus || remainingChargePercent != this.previousRemainingCharge)
{
lock (this.obj)
{
var eventArgs = new BatteryStatusChangedEventArgs(status, remainingChargePercent);
try
{
this.Updated?.Invoke(this, eventArgs);
}
catch (Exception ex)
{
#if DEBUG
System.Diagnostics.Debug.WriteLine(ex.ToString());
#endif
}
finally
{
this.previousStatus = status;
this.previousRemainingCharge = remainingChargePercent;
}
}
}
}
public static void CheckTemperature(float temperature)
{
float minTemperature = 0;
float maxTemperature = 45;
BatteryLevel.BatteryCondition batteryTemperature = BatteryLevel.CheckBatteryCondition(temperature, minTemperature, maxTemperature);
BatteryStatus.DisplayBatteryStatus("Temperature", batteryTemperature);
}
public NetBatteryState(string identifier, BatteryStatus status, double level, bool isCharging, TimeSpan?remainingTime)
{
Identifier = identifier;
Status = status;
Level = level;
IsCharging = isCharging;
RemainingTime = remainingTime;
}
public static void CheckChargeRate(float chargeRate)
{
float minChargeRate = 0.3f;
float maxChargeRate = 0.8f;
BatteryLevel.BatteryCondition batteryChargeRate = BatteryLevel.CheckBatteryCondition(chargeRate, minChargeRate, maxChargeRate);
BatteryStatus.DisplayBatteryStatus("Charge Rate", batteryChargeRate);
}
public static void CheckChargeState(float soc)
{
float minStateOfCharge = 20;
float maxStateOfCharge = 80;
BatteryLevel.BatteryCondition batteryChargeState = BatteryLevel.CheckBatteryCondition(soc, minStateOfCharge, maxStateOfCharge);
BatteryStatus.DisplayBatteryStatus("State of charge", batteryChargeState);
}
public BatteryInfo(byte Percentage, int Charges, BatteryStatus Status, DateTime LastCharged)
{
this.percentage = Percentage;
this.charges = Charges;
this.status = Status;
this.lastCharged = LastCharged;
Valid = true;
}
public Battery(byte[] bytes)
{
BatteryLevel = bytes[0];
Status = (BatteryStatus)bytes[9];
LastCharged = new DateTime(bytes[1] + 2000, bytes[2] + 1, bytes[3], bytes[4], bytes[5], bytes[6]);
Cycles = 0xffff & (0xff & bytes[7] | (0xff & bytes[8]) << 8);
}
private static void PowerManager_BatteryStatusChanged(object sender, object e)
{
BatteryStatus batteryStatus = PowerManager.BatteryStatus;
int remainingCharge = PowerManager.RemainingChargePercent;
OutputMessage($"Battery status changed: {batteryStatus}, {remainingCharge}");
DetermineWorkloads();
}
public Battery(byte[] bytes)
{
BatteryLevel = bytes[0];
Status = (BatteryStatus)bytes[9];
LastCharged = new DateTime(bytes[1] + 2000, bytes[2] + 1, bytes[3], bytes[4], bytes[5], bytes[6]);
Cycles = 0xffff & (0xff & bytes[7] | (0xff & bytes[8]) << 8);
}
public ShutterContactDiff(String Name, Int32 Room_ID, String Room_Name)
{
_DeviceType = DeviceTypes.ShutterContact;
_DeviceName = Name;
_RoomID = Room_ID;
_RoomName = Room_Name;
lowBattery = BatteryStatus.unchanged;
state = ShutterContactModes.unchanged;
}
// Start is called before the first frame update
void Start()
{
lastStatus = SystemInfo.batteryStatus;
percText = transform.parent.GetChild(1).GetComponent <Text> ();
img = GetComponent <Image> ();
//if (Application.platform != RuntimePlatform.Android){
// transform.parent.gameObject.SetActive (false);
//}
}
private void UpdateBatteryStatus(BatteryStatus batteryStatus, double batteryLevel, TimeSpan?batteryRemainingTime, bool isBatteryCharging)
{
BatteryLevel = batteryLevel;
BatteryRemainingTime = batteryRemainingTime;
IsBatteryCharging = isBatteryCharging;
BatteryStatus = batteryStatus;
BatteryChanged?.Invoke(this, new BatteryStateEventArgs(batteryStatus, batteryLevel, isBatteryCharging, batteryRemainingTime));
}
public ShutterContactDiff(String Name, Int32 Room_ID, String Room_Name)
{
_DeviceType = DeviceTypes.ShutterContact;
_DeviceName = Name;
_RoomID = Room_ID;
_RoomName = Room_Name;
lowBattery = BatteryStatus.unchanged;
state = ShutterContactModes.unchanged;
}
public HeatingThermostatDiff(String Name, Int32 Room_ID, String Room_Name)
{
_DeviceType = DeviceTypes.HeatingThermostat;
_DeviceName = Name;
_RoomID = Room_ID;
_RoomName = Room_Name;
lowBattery = BatteryStatus.unchanged;
temperature = Double.NaN;
mode = ThermostatModes.unchanged;
}
public HeatingThermostatDiff(String Name, Int32 Room_ID, String Room_Name)
{
_DeviceType = DeviceTypes.HeatingThermostat;
_DeviceName = Name;
_RoomID = Room_ID;
_RoomName = Room_Name;
lowBattery = BatteryStatus.unchanged;
temperature = Double.NaN;
mode = ThermostatModes.unchanged;
}
private void Init()
{
BatteryUtils = SvrNativeInterface.GetInstance().BatteryUtils;
MaxBatteryValue = GetMaxBatteryValue();
BatteryPowerLevel = 5;
BPLevelUnit = 10 / BatteryPowerLevel;
OldBatteryValue = 0;
OldBatterySts = BatteryStatus.NoCharging;
//InvokeRepeating("CheckDeviceStatus", 0, 1);
}
public string GetStatusDesc()
{
BatteryStatus bs = SystemInfo.batteryStatus;
if (!m_StatusDescDic.TryGetValue(bs, out string desc))
{
desc = bs.ToString();
m_StatusDescDic.Add(bs, desc);
}
return(desc);
}
void Awake()
{
if (instance != null)
{
return;
}
else
{
instance = this;
}
}
// Callback for Application BatteryLowSignal
private void OnNUIApplicationBatteryLow(BatteryStatus status)
{
lock (this)
{
NUIApplicationBatteryLowEventArgs e = new NUIApplicationBatteryLowEventArgs();
// Populate all members of "e" (NUIApplicationBatteryLowEventArgs) with real data
e.BatteryStatus = status;
_applicationBatteryLowEventHandler?.Invoke(this, e);
}
}
void CheckBatteryStatus()
{
BatteryStatus curBatterySts = GetBatteryStatus();
if (curBatterySts != OldBatterySts)
{
if (BatteryStatusChangeCallback != null)
{
BatteryStatusChangeCallback(curBatterySts);
}
OldBatterySts = curBatterySts;
}
}
//----------------- Constructor and its attributes -----------------//
public Battery(int batteryId, int batteryamountOfColumns, int batteryTotalNumberOfFloors, int batteryamountOfBasements, int batteryamountOfElevators, BatteryStatus batteryStatus)
{
id = batteryId;
amountOfColumns = batteryamountOfColumns;
totalNumberOfFloors = batteryTotalNumberOfFloors;
amountOfBasements = batteryamountOfBasements;
amountOfElevators = batteryamountOfElevators;
status = batteryStatus;
columnsList = new List <Column>();
numberOfFloorsPerColumn = calculateNumberOfFloorsPerColumn();
createColumnsList();
setColumnValues();
createListsInsideColumns();
}
private string ToString(BatteryStatus status)
{
switch(status)
{
case BatteryStatus.Undefined:
return "Undefined";
case BatteryStatus.Low:
return "Low";
case BatteryStatus.Charging:
return "Charging";
case BatteryStatus.Full:
return "Full";
case BatteryStatus.NotCharging:
return "NotCharging";
default:
throw new ArgumentOutOfRangeException(nameof(status), status, null);
}
}
void RemainingChargePercentChanged(object sender, object e)
{
if (DefaultBattery.RemainingChargePercent == 100)
status = BatteryStatus.Full;
else if (last > DefaultBattery.RemainingChargePercent)
status = BatteryStatus.Discharging;
else if (last < DefaultBattery.RemainingChargePercent)
status = BatteryStatus.Charging;
else
status = BatteryStatus.Unknown;
last = DefaultBattery.RemainingChargePercent; ;
var dispatcher = CoreApplication.MainView.CoreWindow.Dispatcher;
if(dispatcher != null)
{
dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
OnBatteryChanged(new BatteryChangedEventArgs
{
RemainingChargePercent = DefaultBattery.RemainingChargePercent,
IsLow = DefaultBattery.RemainingChargePercent <= 15,
PowerSource = PowerSource,
Status = Status
});
});
}
else
{
OnBatteryChanged(new BatteryChangedEventArgs
{
RemainingChargePercent = DefaultBattery.RemainingChargePercent,
IsLow = DefaultBattery.RemainingChargePercent <= 15,
PowerSource = PowerSource,
Status = Status
});
}
}
public BatteryInfo()
{
this.status = BatteryStatus.Unknown;
this.voltage = 0;
}
