public static FrameTypeDescriptor GetFrameTypeDescriptor(IXBeeFrame frame)
        {
            if (frame == null)
                throw new ArgumentNullException("frame");

            return GetFrameTypeDescriptor(frame.FrameType);
        }
Example #2
0
        private void WriteFrameToSerialPort(IXBeeFrame frame)
        {
            byte[] bytesToWrite = FrameSerializer.Serialize(frame);

            serialPort.WriteFrame(bytesToWrite);

            // statistics counting
            XBeeStatistics.MessagesSent++;
        }
        private void StartRegisteringUnknownDevice(XBeeDeviceNetwork deviceNetwork, IXBeeFrame frame)
        {
            // check if this device is already staging
            if (!HomeAutomationSystem.DeviceRegistry.IsStagingDevice(deviceNetwork, frame.Address))
            {
                HomeAutomationSystem.DeviceRegistry.RegisterStagingDevice(deviceNetwork, frame.Address);

                AskForDeviceType(deviceNetwork, frame);
            }
        }
        private void AskForDeviceType(XBeeDeviceNetwork deviceNetwork, IXBeeFrame remoteFrame)
        {
            frameId++;
            if (frameId == 0) frameId++;

            Log.Debug($"Received a frame from an unknown device, so we are asking type ID from this device. Address: {remoteFrame.Address.ToHexString()}");

            // create the XBee frame to send
            IXBeeFrame frame = XBeeFrameBuilder.CreateRemoteATCommand(ATCommands.DD, frameId, remoteFrame.Address, remoteFrame.NetworkAddress);

            deviceNetwork.XBeeService.SendFrame(frame);
        }
        /// <summary>
        /// Serializes the frame to the provided buffer.
        /// </summary>
        /// <param name="frame"></param>
        /// <param name="apiVersion"></param>
        public static byte[] Serialize(IXBeeFrame frame)
        {
            byte[] buffer = new byte[XBeeConstants.MaxFrameLength];

            FrameTypeDescriptor descriptor = FrameTypeDescriptorRegistry.GetFrameTypeDescriptor(frame);

            // set the frame start byte.
            buffer[FrameIndex.Start] = XBeeConstants.FrameStart;

            MethodInfo getterMethod;
            int index = 0;
            for (int i = 0; i < descriptor.PropertyDescriptors.Length; i++)
            {
                PropertyDescriptor onePropertyDescriptor = descriptor.PropertyDescriptors[i];
                int writtenByteCount = onePropertyDescriptor.ByteCount;

                if (onePropertyDescriptor.PropertyType != PropertyType.Ignored)
                {
                    // get the setter method information
                    getterMethod = descriptor.FrameClassType.GetMethod("get_" + onePropertyDescriptor.PropertyName);

                    object returnValue = getterMethod.Invoke(frame, new object[] { });
                    if (returnValue != null)
                    {
                        writtenByteCount = SetPropertyValueToBuffer(buffer, index, returnValue, onePropertyDescriptor);
                    }
                }

                index += writtenByteCount;
            }

            // calculate the length of the payload, and update the frame with the information
            int payloadLength = index - 3;
            buffer[FrameIndex.LengthMSB] = (byte)(payloadLength / 256);
            buffer[FrameIndex.LengthLSB] = (byte)(payloadLength % 256);

            // calculate the checksum of the payload
            buffer[index] = XBeeFrameUtil.CalculateChecksum(buffer);

            byte[] resultBuffer = null;

            // make a new array which contains only the resulting bytes, and return that array
            resultBuffer = new byte[index + 1];
            Array.Copy(buffer, resultBuffer, index + 1);

            return resultBuffer;
        }
        public void ProcessFrame(XBeeDeviceNetwork deviceNetwork, IXBeeFrame frame)
        {
            // get the device type from device registry. if it's not found
            // then we will ask the device to identify itself.
            IXBeeDevice device = HomeAutomationSystem.DeviceRegistry.GetDeviceById(deviceNetwork, frame.Address) as IXBeeDevice;

            if (device != null)
            {
                device.ProcessFrame(frame);

                deviceNetwork.AnnounceDeviceState(device.DeviceState);
            }
            else
            {
                StartRegisteringUnknownDevice(deviceNetwork, frame);
            }
        }
        public override void ProcessFrame(IXBeeFrame frame)
        {
            base.ProcessFrame(frame);

            IODataSample dataSample = frame as IODataSample;
            if (dataSample != null)
            {
                // The device sent both digital and analog samples
                if (dataSample.Samples.Length == 4)
                {
                    // first 2 bytes are going to the RelayDevice (digital samples)

                    // next 2 bytes are the analog samples
                    double analogReading = (dataSample.Samples[2] * 256 + dataSample.Samples[3]) * AnalogPinMaxVoltage / AnalogPinResolution;

                    // now calculate the temperature
                    temperature = HomeAutomation.Sensor.Temperature.LM35.TemperatureFromVoltage(analogReading);
                }
            }
        }
        public void ProcessFrame(XBeeDeviceNetwork deviceNetwork, IXBeeFrame frame)
        {
            RemoteCommandResponse responseFrame = (RemoteCommandResponse)frame;

            // check if this is a DD command response - used for identifying devices by their type
            if (XBeeFrameUtil.IsSameATCommand(responseFrame.ATCommand, ATCommands.DD))
            {
                // build the ID for the device type based on the frame info
                int deviceIdentification = responseFrame.Parameters[2] * 256 + responseFrame.Parameters[3];

                HomeAutomationSystem.DeviceRegistry.RegisterDeviceWithTypeID(deviceNetwork, deviceIdentification, frame.Address, frame.NetworkAddress);
            }
            else
            {
                // get the device type from device registry, and send the frame for processing it.
                IXBeeDevice device = HomeAutomationSystem.DeviceRegistry.GetDeviceById(deviceNetwork, frame.Address) as IXBeeDevice;

                device?.ProcessFrame(frame);
            }
        }
 public void ProcessFrame(IXBeeFrame frame)
 {
     ReceivePacket dataSample = frame as ReceivePacket;
     if (dataSample != null)
     {
         if (dataSample.ReceivedData[0] == MagiConstant_EpamDevice &&
             dataSample.ReceivedData[1] == MagiConstant_TemperatureDevice)
         {
             Temperature = BitConverter.ToSingle(dataSample.ReceivedData, 2);
         }
         else
         {
             Log.Debug("[EpamTemperatureDeviceV1] Wrong start bytes.");
         }
     }
     else
     {
         Log.Debug("[EpamTemperatureDeviceV1] Wrong frame type (or null).");
     }
 }
        public void ProcessFrame(IXBeeFrame frame)
        {
            IODataSample dataSample = frame as IODataSample;
            if (dataSample != null)
            {
                if (dataSample.Samples.Length == 2)
                {
                    // now read the temperature sensor reading
                    double analogReading = (dataSample.Samples[0] * 256 + dataSample.Samples[1]) * AnalogPinMaxVoltage / AnalogPinResolution;

                    Temperature = HomeAutomation.Sensor.Temperature.LM35.TemperatureFromVoltage(analogReading);
                }
                else
                {
                    Log.Debug("[TemperatureDeviceV2] Wrong number of samples received.");
                }
            }
            else
            {
                Log.Debug("[TemperatureDeviceV2] Wrong frame type (or null) for temperature sensor device.");
            }
        }
        /// <summary>
        /// Processes any frames sent to this device.
        /// </summary>
        /// <param name="frame"></param>
        public virtual void ProcessFrame(IXBeeFrame frame)
        {
            IODataSample dataSample = frame as IODataSample;
            if (dataSample != null)
            {
                // if there are digital pin states in the sample then use them for populating wht switchStates variable.
                if (dataSample.DigitalMask > 0 && dataSample.Samples.Length >= 2)
                {
                    int digitalReadingMLB = dataSample.Samples[0] * 256 + dataSample.Samples[1];

                    // build the switch states
                    for (int i = 0; i < switchStates.Length; i++)
                    {
                        switchStates[i] = dataSample.IsDigitalPinHigh(xbeeConfiguration[i]) ? StateOFF : StateON;
                    }
                }
            }
        }
        private void XbeeService_MessageReceived(object sender, IXBeeFrame e)
        {
            Type frameType = e.GetType();

            IXBeeFrameProcessor processor = XBeeFrameProcessorFactory.GetProcessorByFrameType(frameType);

            if (processor != null)
            {
                processor.ProcessFrame(this, e);
            }
            else
            {
                Log.Debug("Dropping frame with type " + frameType.Name + " as no suitable processor is found.");
            }
        }
 public void ProcessFrame(IXBeeFrame frame)
 {
 }
 public void SendFrame(IXBeeFrame frame)
 {
 }
Example #15
0
 /// <summary>
 /// Sends the frame to the XBee network.
 /// </summary>
 /// <param name="frame"></param>
 public void SendFrame(IXBeeFrame frame)
 {
     messageListToSend.Add(frame);
 }