private void InitLight()
        {
            lightTimeOn = new DateTime(1970, 1, 1, 10, 0, 0);
            lightTimeOff = new DateTime(1970, 1, 1, 22, 0, 0);

            lightRelay = controller.GetSensor(20, 1);
            if (lightRelay == null)
                throw new ArgumentNullException("lightRelay (20, 1)");

            lightTimer = new Timer(1000 * 5);
            lightTimer.Elapsed += lightTimer_Elapsed;
            lightTimer.Start();
        }
Example #2
0
        //[ManyToOne]      // Many to one relationship with Stock
        //public NodeDto Node { get; set; }

        public static SensorDto FromModel(Sensor item)
        {
            if (item == null)
                return null;

            return new SensorDto()
            {
                PK = item.NodeID << 8 + item.ID,
                NodeID = item.NodeID,
                ID = item.ID,
                Type = (byte)item.Type,
                ProtocolVersion = item.ProtocolVersion
            };
        }
        private void InitHeater()
        {
            minHeaterTemperature = 24.0f;

            heaterRelay = controller.GetSensor(20, 0);
            if (heaterRelay == null)
                throw new ArgumentNullException("heaterRelay (20, 0)");

            heaterTemperatureSensor = controller.GetSensor(20, 7);
            if (heaterTemperatureSensor == null)
                throw new ArgumentNullException("heaterTemperatureSensor (20, 8)");

            if (heaterTemperatureSensor.LastValue != null)
                controller.SetSensorValue(heaterRelay, SensorValueType.Light, heaterTemperatureSensor.LastValue.Value < minHeaterTemperature ? 1 : 0);

            heaterTemperatureSensor.PropertyChanged += heaterTemperatureSensor_PropertyChanged;
        }
        private void gatewayProxy_MessageReceived(IGatewayProxy sender, SensorMessageEventArgs args)
        {
            if (!IsStarted)
                return;

            SensorMessage message = args.Message;

            // for debug!!!
            if (Log != null)
                Log(this, message.ToString(), true, LogLevel.Normal);

            bool isNodeMessage = message.NodeID == 0 || message.SensorID == 255;
            Node node = GetNode(message.NodeID);
            Sensor sensor = GetSensor(message.NodeID, message.SensorID); // 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(message.NodeID, (SensorType)message.SubType, message.Payload);
                            dbService.Insert(node);
                            nodes.Add(node);
                        }
                        else
                        {
                            node.Type = (SensorType)message.SubType;
                            node.ProtocolVersion = message.Payload;
                            dbService.Update(node);
                        }
                        communicator.Broadcast(new NetworkMessage(NetworkMessageID.NodePresentation, JsonConvert.SerializeObject(node)));
                    }
                    else
                    {
                        if (node != null)
                        {
                            if (sensor == null)
                            {
                                sensor = new Sensor(message.NodeID, message.SensorID, (SensorType)message.SubType, message.Payload);
                                dbService.Insert(sensor);
                                node.Sensors.Add(sensor);
                            }
                            else
                            {
                                sensor.Type = (SensorType)message.SubType;
                                sensor.ProtocolVersion = message.Payload;
                                dbService.Update(sensor);
                            }
                            communicator.Broadcast(new NetworkMessage(NetworkMessageID.SensorPresentation, JsonConvert.SerializeObject(sensor)));
                        }
                    }
                    break;
                #endregion

                #region Set
                case SensorMessageType.Set: // sent from or to a sensor when a sensor value should be updated
                    if (sensor != null)
                    {
                        SensorValue sv = new SensorValue(message.NodeID, message.SensorID, DateTime.Now, (SensorValueType)message.SubType, float.Parse(message.Payload.Replace('.', ',')));
                        dbService.Insert(sv);
                        sensor.Values.Add(sv);
                        communicator.Broadcast(new NetworkMessage(NetworkMessageID.SensorValue, JsonConvert.SerializeObject(sv)));
                    }
                    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)
                            {
                                BatteryLevel bl = new BatteryLevel(node.ID, DateTime.Now, byte.Parse(message.Payload));
                                dbService.Insert(bl);
                                node.BatteryLevels.Add(bl);
                                communicator.Broadcast(new NetworkMessage(NetworkMessageID.BatteryLevel, JsonConvert.SerializeObject(bl)));
                            }
                            break;
                        case InternalValueType.Time:
                            gatewayProxy.Send(new SensorMessage(message.NodeID, message.SensorID, SensorMessageType.Internal, false, (byte)InternalValueType.Time, GetTimeForSensors().ToString()));
                            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.NodeID, 255, SensorMessageType.Internal, false, (byte)InternalValueType.Config, UnitSystem));
                            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;

                                dbService.Update(node);
                                communicator.Broadcast(new NetworkMessage(NetworkMessageID.NodePresentation, JsonConvert.SerializeObject(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
            }

            //if (node != null && node.Reboot)
            //    gatewayProxy.Send(new Message(node.NodeID, 255, MessageType.Internal, false, (byte)InternalValueType.Reboot, ""));
        }
 public void SetSensorValue(Sensor sensor, SensorValueType valueType, object value)
 {
     if (sensor != null && value != null)
         gatewayProxy.Send(new SensorMessage(sensor.NodeID, sensor.ID, SensorMessageType.Set, false, (byte)valueType, value.ToString()));
 }
 private void UninitLight()
 {
     lightTimer.Stop();
     lightTimer.Elapsed -= lightTimer_Elapsed;
     lightTimer = null;
     lightRelay = null;
 }
 private void UninitHeater()
 {
     heaterTemperatureSensor.PropertyChanged -= heaterTemperatureSensor_PropertyChanged;
     heaterTemperatureSensor = null;
     heaterRelay = null;
 }
 private void UninitPh()
 {
     phSensor.PropertyChanged -= phSensor_PropertyChanged;
     phSensor = null;
     phRelay = null;
 }
        private void InitPh()
        {
            phNormalValue = 7.0f;

            phRelay = controller.GetSensor(20, 0);
            if (phRelay == null)
                throw new ArgumentNullException("phRelay (20, 2)");

            phSensor = controller.GetSensor(20, 10);
            if (phSensor == null)
                throw new ArgumentNullException("phSensor (20, 10)");

            if (phSensor.LastValue != null)
                controller.SetSensorValue(phRelay, SensorValueType.Light, phSensor.LastValue.Value <= phNormalValue ? 1 : 0);

            phSensor.PropertyChanged += phSensor_PropertyChanged;
        }
 public int Update(Sensor item)
 {
     return con.Update(SensorDto.FromModel(item));
 }
 public int Insert(Sensor item)
 {
     return con.Insert(SensorDto.FromModel(item), "OR REPLACE");
 }
        public int Delete(Sensor item)
        {
            foreach (SensorValue sv in item.Values)
                Delete(sv);

            return con.Delete(SensorDto.FromModel(item));
        }