昆仑通态脚本开发函数

更新时间：2024-05-07 09:08:01 阅读量：综合文库文档下载

说明：文章内容仅供预览，部分内容可能不全。下载后的文档，内容与下面显示的完全一致。下载之前请确认下面内容是否您想要的，是否完整无缺。

!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字节整型，

参数：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) 函数意义：根据实时数据变量的名字对变量进行设置，假设该实时数据变量为单精度浮点型（数值型）变量；

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按异或方式计算返回校验结果

实例：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。