public override bool IsMyMessage(SensorMessage message)
{
return
MySensorsPlugin.IsMessageFromSensor(message, SensorSwitch) ||
MySensorsPlugin.IsMessageFromSensor(message, SensorLightSwitch) ||
MySensorsPlugin.IsMessageFromSensor(message, SensorPh);
}
public void Send(SensorMessage message)
{
if (IsStarted && message != null)
{
try
{
Debug.WriteLine("Send: " + message.ToRawMessage());
serialPort.WriteLine(message.ToRawMessage());
Thread.Sleep(1);
}
catch (Exception)
{
Debug.WriteLine("Error send: " + message.ToRawMessage());
}
}
}
public SensorMessageEventArgs(SensorMessage message)
{
Message = message;
}
public virtual void MessageReceived(SensorMessage message)
{
Process();
}
public virtual void MessageCalibration(SensorMessage message)
{
}
private void NotifyMessageReceivedForPlugins(SensorMessage msg)
{
Run(SensorMessageHandlers, x => x(msg));
}
private void MessageCalibration(SensorMessage message)
{
foreach (ControllerBase controller in controllers)
if (controller.IsMyMessage(message))
{
controller.MessageCalibration(message);
break;
}
}
public override void MessageReceived(SensorMessage message)
{
if (MySensorsPlugin.IsMessageFromSensor(message, SensorTemperature))
lastSensorValue = message.PayloadFloat;
base.MessageReceived(message);
}
public override bool IsMyMessage(SensorMessage message)
{
return
MySensorsPlugin.IsMessageFromSensor(message, SensorInSwitch) ||
MySensorsPlugin.IsMessageFromSensor(message, SensorOutSwitch) ||
MySensorsPlugin.IsMessageFromSensor(message, SensorDistance);
}
public void Send(SensorMessage message)
{
if (isConnected)
{
}
}
private void NotifyMessageReceivedForScripts(SensorMessage msg)
{
this.RaiseScriptEvent(x => x.OnMessageReceivedForScripts, msg.NodeNo, msg.SensorNo, msg.Type, msg.SubType, msg.Payload);
}
private void ProcessSensorMessage(SensorMessage message)
{
Debug.WriteLine(message.ToString());
bool isNodeMessage = message.NodeNo == 0 || message.SensorNo == 255;
Node node = GetNode(message.NodeNo);
Sensor sensor = GetSensor(message.NodeNo, message.SensorNo); // if message.SensorID == 255 it returns null
switch (message.Type)
{
#region Presentation
case SensorMessageType.Presentation: // sent by a nodes when they present attached sensors.
if (isNodeMessage)
{
if (node == null)
{
node = new Node
{
Id = Guid.NewGuid(),
NodeNo = message.NodeNo,
Type = (SensorType)message.SubType,
ProtocolVersion = message.Payload
};
Save(node);
}
else
{
node.Type = (SensorType)message.SubType;
node.ProtocolVersion = message.Payload;
SaveOrUpdate(node);
}
NotifyMessageReceivedForPlugins(message);
NotifyMessageReceivedForScripts(message);
NotifyForSignalR(new { MsgId = "NodePresentation", Data = BuildNodeRichWebModel(node) });
}
else // sensor message
{
if (node != null)
{
if (sensor == null)
{
sensor = new Sensor()
{
Id = Guid.NewGuid(),
NodeNo = node.NodeNo,
SensorNo = message.SensorNo,
Type = (SensorType)message.SubType,
ProtocolVersion = message.Payload
};
Save(sensor);
}
else
{
sensor.Type = (SensorType)message.SubType;
sensor.ProtocolVersion = message.Payload;
SaveOrUpdate(sensor);
}
NotifyMessageReceivedForPlugins(message);
NotifyMessageReceivedForScripts(message);
NotifyForSignalR(new { MsgId = "SensorPresentation", Data = BuildSensorRichWebModel(sensor) });
}
}
break;
#endregion
#region Set
case SensorMessageType.Set: // sent from or to a sensor when a sensor value should be updated
if (sensor != null)
{
NotifyMessageCalibrationForPlugins(message); // before saving to DB plugins may adjust the sensor value due to their calibration params
var sv = SaveSensorValueToDB(message);
NotifyForSignalR(new { MsgId = "MySensorsTileContent", Data = BuildTileContent() }); // update MySensors tile
NotifyMessageReceivedForPlugins(message);
NotifyMessageReceivedForScripts(message);
NotifyForSignalR(new { MsgId = "SensorValue", Data = sv }); // notify Web UI
}
break;
#endregion
#region Request
case SensorMessageType.Request: // requests a variable value (usually from an actuator destined for controller)
break;
#endregion
#region Internal
case SensorMessageType.Internal: // special internal message
InternalValueType ivt = (InternalValueType)message.SubType;
switch (ivt)
{
case InternalValueType.BatteryLevel: // int, in %
if (node != null)
{
var dtDB = DateTime.UtcNow;
var dt = DateTime.Now;
BatteryLevel bl = new BatteryLevel()
{
Id = Guid.NewGuid(),
NodeNo = message.NodeNo,
TimeStamp = dtDB,
Level = byte.Parse(message.Payload)
};
Save(bl);
bl.TimeStamp = dt;
NotifyMessageReceivedForPlugins(message);
NotifyMessageReceivedForScripts(message);
NotifyForSignalR(new { MsgId = "BatteryLevel", Data = bl });
}
break;
case InternalValueType.Time:
var result = Convert.ToInt64(DateTime.Now.Subtract(unixEpoch).TotalSeconds).ToString();
gatewayProxy.Send(new SensorMessage(message.NodeNo, message.SensorNo, SensorMessageType.Internal, false, (byte)InternalValueType.Time, result));
break;
case InternalValueType.Version:
break;
case InternalValueType.IDRequest:
GetNextAvailableNodeID();
break;
case InternalValueType.IDResponse:
break;
case InternalValueType.InclusionMode:
break;
case InternalValueType.Config:
gatewayProxy.Send(new SensorMessage(message.NodeNo, 255, SensorMessageType.Internal, false, (byte)InternalValueType.Config, GetSetting("UnitSystem").Value));
break;
case InternalValueType.FindParent:
break;
case InternalValueType.FindParentResponse:
break;
case InternalValueType.LogMessage:
break;
case InternalValueType.Children:
break;
case InternalValueType.SketchName:
case InternalValueType.SketchVersion:
if (node != null)
{
if (ivt == InternalValueType.SketchName)
node.SketchName = message.Payload;
else
node.SketchVersion = message.Payload;
SaveOrUpdate(node);
NotifyMessageReceivedForPlugins(message);
NotifyMessageReceivedForScripts(message);
NotifyForSignalR(new { MsgId = "NodePresentation", Data = BuildNodeRichWebModel(node) });
}
break;
case InternalValueType.Reboot:
break;
case InternalValueType.GatewayReady:
break;
}
break;
#endregion
#region Stream
case SensorMessageType.Stream: //used for OTA firmware updates
switch ((StreamValueType)message.SubType)
{
case StreamValueType.FirmwareConfigRequest:
//var fwtype = pullWord(payload, 0);
//var fwversion = pullWord(payload, 2);
//sendFirmwareConfigResponse(sender, fwtype, fwversion, db, gw);
break;
case StreamValueType.FirmwareConfigResponse:
break;
case StreamValueType.FirmwareRequest:
break;
case StreamValueType.FirmwareResponse:
//var fwtype = pullWord(payload, 0);
//var fwversion = pullWord(payload, 2);
//var fwblock = pullWord(payload, 4);
//sendFirmwareResponse(sender, fwtype, fwversion, fwblock, db, gw);
break;
case StreamValueType.Sound:
break;
case StreamValueType.Image:
break;
}
break;
#endregion
}
CheckRebootRequest(node);
}
private void NotifyMessageCalibrationForPlugins(SensorMessage msg)
{
Run(SensorMessageCalibrationHandlers, x => x(msg));
}
private SensorValue SaveSensorValueToDB(SensorMessage message)
{
//SensorValue lastSV = GetLastSensorValue(message.NodeNo, message.SensorNo);
//if (lastSV != null && lastSV.Type == (SensorValueType)message.SubType && lastSV.Value == message.PayloadFloat)
// return lastSV;
var dtDB = DateTime.UtcNow;
var dt = DateTime.Now;
SensorValue sv = new SensorValue()
{
Id = Guid.NewGuid(),
NodeNo = message.NodeNo,
SensorNo = message.SensorNo,
TimeStamp = dtDB,
Type = (SensorValueType)message.SubType,
Value = message.PayloadFloat
};
Save(sv);
sv.TimeStamp = dt;
return sv;
}
public static SensorMessage FromRawMessage(string str)
{
if (string.IsNullOrEmpty(str))
return null;
string[] parts = str.Split(new char[] { ';' }, StringSplitOptions.None);
if (parts.Length != 6)
return null;
SensorMessage msg = null;
try
{
msg = new SensorMessage(
byte.Parse(parts[0]),
byte.Parse(parts[1]),
(SensorMessageType)byte.Parse(parts[2]),
byte.Parse(parts[3]) == 1,
byte.Parse(parts[4]),
parts[5].Trim());
}
catch (Exception) { }
return msg;
}
public override void MessageCalibration(SensorMessage message)
{
if (MySensorsPlugin.IsMessageFromSensor(message, SensorTemperature))
message.PayloadFloat += configuration.TemperatureCalibration;
}
private void MessageReceived(SensorMessage message)
{
if (MySensorsPlugin.IsMessageFromSensor(message, SensorTemperatureInner) ||
MySensorsPlugin.IsMessageFromSensor(message, SensorHumidityInner) ||
MySensorsPlugin.IsMessageFromSensor(message, SensorTemperatureOuter) ||
MySensorsPlugin.IsMessageFromSensor(message, SensorHumidityOuter) ||
MySensorsPlugin.IsMessageFromSensor(message, SensorAtmospherePressure) ||
MySensorsPlugin.IsMessageFromSensor(message, SensorForecast))
NotifyForSignalR(new { MsgId = "MeteoStationTileContent", Data = BuildTileContent() });
}
public override bool IsMyMessage(SensorMessage message)
{
return
MySensorsPlugin.IsMessageFromSensor(message, SensorTemperature) ||
MySensorsPlugin.IsMessageFromSensor(message, SensorSwitch);
}
public abstract bool IsMyMessage(SensorMessage message);
private void MessageReceived(SensorMessage message)
{
foreach (ControllerBase controller in controllers)
if (controller.IsMyMessage(message))
controller.MessageReceived(message);
}
public static bool IsMessageFromSensor(SensorMessage msg, Sensor sensor)
{
return msg != null && sensor != null && sensor.NodeNo == msg.NodeNo && sensor.SensorNo == msg.SensorNo;
}
