zw_cmd_classes.cs

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

                 
                int paramCount = 0;
                
                paramCount = (tempCmd.cmdRecursive ? payload.Length : tempCmd.cmdParams.Count); // tempCmd.cmdParams.Count;
                int cmdParamCount = paramCount;
                int cmdParamOffs = 0;
                if (paramCount != 0)
                {
                    int paramOffs = 0;
                    ArrayList[] cmdParams = new ArrayList[paramCount];
                    ArrayList paramDetails = new ArrayList();
                    int recurlength = 0;
                    int variantLength = 0;
                    int amount = 0;

                    byte variantKey = 0;
                    int variantAtParamNo = 0;
                    bool inVariantGroup = false;
                    int variant_groupCount = 0;

                    string recurclassname = "";
                    byte tempRecurClassByte = 0;
                    byte tempRecurCmdByte = 0;
                    ZWaveClass tempRecurClass = (ZWaveClass)classes.ZwClasses[cmdClass];
                    CmdParam tempRecurParam = new CmdParam();
                    ZWaveCmd tempRecurCmd = new ZWaveCmd();

                    for (int paramNo = 0; paramNo < paramCount; paramNo++)
                    {
                        /*if (paramNo >= payload.Length)
                        {
                            break;
                        }*/
                        StringBuilder str = new StringBuilder();
                        StringBuilder recurstr = new StringBuilder();

                        // See if next key is a variant_group

                        CmdParam tempParam = new CmdParam();
                        Variant_Group tempVarGrp = new Variant_Group();

                        paramDetails.Clear();

                        // First time spotted new variantgroup
                        if (tempCmd.variantGroups.Contains(variantKey) && ((Variant_Group)tempCmd.variantGroups[variantKey]).paramKey == paramNo)
                        {
                            variantAtParamNo = paramNo;
                            tempVarGrp = (Variant_Group)tempCmd.variantGroups[variantKey];
                            variant_groupCount = (int)((payload[tempVarGrp.paramOffs] & tempVarGrp.sizeMask) >> tempVarGrp.sizeOffs);
                            inVariantGroup = true;
                            tempParam = (CmdParam)tempVarGrp.grpParams[(byte)(paramNo - variantAtParamNo)];
                        }
                        else if (inVariantGroup)
                        {
                            tempVarGrp = (Variant_Group)tempCmd.variantGroups[variantKey];


                            // We've left VARIANT_GROUP
                            if ((!((Variant_Group)tempCmd.variantGroups[variantKey]).grpParams.Contains((byte)(paramNo - variantAtParamNo)) &&
                                (payload[variantAtParamNo] < (paramNo - variantAtParamNo))) ||
                                (payload[variantAtParamNo] < (paramNo - variantAtParamNo)))
                            {  // paramNo - ((Variant_Group)tempCmd.variantGroups[variantKey]).paramKey >= ((Variant_Group)tempCmd.variantGroups[variantKey]).grpParams.Count)

                                // There are still more groups of same type left
                                if (variant_groupCount > 1)
                                {
                                    variantAtParamNo = paramNo;
                                    variant_groupCount--;
                                    tempVarGrp = (Variant_Group)tempCmd.variantGroups[variantKey];
                                    tempParam = (CmdParam)tempVarGrp.grpParams[(byte)(paramNo - variantAtParamNo)];

                                }
                                else if (tempCmd.cmdParams.Contains((byte)paramNo - variantAtParamNo)) // No params left in group, try normal cmd
                                {
                                    tempParam = (CmdParam)tempCmd.cmdParams[(byte)paramNo - variantAtParamNo];
                                }
                                else if (tempCmd.variantGroups.Contains(variantKey + 1))
                                {
                                    if (((Variant_Group)tempCmd.variantGroups[variantKey + 1]).grpParams.Contains((byte)paramNo - variantAtParamNo))
                                    {
                                        variantKey++;

                                        break;
                                    }
                                }
                                else
                                {
                                    paramCount = paramNo;
                                }
                                // Leaving variantGroup

                                //break;
                            }
                            else
                            {
                                tempParam = (CmdParam)tempVarGrp.grpParams[(byte)(((paramNo - variantAtParamNo) > tempVarGrp.grpParams.Count - 1 ? (byte)(tempVarGrp.grpParams.Count - 1) : paramNo - variantAtParamNo))];
                            }

                        }
                        else
                        {
                            tempParam = (CmdParam)tempCmd.cmdParams[(byte)paramNo];
                        }

                        switch (tempParam.paramType)
                        {
                            case ParamType.BYTE:
                                {// abyte value, a byte can have zero or more defines.
                                    //str.Append(tempParam.paramName);
                                    str = new StringBuilder(tempParam.paramName);

                                    ValueAttrib valAttrib = new ValueAttrib();

                                    if (tempCmd.cmdRecursive)
                                    {
                                        switch (tempParam.paramRecurType)
                                        {
                                            case "length":
                                                recurlength = (int)payload[paramNo];
                                                variantLength = recurlength + paramNo + 1;
                                                recurstr.Append(tempParam.paramName + ": " + recurlength.ToString());
                                                break;
                                            case "cmdclass":
                                                tempRecurClassByte = payload[paramNo];
                                                if (!classes.ZwClasses.ContainsKey(tempRecurClassByte))
                                                {
                                                    recurstr.Append(tempParam.paramName + ": unknown (" + tempRecurClassByte.ToString() + ")");
                                                }
                                                else
                                                {
                                                    tempRecurClass = (ZWaveClass)classes.ZwClasses[tempRecurClassByte];
                                                    recurstr.Append(tempParam.paramName + ": " + tempRecurClass.cmdClassName);
                                                    recurclassname = tempRecurClass.cmdClassName;
                                                }
                                                break;
                                            case "cmd":
                                                tempRecurCmdByte = payload[paramNo];
                                                if (tempRecurClass.cmdClassName == recurclassname)
                                                {
                                                    if (!tempRecurClass.cmd.ContainsKey(tempRecurCmdByte))
                                                    {
                                                        recurstr.Append(tempParam.paramName + ": unknown (" + tempRecurCmdByte.ToString() + ")");
                                                    }
                                                    else
                                                    {
                                                        tempRecurCmd = (ZWaveCmd)tempRecurClass.cmd[tempRecurCmdByte];
                                                        tempRecurParam = (CmdParam)((Variant_Group)tempCmd.variantGroups[variantKey]).grpParams[(byte)(paramNo - variantAtParamNo)];
                                                        recurstr.Append(tempParam.paramName + ": " + tempRecurCmd.cmdName.ToString());
                                                    }
                                                    if (recurlength == 2) // No data variant, remove field
                                                    {
                                                        //((Variant_Group)tempCmd.variantGroups[variantKey]).grpParams.Remove((byte)3); // Remove variant param from list

                                                        //if (((Variant_Group)tempCmd.variantGroups[variantKey]).grpParams.Contains((byte)nextcmd))
                                                        //{
                                                        //    Hashtable tempStorage = new Hashtable(((Variant_Group)tempCmd.variantGroups[variantKey]).grpParams.Count - 1);

                                                        //((Variant_Group)tempCmd.variantGroups[variantKey]).grpParams.Remove((byte)4);
                                                        //tempCmd.cmdParams.Remove((byte)4);

                                                        //paramCount--;
                                                        /*for (int i = 0; i < tempCmd.cmdParams.Count - 1; i++)
                                                        {
                                                            tempStorage[(byte)i] = ((Variant_Group)tempCmd.variantGroups[variantKey]).grpParams[(byte)(i >= 4 ? i + 1 : i)];
                                                        }

                                                        paramCount--;
                                                        tempCmd.cmdParams = tempStorage;
                                                    //}*/
                                                    }
                                                }
                                                else
                                                {
                                                    recurstr.Append("Error: No recurring class found");
                                                }
                                                break;
                                            case "amount":
                                                amount = (int)payload[paramNo];
                                                //paramCount = amount * 4 + 1;
                                                //paramCount = paramCount + ((amount-1) * 2);
                                                recurstr.Append(tempParam.paramName + ": " + amount.ToString());
                                                break;
                                            default:
                                                break;
                                        }
                                    }
                                    else
                                    {

                                        if (tempParam.paramAttribs.Count > 0)
                                        {
                                            valAttrib = (ValueAttrib)tempParam.paramAttribs[(byte)0];
                                        }
                                        else
                                        {
                                            valAttrib.showHex = true;
                                        }
                                        if (valAttrib.hasDefines)
                                        {
                                            bool found = false;
                                            if (paramOffs >= payload.Length)
                                            {
                                                str.Append(" : ");
                                                str.Append(" Missing Value");
                                            }
                                            else
                                            {
                                                for (int i = 1; i < tempParam.paramAttribs.Count; i++)
                                                {
                                                    BitFlag bitFlag = (BitFlag)tempParam.paramAttribs[(byte)i];
                                                    if (bitFlag.flagMask == payload[paramOffs])
                                                    {
                                                        found = true;
                                                        str.Append(" : ");
                                                        str.Append(bitFlag.flagName);
                                                        //str += " : " + bitFlag.flagName;
                                                        break;
                                                    }
                                                }
                                                if (!found)
                                                {
                                                    str.Append(" : ");
                                                    if (valAttrib.showHex)
                                                    {
                                                        str.Append("0x");
                                                        str.Append(payload[paramOffs].ToString("X2").PadLeft(2, '0'));
                                                    }
                                                    else
                                                        str.Append(payload[paramOffs].ToString());
                                                }
                                            }
                                        }
                                        else
                                        {
                                            if (payload.Length > paramOffs)
                                            {
                                                str.Append(" : ");
                                                if (valAttrib.showHex)
                                                {
                                                    str.Append("0x");
                                                    str.Append(payload[paramOffs].ToString("X2").PadLeft(2, '0'));
                                                }
                                                else
                                                {
                                                    str.Append(payload[paramOffs].ToString());
                                                }
                                            }
                                            else
                                            {
                                                str.Append(" Invalid paramOffs = ");
                                                str.Append(paramOffs);
                                            }
                                        }
                                    }
                                    paramDetails.Add((tempCmd.cmdRecursive ? recurstr.ToString() : str.ToString()));
                                    paramOffs++;
                                }
                                break;
                            case ParamType.WORD:
                                {
                                    str = new StringBuilder(tempParam.paramName);
                                    ushort x = 0;
                                    x = payload[paramOffs++];
                                    x <<= 8;
                                    x |= payload[paramOffs++];
                                    ValueAttrib valAttrib = (ValueAttrib)tempParam.paramAttribs[(byte)0];
                                    if (valAttrib.showHex)
                                    {
                                        str.Append(" : ");
                                        str.Append("0x");