!GetCurrentChannelNum()
函数意义：得到当前触发单通道写的通道号； 返 回 值：整型。-1 失败，> 0 通道号； 参 数：无；
实 例：!GetCurrentChannelNum()。
!SetIntChannelValueByName(DataStr,n)
函数意义：根据通道的名称对通道进行设置，假设该通道类型为整型（开关型）变量； 返 回 值：整型。-1 失败，0 成功。
参 数：DataStr，字符型，需要设置的通道名称的字符串。 n，整型，需要设定的整型值
实 例：! SetIntChannelValueByName (\发电机启动\。 实例说明：将通道“发电机启动”的值设为1；
!SetSingleChannelValueByName(DataStr,x)
函数意义：根据通道的名称对通道进行设置，假设该通道类型为单精度浮点型（数值型）变量；
返 回 值：整型。-1 失败，0 成功。
参 数：DataStr，字符型，需要设置的通道名称的字符串。 n，单精度浮点型，需要设定的值
实 例：! SetSingleChannelValueByName (\温度\。 实例说明：将通道“温度”的值设为45.5；
!SetIntChannelValueByNum(DataNum,n)
函数意义：根据通道的编号对通道进行设置，假设该通道类型为整型（开关型）变量； 返 回 值：整型。-1 失败，0 成功。
参 数：DataNum，整型，需要设置的通道编号，从1开始。 n，整型，需要设定的整型值
实 例：! SetIntChannelValueByNum(3,1)。 实例说明：将通道3的值设为1；
!SetSingleChannelValueByNum(DataNum,x)
函数意义：根据通道的编号对通道进行设置，假设通道为单精度浮点型（数值型）变量； 返 回 值：整型。-1 失败，0 成功。
参 数：DataNum，整型，需要设置的通道编号，从1开始。 x，单精度数值型，需要设定的数值
实 例：!SetSingleDataValueByNum(2,45.5)。 实例说明：将通道2的值设为45.5。
!GetIntChannelValueByName(DataStr,ByRef n)
函数意义：根据通道的名字，将该通道的值读出，假设该通道为整型（开关型）变量； 返 回 值：整型。-1 失败，0 成功。
参 数：DataStr，字符型，需要读取的通道名的字符串。
n，引用型，整型，保存读出值的变量；
实 例：! GetIntChannelValueByName (\发电机启动\。 实例说明：将通道“显示内容”的值读出，赋给变量n；
!GetSingleChannelValueByName(DataStr,ByRef x)
函数意义：根据通道的名字，将该通道的值读出，假设该通道为单精度浮点型（开关型）变量；
返 回 值：整型。-1 失败，0 成功。
参 数：DataStr，字符型，需要读取的通道名的字符串。 x，引用型，单精度浮点型，保存读出值的变量； 实 例：! GetSingleChannelValueByName (\温度\。 实例说明：将通道“温度”的值读出，赋给变量x；
!GetIntChannelValueByNum(DataNum,ByRef n)
函数意义：根据通道的编号，将该通道的值读出，假设该通道为整型（开关型）变量； 返 回 值：整型。-1 失败，0 成功。
参 数：DataNum，整型，需要读取的通道的编号。 n，引用型，整型，保存读出值的变量； 实 例：! GetIntChannelValueByNum (1,n)。 实例说明：将通道1的值读出，赋给变量n；
!GetSingleChannelValueByNum(DataNum,ByRef x)
函数意义：根据通道的编号，将该通道的值读出，假设该通道为单精度浮点型（开关型）变量；
返 回 值：整型。-1 失败，0 成功。
参 数：DataNum，整型，需要读取的通道的编号。 x，引用型，单精度浮点型，保存读出值的变量； 实 例：! GetSingleChannelValueByNum (2,x)。 实例说明：将通道2的值读出，赋给变量x；
!GetChannelCount()
函数意义：得到驱动的通道总数；
返 回 值：整型。-1 失败，>= 0 通道总数； 参 数：无；
实 例：! GetChannelCount ()。
!Trace(Str)
函数意义：在脚本驱动开发工具的调试功能中，在输出框输出一些信息，在运行环境下不起作用；
返 回 值：整型。-1 失败， 0 成功； 参 数：str，字符型，输出字符串； 实 例：!Trace(!strFormat(\。
!Sleep(n)
函数意义：在脚本执行的过程中，暂停一段时间。 返 回 值：整型。-1 失败， 0 成功；
参 数：n，整型，暂停时间，以毫秒（ms）为单位； 实 例：!Sleep(500)。
实例说明：暂停执行500毫秒；
!Ascii2I(str)
函数意义：返回字符串str的首字符的Ascii值。 返 回 值：整型。
参 数：str， 字符型。
实 例：!Ascii2I(\。
!Bin2I(str)
函数意义：把二进制字符串转换为数值。 返 回 值：整型。
参 数：str， 字符型。 实 例：!Bin2I(\。
!Format(x，str)
函数意义：格式化数值型数据对象。 返 回 值：字符型。
参 数：x， 数值型，要格式化的数值； str， 字符型，格式化数值的格式。表示为0.00样式。小数点后的0的个数表示需要格式化出的小数
位数。小数点前的0为一个时，表示小数点前根据实际数值显示。当小数点前没有0时，表示
为.xx式样，当小数点前的0不止一个时，使用0来填充不够的位数。
实 例：!Format(1.236,\；!Format(1.236,\； !Format(1.236,\。
!Hex2I(str)
函数意义：把16进制字符串转换为数值。 返 回 值：整型。
参 数：str， 字符型。
实 例：!Hex2I (\。
!I2Ascii(n)
函数意义：返回指定Ascii值的字符。 返 回 值：字符型。 参 数：n， 整型。
实 例：!I2Ascii(65) =\。
!I2Bin(n)
函数意义：把数值转换为二进制字符串。 返 回 值：字符型。 参 数：n，整型。
实 例：!I2Bin (5) =\
!I2Hex(n)
函数意义：把数值转换为16进制字符串。 返 回 值：字符型。 参 数：n，整型。
实 例：!I2Hex (17) =\。
!I2Oct(n)
函数意义：把数值转换为8进制字符串。 返 回 值：字符型。 参 数：n，整型。
实 例：!I2Oct (9) =\。
!InStr(n,str1,str2) 函数意义：查找一字符串str2在另一字符串str1中第一次出现的位置，字符串的首位置为1。 返 回 值：整型，如果找到，则返回位置，如果未找到，则返回0。 参 数：n，整型，开始搜索的位置，字符串的首位置为1； str1，字符型，被搜索的字符串； str2，字符型，要搜索的子字符串。
实 例：!InStr(1,\；!InStr(3,\。
!Lcase(str)
函数意义：把字符型数据对象str的所有字符转换成小写。 返 回 值：字符型。
参 数：str， 字符型。
实 例：!LCase(\。
!Left(str,n)
函数意义：字符型数据对象str左边起，取n个字符。 返 回 值：字符型。
参 数：str：字符型，源字符串；n，整型，取字符个数。 实 例：!Left(\ =\
!Len(str)
函数意义：求字符型数据对象str的字符串长度（字符个数）。 返 回 值：浮点数。
参 数：str， 字符型。
实 例：!Len(\；!Len(\昆仑通态\。
!Ltrim(str)
函数意义：把字符型数据对象str中最左边的空格剔除。 返 回 值：字符型。
参 数：str， 字符型。
实 例：!LTrim(\ dsfk \ \
!Mid(str,n,k)
函数意义：从字符型数据对象str左边第n个字符起，取k个字符。字符首位置从1开始算起。
返 回 值：字符型。
参 数：str， 字符型，源字符串； n， 整型，起始位置； k， 整型，取字符数。
实 例：!Mid(\。
!Oct2I(str)
函数意义：把8进制字符串转换为数值。 返 回 值：整型。
参 数：str， 字符型。 实 例：!Oct2I (\。
!Right(str,n)
函数意义：从字符型数据对象str右边起，取n个字符。 返 回 值：字符型。
参 数：str，字符型，源字符串；n，整型，取字符个数。 实 例：!Right(\ =\。
!Rtrim(str)
函数意义：把字符型数据对象str中最右边的空格剔除。 返 回 值：字符型。
参 数：str， 字符型。
实 例：!LTrim(\ dsfk \ dsfk\。
!Str(x)
函数意义：将数值型数据对象x的值转换成字符串。 返 回 值：字符型。 参 数：x， 数值型。
实 例：!Str(0.712) =\。
!StrComp(str1,str2)
函数意义：比较字符型数据对象str1和str2是否相等，返回值为0时相等，返回值为1时则str1 > str2，
返回值为-1 时则 str1 < str2。此函数区分字母大小写。 返 回 值：整型。
参 数：str1， 字符型；
str2， 字符型。
实 例：!StrComp(\。
!StrCompCase(str1,str2)
函数意义：比较字符型数据对象str1和str2是否相等，返回值为0时相等，返回值为1时则str1 > str2，
返回值为-1 时则 str1 < str2。此函数不区分字母大小写。 返 回 值：整型。
参 数：str1， 字符型； str2， 字符型。
实 例：!StrCompCase(\，!StrCompCase(\。
!StrFormat(FormatStr,任意个数变量)
函数意义：格式化字符串，可以格式化任意多个数值。 返 回 值：字符型。
参 数：FormatStr， 字符型，格式化字符串。后面的参数可以任意多个。 实 例：!StrFormat(\。
!Trim(str)
函数意义：把字符型数据对象str中左右两端的空格剔除。 返 回 值：字符型。
参 数：str， 字符型。
实 例：!Trim(\ dsfk \。
!Ucase(str)
函数意义：把字符型数据对象str的所有字符转换成大写。 返 回 值：字符型。
参 数：str， 字符型。
实 例：!UCase(\。
!Val(str)
函数意义：把字符型数据对象str的值转换成数值。 返 回 值：数值型。
参 数：str， 字符型。
实 例：!Val(\。
!Sscanf(str1, str2, 任意)
函数意义：根据给出的字符串按一定的格式读取其值到变量中。 返 回 值：-1 失败， 0 成功。
参 数：str1，字符串型，需要转化为数值的字符串。 str2，字符串型，转化格式。任意，任意个需要转化出来的变量值
实 例：!Sscanf(\，则 int1 = 123 value1 = 45.23。 !Sscanf(\ 则 value = -123.234。
说明：这里转化格式支持两种 %f 和 %d，以及支持在格式字符串中用 %% 匹配源字符串
的 %。
!Space(n)
函数意义：由多个空格形成长度为n的新字符串 返 回 值：字符型。
参 数：n， 整型，形成的新字符串长度； 实 例：!Space(3) = \ \。
!Strings(chr,n)
函数意义：由多个chr形成长度为n的新字符串 返 回 值：字符型。
参 数：chr， 字符型，源字符串； n， 整型，形成的新字符串长度； 实 例：!Strings(\。 !Strings(\中\中中\。
!Chr(n)
函数意义：返回指定Ascii值的字符。 返 回 值：字符型。 参 数：n， 整型。 实 例：!Chr(65) =\。
说 明：与I2Ascii的功能一致，为了与VB的语法保持一致；
!Asc(s)
函数意义：返回字符串s的首字母的Ascii值。 返 回 值：整型。
参 数：s， 字符型。
实 例：!Asc (\。
说 明：与Ascii2I的功能一致，为了与VB的语法保持一致；
!MidEx(str,n)
函数意义：从字符型数据对象str左边第n个字符起，右边所有的字符。数字字符时，从1开始算起。
返 回 值：字符型。
参 数：str， 字符型，源字符串； n， 整型，起始位置；
实 例：!MidEx(\。
!Prifix(str,chr,n)
函数意义：使字符型数据对象str左边增加前缀字符chr，使得新字符串的长度为n。
如果字符型数据对象str的长度已超过n，则只保留右边长度为n的字符串。
返 回 值：字符型。
参 数：str， 字符型，源字符串；
chr, 字符型，前缀字符； n， 整型，新字符串的长度； 实 例：!Prifix(\。 !Prifix(\。 !Prifix(\。
!Postfix(str,chr,n)
函数意义：使字符型数据对象str右边增加后缀字符chr，使得新字符串的长度为n。
如果字符型数据对象str的长度已超过n，则只保留左边长度为n的字符串。
返 回 值：字符型。
参 数：str， 字符型，源字符串； chr, 字符型，后缀字符； n， 整型，新字符串的长度； 实 例：!Postfix(\。 !Postfix(\。 !Postfix(\。
!InStrRev(n,str1,str2) 函数意义：查找一字符串str2在另一字符串str1中第一次出现的位置，字符串的首位置为1， 本函数与Instr函数的区别为，它是从字符串的尾部开始进行查找。字符串的首位置为1。
返 回 值：整型，如果找到，则返回位置，如果未找到，则返回 -1。
参 数：n，整型，开始搜索的位置，该位置是从字符串的首位置开始计算的，字符串的首位置为1，
如果值为0，则表示从最后一个字符开始； str1，字符型，被搜索的字符串； str2，字符型，要搜索的子字符串。
实 例：!InStrRev(0,\；!InStrRev(3,\。
!Replace(expression, find, replace, start, count) 函数意义：将字符串expression中的字符串find替换为字符串replace，字符串的首位置为1。 返 回 值：字符型，返回被替换后的结果字符串。 参 数：expression，字符型，源字符串； find，字符型，需替代的字符串； replace，字符型，替代的字符串； start， 查询的起始位置，字符串的首位置为1； count, 替换次数，-1表示将所有的可能字符串全部替换，1表示只替换第一个发现的字符串。
实 例：!Replace(\= \；!Replace(\= \。
!Atn(x)
函数意义：反正切函数。
返 回 值：数值型，用弧度表示。 参 数：x，数值型。
实 例：!Atn(1) =0.785398。
!Cos(x)
函数意义：余弦函数。 返 回 值：数值型。
参 数：x，数值型，用弧度表示。 实 例：!Cos(3.14159)=-1.0。
!Sin(x)
函数意义：正弦函数。 返 回 值：数值型。
参 数：x，数值型，用弧度表示。 实 例：!Sin(3.14159)=0.0。
!Tan(x)
函数意义：正切函数。 返 回 值：数值型。
参 数：x，数值型，用弧度表示。 实 例：!Tan(3.14159)=0.0。
!Exp(x)
函数意义：指数函数。 返 回 值：数值型。 参 数：x，数值型。
实 例：!Exp(2.3020585093)=10.0。
!Log(x)
函数意义：对数函数。 返 回 值：数值型。 参 数：x，数值型。 实 例：!Log(10)=2.302。
!Sqr(x)
函数意义：平方根函数。 返 回 值：数值型。 参 数：x，数值型。 实 例 ：!Sqr(4.0)=2.0。
!Abs(x)
函数意义：绝对值函数。 返 回 值：数值型。 参 数：x，数值型。
实 例 ：!Abs(-3.14159)=3.14159。
!Sgn(x)
函数意义：符号函数。 返 回 值：数值型。 参 数：x，数值型。
实 例：!Sgn(-10) = -1；!Sgn(10) = 1；!Sgn(0) = 0。
!Rand(x,y)
函数意义：生成随机数，随机数的范围在x和y之间。 返 回 值：数值型。
参 数：x，数值型。Y, 数值型。 实 例：!Rand(3,4) = 3.1。
!BitAnd(m,n)
函数意义：按位与，位的计算从0开始。 返 回 值：整型。
参 数：m，整型，n，整型。
实 例：!BitAnd(&H03, &H04) =&H00。
!BitOr(m,n)
函数意义：按位或，位的计算从0开始。 返 回 值：整型。
参 数：m，整型。n,整型。
实 例：!BitOr(&H03, &H04) =&H07。
!BitXor(m,n)
函数意义：按位异或，位的计算从0开始。 返 回 值：整型。
参 数：m，整型。n,整型。
实 例：!BitXor(&H03, &H04) = &H07。
!BitClear(m,n)
函数意义：清除m的指定n位为0，位置从0开始计算。 返 回 值：整型。
参 数：m，整型。n,整型。
实 例：!BitClear(&H03,1) = 1，把第2位清空。
!BitSet(m,n)
函数意义：设置m的指定位为1，位置从0开始计算。 返 回 值：整型。
参 数：m，整型。n,整型。
实 例：!BitSet (&H03,2) = &H07。
!BitNot(m)
函数意义：按位取反。位的计算从0开始。 返 回 值：整型。 参 数：m，整型。
实 例：!BitNot(&H00) = &HFFFF。
!BitTest(m,n)
函数意义：检测指定位是否为1，位置从0开始计算。 返 回 值：整型，如果为1，则返回1，否则返回0。 参 数：m，整型。n,整型。 实 例：!BitTest(3,2) = 0。
!BitLShift(m,n)
函数意义：左移，位的计算从0开始。 返 回 值：整型。
参 数：m，整型。n,整型。
实 例：!BitLShift(&H03,1) = &H06。
!BitRShift(m,n)
函数意义：右移，位的计算从0开始。 返 回 值：整型。
参 数：m，整型。n,整型。
实 例：!BitRShift(&H03,1) = &H01。
!TimeStr2I(strTime)
函数意义：将表示时间的字符串（YYYY/MM/DD HH:MM:SS）转换为时间值。 返 回 值：整型，转换后的时间值。
参 数：strTime，字符型，以字符串型表示的时间（YYYY/MM/DD HH:MM:SS）。 实 例：!TimeStr2I(\。
实例说明：将表示时间的字符串“2001/1/1 3:15:28”转换为整型的时间值。
!TimeI2Str(iTime,strFormat)
函数意义：将时间值转换为字符串表示的时间。 返 回 值：字符型，转换后的时间字符串。
参 数：iTime，整型，时间值（注意，这里只能用 !TimeStr2I(strTime)转换出的时间值，否则将不能正确转换。）； strFormat，字符型，转换后的时间字符串的格式。 实 例：!TimeI2Str(Time,\ %H:%M:%S\。
实例说明：将时间值转换为字符串型，其表示格式为：星期，月 日，年。
!TimeGetYear(iTime)
函数意义：获取时间值iTime中的年份。 返 回 值：整型，时间值iTime中的年份。 参 数：iTime，整型，时间值。
实 例：!TimeGetYear(iTime)。
实例说明：获取时间值iTime中的年份。
!TimeGetMonth(iTime)
函数意义：获取时间值iTime中的月份。
返 回 值：整型，时间值iTime中的月份（1~12）。 参 数：iTime，整型，时间值。 实 例：!TimeGetMonth (iTime)。
实例说明：获取时间值iTime中的月份。
!TimeGetSecond(iTime)
函数意义：获取时间值iTime中的秒数。
返 回 值：整型，时间值iTime中的秒数（0~59）。 参 数：iTime，整型，时间值。 实 例：!TimeGetSecond (iTime)。 实例说明：获取时间值iTime中的秒数。
!TimeGetSpan(iTime1,iTime2)
函数意义：计算两个时间iTime1和iTime2之差。 返 回 值：整型，两时间之差。 参 数：iTime1，整型，时间值； iTime2，整型，时间值。
实 例：!TimeGetSpan(iTime1,iTime2)
实例说明：计算两个时间iTime1和iTime2之差。
!TimeGetDayOfWeek(iTime)
函数意义：获取时间值iTime中的星期。
返 回 值：整型，时间值iTime中的秒数（1 为星期日, 2 表示星期一，??）。 参 数：iTime，整型，时间值。
实 例：!TimeGetDayOfWeek (iTime)。 实例说明：获取时间值iTime中的星期。
!TimeGetHour(iTime)
函数意义：获取时间值iTime中的小时。
返 回 值：整型，时间值iTime中的小时（0~23）。 参 数：iTime，整型，时间值。 实 例：!TimeGetHour (iTime)。
实例说明：获取时间值iTime中的小时。
!TimeGetMinute(iTime)
函数意义：获取时间值iTime中的分钟。
返 回 值：整型，时间值iTime中的分钟（0~59）。 参 数：iTime，整型，时间值。 实 例：!TimeGetMinute (iTime)。
实例说明：获取时间值iTime中的分钟。
!TimeGetDay(iTime)
函数意义：获取时间值iTime中的日期。
返 回 值：整型，时间值iTime中的日期（1~31）。 参 数：iTime，整型，时间值。 实 例：!TimeGetDay (iTime)。
实例说明：获取时间值iTime中的日期。
!TimeGetCurrentTime()
函数意义：获取当前时间值。 返 回 值：整型，当前的时间值。 参 数：无。
实 例：!TimeGetCurrentTime()。 实例说明：获取当前时间值。
!TimeSpanGetDays(iTimeSpan) 函数意义：获取时间差中的天数；（时间差由TimeGetSpan函数计算得来）。 返 回 值：整型，时间差中的天数（1~31）。 参 数：iTimeSpan，整型，时间差。 实 例：!TimeSpanGetDays(TimeSpan)。 实例说明：获取时间差TimeSpan中的天数。
!TimeSpanGetHours(iTimeSpan)
函数意义：获取时间差中的小时数；（时间差由TimeGetSpan函数计算得来）。 返 回 值：整型，时间差中的小时数（0~23）。 参 数：iTimeSpan，整型，时间差。 实 例：!TimeSpanGetHours(TimeSpan)。 实例说明：获取时间差TimeSpan中的小时数。
!TimeSpanGetMinutes(iTimeSpan) 函数意义：获取时间差中的分钟数；（时间差由TimeGetSpan函数计算得来）。 返 回 值：整型，时间差中的分钟数（0~59）。 参 数：iTimeSpan，整型，时间差。
实 例：!TimeSpanGetMinutes(TimeSpan)。 实例说明：获取时间差TimeSpan中的分钟数。
!TimeSpanGetSeconds(iTimeSpan) 函数意义：获取时间差中的秒数；（时间差由TimeGetSpan函数计算得来）。 返 回 值：整型，时间差中的秒数（0~59）。 参 数：iTimeSpan，整型，时间差。
实 例：!TimeSpanGetSeconds(TimeSpan)。 实例说明：获取时间差TimeSpan中的秒数。
!TimeSpanGetTotalHours(iTimeSpan) 函数意义：获取时间差中的小时总数；（时间差由TimeGetSpan函数计算得来）。 返 回 值：整型，时间差中的小时总数。 参 数：iTimeSpan，整型，时间差。
实 例：!TimeSpanGetTotalHours(TimeSpan)。 实例说明：获取时间差TimeSpan中的小时总数。
!TimeSpanGetTotalMinutes(iTimeSpan) 函数意义：获取时间差中的分钟总数；（时间差由TimeGetSpan函数计算得来）。 返 回 值：整型，时间差中的分钟总数。 参 数：iTimeSpan，整型，时间差。
实 例：!TimeSpanGetTotalMinutes(TimeSpan)。 实例说明：获取时间差TimeSpan中的分钟总数。
!TimeSpanGetTotalSeconds(iTimeSpan) 函数意义：获取时间差中的秒总数；（时间差由TimeGetSpan函数计算得来）。 返 回 值：整型，时间差中的秒总数。 参 数：iTimeSpan，整型，时间差。
实 例：!TimeSpanGetTotalSeconds(TimeSpan)。 实例说明：获取时间差TimeSpan中的秒总数。
!TimeAdd(iTime,iTimeSpan)
函数意义：向时间iTime中加入由iTimeSpan指定的秒数。 返 回 值：整型，相加后的时间值。 参 数：iTime，整型，初始时间值。 iTimeSpan，整型，要加的秒数。 实 例：!TimeAdd(Time,500)。
实例说明：向时间Time中加上500秒。
!Str2ByteArr(str,ByRef ByteArr)
函数意义：将字符串str中的所有字符填入字节数组，字节数组位置计数从1开始。
返 回 值：整型，返回值0表示填充成功，-1表示字符串中字符的长度大于字节数组的长度，
超出部分已经被裁剪；-2 表示不是字节数组，-3 表示操作失败。 参 数：str，字符型，需填充的字符串。 ByteArr，传址型，类型为字节型数组，被填充的字节数组。
实 例：!Str2ByteArr(\，其中BA为字节数组，BA中的数据为：\、\、\、\、\，
从第6个字节开始的数据未知。
!ByteArr2Str(ByRef ByteArr, str, count)
函数意义：将字节数组ByteArr中的前Count个字节的数据填入字符串中。 返 回 值：0 成功， -1 失败。
参 数：ByteArr，传址型，字节型数组。
Str，传址型，取得的字符串。 Count，整型，由字节数组填充而形成的字符串。
实 例：! ByteArr2Str (BA,str, 5)，其中BA为字节数组，BA中的数据为：\、\、\、\、\，
则生成了一个长度为5的字符串 str ：“ABCDE”。
!SetIntToByteArr(ByRef ByteArr,start,n)
函数意义：对字节数组ByteArr中从start位置开始的内容进行填充，填充的长度为4字节，填充的内容为n，
按4字节整型进行填充，字节数组位置计数从1开始。 返 回 值：整型，判断是填充是否正常： 0： 正常； -1： start的值小于1； -2： start的值大于字节数组的长度； -3： 填充后的结果的某些位置超出ByteArr的长度； -4： 不是字节数组。 -5： 操作失败。
参 数：ByteArr，传址型，字节型数组，被填充的字节数组。 start，整型，填充的首位置，从1开始。 n，整型，填充的内容
实 例：!SetIntToByteArr (BA,1, 65)，则形成的字节数组为： 65 00 00 00
!SetShortToByteArr(ByRef ByteArr,start,n)
函数意义：对字节数组ByteArr中从start位置开始的内容进行填充，填充的长度为2字节，填充的内容为n，
按2字节整型进行填充，所以这种填充方式要求n的值范围为： -32767 ≤ n ≤ 32768。
字节数组位置计数从1开始。 返 回 值：整型，判断是填充是否正常： 0： 正常； -1： start的值小于1； -2： start的值大于字节数组的长度； -3： 填充后的结果的某些位置超出ByteArr的长度； -4： 其它错误。
参 数：ByteArr，传址型，字节型数组，被填充的字节数组。 start，整型，填充的首位置，从1开始。 n，整型，填充的内容
实 例：! SetShortToByteArr (BA,1, 65)，则形成的字节数组为： 65 00
!SetStrToByteArr(ByRef ByteArr,start,str)
函数意义：对字节数组ByteArr中从start位置开始的内容进行填充，填充的长度为字符串str的长度字节，
填充的内容为字符串str，字节数组位置计数从1开始。 返 回 值：整型，判断是填充是否正常：
0： 正常； -1： start的值小于1； -2： start的值大于字节数组的长度； -3： 填充后的结果的某些位置超出ByteArr的长度； -4： 填充后的长度。
参 数：ByteArr，传址型，字节型数组，被填充的字节数组。 start，整型，填充的首位置，从1开始。 str，字符型，填充的内容
实 例：!SetStrToByteArr (BA,2, \，则形成的字节数组为： \ \
!SetSingleToByteArr(ByRef ByteArr,start,x)
函数意义：对字节数组ByteArr中从start位置开始的内容进行填充，填充的长度为4，填充的内容为浮点型x，
填充的格式按照BASIC中单精度浮点型格式填充，字节数组位置计数从1开始。
返 回 值：整型，判断是填充是否正常： 0： 正常； -1： start的值小于1； -2： start的值大于字节数组的长度； -3： 填充后的结果的某些位置超出ByteArr的长度； -4： 其他错误。
参 数：ByteArr，传址型，字节型数组，被填充的字节数组。 start，整型，填充的首位置，从1开始。 x，数值型，填充的内容
实 例：!SetSingleToByteArr (BA,1, 12.3 )，则形成的字节数组的前四个字节为BASIC中单精度浮点数的内部表示。
!GetIntFromByteArr(ByRef ByteArr,start,ByRef n)
函数意义：将字节数组ByteArr中从start位置开始的内容输出到变量n中，输出的格式为4字节整型，
字节数组位置计数从1开始。 返 回 值：整型，判断是输出是否正常： 0： 正常； -1： start的值小于1； -2： start的值大于字节数组的长度； -3： ByteArr无足够多的内容用以输出； -4： 变量n不能够用于保存数据，或空间长度不够 -5： 其他错误。
参 数：ByteArr，传址型，字节型数组。 start，整型，输出的首位置，从1开始。 n，传址型，长整型； 实 例：!GetIntFromByteArr (BA,2, A)，字节数组为：00 01 02 03 04 05 06 07 08 09 00 00 则A=67305985
!GetShortFromByteArr(ByRef ByteArr,start,ByRef n)
函数意义：将字节数组ByteArr中从start位置开始的内容输出到变量n中，输出的格式为2字节整型，
字节数组位置计数从1开始。 返 回 值：整型，判断是输出是否正常： 0： 正常； -1： start的值小于1； -2： start的值大于字节数组的长度； -3： ByteArr无足够多的内容用以输出； -4： 变量n不能够用于保存数据，或空间长度不够 -5： 其他错误。
参 数：ByteArr，传址型，字节型数组。 start，整型，输出的首位置，从1开始。 n，传址型，长整型； 实 例：! GetShortFromByteArr (BA,2, A)，字节数组为：00 01 02 03 04 05 06 07 08 09 00 00 则A=513
!GetStrFromByteArr(ByRef ByteArr,start,count,ByRef str) 函数意义：将字节数组ByteArr中从start位置开始的内容输出到字符型变量n中，输出的长度为count，
字节数组位置计数从1开始。 返 回 值：整型，判断是输出是否正常： 0： 正常； -1： start的值小于1； -2： start的值大于字节数组的长度； -3： ByteArr无足够多的内容用以输出； -4： 变量str不能够用于保存数据，或空间长度不够 -5： 其他错误
参 数：ByteArr，传址型，字节型数组。 start，整型，输出的首位置，从1开始。 count，整型，输出的字节数量； str，传值型，字符型，输出的字符串
实 例：!GetStrFromByteArr (BA,2,5, A)，字节数组为：\则A=\
!GetSingleFromByteArr(ByRef ByteArr,start, ByRef x) 函数意义：将字节数组ByteArr中从start位置开始的4字节内容输出到数值型变量x中，字节数组位置计数从1开始。
返 回 值：整型，判断是输出是否正常： 0： 正常； -1： start的值小于1； -2： start的值大于字节数组的长度； -3： ByteArr无足够多的内容用以输出； -4： 变量x不能够用于保存数据，或空间长度不够
-5： 其他错误
参 数：ByteArr，传址型，字节型数组。 start，整型，输出的首位置。 x，传值型，单精度型，输出的变量
!DevSetBaud(参数1)
函数意义：设置串口的波特率。 返 回 值：整型 0：调用正常； -1：设置失败；
参 数：参数1，长整型，波特率，可选值包括： 110 19200 300 38400 600 56000 1200 57600 2400 115200 4800 128000 9600 256000 14400
实 例：! DevSetBaud (57600)。
实例说明：设置父设备的波特率为57600。
!DevSetDataBit(参数1)
函数意义：设置父设备的串口的数据位。 返 回 值：整型 0：调用正常； -1：设置失败；
参 数：参数1，整型， 7 = bit_7；8 = bit_8。 实 例：! DevSetDataBit (8)。
实例说明：设置父设备的数据位为8位。
!DevSetStopBit(参数1)
函数意义：设置父设备的停止位。 返 回 值：整型 0：调用正常； -1：设置失败；
参 数：参数1， 整型，停止位，0 = stop_1；1 = stop_1.5；2 = stop_2。
实 例：! DevSetStopBit (2)。
实例说明：设置父设备的停止位为2位。
!DevSetParityBit(参数1)
函数意义：设置父设备的校验位。 返 回 值：整型 0：调用正常； -1：设置失败；
参 数：参数1， 整型，校验位 0: 无 1: 奇 2: 偶 3: 置1 4: 置0
实 例：! DevSetParityBit (0)。 实例说明：设置父设备无校验。
!DevGetBaud()
函数意义：读取父设备的波特率。
返 回 值：长整型。串口的波特率，见! DevSetBaud，-1表示父设备不支持串口操作或者没有父设备。 参 数：无。
实 例：! DevGetBaud ()。
实例说明：读取父设备的波特率。
!DevGetDataBit()
函数意义：读取父设备的数据位。
返 回 值：整型。串口的数据位，见! DevSetDataBit，-1表示父设备不支持串口操作或者没有父设备。 参 数：无
实 例：! DevGetDataBit ()。 实例说明：读取父设备的数据位。
!DevGetStopBit()
函数意义：读取父设备的停止位。
返 回 值：整型。串口的停止位，见! DevSetStopBit，-1表示父设备不支持串口操作或者没有父设备。 参 数：无。
实 例：! DevGetStopBit ()。 实例说明：读取父设备的停止位。
!DevGetParityBit()
函数意义：读取父设备校验位。
返 回 值：整型。串口的校验位，见! DevSetParityBit，-1表示父设备不支持串口操作或者
没有父设备。 参 数：无。
实 例：!GetDevParityBit (1)。 实例说明：读取父设备的校验位。
!DevClearBuff()
函数意义：清除父设备的读写缓冲区。
返 回 值：整型。0表示清除成功，-1表示操作失败。 参 数：无。
!DevClearInBuff()
函数意义：清除父设备的读缓冲区。
返 回 值：整型。0表示清除成功，-1表示操作失败。 参 数：无。
!DevClearOutBuff()
函数意义：清除父设备的写缓冲区。
返 回 值：整型。0表示清除成功，-1表示操作失败。 参 数：无。
!DevWriteStr(参数1)
函数意义：向串口写一个字符串。 返 回 值：整型 -1：串口没有打开。 -2：写入超时，未写入一个字符； >0，写入的字符数；
参 数：参数1，字符型，写入的字符串。 实 例：! DevWriteStr（\）。 实例说明：向父设备写入字符串”ABCDE”。
!DevReadStr(ByRef 参数1,参数2,参数3)
函数意义：从父设备读取一定长度的字符串。 返 回 值：整型。 -1：串口不正常； -2：读超时，未读入一个字符； >0，读的字符数；
参 数：参数1，传址型，字符型，接收的字符串， 参数2，整型，需接收的字符数，接收到足够多的字符则返回； 参数3，整型，等待的时间，如果超过时间尚未读到足够的字符也返回，如果为0则直接返回。
实 例：! DevReadStr（str,20,500）。
实例说明：从父设备读取字符串，如果在500毫秒内已读到20个字符，则返回， 如果超过500毫秒未读取到20个字符，超时返回。
!DevReadStrByFind(ByRef 参数1,参数2,参数3)
函数意义：从父设备读取字符串，直到读到某字符串。 返 回 值：整型。 -1：串口不正常； -2：读超时，未读入一个字符； >0，读的字符数；
参 数：参数1，传址型，字符型，接收的字符串， 参数2，字符型，如果从串口读到对应的字符串，则返回； 参数3，整型，等待的时间，如果超过时间尚未读到对应的字符串也返回，如果为0则直接返回。
实 例：! DevReadStrByFind（str,!chr(13)+!chr(10),500）。
实例说明：从父设备读取字符串，如果在500毫秒内已读到回车换行字符，则返回， 如果超过500毫秒未读回车换行字符，超时返回。
!DevWriteAndReadStr(参数1,ByRef 参数2,参数3,参数4)
函数意义：往父设备发送一字符串，等待，再从父设备读取指定的字符串。 返 回 值：整型。 -1：父设备工作不正常； -2：写超时或者写失败； -3：读超时，未接收一个数据； -4：其他错误 >0：读取的字节数；
参 数：参数1，字符型，发送的字符串； 参数2，传址型，字符型，接收的字符串； 参数3，整型，需要接收的字符数量； 参数4，整型，读写整个过程的等待延时，单位为毫秒，0表示采用系统缺省的等待时间；
实 例：! DevWriteAndReadStr（\）。 实例说明：往串口发送字符串”ABC”，发送数据完毕后，再从串口设备中读取字符串，如果已读到30个字符，
或者500毫秒内尚未取读完毕，则返回。 注意：该函数首先调用清缓冲区的功能；
!DevWriteAndReadStrByFind(参数1,ByRef 参数2,参数3,参数4)
函数意义：往父设备发送一字符串，等待，再从父设备读取字符串，如果已读到指定的字符串，则返回。 返 回 值：整型。 -1：父设备工作不正常； -2：写超时或者写失败； -3：读超时，未接收一个数据； -4：其他错误 >0：读取的字节数；
参 数：参数1，字符型，发送的字符串； 参数2，传址型，字符型，接收的字符串；
参数3，字符型，匹配的字符串； 参数4，整型，读写整个过程的等待延时，单位为毫秒，0表示采用系统缺省的等待时间；
实 例：! DevWriteAndReadStrByFind（\）。 实例说明：往串口发送字符串”ABC”，发送完毕后，再从串口中读取字符串，如果已读到回车符，
或者100毫秒内尚未取读完毕，则返回。 注意：该函数首先调用清缓冲区的功能；
!DevWriteByte(参数1)
函数意义：向父设备写入一个字节。 返 回 值：整型 0：调用正常； -1：写失败；
参 数：参数1，字节型，写入的字节。 实 例：! DevWriteByte（byte）。 实例说明：向父设备写入byte 。
!DevReadByte(ByRef 参数1,参数2) 函数意义：从父设备读取一个字节。 返 回 值：整型 0：调用正常； -1：串口错误 -2：读取失败；
参 数：参数1，传址型，字节型，保存读取的字节 参数2，等待的时间，0表示立即返回。 实 例：! DevReadByte（A,100）。
实例说明：从父设备读取一个字节，如果超过100毫秒则直接返回。
!DevWriteByteArr(ByRef 参数1,参数2) 函数意义：向串口写一个字节数组。 返 回 值：整型 -1：其他错误。 -2：串口错误。 -3：写入超时，未写入一个字节； >0，写入的字符数；
参 数：参数1，传址型，字节数组，写入的字节数组名称； 参数2，整型，写入的长度， 实 例：! DevWriteByteArr（BA,10）。
实例说明：向父设备写入字节数组的前10个字节。如果，字节数组长度小于指定的长度，那么实际长度有效。
!DevReadByteArr(ByRef 参数1,参数2,参数3) 函数意义：从父设备读取一定长度的数据。
返 回 值：整型。 -1：串口不正常； -2：读超时，未读入一个字节； -3：其他错误 >0，读的字节数；
参 数：参数1，传址型，字节数组型，接收的数据， 参数2，整型，需接收的字符数，接收到足够多的数据则返回； 参数3，整型，等待的时间，如果超过时间尚未读到足够的数据也返回，如果为0则直接返回。
实 例：! DevReadByteArr（BA,20,500）。
实例说明：从父设备读取数据，如果在500毫秒内已读到20个字节，则返回， 如果超过500毫秒未读取到20个字节，超时返回。
!DevReadByteArrByFind(ByRef 参数1,ByRef 参数2,参数3,参数4) 函数意义：从父设备读取数据，直到读到某匹配的内容。 返 回 值：整型。 -1：串口不正常； -2：读超时，未读入一个字节； -3：其他错误 >0，读的字节数；
参 数：参数1，传址型，字节数组型，接收的数据， 参数2，传址型，字节数组型， 参数3，整型，由参数2和参数3组成一定长度的匹配字节数组，如果从串口读到对应的数据，则返回； 参数4，整型，等待的时间，如果超过时间尚未读到对应的数据也返回，如果为0则直接返回。
实 例：! DevReadByteArrByFind（BA,find,4,500）。
实例说明：从父设备读取数据，如果在500毫秒内已读到find数组的前4个字节匹配的内容，则返回，
如果超过500毫秒未读到匹配的内容，超时返回。
!DevWriteAndReadByteArr(ByRef 参数1,参数2,ByRef 参数3,参数4,参数5)
函数意义：往父设备发送一字节数组，等待，再从父设备读取指定的长度的数据。 返 回 值：整型。 -1：串口不正常； -2：写超时； -3：读超时，未接收一个数据； -4：数组长度小于要求长度。 -5：其他错误； >0：读取的字节数；
参 数：参数1，传址型，字节数组型，发送的数组； 参数2，整型，发送数组的长度 参数3，传址型，字节数组型，接收的数组； 参数4，整型，需要接收的字节数量；
参数5，整型，读写整个过程的等待延时，单位为毫秒，0表示采用系统缺省的等待时间；
实 例：! DevWriteAndReadByteArr（OutBA,10,InBA,30,500）。 实例说明：往串口中发送OutBA数组的前10个字节，发送完毕后，再从父设备中读取数据， 如果已读到30个字节，或者500毫秒内尚未取读完毕，则返回。 注意：该函数首先调用清缓冲区的功能；
!DevWriteAndReadByteArrByFind(ByRef 参数1,参数2,ByRef 参数3,ByRef 参数4,参数5,参数6) 函数意义：往父设备发送一数组数据，等待，再从父设备读取数据，如果已读到指定的内容，则返回。
返 回 值：整型。 -1：串口不正常； -2：写超时； -3：读超时，未接收一个数据； -4：其他错误； >0：读取的字节数；
参 数：参数1，传址型，字节数组型，发送的数组； 参数2，整型，发送的长度 参数3，传址型，字节数组型，接收的数组； 参数4，传址型，字节数组型，匹配的数组； 参数5，整型，匹配的数组的长度； 参数6，整型，读写整个过程的等待延时，0表示不判断是否超时； 实 例：! DevWriteAndReadByteByFind（OutBA,10,InBA,Find,4,500）。
实例说明：往串口中发送OutBA字节数组的前10个字节，发送完毕后，再从父设备中读取数据，
如果已读到Find数组的前4个字节匹配的内容，或者500毫秒内尚未取读完毕，则返回。
注意：该函数首先调用清缓冲区的功能；
!Outp(参数1,参数2)
函数意义：向端口输出一个字节。
返 回 值：整型。返回值=0：调用正常，-1：调用不正常。 参 数：参数1，整型，端口号； 参数2，字节型，输出的字节。 实 例：!Outp(&H188,&HFF)。
实例说明：向端口&H188输出字节&HFF。
!OutpW(参数1,参数2)
函数意义：向端口输出两个字节。
返 回 值：整型。返回值=0：调用正常，-1：调用不正常。 参 数：参数1，整型，端口号； 参数2，整型，输出的字节。 实 例：!OutpW(&H188,&HAAFF)。
实例说明：向端口&H188输出字节&HAAFF。
!OutpD(参数1,参数2)
函数意义：向端口输出四个字节。
返 回 值：整型。返回值=0：调用正常，-1：调用不正常。 参 数：参数1，整型，端口号； 参数2，长整型，输出的字节。
实 例：!OutpD(&H188,&H0000AAFF)。
实例说明：向端口&H188输出字节&H0000AAFF。
!Inp(参数1)
函数意义：返回从端口输入的一个字节。 返 回 值：字节型。输入的字节。 参 数：参数1，整型，端口号。 实 例：!Inp(&H188)。
实例说明：返回从端口&H188输入的一个字节。
!InpW(参数1)
函数意义：返回从端口输入的两个字节。 返 回 值：整型。输入的字节。 参 数：参数1，整型，端口号。 实 例：!InpW(&H188)。
实例说明：从端口&H188输入的两个字节。
!InpD(参数1)
函数意义：返回从端口输入的四个字节。 返 回 值：长整型。输入的字节。 参 数：参数1，整型，端口号。 实 例：!InpD(&H188)。
实例说明：返回从端口&H188输入的四个字节。
!SetIntDataValueByName(DataStr,n) 函数意义：根据实时数据变量的名字对变量进行设置，假设该实时数据变量为整型（开关型）变量；
返 回 值：整型。-1 失败，0 成功。
参 数：DataStr，字符型，需要设置的变量名的字符串。 n，整型，需要设定的整型值
实 例：!SetIntDataValueByName(\发电机启动\。
实例说明：将实时数据变量“发电机启动”的值设为1；该函数一般用于设备命令的处理过程中。
!SetSingleDataValueByName(DataStr,x) 函数意义：根据实时数据变量的名字对变量进行设置，假设该实时数据变量为单精度浮点型（数值型）变量；
返 回 值：整型。-1 失败，0 成功。
参 数：DataStr，字符型，需要设置的变量名的字符串。 x，单精度数值型，需要设定的数值
实 例：!SetSingleDataValueByName(\温度\。 实例说明：将实时数据变量“温度”的值设为45.5；该函数一般用于设备命令的处理过程中。
!SetStrDataValueByName(DataStr,str)
函数意义：根据实时数据变量的名字对变量进行设置，假设该实时数据变量为字符型变量； 返 回 值：整型。-1 失败，0 成功。
参 数：DataStr，字符型，需要设置的变量名的字符串。 str，字符型，需要设定的值
实 例：!SetStrDataValueByName(\显示内容\通讯正常\。 实例说明：将实时数据变量“显示内容”的值设为”通讯正常”； 该函数一般用于设备命令的处理过程中。
!GetIntDataValueByName(DataStr,ByRef n) 函数意义：根据实时数据变量的名字，将该变量的值读出，假设该实时数据变量为整型变量； 返 回 值：整型。-1 失败，0 成功。
参 数：DataStr，字符型，需要读取的变量名的字符串。 n，引用型，整型，保存读出值的变量；
实 例：! GetIntDataValueByName (\发电机启动\。
实例说明：将实时数据变量“显示内容”的值读出，赋给变量n；该函数一般用于设备命令的处理过程中。
!GetSingleDataValueByName(DataStr,ByRef x)
函数意义：根据实时数据变量的名字，将该变量的值读出，假设该实时数据变量为单精度浮点型变量；
返 回 值：整型。-1 失败，0 成功。
参 数：DataStr，字符型，需要读取的变量名的字符串。 x，引用型，单精度浮点型，保存读出值的变量； 实 例：! GetSingleDataValueByName (\温度\。
实例说明：将实时数据变量“温度”的值读出，赋给变量x；该函数一般用于设备命令的处理过程中。
!GetStrDataValueByName(ArrName,str)
函数意义：根据实时数据变量的名字，将该变量的值读出，假设该实时数据变量为字符型变量；
返 回 值：整型。-1 失败，0 成功。
参 数：DataStr，字符型，需要读取的变量名的字符串。 str，引用型，字符型，保存读出值的变量； 实 例：! GetIntDataValueByName (\显示内容\。
实例说明：将实时数据变量“显示内容”的值读出，赋给变量str；该函数一般用于设备命令的处理过程中。
!ArrayResize(ArrName, n)
函数意义：重新设置数组的大小。 返 回 值：整型。-1 失败，0 成功。 参 数：ArName，数组名称。 n，整型，需要设置的数组大小； 实 例：! ArrayResize(bArr, 10)。
实例说明：将数组bArr的大小设定为10。
!ArrayAppend(ArrName1, ArrName2)
函数意义：把一个字节数组追加到另外一个数组的后面。要求两个数组类型一致。数组长度变为两数组长度之和。 返 回 值：-1 失败； >=0 追加之后新数组的大小。
参 数：ArrName1，数组名称1，追加内容后生成的数组。 ArrName2，数组名称2，追加到另外一个数组后面的内容。 实 例：! ArrayAppend(ArrA, Arrb)。
实例说明：将数组ArrB的内容追加到数组ArrA之后，ArrA数组的长度变为ArrA与ArrB两个数组长度之和。
!ArrayCopy(ArrDes, ArrSrc)
函数意义：把一个数组复制到另外一个数组。两者必须是同一类型，把源数组的内容复制到目标数组中去。
目标数组的大小也更源数组一致。 返 回 值：-1 失败，0 成功
参 数：ArrDes，数组名称，复制生成的数组，该数组原内容和大小将会被新设置覆盖。 ArrSrc，数组名称，复制生成数组的源内容，新生成数组内容跟它一致。 实 例：! ArrayCopy(ArrDes, ArrSrc)。
实例说明：根据数组ArrSrc 的内容，复制出一个同样的数组 ArrDes。
!ArrayGetSize(Arr)
函数意义：求数组的长度。
返 回 值：-1 失败， >=0 数组的长度。 参 数：Arr ，数组名称，求长度的数组。 实 例：! ArrayGetSize(Arr)。 实例说明：求数组Arr的长度。
!ArrayIntAdd(Arr, n)
函数意义：在一个整型数组后面添加一个整数元素，数组长度加1。 返 回 值：-1 失败， 0 成功。
参 数：Arr ，数组名称，需要增加整数元素的整数数组。 n， 整数，需要添加的整数元素。 实 例：! ArrayIntAdd(Arr, 5)。
实例说明：在数组Arr的末尾增加一个数值为5的元素，Arr数组长度增加1。
!ArraySingleAdd(Arr, x)
函数意义：给一个浮点数组添加一个浮点数元素，数组长度加1。 返 回 值：-1 失败， 0 成功。
参 数：Arr ，数组名称，需要增加浮点数元素的浮点数组。 x，浮点数，添加的浮点数。
实 例：! ArraySingleAdd(Arr, 5.1234)。
实例说明：在浮点数组Arr的末尾增加一个数值为5.1234的元素，Arr数组长度增加1。
!ArrayByteAdd(Arr, b)
函数意义：给一个字节数组添加一个字节元素，数组长度加1。 返 回 值：-1 失败, 0 成功。
参 数：Arr ，数组名称，需要添加字节元素的字节数组。 b，字节，添加的字节元素。 实 例：! ArrayByteAdd(Arr, b)。
实例说明：在字节数组Arr的末尾增加一个字节 b，Arr数组长度增加1。
!ArrayStringAdd(Arr, str)
函数意义：给一个字符串数组添加字符串元素，数组长度加1。 返 回 值：-1 失败， 0 成功。
参 数：Arr ，数组名称，需要添加元素的字符串数组。 b，字符串，添加到数组的字符串。 实 例：! ArrayStringAdd(Arr, str)。
实例说明：在字节数组Arr的末尾增加一个字符串str，Arr数组长度增加1。
!SvrGetByteFromByteArr(ByRef ByteArr ，start, ByRef n, Flag)
函数意义：将字节数组ByteArr中从start位置开始的内容输出到变量n中，输出的格式为1字节整型，字节数组位置计数从1开始。 返 回 值：整型，判断是输出是否正常： 0： 正常； 小于0： 错误，具体意义如下： -1：启始索引start小于1 -2：启始索引start大于数组上限 -3：字节数组长度不足 -4：n 不是整型变量 -5：其他错误
参 数：ByteArr，传址型，字节型数组。 start，整型，输出的首位置，从1开始。 n，传址型，长整型；
Flag, 长整型,解析方式[0：8位无符号；1：8位有符号；2：8位BCD码] 实 例：! SvrGetByteFromByteArr (BA,2, A，1)，字节数组为：00 01 02 03 04 05 06 07 08 09 00 00 则A=1。
!SvrGetShortFromByteArr(ByRef ByteArr ，start, ByRef n, Flag)
函数意义：将字节数组ByteArr中从start位置开始的内容输出到变量n中，输出的格式为2
字节整型，字节数组位置计数从1开始。 返 回 值：整型，判断是输出是否正常： 0： 正常； 小于0： 错误，具体意义如下: -1：启始索引start小于1 -2：启始索引start大于数组上限 -3：字节数组长度不足 -4：n 不是整型变量 -5：其他错误
参 数：ByteArr，传址型，字节型数组。 start，整型，输出的首位置，从1开始。 n，传址型，长整型；
Flag, 长整型,解析方式[0：16位无符号；1：16位有符号；2：16位BCD码] 实 例：! SvrGetByteFromByteArr (BA,2, A，1)，字节数组为：00 01 02 03 04 05 06 07 08 09 00 00 则A=513。
!SvrGetIntFromByteArr(ByRef ByteArr ，start, ByRef n, Flag)
函数意义：将字节数组ByteArr中从start位置开始的内容输出到变量n中，输出的格式为4字节整型，字节数组位置计数从1开始。 返 回 值：整型，判断是输出是否正常： 0： 正常； 小于0： 错误，具体意义如下: -1：启始索引start小于1 -2：启始索引start大于数组上限 -3：字节数组长度不足 -4：n 不是整型变量 -5：其他错误
参 数：ByteArr，传址型，字节型数组。 start，整型，输出的首位置，从1开始。 n，传址型，长整型；
Flag, 长整型,解析方式[0：32位无符号；1：32位有符号；2：32位BCD码] 实 例：! SvrGetIntFromByteArr (BA,2, A，1)，字节数组为：00 01 02 03 04 05 06 07 08 09 00 00 则A=67305985 。
!SvrGetSingleFromByteArr(ByRef ByteArr ，start, ByRef x, Flag)
函数意义：将字节数组ByteArr中从start位置开始的内容输出到变量x中，输出的格式为4字节数值型，字节数组位置计数从1开始。 返 回 值：整型，判断是输出是否正常： 0： 正常；
小于0： 错误，具体意义如下: -1：启始索引start小于1 -2：启始索引start大于数组上限 -3：字节数组长度不足 -4：n 不是浮点型变量
-5：其他错误
参 数：ByteArr，传址型，字节型数组。 start，整型，输出的首位置，从1开始。 n，传址型，长整型；
Flag, 长整型,对应4种解码次序[数值范围：0~3]
实 例：SvrGetSingleFromByteArr(BA,1, x，3) 字节数组为：00 00 80 40 04 05 06 07 08 09 00 00 则A=4.0。
!SvrGetByteFromHexStr(str, ByRef n, Flag)
函数意义：获得将HEX表示的字符数据的内容输出到变量x中，输出的格式为1字节数值型，从头取2个字符转换成一个字节HEX值 返 回 值：整型，判断是输出是否正常： 0： 正常； 小于0： 错误，具体意义如下: -1：解析字符长度不足，至少长度为2字符 -2：解析字符长度一定为偶数个 -3：解析字符长度大于2个，只取左边2字符解析 -4：变量类型，不是整形 -5：其他错误
参 数：str，字符数据。 n，传址型，长整型；
Flag, 长整型,解析方式[0：8位无符号；1：8位有符号；2：8位BCD码] 实 例：! SvrGetByteFromHexStr (str，n，0)，str为：“0102030405060708” 则n = 1。
!SvrGetShortFromHexStr(str, ByRef n, Flag)
函数意义：获得将HEX表示的字符数据的内容输出到变量x中，输出的格式为2字节数值型，从头取4个字符转换成2个字节短整型值 返 回 值：整型，判断是输出是否正常： 0： 正常； 小于0： 错误，具体意义如下: -1：解析字符长度不足，至少长度为4字符 -2：解析字符长度一定为偶数个 -3：解析字符长度大于2个，只取左边2字符解析 -4：变量类型，不是整形 -5：其他错误
参 数：str，字符数据。 n，传址型，长整型；
Flag, 长整型,解析方式[0：16位无符号；1：16位有符号；2：16位BCD码] 实 例：!SvrGetShortFromHexStr (str，n，0) str为：“0201030405060708” 则n = 513
!SvrGetIntFromHexStr(str, ByRef n, Flag)
函数意义：获得将HEX表示的字符数据的内容输出到变量x中，输出的格式为4字节数值型，从头取8个字符转换成4个字节整型值 返 回 值：整型，判断是输出是否正常：
0： 正常； 小于0： 错误，具体意义如下: -1：解析字符长度不足，至少长度为8字符 -2：解析字符长度一定为偶数个 -3：解析字符长度大于2个，只取左边2字符解析 -4：变量类型，不是整形 -5：其他错误
参 数：str，字符数据。 n，传址型，长整型；
Flag, 长整型,解析方式[0：32位无符号；1：32位有符号；2：32位BCD码] 实 例：! SvrGetIntFromHexStr (str，n，0)，str为：“00000201030405060708” 则n = 513。
!SvrGetSingleFromHexStr(str, ByRef x, Flag)
函数意义：获得将HEX表示的字符数据的内容输出到变量x中，输出的格式为4字节数值型，从头取8个字符转换成4个字节单精度浮点值 返 回 值：整型，判断是输出是否正常： 0： 正常； 小于0： 错误，具体意义如下: -1：解析字符长度不足，至少长度为8字符 -2：解析字符长度一定为偶数个 -3：解析字符长度大于2个，只取左边2字符解析 -4：变量类型，不是浮点型变量 -5：其他错误
参 数：str，字符数据。 x，传址型，数值型；
Flag, 长整型,对应4种解码次序[数值范围：0~3]。 实 例：! SvrGetSingleFromHexStr (str，x，3)，str为：“000080400102030405060708” 则x = 4.0。
!SvrByteArraySum(ByRef ByteArr，start, length)
函数意义： 从数组中start索引开始，连续length个字节，按求和方式计算返回校验结果 返 回 值：整型，返回正确的校验值/判断是输出是否正常： >=0： 校验结果； 小于0： 错误，具体意义如下: -1：启始索引start小于1 -2：启始索引start大于数组上限 -3：校验数组长度小于等于零 -4：字节数组长度不足 -5：其他错误
参 数：ByteArr，传址型，字节型数组。 start，长整型，检验数据的启始字节在数组中 length, 长整型，连续校验数据的个数
实 例：n = !SvrByteArraySum(ByteArr,1,4) ByteArr为：00 01 02 03 04 05 06 07 则n = 0x06。
!SvrStrSum(str，Flag)
函数意义：对字符串str按求和方式计算返回校验结果
返 回 值：字符型，返回正确的校验值/判断是输出是否正常： 错误返回值: ”-1”校验字符串长度为0 ”-2”校验的字符串长度必须为偶数 参 数：str，字符型，需要校验数据 Flag，长整型，0：按2个字符形成1BYTE HEX值进行校验；1：直接按ASCII字符值进行校验
实 例：strRe = !SvrStrSum(str,0), str为:\则strRe = “1C”。。
!SvrByteArrayXOR( ByRef ByteArr，start, length)
函数意义： 从数组中start索引开始，连续length个字节，按异或方式计算返回校验结果 返 回 值：整型，返回正确的校验值/判断是输出是否正常： >=0： 校验结果； 小于0： 错误，具体意义如下: -1：启始索引start小于1 -2：启始索引start大于数组上限 -3：校验数组长度小于等于零 -4：字节数组长度不足 -5：其他错误
参 数：ByteArr，传址型，字节型数组。 start，长整型，检验数据的启始字节在数组中 length, 长整型，连续校验数据的个数
实 例：n = !SvrByteArraySum(ByteArr,1,4) ByteArr为：00 01 02 03 04 05 06 07则n = 0。
!SvrStrXOR(str，Flag)
函数意义：对字符串str按异或方式计算返回校验结果
返 回 值：字符型，返回正确的校验值/判断是输出是否正常： 错误返回值: ”-1”校验字符串长度为0 ”-2”校验的字符串长度必须为偶数 参 数：str，字符型，需要校验数据 Flag，长整型，0：按2个字符形成1BYTE HEX值进行校验；1：直接按ASCII字符值进行校验
实 例：strRe = !SvrStrSum(str,0) str为：“0001020304050607”则strRe = “00”。
!SvrByteArrayModbusCRC(ByteArr，start, length)
函数意义： 从数组中start索引开始，连续length个字节，按ModbusCRC方式计算返回校验结果
返 回 值：整型，返回正确的校验值/判断是输出是否正常： >=0： 校验结果； 小于0： 错误，具体意义如下: -1：启始索引start小于1 -2：启始索引start大于数组上限
-3：校验数组长度小于等于零 -4：字节数组长度不足
参 数：ByteArr，传址型，字节型数组。
start，长整型，检验数据的启始字节在数组中 length, 长整型，连续校验数据的个数
实 例：nReturn = !SvrByteArrayModbusCRC(ByteArr,1,6) //ByteArr为:01 03 00 00 00 08 ByteArr[7] = !BitAnd(nReturn,&H000000FF) // nRetrun = 0xC44, ByteArr[7] = 0x44 nTmp = !BitAnd(nReturn,&H0000FF00)
ByteArr[8] = !BitRShift(nTmp ,8) //ByteArr[8] = 0x0C
!SvrStrModbusLRC(str，start, length)
函数意义： 对字符串str中start索引开始，连续length个字节，按LRC方式计算返回校验结果
返 回 值：字符型，返回正确的校验值/判断是输出是否正常： 错误返回值: “-1”：校验数组长度小于等于零 “-2”：启始索引start小于1 “-3”：启始索引start大于数组上限 “-4”：字节数组长度不足， 或者所校验的位数为奇数个 参 数：str，字符型，需要校验数据 start，长整型，检验数据的启始字节在数组中 length, 长整型，连续校验数据的个数 实 例：strRe = !SvrStrModbusLRC (str,1,12) str为：str为:\，则strRe = “F8”。
!SvrOpenLog()
函数意义： 启动日志功能，PC上自动在C盘根目录生成LOG文件，TPC上自动在HARDDISK盘根目录生成LOG文件。 返 回 值： 开关型，0：成功 -1失败 参 数： 无
实 例： !SvrOpenLog()。
!SvrCloseLog()
函数意义：关闭日志功能
返 回 值： 开关型，0：成功 -1失败 参 数： 无
实 例： !SvrCloseLog()。
!HStr2HByte(str, arByte)
函数意义： 将字符串转为字符数组 返 回 值：>=0： 转换字节个数 小于0： 错误，具体意义如下: -1：没有定义数组arByte -2：arByte不是数组类型 -3：str 必须为偶数个
-4：转换错误
参 数：str，字符型，需要校验数据 arByte，经过转换后的字节数组
实 例：!HStr2Hbyte(str,arByte), str = \则转换后 arByte值分别为 0x31 0x32。
!Hbyte2HStr(arByte，str)
函数意义： 将字符串转为字符数组
返 回 值：字符型，返回正确的校验值/判断是输出是否正常： 正确：返回校验值 错误：返回空字符串
参 数：str，字符型，需要校验数据 arByte，经过转换后的字节数组 实 例：!Hbyte2HStr(arByte,str), arByte值分别为 0x35 0x36 0x37 0x38 0x39 , 则转换后str = \。