protected int GetZclPayloadOffset(ref byte[] buffer) { int offset = GetZigBeePayloadOffset(); offset += ZclHelper.GetPayloadOffset(ref buffer, offset); return(offset); }
public uint GetProperty( IAdapterProperty Property, out IAdapterIoRequest RequestPtr) { RequestPtr = null; // sanity check if (Property == null) { return(ERROR_INVALID_PARAMETER); } // cast back IAdapterProperty to ZclCluster ZclCluster cluster = (ZclCluster)Property; // read all attributes for the attribute foreach (var item in cluster.InternalAttributeList) { var attribute = item.Value; object value; if (!attribute.Read(out value)) { // give up at 1st read error return((uint)ZclHelper.ZigBeeStatusToHResult(attribute.Status)); } } return(ERROR_SUCCESS); }
public uint SetProperty( IAdapterProperty Property, out IAdapterIoRequest RequestPtr) { RequestPtr = null; // sanity check if (Property == null) { return(ERROR_INVALID_PARAMETER); } // cast back IAdapterProperty to ZclCluster ZclCluster cluster = (ZclCluster)Property; // write new value for all attributes // note that it is assumed that BridgeRT has set the new value // for each attribute foreach (var item in cluster.InternalAttributeList) { var attribute = item.Value; if (attribute.Write(attribute.Value.Data)) { // give up at 1st write error return((uint)ZclHelper.ZigBeeStatusToHResult(attribute.Status)); } } return(ERROR_SUCCESS); }
internal ZclCommand(ZclCluster cluster, byte id, String name, bool specificResponseRequired) { m_cluster = cluster; m_Id = id; m_zigBeeStatus = ZclHelper.ZCL_ERROR_SUCCESS; // as far as ZigBeeCommand class is concerned a response will always be required // ZCL will use the Default Response if ZclCommand require no specific response m_responseRequired = true; if (specificResponseRequired) { m_useDefaultResponse = false; } else { m_useDefaultResponse = true; } this.Name = m_cluster.Name + "_" + name; this.Description = null; this.HResult = ZclHelper.ZigBeeStatusToHResult(m_zigBeeStatus); m_isZdoCommand = false; ZclHelper.SetClusterSpecificHeader(ref m_zclHeader, 0); int offset = ZclHelper.GetCommandIdOffset(ref m_zclHeader, 0); m_zclHeader[offset] = m_Id; m_zclInParamList = new List <ZclValue>(); InputParams = new List <IAdapterValue>(); OutputParams = new List <IAdapterValue>(); }
public uint SetPropertyValue( IAdapterProperty Property, IAdapterValue Value, out IAdapterIoRequest RequestPtr) { RequestPtr = null; // sanity check if (Property == null) { return(ERROR_INVALID_PARAMETER); } // cast back IAdapterProperty to ZclCluster ZclCluster cluster = (ZclCluster)Property; // look for the attribute and write new data foreach (var item in cluster.InternalAttributeList) { var attribute = item.Value; if (attribute.Value.Name == Value.Name) { if (attribute.Write(Value.Data)) { return(ERROR_SUCCESS); } else { return((uint)ZclHelper.ZigBeeStatusToHResult(attribute.Status)); } } } return(ERROR_NOT_SUPPORTED); }
public ZclDiscoverAttributes() { // ZigBee command specific m_isZdoCommand = false; int offset = ZclHelper.GetCommandIdOffset(ref m_zclHeader, 0); m_zclHeader[offset] = COMMAND_ID_DISCOVER_ATTRIBUTES; }
internal ZclValue(byte zigBeeType, string name) { Name = name; ZigBeeType = zigBeeType; object tempObject = null; ZclHelper.CreateDefaultValue(zigBeeType, out tempObject); Data = tempObject; }
public override bool ParseResponse(byte[] buffer) { m_status = ZclHelper.ZCL_ERROR_FAILURE; if (!IsResponseOK(buffer)) { return(false); } // verify command Id int offset = GetZclCommandIdOffset(ref buffer); if (COMMAND_ID_READ_ATTRIBUTE_RESPONSE != buffer[offset]) { return(false); } // parse ZCL payload offset = GetZclPayloadOffset(ref buffer); // check attribute Id UInt16 id = AdapterHelper.UInt16FromZigBeeFrame(buffer, offset); if (id != m_Id) { return(false); } offset += sizeof(UInt16); // check status m_status = buffer[offset]; if (m_status != ZclHelper.ZCL_ERROR_SUCCESS) { return(false); } offset += ZIGBEE_STATUS_LENGTH; // set data bool retValue = false; object value = null; // from ZCL command payload // - 1st byte indicates the type // - following byte(s) contain the value byte type = buffer[offset]; offset += sizeof(byte); retValue = ZclHelper.GetValue(type, ref buffer, ref offset, out value); Value.Data = value; return(retValue); }
internal void Send() { // set cluster Id m_clusterId = m_cluster.Id; m_responseClusterId = m_cluster.Id; // add header to payload m_payload = new byte[m_zclHeader.Length]; Array.Copy(m_zclHeader, m_payload, m_zclHeader.Length); // add command parameters to payload foreach (var item in m_zclInParamList) { // copy in parameter data from "BridgeRT" in parameter to // "internal" ZCL parameter IAdapterValue value = GetInputParamByName(item.Name); item.Data = value.Data; // add parameter in ZCL payload byte[] tempBuffer = item.ToByteBuffer(); if (tempBuffer == null) { // can't set current parameter => give up with sending m_zigBeeStatus = ZclHelper.ZCL_ERROR_INVALID_VALUE; HResult = ZclHelper.ZigBeeStatusToHResult(m_zigBeeStatus); return; } int previousLength = m_payload.Length; Array.Resize(ref m_payload, previousLength + tempBuffer.Length); Array.Copy(tempBuffer, 0, m_payload, previousLength, tempBuffer.Length); } // send command m_zigBeeStatus = ZclHelper.ZCL_ERROR_SUCCESS; if (!SendCommand(m_cluster.EndPoint.Device.Module, m_cluster.EndPoint.Device, m_cluster.EndPoint)) { m_zigBeeStatus = ZclHelper.ZCL_ERROR_TIMEOUT; } HResult = ZclHelper.ZigBeeStatusToHResult(m_zigBeeStatus); return; }
public static byte[] ToByteBufferWithType(object value, byte zigBeeType) { byte[] buffer = null; byte[] valueBuffer = null; // get buffer that correspond to the vale valueBuffer = ZclHelper.ToByteBuffer(value); if (valueBuffer == null) { return(null); } // add ZigBee type to returned buffer buffer = new byte[ZclHelper.ZCL_TYPE_CODE_LENGTH + valueBuffer.Length]; buffer[0] = zigBeeType; Array.Copy(valueBuffer, 0, buffer, ZclHelper.ZCL_TYPE_CODE_LENGTH, valueBuffer.Length); return(buffer); }
internal bool Read(out object value) { // set value(s) to null Value.Data = null; value = null; m_status = ZclHelper.ZCL_ERROR_SUCCESS; // set cluster Id m_clusterId = m_cluster.Id; m_responseClusterId = m_cluster.Id; // set read command Id int offset = ZclHelper.GetCommandIdOffset(ref m_zclHeader, 0); m_zclHeader[offset] = COMMAND_ID_READ_ATTRIBUTE; // set payload byte[] tempBuffer = AdapterHelper.ToZigBeeFrame(m_Id); m_payload = new byte[m_zclHeader.Length + tempBuffer.Length]; Array.Copy(m_zclHeader, m_payload, m_zclHeader.Length); Array.Copy(tempBuffer, 0, m_payload, m_zclHeader.Length, tempBuffer.Length); // send command m_responseRequired = true; if (!SendCommand(m_cluster.EndPoint.Device.Module, m_cluster.EndPoint.Device, m_cluster.EndPoint)) { m_status = ZclHelper.ZCL_ERROR_TIMEOUT; return(false); } // set out value if (Value.Data == null) { return(false); } value = Value.Data; return(true); }
internal bool Write(object value) { // sanity check if (value == null) { return(false); } // get byte buffer from value to set byte[] attributeValueBuffer = ZclHelper.ToByteBufferWithType(value, m_zigBeeType); if (attributeValueBuffer == null) { return(false); } // set cluster Id m_clusterId = m_cluster.Id; m_responseClusterId = m_cluster.Id; // set write command Id int offset = ZclHelper.GetCommandIdOffset(ref m_zclHeader, 0); m_zclHeader[offset] = COMMAND_ID_WRITE_ATTRIBUTE; // set payload byte[] tempBuffer = AdapterHelper.ToZigBeeFrame(m_Id); m_payload = new byte[m_zclHeader.Length + tempBuffer.Length + attributeValueBuffer.Length]; Array.Copy(m_zclHeader, m_payload, m_zclHeader.Length); Array.Copy(tempBuffer, 0, m_payload, m_zclHeader.Length, tempBuffer.Length); Array.Copy(attributeValueBuffer, 0, m_payload, m_zclHeader.Length + tempBuffer.Length, attributeValueBuffer.Length); // send command m_responseRequired = false; if (!SendCommand(m_cluster.EndPoint.Device.Module, m_cluster.EndPoint.Device, m_cluster.EndPoint)) { return(false); } return(true); }
public uint GetPropertyValue( IAdapterProperty Property, string AttributeName, out IAdapterValue ValuePtr, out IAdapterIoRequest RequestPtr) { ValuePtr = null; RequestPtr = null; // sanity check if (Property == null) { return(ERROR_INVALID_PARAMETER); } // cast back IAdapterProperty to ZclCluster ZclCluster cluster = (ZclCluster)Property; // look for the attribute foreach (var item in cluster.InternalAttributeList) { var attribute = item.Value; if (attribute.Value.Name == AttributeName) { object value; if (attribute.Read(out value)) { ValuePtr = attribute.Value; return(ERROR_SUCCESS); } else { return((uint)ZclHelper.ZigBeeStatusToHResult(attribute.Status)); } } } return(ERROR_NOT_SUPPORTED); }
internal ZclAttribute(ZclCluster cluster, UInt16 id, String name, byte zigBeeType, bool isReadOnly = false, bool isOptional = false, bool isReportable = false) { // save parent cluster m_cluster = cluster; // attribute specific m_Id = id; m_isReadOnly = isReadOnly; m_isOptional = isOptional; m_zigBeeType = zigBeeType; // ZigBee command specific m_isZdoCommand = false; int offset = ZclHelper.GetCommandIdOffset(ref m_zclHeader, 0); m_zclHeader[offset] = COMMAND_ID_READ_ATTRIBUTE; // BridgeRT specific Value = new ZclValue(zigBeeType, name); Annotations = new Dictionary <string, string>(); if (isReadOnly) { Access = E_ACCESS_TYPE.ACCESS_READ; } else { Access = E_ACCESS_TYPE.ACCESS_READWRITE; } if (isReportable) { COVBehavior = SignalBehavior.Always; } else { COVBehavior = SignalBehavior.Unspecified; } }
public override bool ParseResponse(byte[] buffer) { if (m_commandList.Count == 0) { // no server command registered return(false); } // get Mac address, endpoint Id, cluster Id and command Id of source int offset = 0; UInt64 macAddress = AdapterHelper.UInt64FromXbeeFrame(buffer, offset); offset = AdapterHelper.MAC_ADDR_LENGTH; // skip network address (mac address is enough) offset += AdapterHelper.NETWORK_ADDRESS_LENGTH; byte endpointId = buffer[offset]; offset++; // skip destination end point offset++; UInt16 clusterId = AdapterHelper.UInt16FromXbeeFrame(buffer, offset); offset = GetZclCommandIdOffset(ref buffer); byte commandId = buffer[offset]; // find element that matches Mac address, network address, endpoint Id and cluster Id var element = Find(macAddress, endpointId, clusterId, commandId); if (element == null) { // no corresponding element for that Zcl server command return(false); } if (element.OnReception == null) { // no notification hence nothing else to do return(true); } // get parameters offset = GetZclPayloadOffset(ref buffer); // fill in out parameters foreach (var parameter in element.ParamList) { object value; if (!ZclHelper.GetValue(parameter.ZigBeeType, ref buffer, ref offset, out value)) { // can't get one of the out parameters => nothing else to do // note that return value is true because server command has been found but can't be parsed return(true); } parameter.Data = value; } // execute notification callback asynchronously Task.Run(() => { element.OnReception(element); }); return(true); }
public override bool ParseResponse(byte[] buffer) { SOURCE_INFO sourceInfo = new SOURCE_INFO(); // verify command Id int offset = GetZclCommandIdOffset(ref buffer); if (COMMAND_ID_REPORT_ATTRIBUTES != buffer[offset]) { return(false); } if (OnReception == null) { // can't signal anything // however this is not an error => return true return(true); } // get Mac address, network address, endpoint Id and cluster Id of source offset = 0; sourceInfo.macAddress = AdapterHelper.UInt64FromXbeeFrame(buffer, offset); offset = AdapterHelper.MAC_ADDR_LENGTH; sourceInfo.networkAddress = AdapterHelper.UInt16FromXbeeFrame(buffer, offset); offset += AdapterHelper.NETWORK_ADDRESS_LENGTH; sourceInfo.endpointId = buffer[offset]; offset++; // skip destination end point offset++; sourceInfo.clusterId = AdapterHelper.UInt16FromXbeeFrame(buffer, offset); // parse ZCL payload offset = GetZclPayloadOffset(ref buffer); while (offset < buffer.Length) { object value = null; // from ZCL report attribute payload // - 1st byte is the attribute Id // - 2nd byte indicates the type // - following byte(s) contain the value UInt16 attributeId = AdapterHelper.UInt16FromZigBeeFrame(buffer, offset); offset += sizeof(UInt16); byte type = buffer[offset]; offset += sizeof(byte); if (!ZclHelper.GetValue(type, ref buffer, ref offset, out value)) { // give up if attribute can't be retrieved break; } // execute notification callback asynchronously Task.Run(() => { OnReception(sourceInfo, attributeId, value); }); } return(true); }
public override bool ParseResponse(byte[] buffer) { m_zigBeeStatus = ZclHelper.ZCL_ERROR_SUCCESS; if (!m_responseRequired) { // no response require => leave with success return(true); } // verify response status if (!IsResponseOK(buffer)) { m_zigBeeStatus = ZclHelper.ZCL_ERROR_FAILURE; return(false); } // parse response int offset = GetZclPayloadOffset(ref buffer); if (m_useDefaultResponse) { // Default response to command // verify response command Id and sent command Id if (COMMAND_DEFAULT_RESPONSE != buffer[offset - 1] || m_Id != buffer[offset]) { m_zigBeeStatus = ZclHelper.ZCL_ERROR_FAILURE; return(false); } // save away status offset++; m_zigBeeStatus = buffer[offset]; } else { // specific response to command // verify response command Id if (m_Id != buffer[offset - 1]) { m_zigBeeStatus = ZclHelper.ZCL_ERROR_FAILURE; return(false); } // fill in out parameters foreach (var item in OutputParams) { // cast back out param var outParam = (ZclValue)item; object value; if (!ZclHelper.GetValue(outParam.ZigBeeType, ref buffer, ref offset, out value)) { // can't get one of the out parameters => give up m_zigBeeStatus = ZclHelper.ZCL_ERROR_FAILURE; return(false); } outParam.Data = value; } } return(true); }
internal byte[] ToByteBuffer() { return(ZclHelper.ToByteBuffer(Data)); }