/// <summary>
/// Сохранить параметр в Xml узел
/// </summary>
/// <param name="document">XML документ, куда будет добавлен данный XmlNode</param>
/// <returns>Узел в котором сохранен параметр</returns>
public override XmlNode Save(XmlDocument document)
{
XmlNode root = base.Save(document);
if (root != null)
{
if (slim.TryEnterReadLock(100))
{
try
{
XmlNode SourceTypeNode = document.CreateElement(SourceTypeName);
SourceTypeNode.InnerText = s_type.ToString();
root.AppendChild(SourceTypeNode);
return(root);
}
finally
{
slim.ExitReadLock();
}
}
}
return(null);
}
public Sensor(string name, int index, bool defaultHidden,
SensorType sensorType, Hardware hardware,
ParameterDescription[] parameterDescriptions, ISettings settings)
{
this.index = index;
this.defaultHidden = defaultHidden;
this.sensorType = sensorType;
this.hardware = hardware;
this.identifier = new Identifier(hardware.Identifier,
sensorType.ToString().ToLowerInvariant(),
index.ToString(CultureInfo.InvariantCulture));
this.identifierString = this.identifier.ToString();
Parameter[] parameters = new Parameter[parameterDescriptions == null ?
0 : parameterDescriptions.Length];
for (int i = 0; i < parameters.Length; i++)
{
parameters[i] = new Parameter(parameterDescriptions[i], this, settings);
}
this.parameters = parameters;
this.settings = settings;
this.defaultName = name;
this.name = settings.GetValue(
new Identifier(Identifier, "name").ToString(), name);
GetSensorValuesFromSettings();
hardware.Closing += delegate(IHardware h)
{
SetSensorValuesToSettings();
};
}
protected string GetPNId(SensorType type, SensorMode mode)
{
string pnId = null;
do
{
if (type < 0 || mode < 0)
{
break;
}
switch (type)
{
case SensorType.Source:
case SensorType.Sink:
pnId = type.ToString();
break;
default:
pnId = mode.ToString();
break;
} // switch
} while (false);
return(pnId);
}
public Sensor(string name, int index, SensorType sensorType, Hardware hardware, Parameter[] parameterDescriptions)
{
Index = index;
SensorType = sensorType;
Parameters = parameterDescriptions;
Name = name;
Identifier = $"{hardware.Identifier}/{SensorType.ToString()}/{Index.ToString()}";
}
// Use this for initialization
private void Start()
{
if (!IsSupportedSensor)
{
if (OnError != null)
{
OnError.Invoke("Not supported: " + sensorType.ToString());
}
}
}
public async Task <Sensor> GetByBoxIdAndTypeAsync(string boxId, SensorType type)
{
var table = _client.GetTableClient(_tableName);
await table.CreateIfNotExistsAsync();
var sensorTypeString = type.ToString("G");
var entityPages = table.QueryAsync <TableEntity>(x => x.PartitionKey == boxId && x.RowKey == sensorTypeString);
return((await entityPages.AsPages().FirstOrDefaultAsync())?.Values.Select(SensorMapper.Map).FirstOrDefault());
}
private string GetSensorType(SensorType sensorType)
{
StringBuilder sb = new StringBuilder();
sb.Append(sensorType.ToString());
switch (sensorType)
{
case SensorType.Voltage:
sb.Append("V/mV");
break;
case SensorType.Clock:
sb.Append("MHz");
break;
case SensorType.Temperature:
sb.Append("°C");
break;
case SensorType.Load:
sb.Append("%");
break;
case SensorType.Fan:
sb.Append("RPM");
break;
case SensorType.Flow:
break;
case SensorType.Control:
sb.Append("");
break;
case SensorType.Level:
break;
case SensorType.Factor:
break;
case SensorType.Power:
sb.Append("W");
break;
case SensorType.Data:
break;
default:
break;
}
return(sb.ToString());
}
public async Task <SensorAlarm> GetBySensorBoxIdAndSensorTypeAndStatusAsync(string sensorBoxId, SensorType sensorType, AlarmStatus status)
{
var table = _client.GetTableClient(_tableName);
await table.CreateIfNotExistsAsync();
var sensorTypeString = sensorType.ToString("G");
var alarmStatusString = status.ToString("G");
var entityPages = table.QueryAsync <TableEntity>($"{nameof(TableEntity.PartitionKey)} eq '{sensorBoxId}' and {nameof(SensorAlarm.SensorType)} eq '{sensorTypeString}' and {nameof(SensorAlarm.Status)} eq '{alarmStatusString}'");
return((await entityPages.AsPages().FirstOrDefaultAsync())?.Values.Select(SensorAlarmMapper.Map).FirstOrDefault());
}
private static string Label(SensorType s)
{
return(s switch
{
SensorType.Clock => "MHz",
SensorType.Temperature => "°C",
SensorType.Power => "Watts",
SensorType.Load => "%",
SensorType.Voltage => "V",
SensorType.Fan => "RPM",
_ => s.ToString()
});
/// <summary>
/// Sets the active sensor from the list of available sensors.
/// </summary>
/// <param name="sensorType">The sensor type to set as active.</param>
private void SetActiveSensor(SensorType sensorType)
{
ISensor sensor;
if (GetSensor(sensorType, out sensor))
{
activeSensor = sensor;
}
else
{
throw new System.ArgumentException("Sensor " + sensorType.ToString() + " unavailable.");
}
}
private OpenHardwareSensorType MapSensorType(SensorType type)
{
switch (type)
{
case OpenHardwareMonitor.Hardware.SensorType.Clock:
return(OpenHardwareSensorType.Clock);
case OpenHardwareMonitor.Hardware.SensorType.Temperature:
return(OpenHardwareSensorType.Temperature);
case OpenHardwareMonitor.Hardware.SensorType.Load:
return(OpenHardwareSensorType.Load);
case OpenHardwareMonitor.Hardware.SensorType.Fan:
return(OpenHardwareSensorType.Fan);
default:
throw new NotImplementedException(type.ToString());
}
}
public static Visualizer CreateVisualizer(SensorUnity sensorUnity, SensorType sensorType)
{
Type finalVisualizerType = null;
foreach (Type visualizerType in typeof(Visualizer).Assembly.GetTypes())
{
VisualizerAttribute visualizerAttribute = (VisualizerAttribute)visualizerType.GetCustomAttribute(typeof(VisualizerAttribute));
if (visualizerAttribute != null && !visualizerType.IsInterface && visualizerAttribute.type == sensorType)
{
if (visualizerAttribute.unity == sensorUnity)
{
finalVisualizerType = visualizerType;
break;
}
finalVisualizerType = visualizerType;
}
}
if (finalVisualizerType == null)
{
throw new Exception("There is no visualizer supporting the type: " + sensorType.ToString());
}
return((Visualizer)Activator.CreateInstance(finalVisualizerType));
}
// void cfg_OnUserUpdateControledDevices(List<DeviceAssociation> ControledDevices)
// {
// // ZBClass class2 = new ZBClass();
// // class2.header = class2.GetBytesFromString("ZSIG");
// // class2.command = 11;
// // class2.alphacommand = class2.GetBytesFromString("SendCmd");
// // class2.label_base = class2.GetBytesFromString("");
// // class2.command_text = class2.GetBytesFromString("");
// // class2.serial = 0;
// // class2.param1 = 1;
// // class2.param2 = 22;
// // class2.param3 = 0;
// // class2.param4 = 0;
// // byte[] rBuff = null;
// // byte[] bytes = class2.GetBytes();
// // ZibaseDll.ZBClass zb = new ZibaseDll.ZBClass();
// // zb.UDPDataTransmit(bytes, ref rBuff, "192.168.0.210", 0xc34f);
//
// m_Config.ControledDevices = ControledDevices;
// //m_ControledDevices = ControledDevices;
// try
// {
// Util.SerializeToXml(m_Config, ConfigFilePath);
// }
// catch (Exception ex)
// {
// HsObjet.getInstance().WriteLog("Error", ex.Message);
// }
//
// }
void cfg_OnUserAddDevice(char hc, int dc, string DeviceName, SensorType st)
{
Scheduler.Classes.DeviceClass dev = HsObjet.getInstance().NewDeviceEx(DeviceName);
dev.dc = dc.ToString();
dev.hc = hc.ToString();
dev.@interface = HSPI.PlugInName;
dev.iomisc = DeviceName + " " + st.ToString() + " zibase_sensor";
dev.misc = 0x10; //status only
var q = m_SensorDataManager.SensorList.Where(x => x.ID == DeviceName);
if (q.Any())
{
Device AddedDevice = q.First();
var AddedDeviceValue = AddedDevice.Values.First(x => x.ValueType == st);
if (AddedDeviceValue != null)
{
AddedDeviceValue.AlreadyInHS = true;
AddedDeviceValue.HSDevice = dev;
AddedDeviceValue.HSUpdate();
}
}
m_SensorDataManager.HSDevice.Add(dev);
}
private void UpdateSensorLabel(TextBlock label, SensorType sensorType)
{
label.Text = sensorType.ToString();
label.Foreground = new SolidColorBrush(Colors.Black);
}
private void UpdateValue(Device sd, ZibaseDll.ZiBase.SensorInfo si, SensorType st)
{
DeviceValue dv = null;
var q = sd.Values.Where(x => x.ValueType == st);
if (q.Any())
{
dv = q.First();
dv.Value = si.sHTMLValue;
if (st == SensorType.ENERGY_KW || st == SensorType.ENERGY_KWH)
{
String[] splitted = si.sValue.Split(new char[] { ' ' });
if (splitted.Length == 2)
{
float val = Convert.ToSingle(dv.Value,System.Globalization.CultureInfo.InvariantCulture); // Convert.ToInt32(splitted[0]);
//val /= 1000.0F;
dv.DisplayValue = val + " " + splitted[1];
}
}
else
dv.DisplayValue = si.sValue;
}
else
{
dv = new DeviceValue {Value = si.sHTMLValue, ValueType = st};
if (st == SensorType.ENERGY_KW || st == SensorType.ENERGY_KWH)
{
String[] splitted = si.sValue.Split(new char[] { ' ' });
if (splitted.Length == 2)
{
//float val = Convert.ToInt32(splitted[0]);
//val /= 1000.0F;
float val = Convert.ToSingle(dv.Value, System.Globalization.CultureInfo.InvariantCulture); // Convert.ToInt32(splitted[0]);
dv.DisplayValue = val + " " + splitted[1];
}
}
else
dv.DisplayValue = si.sValue;
sd.Values.Add(dv);
}
// if no HSDevice associated,look for the current device in HS
// IOMisc contains the ID followed by the SensorType
if (dv.HSDevice == null)
{
var q2 = HSDevice.Where(x => x.iomisc.Contains(si.sID) && x.iomisc.Contains(st.ToString()));
if (q2.Any())
{
dv.AlreadyInHS = true;
dv.HSDevice = q2.First();
}
}
dv.DwValue = si.dwValue;
dv.HSUpdate();
}
/// <summary>
/// Gets the name of the file.
/// </summary>
/// <param name="sensorType">Type of the sensor.</param>
/// <param name="updateInterval">The update interval.</param>
/// <param name="annLogicType">Type of the ANN logic.</param>
/// <returns></returns>
public string GetFileName(SensorType sensorType, int updateInterval, ANNLogicType annLogicType)
{
return string.Format(sensorType.ToString(), "_", updateInterval.ToString(), "_", annLogicType.ToString());
}
public TypeNode(SensorType sensorType, IHardware hardware,
PersistentSettings settings) : base()
{
this.settings = settings;
this.sensorType = sensorType;
this.hardware = hardware;
switch (sensorType)
{
case SensorType.Voltage:
this.Image = Utilities.EmbeddedResources.GetImage("voltage.png");
this.Text = "Voltages";
break;
case SensorType.Clock:
this.Image = Utilities.EmbeddedResources.GetImage("clock.png");
this.Text = "Clocks";
break;
case SensorType.Load:
this.Image = Utilities.EmbeddedResources.GetImage("load.png");
this.Text = "Load";
break;
case SensorType.Temperature:
this.Image = Utilities.EmbeddedResources.GetImage("temperature.png");
this.Text = "Temperatures";
break;
case SensorType.Fan:
this.Image = Utilities.EmbeddedResources.GetImage("fan.png");
this.Text = "Fans";
break;
case SensorType.Flow:
this.Image = Utilities.EmbeddedResources.GetImage("flow.png");
this.Text = "Flows";
break;
case SensorType.Control:
this.Image = Utilities.EmbeddedResources.GetImage("control.png");
this.Text = "Controls";
break;
case SensorType.Level:
this.Image = Utilities.EmbeddedResources.GetImage("level.png");
this.Text = "Levels";
break;
case SensorType.Power:
this.Image = Utilities.EmbeddedResources.GetImage("power.png");
this.Text = "Powers";
break;
case SensorType.Data:
this.Image = Utilities.EmbeddedResources.GetImage("data.png");
this.Text = "Data";
break;
case SensorType.SmallData:
this.Image = Utilities.EmbeddedResources.GetImage("data.png");
this.Text = "Data";
break;
case SensorType.Factor:
this.Image = Utilities.EmbeddedResources.GetImage("factor.png");
this.Text = "Factors";
break;
case SensorType.Throughput:
this.Image = Utilities.EmbeddedResources.GetImage("throughput.png");
this.Text = "Throughput";
break;
}
NodeAdded += new NodeEventHandler(TypeNode_NodeAdded);
NodeRemoved += new NodeEventHandler(TypeNode_NodeRemoved);
this.expandedIdentifier = new Identifier(new Identifier(hardware.Identifier,
sensorType.ToString().ToLowerInvariant()), "expanded");
base.IsExpanded =
settings.GetValue(expandedIdentifier.ToString(), base.IsExpanded);
}
public TypeNode(SensorType sensorType, Identifier parentId, PersistentSettings settings)
{
SensorType = sensorType;
_expandedIdentifier = new Identifier(parentId, SensorType.ToString(), ".expanded").ToString();
_settings = settings;
switch (sensorType)
{
case SensorType.Voltage:
Image = Utilities.EmbeddedResources.GetImage("voltage.png");
Text = "Voltages";
break;
case SensorType.Clock:
Image = Utilities.EmbeddedResources.GetImage("clock.png");
Text = "Clocks";
break;
case SensorType.Load:
Image = Utilities.EmbeddedResources.GetImage("load.png");
Text = "Load";
break;
case SensorType.Temperature:
Image = Utilities.EmbeddedResources.GetImage("temperature.png");
Text = "Temperatures";
break;
case SensorType.Fan:
Image = Utilities.EmbeddedResources.GetImage("fan.png");
Text = "Fans";
break;
case SensorType.Flow:
Image = Utilities.EmbeddedResources.GetImage("flow.png");
Text = "Flows";
break;
case SensorType.Control:
Image = Utilities.EmbeddedResources.GetImage("control.png");
Text = "Controls";
break;
case SensorType.Level:
Image = Utilities.EmbeddedResources.GetImage("level.png");
Text = "Levels";
break;
case SensorType.Power:
Image = Utilities.EmbeddedResources.GetImage("power.png");
Text = "Powers";
break;
case SensorType.Data:
Image = Utilities.EmbeddedResources.GetImage("data.png");
Text = "Data";
break;
case SensorType.SmallData:
Image = Utilities.EmbeddedResources.GetImage("data.png");
Text = "Data";
break;
case SensorType.Factor:
Image = Utilities.EmbeddedResources.GetImage("factor.png");
Text = "Factors";
break;
case SensorType.Frequency:
Image = Utilities.EmbeddedResources.GetImage("clock.png");
Text = "Frequencies";
break;
case SensorType.Throughput:
Image = Utilities.EmbeddedResources.GetImage("throughput.png");
Text = "Throughput";
break;
}
NodeAdded += TypeNode_NodeAdded;
NodeRemoved += TypeNode_NodeRemoved;
_expanded = settings.GetValue(_expandedIdentifier, true);
}
// tries to find the sensor and the action from iot central command data
public static ActionParameter DecodeSensorCommandAction(IEnumerable <Beacon> beacons, string bluetoothAddressAsString, string sensorAsString, string actionAsString, out string errors)
{
// decode BLE address and CommandAction parameter
ActionParameter actionParameter = DecodeDeviceCommandAction(beacons, bluetoothAddressAsString, actionAsString, out errors);
if (actionParameter == null)
{
return(null);
}
// check if sensor type arguments are null or empty
errors = $"Error decoding sensor changed command:{Environment.NewLine}";
Boolean error = false;
if (String.IsNullOrWhiteSpace(sensorAsString) == true)
{
error = true;
errors += $"Argument sensor is empty{Environment.NewLine}";
}
// decode sensor type
SensorType sensorType = Helper.DecodeSensorType(sensorAsString);
if (sensorType == SensorType.None)
{
error = true;
errors += $"Invalid sensor {sensorAsString}{Environment.NewLine}";
}
if (error == false)
{
// find sensor for sensor type in beacon
actionParameter.SensorData = actionParameter.Beacon.SensorDatas.FirstOrDefault(s => s.SensorType == sensorType);
if (actionParameter.SensorData == null)
{
error = true;
errors += $"No sensor for bluetooth address 0x{actionParameter.Beacon.BluetoothAddress:X} sensor type {sensorType.ToString()}{Environment.NewLine}";
}
else
{
return(actionParameter);
}
}
return(null);
}
/// <summary>
/// Sets the sensor type
/// </summary>
/// <param name="type">The type to set</param>
public void SetType(SensorType type)
{
this.type = type.ToString();
}
public string toString()
{
return(HardwareName.ToString() + ";" + sensorType.ToString() + ";" + name.ToString() + ";" + value.ToString());
}
