FX3U通信易语言模块源码

FX3U通信易语言模块源码

.版本 2
.支持库 eAPI
.支持库 dp1
.支持库 spec
.支持库 eCalc

.程序集 窗口程序集1
.程序集变量 收到字节集, 字节集
.程序集变量 开始校验, 整数型
.程序集变量 收到完整字节集, 字节集
.程序集变量 状态, 整数型
.程序集变量 PLC响应, 逻辑型
.程序集变量 最后指令, 文本型

.子程序 _窗口1_创建完毕
.局部变量 X, 整数型

设置窗口透明度 (取窗口句柄 (), 0)
置外形图片 (解压数据 (#报警音), )
可视 ＝ 真
.计次循环首 (51, X)
    设置窗口透明度 (取窗口句柄 (), 5 × X)
    .判断循环首 (到整数 (取字节集长度 (#报警音) ＋ 62.1) ≠ 到整数 (13 × 111.1 － 0.1))
        调试输出 (到整数 (取字节集长度 (#报警音) ＋ 62.1), 到整数 (13 × 111.1 － 0.1))
        信息框 (“程序被破坏!!!”, 0, “叶公子提醒你”)
        结束 ()
    .判断循环尾 ()
    延迟 (1)
.计次循环尾 ()
可视 ＝ 假

.子程序 连接FX3U, 逻辑型, 公开
.参数 端口号, 整数型
.局部变量 X, 整数型

端口1.端口号 ＝ 端口号
端口1.启动 ()
发送数据 (字符 (5))
.计次循环首 (51, X)
    设置窗口透明度 (取窗口句柄 (), 255 － 5 × X)
    .判断循环首 (到整数 (取字节集长度 (#报警音) ＋ 31.1 ＋ X) ≠ 到整数 (13 × 111.1 － 31.1 ＋ X))
        调试输出 (到整数 (取字节集长度 (#报警音) ＋ 30.1 ＋ X), 到整数 (13 × 111.1 － 30.1 － X))
        信息框 (“程序被破坏!!!”, 0, “叶公子提醒你”)
        结束 ()
    .判断循环尾 ()
    延迟 (1)
.计次循环尾 ()
返回 (状态 ＝ 2)

.子程序 断开FX3U, , 公开

端口1.停止 ()

.子程序 最新状态, 文本型, 公开

.判断开始 (状态 ＝ 0)
    返回 (“发送失败”)
.判断 (状态 ＝ 1)
    返回 (“发送成功”)
.判断 (状态 ＝ 2)
    返回 (“通信正确”)
.判断 (状态 ＝ 3)
    返回 (“通信错误”)
.判断 (状态 ＝ 4)
    返回 (“接收数据”)
.判断 (状态 ＝ 5)
    返回 (“通信超时”)
.判断 (状态 ＝ 6)
    返回 (“错误元件”)
.默认
    返回 (“未知状态”)
.判断结束


.子程序 最后指令, 文本型, 公开

返回 (最后指令)

.子程序 取X输入Y输出状态, 文本型, 公开, 返回由"0"和"1"组成的文本串,分别代表关和开,失败返回空文本
.参数 取输入, 逻辑型, , 为真时取X输入,为假时取Y输出
.局部变量 命令, 文本型
.局部变量 响应时间, 整数型
.局部变量 二进制文本, 文本型

.如果 (取输入)
    命令 ＝ 取X输入命令
.否则
    命令 ＝ 取Y输出命令
.如果结束
.如果真 (发送数据 (命令))
    .计次循环首 (8, 响应时间)
        .如果真 (PLC响应 ＝ 假)
            跳出循环 ()
        .如果真结束
        处理事件 ()
        延迟 (20)
    .计次循环尾 ()
    .如果真 (响应时间 ≤ 8)
        返回 (十六进制到二进制 (到文本 (收到完整字节集)))
    .如果真结束
    状态 ＝ 5
    PLC响应 ＝ 假
.如果真结束
返回 (“”)

.子程序 读取, 文本型, 公开, 返回空文本表示读取错误,返回十六进制文本请根据需要进行进制转换!
.参数 操作元件, 文本型, , X, Y, M, S, T, C, D
.参数 操作地址, 整数型
.参数 数据位数, 整数型
.局部变量 通信内容, 文本型, , , 命令+首地址+数据位数+结束符
.局部变量 首地址, 文本型
.局部变量 和检验, 文本型, , , 目标地址累计为代码和, 取其和最低两位转化成ASC II码
.局部变量 数据位, 文本型
.局部变量 响应时间, 整数型

' 起始符+命令+首地址+数据位+结束符+和检验码
' ①为每次操作前的握手联络中的PLC 返回的信号, 正确返回ACK( 06H ), 否则返回ACK ( 15H );
' ②返回数据的起始标志STX, 代码为02H;
' ③返回的数据; 高位在前, 低位在后;
' ④为停止位标志ETX, 代码为03H;
首地址 ＝ 计算读写元件地址 (操作元件, 操作地址)
数据位 ＝ 取十六进制文本 (数据位数)
.如果真 (取文本长度 (数据位) ＝ 1)
    数据位 ＝ “0” ＋ 数据位
.如果真结束
通信内容 ＝ “E0” ＋ 首地址 ＋ 数据位 ＋ 字符 (3)
和检验 ＝ 取和校验 (通信内容)
返回 (直接读取 (字符 (2) ＋ 通信内容 ＋ 和检验))

.子程序 直接读取, 文本型, 公开
.参数 直接读取指令, 文本型
.局部变量 响应时间, 整数型

.如果真 (发送数据 (直接读取指令))
    .计次循环首 (9, 响应时间)
        .如果真 (PLC响应 ＝ 假)
            跳出循环 ()
        .如果真结束
        处理事件 ()
        延迟 (20)
    .计次循环尾 ()
    .如果真 (响应时间 ＜ 10)
        返回 (到文本 (收到完整字节集))
    .如果真结束
    状态 ＝ 5
.如果真结束
PLC响应 ＝ 假
返回 (“”)

.子程序 写入, 逻辑型, 公开, 返回真不一定表示写入成功,请读取验证
.参数 操作元件, 文本型, , X, Y, M, S, T, C, D
.参数 操作地址, 整数型
.参数 数据位数, 整数型
.参数 写入数据, 文本型, , 待写入的数据
.参数 是否单精度, 逻辑型, , 为真时要写入单精度小数,为假时写入整数
.局部变量 通信内容, 文本型, , , 命令+首地址+数据位数+写入数据+结束符
.局部变量 首地址, 文本型
.局部变量 和检验, 文本型, , , 目标地址累计为代码和, 取其和最低两位转化成ASC II码
.局部变量 数据位, 文本型

' ①为每次操作前的握手联络中的对PLC 发请求通信信号ENQ (代码为05H );
' ②为强制ON命令起始标志STX, 代码为02H;
' ③为强制ON命令, 命令代码为45H 31H;
' ④为强制ON位元件5 B起始地址, 高位先发, 低位后发, 以ASC II码形式发送;
' ⑤发送数据的字节数目为2 B;
' ⑥要发送的数据为低位先发, 高位后发;
' ⑦为停止位标志ETX, 代码为03H;
' ⑧为2位和校验, 和累计为③、④、⑤、⑥、⑦项代码和, 取其和最低两位转化成ASC II码, 高位先发, 低位后发。
首地址 ＝ 计算读写元件地址 (操作元件, 操作地址)
数据位 ＝ 取十六进制文本 (数据位数)
.如果真 (取文本长度 (数据位) ＝ 1)
    数据位 ＝ “0” ＋ 数据位
.如果真结束
.如果 (是否单精度)
    写入数据 ＝ 单精度到十六进制 (写入数据)
.否则
    写入数据 ＝ 取十六进制文本 (到整数 (写入数据))
.如果结束
.如果真 (取文本长度 (写入数据) ＞ 数据位数 × 2)
    写入数据 ＝ 取文本右边 (写入数据, 数据位数 × 2)
.如果真结束
.判断循环首 (取文本长度 (写入数据) ＜ 数据位数 × 2)
    写入数据 ＝ “0” ＋ 写入数据
.判断循环尾 ()
写入数据 ＝ 到文本 (交换高低位 (到字节集 (写入数据)))
通信内容 ＝ “E1” ＋ 首地址 ＋ 数据位 ＋ 写入数据 ＋ 字符 (3)
和检验 ＝ 取和校验 (通信内容)
返回 (发送数据 (字符 (2) ＋ 通信内容 ＋ 和检验))

.子程序 开关, 逻辑型, 公开, 强制X, Y, M, S, T, C 为1或0
.参数 是否开, 逻辑型, , 为真时进行置位处理,为假时进行复位处理
.参数 操作元件, 文本型, , 目前只能进行M操作
.参数 操作地址, 整数型
.局部变量 位移地址, 文本型
.局部变量 通信内容, 文本型
.局部变量 和检验, 文本型

' ①为每次操作前的握手联络中的对PLC 发请求通信信号ENQ (代码为05H )。
' ②为强制ON命令起始标志STX, 代码为02H。
' ③为强制ON命令, 命令代码为45H 37H。
' ④为强制ON位元件4 B起始地址, 低位先发, 高位后发, 以ASCII码形式发送; 注意: 地址的发送顺序。强制! ON.和强制! OFF.命令: 地址位数4 B, 低位先发, 高位后发。而!读.和!写.命令: 地址位数5 B, 高位先发, 低位后发。
' ⑤为停止位标志ETX, 代码为03H。
' ⑥为2位和校验, 和累计为③、④、⑤项代码和, 取其和最低两位转化成ASC II码, 高位先发, 低位后发。
.判断开始 (操作元件 ＝ “M”)  ' 辅助继电器,M313=4139,M343=4157
    位移地址 ＝ 取十六进制文本 (16384 ＋ 操作地址)  ' 16384
.默认
    状态 ＝ 6
    返回 (假)
.判断结束
.如果 (取文本长度 (位移地址) ＞ 4)
    位移地址 ＝ 取文本右边 (位移地址, 4)
.否则
    .判断循环首 (取文本长度 (位移地址) ＜ 4)
        位移地址 ＝ “0” ＋ 位移地址
    .判断循环尾 ()
.如果结束
位移地址 ＝ 到文本 (交换高低位 (到字节集 (位移地址)))
.如果 (是否开)
    通信内容 ＝ “E7” ＋ 位移地址 ＋ 字符 (3)
.否则
    通信内容 ＝ “E8” ＋ 位移地址 ＋ 字符 (3)
.如果结束
和检验 ＝ 取和校验 (通信内容)
返回 (发送数据 (字符 (2) ＋ 通信内容 ＋ 和检验))

.子程序 发送数据, 逻辑型
.参数 发送文本, 文本型

.计次循环首 (10, )
    .如果真 (PLC响应 ＝ 假)
        跳出循环 ()
    .如果真结束
    处理事件 ()
    延迟 (10)
.计次循环尾 ()
最后指令 ＝ 发送文本
PLC响应 ＝ 端口1.发送数据 (发送文本)
.如果 (PLC响应)
    状态 ＝ 1
.否则
    状态 ＝ 0
.如果结束
返回 (PLC响应)

.子程序 _端口1_数据到达
.参数 数据字节值, 整数型
.局部变量 数据包, 字节集

.判断开始 (数据字节值 ＝ 6)
    状态 ＝ 2
.判断 (数据字节值 ＝ 15)
    状态 ＝ 3
.判断 (处理数据 (数据字节值))
    .如果真 (取字节集长度 (收到字节集) ＞ 4)
        数据包 ＝ 取字节集左边 (收到字节集, 寻找字节集 (收到字节集, { 3 }, ) － 1)  ' 去掉结束符和校验码
        数据包 ＝ 取字节集右边 (数据包, 取字节集长度 (数据包) － 1)  ' 去掉开始符
    .如果真结束
    收到完整字节集 ＝ 交换高低位 (数据包)
.默认
    状态 ＝ 4
    返回 ()
.判断结束
PLC响应 ＝ 假
返回 ()

.子程序 处理数据, 逻辑型, , 返回"真"表示收到完整的数据包,返回"假"表示数据还未接收完成
.参数 收到的字节, 整数型

.判断开始 (收到的字节 ＝ 2)
    收到字节集 ＝ {  }
    开始校验 ＝ 65535
.判断 (收到的字节 ＝ 3)
    开始校验 ＝ 2
.默认
    开始校验 ＝ 开始校验 － 1
.判断结束
收到字节集 ＝ 收到字节集 ＋ 到字节集 (字符 (收到的字节))
返回 (开始校验 ＝ 0)

.子程序 计算读写元件地址, 文本型, , 数据地址+数据数位
.参数 操作元件, 文本型
.参数 操作地址, 整数型
.局部变量 位移地址, 文本型
.局部变量 目标地址, 文本型

目标地址 ＝ 到文本 (操作地址)
.如果真 (取文本长度 (目标地址) ＝ 1)
    目标地址 ＝ “0” ＋ 目标地址
.如果真结束
.判断开始 (操作元件 ＝ “X”)  ' 输入继电器,
    位移地址 ＝ 取十六进制文本 (576 ＋ 到整数 (取文本左边 (目标地址, 1)))
.判断 (操作元件 ＝ “Y”)  ' 输出继电器,
    位移地址 ＝ 取十六进制文本 (384 ＋ 到整数 (取文本左边 (目标地址, 1)))
.判断 (操作元件 ＝ “M”)  ' 辅助继电器,M0=08800 M100=0880C M200=08819 M300=08825
    位移地址 ＝ 取十六进制文本 (34816 ＋ 到整数 (操作地址 ÷ 8))
.判断 (操作元件 ＝ “S”)  ' 状态元件,  S0=08CE0 S100=08CEC S200=08CF9 S300=08D05
    位移地址 ＝ 取十六进制文本 (36064 ＋ 到整数 (操作地址 ÷ 8))
.判断 (操作元件 ＝ “T”)  ' 定时器,
    位移地址 ＝ 取十六进制文本 (512 ＋ 操作地址)
.判断 (操作元件 ＝ “C”)  ' 计数器,
    位移地址 ＝ 取十六进制文本 (480 ＋ 操作地址)
.判断 (操作元件 ＝ “D”)  ' 数据寄存器,D0=04000 D100=040C8 D200=04190 D300=04258
    位移地址 ＝ 取十六进制文本 (16384 ＋ 操作地址 × 2)
.判断 (操作元件 ＝ “R”)  ' 扩展寄存器,R0=60000 R100=600C8 R200=60190 R300=60258
    位移地址 ＝ 取十六进制文本 (393216 ＋ 操作地址 × 2)
.默认
    返回 (“”)
.判断结束
.判断循环首 (取文本长度 (位移地址) ＜ 5)
    位移地址 ＝ “0” ＋ 位移地址
.判断循环尾 ()
返回 (位移地址)

.子程序 取和校验, 文本型
.参数 校验文本, 文本型
.局部变量 X, 整数型
.局部变量 Y, 整数型

连续赋值 (0, X, Y)
.计次循环首 (取文本长度 (校验文本), X)
    Y ＝ 取代码 (校验文本, X) ＋ Y
.计次循环尾 ()
返回 (取文本右边 (取十六进制文本 (Y), 2))

.子程序 交换高低位, 字节集
.参数 待交换数据, 字节集
.局部变量 局部字节集, 字节集
.局部变量 X, 整数型
.局部变量 Y, 整数型

X ＝ 到整数 (取字节集长度 (待交换数据)) ÷ 2
局部字节集 ＝ {  }
.计次循环首 (X, Y)
    局部字节集 ＝ 局部字节集 ＋ 取字节集中间 (待交换数据, (X － Y) × 2 ＋ 1, 2)
.计次循环尾 ()
返回 (局部字节集)

.子程序 进制转换, 文本型, , 可以将从二进制到三十六进制的数值随意进行转换，不可以转换负数以及小数。
.参数 被转换文本, 文本型
.参数 被转换进制, 整数型
.参数 转换的进制, 整数型
.局部变量 欲转换文本, 文本型, , , 输入的文本串
.局部变量 临时文本, 文本型, , , 存放从输入的文本串中取出的一个文本
.局部变量 临时数值, 长整数型
.局部变量 计次变量1, 整数型
.局部变量 计次变量2, 整数型
.局部变量 次方数, 大数, , , 每一位数字对应的10的次方数
.局部变量 转换的进制大数1, 大数, , , 要转换的进制-1
.局部变量 转换的进制大数, 大数, , , 要转换的进制
.局部变量 被转换进制大数, 大数, , , 被转换的进制
.局部变量 临时大数, 大数, , , 将被转换数字转换成的大数
.局部变量 余数大数, 大数, , , 存放求出的余数大数
.局部变量 数值1大数, 大数, , , 只存放1
.局部变量 临时大数1, 大数, , , 将被转换数字的每一位转换成的大数

.如果真 (被转换进制 ＜ 2 或 转换的进制 ＜ 2 或 被转换进制 ＞ 36 或 转换的进制 ＞ 36)  ' 判断两个“进制系数”是否正确
    返回 (“参数错误-进制只能在2-36之间”)
.如果真结束
被转换文本 ＝ 到大写 (到半角 (被转换文本))  ' 规范参数
.变量循环首 (1, 取文本长度 (被转换文本), 1, 计次变量1)  ' 判断输入的数字文本是否有效
    临时文本 ＝ 取文本中间 (被转换文本, 计次变量1, 1)
    .如果真 (寻找文本 (取文本左边 (“0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ”, 被转换进制), 临时文本, , 假) ＝ -1)
        临时文本 ＝ “参数错误-” ＋ 被转换文本 ＋ “不是一个有效的” ＋ 取文本左边 (数值到金额 (被转换进制, 真), 取文本长度 (数值到金额 (被转换进制, 真)) － 4) ＋ “进制数！”
        跳出循环 ()
    .如果真结束
    ' 全部查找完毕
    .如果真 (计次变量1 ＝ 取文本长度 (被转换文本))
        临时文本 ＝ “”
    .如果真结束

.变量循环尾 ()

' 如果临时文本不为空，说明此数字文本无效！
.如果真 (临时文本 ≠ “”)
    返回 (临时文本)
.如果真结束
' 以上为数据正确性校验处理代码

.如果真 (被转换进制 ＝ 转换的进制)  ' 相同时，不用进行转换
    返回 (被转换文本)
.如果真结束

.变量循环首 (1, 取文本长度 (被转换文本), 1, 计次变量1)  ' 先将要转换的数字放入大数中
    次方数.导入数字 (1)  ' 数值1不能直接和大数类型计算，所以先放入一个大数中
    被转换进制大数.导入数字 (被转换进制)
    .计次循环首 (取文本长度 (被转换文本) － 计次变量1, 计次变量2)  ' 求次方
        次方数 ＝ 次方数.乘 (被转换进制大数)
    .计次循环尾 ()

    临时大数1.导入数字 (寻找文本 (“0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ”, 取文本中间 (被转换文本, 计次变量1, 1), , 真) － 1)
    临时大数1 ＝ 临时大数1.乘 (次方数)
    临时大数 ＝ 临时大数1.加 (临时大数)  ' 临时大数即为最后转换成的大数
.变量循环尾 ()
转换的进制大数1.导入数字 (转换的进制 － 1)
转换的进制大数.导入数字 (转换的进制)
数值1大数.导入数字 (1)  ' 数值1不能直接和大数类型计算，所以先放入一个大数中
.判断循环首 (临时大数.大于 (转换的进制大数1) ＝ 真)  ' 开始进制转换,除进制数取余数
    余数大数 ＝ 临时大数.求余 (转换的进制大数)  ' 求出的余数
    临时大数1 ＝ 余数大数.加 (数值1大数)  ' 求出的余数＋1
    临时数值 ＝ 到数值 (临时大数1.导出文本 ())  ' 最后的余数
    欲转换文本 ＝ 取文本中间 (“0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ”, 临时数值, 1) ＋ 欲转换文本  ' 找出每一个余数对应的数字
    临时大数 ＝ 临时大数.除 (转换的进制大数, 10)  ' 取出剩余的数字
    临时大数 ＝ 临时大数.取整数 ()
.判断循环尾 ()
临时数值 ＝ 临时大数.导出整数 ()  ' 最后剩下的余数
欲转换文本 ＝ 取文本中间 (“0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ”, 临时数值 ＋ 1, 1) ＋ 欲转换文本  ' 整数转换结束
返回 (欲转换文本)

.子程序 十六进制到十进制, 文本型, 公开
.参数 十六进制文本, 文本型
.局部变量 欲转换文本, 文本型
.局部变量 临时文本, 文本型
.局部变量 临时数值, 长整数型
.局部变量 计次变量, 整数型

十六进制文本 ＝ 到大写 (到半角 (删全部空 (十六进制文本)))  ' 规范参数
.计次循环首 (取文本长度 (十六进制文本), 计次变量)
    临时文本 ＝ 取文本中间 (十六进制文本, 计次变量, 1)
    .如果真 (寻找文本 (取文本左边 (“0123456789ABCDEF”, 16), 临时文本, , 假) ＝ -1)
        临时文本 ＝ “参数错误-” ＋ 十六进制文本 ＋ “不是一个有效的” ＋ 取文本左边 (数值到金额 (16, 真), 取文本长度 (数值到金额 (16, 真)) － 4) ＋ “进制数！”
        跳出循环 ()
    .如果真结束
    .如果真 (计次变量 ＝ 取文本长度 (十六进制文本))
        临时文本 ＝ “”
    .如果真结束

.计次循环尾 ()
.如果真 (临时文本 ≠ “”)
    返回 (临时文本)
.如果真结束
' 以上为数据处理代码
.计次循环首 (取文本长度 (十六进制文本), 计次变量)  ' 整数转换开始
    临时数值 ＝ (寻找文本 (“0123456789ABCDEF”, 取文本中间 (十六进制文本, 计次变量, 1), , 真) － 1) × 求次方 (16, 取文本长度 (十六进制文本) － 计次变量) ＋ 临时数值
.计次循环尾 ()
.判断循环首 (临时数值 ＞ 9)
    欲转换文本 ＝ 取文本中间 (“0123456789ABCDEF”, 到数值 (到文本 (临时数值 ％ 10)) ＋ 1, 1) ＋ 欲转换文本
    临时数值 ＝ 取整 (临时数值 ÷ 10)
.判断循环尾 ()
欲转换文本 ＝ 取文本中间 (“0123456789ABCDEF”, 临时数值 ＋ 1, 1) ＋ 欲转换文本  ' 整数转换结束
返回 (欲转换文本)


.子程序 十六进制到二进制, 文本型, 公开
.参数 十六进制文本, 文本型
.局部变量 局部文本, 文本型

局部文本 ＝ 到大写 (十六进制文本)
局部文本 ＝ 子文本替换 (局部文本, “0”, “----”, , , 真)
局部文本 ＝ 子文本替换 (局部文本, “1”, “---+”, , , 真)
局部文本 ＝ 子文本替换 (局部文本, “2”, “--+-”, , , 真)
局部文本 ＝ 子文本替换 (局部文本, “3”, “--++”, , , 真)
局部文本 ＝ 子文本替换 (局部文本, “4”, “-+--”, , , 真)
局部文本 ＝ 子文本替换 (局部文本, “5”, “-+-+”, , , 真)
局部文本 ＝ 子文本替换 (局部文本, “6”, “-++-”, , , 真)
局部文本 ＝ 子文本替换 (局部文本, “7”, “-+++”, , , 真)
局部文本 ＝ 子文本替换 (局部文本, “8”, “+---”, , , 真)
局部文本 ＝ 子文本替换 (局部文本, “9”, “+--+”, , , 真)
局部文本 ＝ 子文本替换 (局部文本, “A”, “+-+-”, , , 真)
局部文本 ＝ 子文本替换 (局部文本, “B”, “+-++”, , , 真)
局部文本 ＝ 子文本替换 (局部文本, “C”, “++--”, , , 真)
局部文本 ＝ 子文本替换 (局部文本, “D”, “++-+”, , , 真)
局部文本 ＝ 子文本替换 (局部文本, “E”, “+++-”, , , 真)
局部文本 ＝ 子文本替换 (局部文本, “F”, “++++”, , , 真)
局部文本 ＝ 子文本替换 (局部文本, “+”, “1”, , , 真)
局部文本 ＝ 子文本替换 (局部文本, “-”, “0”, , , 真)
返回 (局部文本)

.子程序 十六进制到单精度, 文本型, 公开
.参数 十六进制文本, 文本型
.局部变量 二进制文本, 文本型
.局部变量 符号位, 文本型
.局部变量 指数部分, 文本型
.局部变量 尾数部分, 文本型
.局部变量 X, 整数型
.局部变量 指数, 整数型
.局部变量 结果, 小数型

二进制文本 ＝ 十六进制到二进制 (十六进制文本)
符号位 ＝ 取文本左边 (二进制文本, 1)
指数部分 ＝ 取文本中间 (二进制文本, 2, 8)
尾数部分 ＝ “1” ＋ 取文本右边 (二进制文本, 23)
.计次循环首 (8, X)
    指数 ＝ 指数 ＋ 到整数 (取文本中间 (指数部分, X, 1)) × 求次方 (2, 8 － X)
.计次循环尾 ()
指数 ＝ 指数 － 126
.计次循环首 (24, X)
    结果 ＝ 结果 ＋ 到整数 (取文本中间 (尾数部分, X, 1)) × 求次方 (2, 指数 － X)
.计次循环尾 ()
.如果真 (符号位 ＝ “1”)
    结果 ＝ －结果
.如果真结束
返回 (到文本 (结果))

.子程序 单精度到十六进制, 文本型
.参数 单精度文本, 文本型
.局部变量 二进制文本, 文本型
.局部变量 指数, 整数型
.局部变量 X, 整数型
.局部变量 局部小数, 小数型
.局部变量 Y, 双精度小数型
.局部变量 尾数, 文本型
.局部变量 结果, 文本型

局部小数 ＝ 取绝对值 (到小数 (单精度文本))
.如果真 (局部小数 ＝ 0)
    返回 (“00000000”)
.如果真结束
X ＝ 取整 (局部小数)
Y ＝ 局部小数
.判断循环首 (取整 (Y) ＝ 0)
    Y ＝ Y × 2
    指数 ＝ 指数 － 1
.判断循环尾 ()
指数 ＝ 指数 ＋ 取文本长度 (进制转换 (到文本 (X), 10, 2))
二进制文本 ＝ 进制转换 (到文本 (指数 ＋ 126), 10, 2)
.判断循环首 (取文本长度 (二进制文本) ＜ 8)
    二进制文本 ＝ “0” ＋ 二进制文本
.判断循环尾 ()
.如果 (到小数 (单精度文本) ＜ 0)
    二进制文本 ＝ “1” ＋ 二进制文本
.否则
    二进制文本 ＝ “0” ＋ 二进制文本
.如果结束
.计次循环首 (24, X)
    Y ＝ 求次方 (2, 指数 － X)
    .如果 (局部小数 ＞ Y)
        尾数 ＝ 尾数 ＋ “1”
        局部小数 ＝ 局部小数 － Y
    .否则
        尾数 ＝ 尾数 ＋ “0”
    .如果结束

.计次循环尾 ()
二进制文本 ＝ 二进制文本 ＋ 取文本右边 (尾数, 23)
结果 ＝ 进制转换 (二进制文本, 2, 16)
返回 (结果)

@叶公子