zw_cmd_classes.cs

zwave 无线通讯协议 PC controller 控制器源码

                                        str.Append(x.ToString("X2").PadLeft(4, '0'));
                                    }
                                    else
                                    {
                                        str.Append(" : ");
                                        str.Append(x);
                                    }
                                    paramDetails.Add(str.ToString());
                                }
                                break;
                            case ParamType.DWORD:
                                {
                                    str = new StringBuilder(tempParam.paramName);
                                    ulong x = 0;
                                    x = payload[paramOffs++];
                                    x <<= 8;
                                    x |= payload[paramOffs++];
                                    x <<= 8;
                                    x |= payload[paramOffs++];
                                    x <<= 8;
                                    x |= payload[paramOffs++];
                                    ValueAttrib valAttrib = (ValueAttrib)tempParam.paramAttribs[(byte)0];
                                    str.Append(" : ");
                                    if (valAttrib.showHex)
                                    {
                                        str.Append("0x");
                                        str.Append(x.ToString("X2").PadLeft(8, '0'));
                                    }
                                    else
                                    {
                                        str.Append(x.ToString());
                                    }
                                    paramDetails.Add(str.ToString());
                                }
                                break;

                            case ParamType.BIT_24:
                                {
                                    str = new StringBuilder(tempParam.paramName);
                                    ulong x = 0;
                                    x = payload[paramOffs++];
                                    x <<= 8;
                                    x |= payload[paramOffs++];
                                    x <<= 8;
                                    x |= payload[paramOffs++];
                                    ValueAttrib valAttrib = (ValueAttrib)tempParam.paramAttribs[(byte)0];
                                    str.Append(" : ");
                                    if (valAttrib.showHex)
                                    {
                                        str.Append("0x");
                                        str.Append(x.ToString("X2").PadLeft(6, '0'));
                                    }
                                    else
                                    {
                                        str.Append(x.ToString());
                                    }
                                    paramDetails.Add(str.ToString());
                                }
                                break;


                            case ParamType.BITMASK:
                                {
                                    paramDetails.Add(tempParam.paramName + " :");
                                    if (payload.Length == 0)
                                    {
                                        str = new StringBuilder("Invalid");
                                        paramDetails.Add(str.ToString());
                                    }
                                    else
                                    {
                                        ParamDescLoc maskLen = (ParamDescLoc)tempParam.paramAttribs[(byte)0];
                                        int bitOffset = 0;
                                        if (tempParam.paramAttribs.Contains(1))
                                        {
                                            bitOffset = (int)tempParam.paramAttribs[(byte)1];
                                        }
                                        bitOffset++;
                                        int len;
                                        if (maskLen.paramDesc == 0xFF)
                                        {
                                            if (maskLen.paramStart != 0xFF) // if the length parameter offset is 0xff then the bitmask has no length field.
                                                len = payload[maskLen.paramStart];
                                            else
                                            {// the length parameter is a byte.
                                                len = payload.Length - paramOffs;
                                            }
                                        }
                                        else
                                        {// the length parameter is a bitfiled structure
                                            BitField bitField = (BitField)(((CmdParam)tempCmd.cmdParams[maskLen.param]).paramAttribs[maskLen.paramDesc]);
                                            len = (bitField.fieldMask & payload[maskLen.paramStart]) >> bitField.shifter;
                                        }

                                        for (int maskOffs = 0; maskOffs < len; maskOffs++)
                                        {
                                            if (payload.Length <= paramOffs + maskOffs)
                                            {
                                                str = new StringBuilder("Invalid");
                                                paramDetails.Add(str.ToString());

                                            }
                                            else
                                            {
                                                byte bitMask;
                                                byte maskByte = payload[paramOffs + maskOffs];
                                                if (maskByte == 0)
                                                {
                                                    continue;
                                                }
                                                str = new StringBuilder("0x");
                                                str.Append(maskByte.ToString("X2"));
                                                str.Append(" = [");
                                                bitMask = 0x01;
                                                for (int i = 0; i < 8; i++)
                                                {
                                                    if ((bitMask & maskByte) != 0)
                                                    {
                                                        byte nodeID = (byte)(((maskOffs * 8) + i) + bitOffset);
                                                        if (!str.ToString().EndsWith("["))
                                                            str.Append(',');
                                                        str.Append(nodeID);
                                                    }
                                                    bitMask <<= 1;
                                                }
                                                str.Append(']');
                                                paramDetails.Add(str.ToString());
                                            }
                                        }
                                        paramOffs += (byte)len;
                                    }
                                }
                                break;
                            case ParamType.CONST:
                                {
                                    str = new StringBuilder(tempParam.paramName);
                                    str.Append(" : ");
                                    bool found = false;
                                    byte constValue = payload[paramOffs++];
                                    for (int i = 0; i < tempParam.paramAttribs.Count; i++)
                                    {
                                        BitFlag bitFlag = (BitFlag)tempParam.paramAttribs[(byte)i];
                                        if (bitFlag.flagMask == constValue)
                                        {
                                            found = true;
                                            str.Append(" : ");
                                            str.Append(bitFlag.flagName);
                                            break;
                                        }
                                    }
                                    if (!found)
                                    {
                                        str.Append("0x");
                                        str.Append(constValue.ToString("X2").PadLeft(2, '0'));
                                    }
                                    paramDetails.Add(str.ToString());
                                }
                                break;
                            case ParamType.ARRAY:
                                {
                                    str = new StringBuilder(tempParam.paramName);
                                    str.Append(" : ");
                                    ArrayAttrib arrAttrib = (ArrayAttrib)tempParam.paramAttribs[(byte)0];
                                    int len = arrAttrib.len;
                                    if (len == 0xff) // if length attribute if 0xff then the array is daynamic, calculate the array from the payload length
                                    {
                                        if (tempParam.paramAttribs.Contains((byte)1))
                                        {
                                            ArrayLen arrLen = (ArrayLen)tempParam.paramAttribs[(byte)1];
                                            len = ((payload[arrLen.paramOffes] & arrLen.lenMask) >> arrLen.lenOffs);

                                        }
                                        else
                                            len = payload.Length - paramOffs;
                                    }
                                    if (arrAttrib.isAscii)
                                    {
                                        for (int i = 0; i < len; i++)
                                        {
                                            str.Append(char.ToString((char)payload[paramOffs + i]));
                                        }
                                    }
                                    else
                                    {
                                        str.Append('[');
                                        for (int i = 0; i < len; i++)
                                        {
                                            str.Append(payload[paramOffs + i]);
                                            if (i != len - 1)
                                                str.Append(',');
                                        }
                                        str.Append(']');
                                    }
                                    paramOffs += (byte)len;
                                    paramDetails.Add(str.ToString());
                                }
                                break;
                            case ParamType.ENUM:
                                {
                                    str = new StringBuilder(tempParam.paramName);
                                    str.Append(" : ");
                                    if (tempParam.paramAttribs.Contains(payload[paramOffs]))
                                    {
                                        str.Append(tempParam.paramAttribs[payload[paramOffs]]);
                                        str.Append(" = ");
                                        str.Append(payload[paramOffs]);
                                    }
                                    else
                                    {
                                        str.Append("Unknown value = ");
                                        str.Append("0x");
                                        str.Append(payload[paramOffs].ToString("X2").PadLeft(2, '0'));
                                    }
                                    paramOffs++;
                                    paramDetails.Add(str.ToString());

                                }
                                break;

                            case ParamType.ENUM_ARRAY:
                                { // command classes
                                    byte elm;
                                    paramDetails.Add(tempParam.paramName + " : ");

                                    int len = 0xffff;//(int)tempParam.paramAttribs[(byte)0];
                                    //int len = tempParam.paramAttribs.Count;

                                    if (len == 0xffff)
                                        len = payload.Length - paramOffs;
                                    for (int i = 0; i < len; i++)
                                    {
                                        str = new StringBuilder();
                                        elm = payload[paramOffs + i];
                                        if ((elm != 0xFF) && (tempParam.paramAttribs.Contains((byte)(elm + 1))))
                                        {
                                            str.Append(tempParam.paramAttribs[(byte)(elm + 1)]);
                                            str.Append(" = ");
                                            str.Append(elm.ToString());
                                        }
                                        else
                                        {
                                            str.Append("0x");
                                            str.Append(elm.ToString("X2").PadLeft(2, '0'));
                                        }
                                        paramDetails.Add(str.ToString());
                                    }
                                    paramOffs += (byte)len;
                                }
                                break;
                            case ParamType.MULTI_ARRAY:
                                {
                                    ParamDescLoc loc = (ParamDescLoc)tempParam.paramAttribs[(byte)0];
                                    str = new StringBuilder();
                                    byte firstDem;
                                    byte secondDem = payload[paramOffs];
                                    // get the command parameter that descripe the array first deminsion
                                    if (loc.paramDesc == 0xFF) // it a byte parameter
                                    {
                                        firstDem = payload[loc.paramStart];
                                    }
                                    else
                                    { // it's a bitfield paramter
                                        BitField bitField = (BitField)(((CmdParam)tempCmd.cmdParams[loc.param]).paramAttribs[loc.paramDesc]);
                                        firstDem = (byte)((bitField.fieldMask & payload[loc.paramStart]) >> bitField.shifter);
                                    }


                                    // Handle SPECIFIC_NOT_USED for payload value = 255
                                    if (firstDem >= 255)
                                    {
                                        str = new StringBuilder("