commit f2305e0abc141b3bfc4a91f261efdc5d2f64c496 Author: zhangsan Date: Fri Dec 10 18:04:10 2021 +0800 Initial Version. diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..c353f76 --- /dev/null +++ b/.gitignore @@ -0,0 +1,34 @@ +### vim +*.swp +*.swo +*~ + +### Keil5 +/keil/* +/keilp/* +!*.sct +!*.uvprojx + +### Source Insight +*.IAB +*.IAD +*.IMB +*.IMD +*.PFI +*.PO +*.PR +*.PRI +*.PS +*.WK3 +*.SearchResults +*.bookmarks.xml +*.snippets.xml +*.siwork +si/**/cache/ +si/**/Backup/ +si4/**/cache/ +si4/**/Backup/ + +### Source file +source/bak/ +/out/ diff --git a/docs/CS1232称重传感重量计算说明-v2.5-20200917.docx b/docs/CS1232称重传感重量计算说明-v2.5-20200917.docx new file mode 100644 index 0000000..e1ee4b5 --- /dev/null +++ b/docs/CS1232称重传感重量计算说明-v2.5-20200917.docx @@ -0,0 +1,438 @@ + + + CS1232称重传感重量计算说明 + + 传控科技 v2.5.1 + + + + + + + + + + + + + + + + +版本 +日期 +作者 +参与 +校对 +审核 +备注 +1.020200619 +zhangsan无 +zhangsan +zhangsan +初稿 +1.1 +20200619 +zhangsan +无 +zhangsan +zhangsan +修改参数 +1.2 +20200701 +zhangsan +无 +zhangsan +zhangsan +修改滤波 +1.3 +20200706 +zhangsan +无 +zhangsan +zhangsan +修改滤波 +1.4 +20200708 +zhangsan +无 +zhangsan +zhangsan +修改滤波 +2.5 +20200917 +zhangsan +无 +zhangsan +zhangsan +添加标定 +2.5.1 +20200921 +zhangsan +无 +zhangsan +zhangsan +修改10协议 + + + + + + + +重量计算 + CS1232是高精度、低功耗模数转换芯片。其分辨率为24bit，有效分辨率可达20.8位。通过实验测试，测试AD转换效果，要求1000kg量程的传感器，采样精度可以达到1kg。 + 测试方案将针对不同的设置方式获取精度要求，直到结果满足精度要求。增益分别按照1，2，64，128进行测试，对比测试结果。 +1、 采样数据和称重结果转换关系 + 1） 采样电压与读取采样结果的关系 + 采样电压U（V），采样结果D（二进制数） + + 12*VRGainU=223-1D （1） + A） 其中，U表示模拟信号大小，单位（V） + B） 其中，D表示模拟信号转换的二进制数据 + C） 其中，VR表示应变桥施加的基准电压 + D） 其中，Gain表示硬件设计的AD转换信号增益（1，2，64，128） + 由（1）式可推导出输出电压U的表达式（2） + U=VR*D2*223-1*Gain （2） + + 1） 采样电压与对应重量的计算关系 + VR*灵敏度*10-3量程=Um （3） +A） 其中，灵敏度是传感器标称参数，单位是mV/V +B） 其中，量程是传感器的最大称重量程，比如：500kg，1000kg +C） 其中，m是被称物体的重量，单位kg。 +D） 其中，U是传感器输出的电压，单位V。 + 根据（3）式，可推导出质量m的表达式（4） + m=量程*UVR*10-3*灵敏度 （4） + 1） 采样数据与称重结果的转换关系 + 根据（2）、（4）式，可以推导出质量m与AD值的对应关系，如式（5） + m=量程*D2*223-1*10-3*Gain*灵敏度 （5） +1、 测试结果对照表 +Modbus协议 +采集速率：最高80Hz ==> 采集间隔>= 1000/80 ms = 12.5ms，程序采用20ms +通道切换建立时间：57ms，程序采用80ms +s + 每一路采样都是 采集N个点去掉最大最小求平均 + 1次完整的重量采样所用时间 = 3路的采样时间 + 2路的通道切换时间（ch3不需要切换通道） = N * 3 * 12.5ms + 2* 60ms = N*37.5ms + 120ms + CH_ADCVAL (每一路的采样) = (采集N个点之和 - 最大 - 最小) / (N-2) + CH_WEIGHT (每一路的重量) = [补偿系数 * ( (CH_ADCVAL - adcval_zero) * 量程 / (2 * 0x7FFFFF * 增益 * 灵敏度 * 10^-3) )] +其中adcval_zero为标0时adc值 + 总重量 = 1路当前重量 + 2路当前重量 + 3路当前重量 + +Modbus每个数据帧之间间隔要求 > 20ms + 寄存器地址（十进制） + 实际地址（十六进制） + 说明 + 40001 + 0001 +Reserved1 + 只读寄存器（多字节）（功能码0x03） + 40002 + 0002 +当前重量值（净重）（4字节无符号数，高位在前，实际重量*补偿系数) + 40003 + 0003 + + 40004 + 0004 +当前标0重量值（皮重）（4字节无符号数，高位在前，实际重量*补偿系数) + 40005 + 0005 + + 40006 + 0006 +Reserved2 + 可读可写寄存器（两字节）（写功能码0x06，读功能码0x03） + 40007 + 0007 +重置，该寄存器写入任何值参数重置 + 40008 + 0008 +AD采样掩码，默认3路 + 40009 + 0009 +485从设备ID + 40010 + 000A +清零（写入非零值清0） + 40011 + 000B +量程(eg: 1000kg、500kg) + 40012 + 000C +灵敏度(eg: 2mv/v) + 40013 + 000D +单路均值滤波点数（默认为6） + 40014 + 000E +单路移位滤波右移位数（默认为2）（level3） + 40015 + 000F +和值移位滤波右移位数（默认为2）（level2） + 40016 + 0010 +和值移位滤波右移位数（默认为4）（level1） + 40017 + 0011 +移位比较阈值（默认为1kg） + 40018 + 0012 +移位比较阈值1（默认为1kg） + 40019 + 0013 +移位比较阈值2（默认为1kg） + 40020 + 0014 +应当显示的次数 + 40021 + 0015 +显示阈值 + 可读可写寄存器（多字节）（写功能码0x10，读功能码0x03） + 40022 + 0016 +标定量程1 + 40023 + 0017 +标定量程1系数（x100） + 40024 + 0018 +标定量程2 + 40025 + 0019 +标定量程2系数（x100） + 40026 + 001A +标定量程3 + 40027 + 001B +标定量程3系数（x100） + 40028 + 001C +标定量程4 + 40029 + 001D +标定量程4系数（x100） + 40030 + 001E +标定量程5 + 40031 + 001F +标定量程5系数（x100） + 40032 + 0020 +标定量程6 + 40033 + 0021 +标定量程6系数（x100） + 40034 + 0022 +标定量程7 + 40035 + 0023 +标定量程7系数（x100） + 40036 + 0024 +标定量程8 + 40037 + 0025 +标定量程8系数（x100） + 40038 + 0026 +标定量程9 + 40039 + 0027 +标定量程9系数（x100） + 40040 + 0028 +标定量程10 + 40041 + 0029 +标定量程10系数（x100） + 40042 + 002A +Reserved3 + 只读寄存器（四字节）（功能码0x03） + + + + + + + + +注1：补偿系数，默认为100，代表实际重量的1倍,x100是为了上位机可以处理2位小数点，上位机可以设置为110或者90分别代表，实际重量的1.1倍和0.9倍 +注2：采样序号，传感器内部采样的序号，从0开始，每完成一次完整采样（3个传感器）序号加1，16bit无符号值，自动溢出,上位机可以通过读取采样序号来判断 读出的重量是新值还是旧值 +注3：采样个数，针对某个固定通道，adc采样结果总是（N个数-最大-最小）求平均/均方，N的值即该通道的采样个数，3<=N<=10，采集间隔固定12.5ms，不提供更改协议。一次完整重量采样时间 = 采样个数 * 3通道 * 12.5ms + 60ms(切换通道时间) * 2。 +注4：Modbus携带数据域部分（modbus数据帧去掉1字节从机地址，去掉1字节功能码，去掉crc校验）长度不超过32字节。 + +Modbus协议举例 +03(hex) 读寄存器状态 +查询：查询信息规定了要读的寄存器起始地址及寄存器的数量。 +响应：响应信息中规定了被读寄存器的字节数，每个寄存器分别对应2个字节；其信息中还具有各被读寄存器的数据值。 +例：读寄存器40007、40008。 +1） 当使用RTU模式进行通讯时： +查询命令： +传感器地址 +功能码 +起始地址 +查询寄存器数量 +CRC校验 +1byte +1byte +2byte +2byte +2byte + + + + + + +传感器接受正确后的响应： +传感器地址 +功能码 +计数字节 +寄存器(007)数据 +寄存器(008)数据 +CRC校验 +1byte +1byte +1byte +2byte +2byte +2byte + +查询命令：01 03 00 07 00 02 75 CA +正确响应：01 03 04 00 00 00 05 3A 30 +寄存器0007、0008中的数据分别为：0（Hex：0000H）、5（Hex：0005H） +06(hex) 预置单个寄存器 +预置：预置信息规定了要预置寄存器的地址和预置值。 +响应：寄存器的内容被预置后返回正常响应。 +例：请求把称重传感器01中的40001寄存器预置为0003H +1）当使用RTU模式进行通讯时： +预置命令： +传感器地址 +功能码 +寄存器地址 +预置值 +CRC校验 +1byte +1byte +2byte +2byte +2byte + +显示器接收正确后的响应： +传感器地址 +功能码 +寄存器地址 +预置值 +CRC校验 +1byte +1byte +2byte +2byte +2byte + +预置命令：01 06 00 01 00 03 98 0B （将传感器地址设置为0003） +正确响应：01 06 00 01 00 03 98 0B +寄存器0001中的值为：3（Hex：0003H） +10(hex) 预置多个寄存器 +预置：预置信息规定了要预置寄存器的起始地址、数量、预置值。 +响应：寄存器的内容被预置后返回正常响应。 +例：请求把称重传感器01中的40022和40023寄存器预置为0064H,0064H +1）当使用RTU模式进行通讯时： +预置命令： +传感器地址 +功能码 +寄存器地址（起始） +寄存器数量 +计数字节 +预置值 +CRC校验 +1byte +1byte +2byte +2bytes +1bytes +2byte * (寄存器数量) +2byte + +显示器接收正确后的响应： +传感器地址 +功能码 +寄存器地址（起始） +寄存器数量 +CRC校验 +1byte +1byte +2byte +2byte +2byte + +预置命令：01 10 00 16 00 02 04 00 64 00 63 73 7F (标定10-1 ：量程100Kg 系数0.99) +正确响应：01 10 00 16 00 02 A0 0C + +Modbus错误响应 +协议格式 +传感器地址 +功能码 +错误码 +CRC校验 +1byte +1byte +1byte +2byte + +协议执行错误 +定义：协议本身正确，但"传感器mcu"在执行协议对应命令时出现错误 +功能码：原功能码+0x80，比如功能码为03，则响应0x83；功能码为06，则响应0x86 +错误码：00 +协议错误 +定义：协议解析过程中产生错误，即协议本身不正确. +oo 功能码：0x8F +oo 错误码：见下表 +序号 +功能码 +错误码 +描述 +备注 +01 + 0x8F +0x01 +协议长度大于最大长度 +通常是由于协议间隔小于规定的最小间隔，导致协议粘包 +02 + +0x02 +协议校验错误 +校验码不正确 +03 + +0x03 +无效的功能码 +功能码错误 + + +标定说明 +提供10个分段量程标定位置，标定系数需要 x 100，量程不需要 +预置命令：01 10 00 16 00 02 04 00 64 00 63 73 7F（标定10-1 量程100Kg,系数0.99） +正确响应：01 10 00 16 00 02 A0 0C + +举例： +100Kg，系数1.01 +200kg，系数0.99 +300kg，系数0.99 +... +... + +对应的标定指令为： +01 10 00 16 00 02 04 00 64 00 65 XXXX +其中 0016为寄存器地址 0002为寄存器数量 04为计数字节 0064为量程100（100Kg） 0065为系数101（1.01*100） XXXX为CRC16校验 + +01 10 00 18 00 02 04 00 C8 00 63 XXXX +其中 0018为寄存器地址 0002为寄存器数量 04为计数字节 00C8为量程200（200Kg） 0063为系数99（0.99*100） XXXX为CRC16校验 + +01 10 00 1A 00 02 04 012C 00 63 XXXX +其中 001A为寄存器地址 0002为寄存器数量 04为计数字节 012C为量程300（300Kg） 0063为系数99（1.00*100） XXXX为CRC16校验 + diff --git a/docs/CS1232称重传感重量计算说明-v2.6-20200927.docx b/docs/CS1232称重传感重量计算说明-v2.6-20200927.docx new file mode 100644 index 0000000..aa2a894 --- /dev/null +++ b/docs/CS1232称重传感重量计算说明-v2.6-20200927.docx @@ -0,0 +1,464 @@ + + + CS1232称重传感重量计算说明 + + 传控科技 v2.6 + + + + + + + + + + + + + + + + +版本 +日期 +作者 +参与 +校对 +审核 +备注 +1.020200619 +卫 +杨 +杨 +周勇 +初稿 +1.1 +20200619 +卫 +杨 +杨 +周勇 +修改参数 +1.2 +20200701 +卫 +杨 +杨 +周勇 +修改滤波 +1.3 +20200706 +卫 +杨 +杨 +周勇 +修改滤波 +1.4 +20200708 +卫 +杨 +杨 +周勇 +修改滤波 +2.5 +20200917 +卫 +杨 +杨 +周勇 +添加标定 +2.5.1 +20200921 +卫 +杨 +杨 +周勇 +修改10协议 +2.6 +20200927 +卫 +杨 +杨 +周勇 +修改显示分辨率 + + + + +重量计算 + CS1232是高精度、低功耗模数转换芯片。其分辨率为24bit，有效分辨率可达20.8位。通过实验测试，测试AD转换效果，要求1000kg量程的传感器，采样精度可以达到1kg。 + 测试方案将针对不同的设置方式获取精度要求，直到结果满足精度要求。增益分别按照1，2，64，128进行测试，对比测试结果。 +1、 采样数据和称重结果转换关系 + 1） 采样电压与读取采样结果的关系 + 采样电压U（V），采样结果D（二进制数） + + 12*VRGainU=223-1D （1） + A） 其中，U表示模拟信号大小，单位（V） + B） 其中，D表示模拟信号转换的二进制数据 + C） 其中，VR表示应变桥施加的基准电压 + D） 其中，Gain表示硬件设计的AD转换信号增益（1，2，64，128） + 由（1）式可推导出输出电压U的表达式（2） + U=VR*D2*223-1*Gain （2） + + 1） 采样电压与对应重量的计算关系 + VR*灵敏度*10-3量程=Um （3） +A） 其中，灵敏度是传感器标称参数，单位是mV/V +B） 其中，量程是传感器的最大称重量程，比如：500kg，1000kg +C） 其中，m是被称物体的重量，单位kg。 +D） 其中，U是传感器输出的电压，单位V。 + 根据（3）式，可推导出质量m的表达式（4） + m=量程*UVR*10-3*灵敏度 （4） + 1） 采样数据与称重结果的转换关系 + 根据（2）、（4）式，可以推导出质量m与AD值的对应关系，如式（5） + m=量程*D2*223-1*10-3*Gain*灵敏度 （5） +1、 测试结果对照表 +Modbus协议 +采集速率：最高80Hz ==> 采集间隔>= 1000/80 ms = 12.5ms，程序采用20ms +通道切换建立时间：57ms，程序采用80ms +s + 每一路采样都是 采集N个点去掉最大最小求平均 + 1次完整的重量采样所用时间 = 3路的采样时间 + 2路的通道切换时间（ch3不需要切换通道） = N * 3 * 12.5ms + 2* 60ms = N*37.5ms + 120ms + CH_ADCVAL (每一路的采样) = (采集N个点之和 - 最大 - 最小) / (N-2) + CH_WEIGHT (每一路的重量) = [补偿系数 * ( (CH_ADCVAL - adcval_zero) * 量程 / (2 * 0x7FFFFF * 增益 * 灵敏度 * 10^-3) )] +其中adcval_zero为标0时adc值 + 总重量 = 1路当前重量 + 2路当前重量 + 3路当前重量 + +Modbus每个数据帧之间间隔要求 > 20ms + 寄存器地址（十进制） + 实际地址（十六进制） + 说明 + 40001 + 0001 +Reserved1 + 只读寄存器（多字节）（功能码0x03） + 40002 + 0002 +当前重量值（净重）（4字节无符号数，高位在前，实际重量*补偿系数) + 40003 + 0003 + + 40004 + 0004 +当前标0重量值（皮重）（4字节无符号数，高位在前，实际重量*补偿系数) + 40005 + 0005 + + 40006 + 0006 +Reserved2 + 可读可写寄存器（两字节）（写功能码0x06，读功能码0x03） + 40007 + 0007 +重置，该寄存器写入任何值参数重置 + 40008 + 0008 +AD采样掩码，默认3路 + 40009 + 0009 +485从设备ID + 40010 + 000A +清零（写入非零值清0） + 40011 + 000B +量程(eg: 1000kg、500kg) + 40012 + 000C +灵敏度(eg: 2mv/v) + 40013 + 000D +单路均值滤波点数（默认为6） + 40014 + 000E +单路移位滤波右移位数（默认为2）（level3） + 40015 + 000F +和值移位滤波右移位数（默认为2）（level2） + 40016 + 0010 +和值移位滤波右移位数（默认为4）（level1） + 40017 + 0011 +移位比较阈值（默认为0.2kg） + 40018 + 0012 +移位比较阈值1（默认为0.2kg） + 40019 + 0013 +重量显示设定1 + 40020 + 0014 +重量显示设定1次数 + 40021 + 0015 +重量显示设定2 + 40022 + 0016 +重量显示设定2次数 + 40023 + 0017 +重量显示设定3 + 40024 + 0018 +重量显示设定3次数 + 40025 + 0019 +重量显示设定4 + 40026 + 001A +重量显示设定4次数 + 40027 + 001B +重量显示设定5 + 40028 + 001C +重量显示设定5次数 + 可读可写寄存器（多字节）（写功能码0x10，读功能码0x03） + 40029 + 001D +标定量程1 + 40030 + 001E +标定量程1系数（x100） + 40031 + 001F +标定量程2 + 40032 + 0020 +标定量程2系数（x100） + 40033 + 0021 +标定量程3 + 40034 + 0022 +标定量程3系数（x100） + 40035 + 0023 +标定量程4 + 40036 + 0024 +标定量程4系数（x100） + 40037 + 0025 +标定量程5 + 40038 + 0026 +标定量程5系数（x100） + 40039 + 0027 +标定量程6 + 40040 + 0028 +标定量程6系数（x100） + 40041 + 0029 +标定量程7 + 40042 + 002A +标定量程7系数（x100） + 40043 + 002B +标定量程8 + 40044 + 002C +标定量程8系数（x100） + 40045 + 002D +标定量程9 + 40046 + 002E +标定量程9系数（x100） + 40047 + 002F +标定量程10 + 40048 + 0030 +标定量程10系数（x100） + 40049 + 0031 +Reserved3 + 只读寄存器（四字节）（功能码0x03） + + + + + + + + +注1：补偿系数，默认为100，代表实际重量的1倍,x100是为了上位机可以处理2位小数点，上位机可以设置为110或者90分别代表，实际重量的1.1倍和0.9倍 +注2：采样序号，传感器内部采样的序号，从0开始，每完成一次完整采样（3个传感器）序号加1，16bit无符号值，自动溢出,上位机可以通过读取采样序号来判断 读出的重量是新值还是旧值 +注3：采样个数，针对某个固定通道，adc采样结果总是（N个数-最大-最小）求平均/均方，N的值即该通道的采样个数，3<=N<=10，采集间隔固定12.5ms，不提供更改协议。一次完整重量采样时间 = 采样个数 * 3通道 * 12.5ms + 60ms(切换通道时间) * 2。 +注4：Modbus携带数据域部分（modbus数据帧去掉1字节从机地址，去掉1字节功能码，去掉crc校验）长度不超过32字节。 + +Modbus协议举例 +03(hex) 读寄存器状态 +查询：查询信息规定了要读的寄存器起始地址及寄存器的数量。 +响应：响应信息中规定了被读寄存器的字节数，每个寄存器分别对应2个字节；其信息中还具有各被读寄存器的数据值。 +例：读寄存器40007、40008。 +1） 当使用RTU模式进行通讯时： +查询命令： +传感器地址 +功能码 +起始地址 +查询寄存器数量 +CRC校验 +1byte +1byte +2byte +2byte +2byte + + + + + + +传感器接受正确后的响应： +传感器地址 +功能码 +计数字节 +寄存器(007)数据 +寄存器(008)数据 +CRC校验 +1byte +1byte +1byte +2byte +2byte +2byte + +查询命令：01 03 00 07 00 02 75 CA +正确响应：01 03 04 00 00 00 05 3A 30 +寄存器0007、0008中的数据分别为：0（Hex：0000H）、5（Hex：0005H） +06(hex) 预置单个寄存器 +预置：预置信息规定了要预置寄存器的地址和预置值。 +响应：寄存器的内容被预置后返回正常响应。 +例：请求把称重传感器01中的40001寄存器预置为0003H +1）当使用RTU模式进行通讯时： +预置命令： +传感器地址 +功能码 +寄存器地址 +预置值 +CRC校验 +1byte +1byte +2byte +2byte +2byte + +显示器接收正确后的响应： +传感器地址 +功能码 +寄存器地址 +预置值 +CRC校验 +1byte +1byte +2byte +2byte +2byte + +预置命令：01 06 00 01 00 03 98 0B （将传感器地址设置为0003） +正确响应：01 06 00 01 00 03 98 0B +寄存器0001中的值为：3（Hex：0003H） +10(hex) 预置多个寄存器 +预置：预置信息规定了要预置寄存器的起始地址、数量、预置值。 +响应：寄存器的内容被预置后返回正常响应。 +例：请求把称重传感器01中的40022和40023寄存器预置为0064H,0064H +1）当使用RTU模式进行通讯时： +预置命令： +传感器地址 +功能码 +寄存器地址（起始） +寄存器数量 +计数字节 +预置值 +CRC校验 +1byte +1byte +2byte +2bytes +1bytes +2byte * (寄存器数量) +2byte + +显示器接收正确后的响应： +传感器地址 +功能码 +寄存器地址（起始） +寄存器数量 +CRC校验 +1byte +1byte +2byte +2byte +2byte + +预置命令：01 10 00 16 00 02 04 00 64 00 63 73 7F (标定10-1 ：量程100Kg 系数0.99) +正确响应：01 10 00 16 00 02 A0 0C + +Modbus错误响应 +协议格式 +传感器地址 +功能码 +错误码 +CRC校验 +1byte +1byte +1byte +2byte + +协议执行错误 +定义：协议本身正确，但"传感器mcu"在执行协议对应命令时出现错误 +功能码：原功能码+0x80，比如功能码为03，则响应0x83；功能码为06，则响应0x86 +错误码：00 +协议错误 +定义：协议解析过程中产生错误，即协议本身不正确. +oo 功能码：0x8F +oo 错误码：见下表 +序号 +功能码 +错误码 +描述 +备注 +01 + 0x8F +0x01 +协议长度大于最大长度 +通常是由于协议间隔小于规定的最小间隔，导致协议粘包 +02 + +0x02 +协议校验错误 +校验码不正确 +03 + +0x03 +无效的功能码 +功能码错误 + + +标定说明 +提供10个分段量程标定位置，标定系数需要 x 100，量程不需要 +预置命令：01 10 00 16 00 02 04 00 64 00 63 73 7F（标定10-1 量程100Kg,系数0.99） +正确响应：01 10 00 16 00 02 A0 0C + +举例： +100Kg，系数1.01 +200kg，系数0.99 +300kg，系数0.99 +... +... + +对应的标定指令为： +01 10 00 16 00 02 04 00 64 00 65 XXXX +其中 0016为寄存器地址 0002为寄存器数量 04为计数字节 0064为量程100（100Kg） 0065为系数101（1.01*100） XXXX为CRC16校验 + +01 10 00 18 00 02 04 00 C8 00 63 XXXX +其中 0018为寄存器地址 0002为寄存器数量 04为计数字节 00C8为量程200（200Kg） 0063为系数99（0.99*100） XXXX为CRC16校验 + +01 10 00 1A 00 02 04 012C 00 63 XXXX +其中 001A为寄存器地址 0002为寄存器数量 04为计数字节 012C为量程300（300Kg） 0063为系数99（1.00*100） XXXX为CRC16校验 + diff --git a/docs/stc8f2k16s2_encrypt_v1.0.exe b/docs/stc8f2k16s2_encrypt_v1.0.exe new file mode 100644 index 0000000..3c39cd7 Binary files /dev/null and b/docs/stc8f2k16s2_encrypt_v1.0.exe differ diff --git a/docs/称重传感器设计v1.5 20200530.xlsx b/docs/称重传感器设计v1.5 20200530.xlsx new file mode 100644 index 0000000..c899391 Binary files /dev/null and b/docs/称重传感器设计v1.5 20200530.xlsx differ diff --git a/keilp/cc_as_stc02_ps5ws.uvprojx b/keilp/cc_as_stc02_ps5ws.uvprojx new file mode 100644 index 0000000..57f3e1d --- /dev/null +++ b/keilp/cc_as_stc02_ps5ws.uvprojx @@ -0,0 +1,471 @@ + + + + 2.1 + +
### uVision Project, (C) Keil Software
+ + + + STC8F2K16S2 + 0x0 + MCS-51 + + + AT80C31X2 + Atmel + IRAM(0 - 0x7F) CLOCK(60000000) MODP2 + + "LIB\STARTUP.A51" ("Standard 8051 Startup Code") + + 4027 + REG51.H + + + + + + + + + + + 0 + 0 + d:\Keil\C51\BIN\ + + + + + + 0 + 0 + 0 + 0 + 1 + + ..\out\ + cc_stc02_ps5ws + 1 + 0 + 1 + 1 + 1 + ..\out\ + 0 + 0 + 0 + + 0 + 0 + + + 0 + 0 + 0 + 0 + + + 0 + 0 + + + 0 + 0 + 0 + 0 + + + 0 + 0 + + + 0 + 0 + 0 + 0 + + 0 + + + + 0 + 0 + 0 + 0 + 0 + 1 + 0 + 0 + 0 + 0 + 3 + + + 1 + 65535 + + + S8051.DLL + + DP51.DLL + -p51X + S8051.DLL + + TP51.DLL + -p51X + + + + 0 + 0 + 0 + 0 + 16 + + + + + 0 + 0 + 0 + 0 + 0 + -1 + + 0 + + + + + + + 0 + + + + 2 + 0 + 2 + 0 + 0 + 0 + 0 + 0 + 0 + 1 + 0 + 0 + 0 + 0 + 1 + 0 + 0 + 0 + 0 + 0 + 1 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + + + 0 + 0x0 + 0xffff + + + 0 + 0x0 + 0x0 + + + 0 + 0x0 + 0x0 + + + 0 + 0x0 + 0x0 + + + 0 + 0x0 + 0x0 + + + 0 + 0x0 + 0x0 + + + 0 + 0x0 + 0x0 + + + 0 + 0x0 + 0x0 + + + 1 + 0x0 + 0x0 + + + 0 + 0x0 + 0x80 + + + 0 + 0x0 + 0x0 + + + 0 + 0x0 + 0x0 + + + 0 + 0x0 + 0x0 + + + + + 0 + 0 + 0 + 0 + 1 + 3 + 2 + 2 + 0 + 1 + 1 + 0 + + + + + ..\source\msp + + + + 0 + 1 + 0 + 0 + + + + + + + + + 0 + 0 + 1 + 0 + 2 + 1 + + REMOVEUNUSED + + + + + + + + + + + + + + + + + + + + + + + + + + + app + + + main.c + 1 + ..\source\app\main.c + + + task_adc.c + 1 + ..\source\app\task_adc.c + + + task_debug.c + 1 + ..\source\app\task_debug.c + + + task_register.c + 1 + ..\source\app\task_register.c + + + task_modbus.c + 1 + ..\source\app\task_modbus.c + + + app_config.c + 1 + ..\source\app\app_config.c + + + task_encrypt.c + 1 + ..\source\app\task_encrypt.c + + + + + cpu + + + STARTUP.A51 + 2 + ..\source\cpu\STARTUP.A51 + + + + + msp + + + time.c + 1 + ..\source\msp\time.c + + + UART0.C + 1 + ..\source\msp\UART0.C + + + eeprom.c + 1 + ..\source\msp\eeprom.c + + + uart_x.c + 1 + ..\source\msp\uart_x.c + + + UART2.C + 1 + ..\source\msp\UART2.C + + + + + bsp + + + bsp_config.c + 1 + ..\source\bsp\bsp_config.c + + + chipid.c + 1 + ..\source\bsp\chipid.c + + + cs1232.c + 1 + ..\source\bsp\cs1232.c + + + rs485.c + 1 + ..\source\bsp\rs485.c + + + + + ctask + + + task.c + 1 + ..\source\ctask\task.c + + + tick.c + 1 + ..\source\ctask\tick.c + + + + + tpc + + + modbus.c + 1 + ..\source\tpc\modbus.c + + + ccmodbus.c + 1 + ..\source\tpc\ccmodbus.c + + + + + clib + + + clib.c + 1 + ..\source\clib\clib.c + + + + + + + + diff --git a/si4/keywords.txt b/si4/keywords.txt new file mode 100644 index 0000000..d39a8c6 --- /dev/null +++ b/si4/keywords.txt @@ -0,0 +1,152 @@ +#define, Keyword +#elif, Directive +#else, Directive +#endif, Directive +#if, Directive +#ifdef, Directive +#ifndef, Directive +#include, Keyword +#pragma, Keyword +#undef, Keyword +(, Delimiter +), Delimiter +",", Delimiter +;, Delimiter +abstract, Keyword +__abstract, Keyword +alignas, Keyword +alignof, Keyword +asm, Keyword +__asm, Keyword +assert, Debug +Assert, Debug +async, Keyword +auto, Keyword +bool, Keyword +break, Control +case, Control +catch, Control +cdecl, Keyword +__cdecl, Keyword +char, Keyword +class, Control +coclass, Control +const, Keyword +constexpr, Keyword +const_cast, Keyword +continue, Control +cout, Keyword +decltype, Keyword +default, Control +__delegate, Keyword +delete, Control +do, Control +double, Keyword +DWORD, Keyword +dynamic_cast, Keyword +each, Control +else, Control +enum, Control +__event, Keyword +except, Control +__except, Control +exception, Keyword +explicit, Keyword +export, Keyword +extern, Keyword +FALSE, Boolean +false, Boolean +FAR, Keyword +far, Keyword +final, Keyword +__finally, Control +float, Keyword +for, Control +fortran, Keyword +for_each, Control +friend, Keyword +__gc, Keyword +goto, Control +HUGE, Keyword +huge, Keyword +if, Control +inline, Keyword +INT, Keyword +int, Keyword +int16_t, Keyword +int32_t, Keyword +int64_t, Keyword +int8_t, Keyword +interface, Control +LONG, Keyword +long, Keyword +mutable, Keyword +namespace, Control +near, Keyword +NEAR, Keyword +new, Control +noexcept, Keyword +NULL, Null Value +nullptr, Null Value +__nullptr, Null Value +operator, Keyword +override, Keyword +pascal, Keyword +PASCAL, Keyword +private, Keyword +__property, Keyword +protected, Keyword +public, Keyword +ref, Keyword +REGISTER, Keyword +register, Keyword +reinterpret_cast, Keyword +return, Control +sealed, Keyword +short, Keyword +SHORT, Keyword +signed, Keyword +sizeof, Keyword +static, Keyword +static_cast, Keyword +struct, Control +__super, Keyword +switch, Control +template, Control +this, Keyword +thread_local, Keyword +throw, Control +TRUE, Boolean +true, Boolean +try, Control +__try, Control +TTSS_step01, Highlight +TTSS_Task_end, Highlight +TTSS_Task_init, Highlight +TTSS_Task_step, Highlight +TTSS_step01, Highlight +TTSS_step02,Highlight +TTSS_step03,Highlight +TTSS_step04,Highlight +TTSS_step05,Highlight +TTSS_step06,Highlight +TTSS_step07,Highlight +TTSS_Task_step, Highlight +typedef, Control +typeid, Keyword +typename, Keyword +UINT, Keyword +union, Control +unsigned, Keyword +using, Keyword +virtual, Keyword +VOID, Keyword +void, Keyword +volatile, Keyword +wchar_t, Keyword +while, Control +WORD, Keyword +{, Delimiter +[, Delimiter +], Delimiter +}, Delimiter diff --git a/si4/ps5ws.si4project/soft_ps5ws.sip_sym b/si4/ps5ws.si4project/soft_ps5ws.sip_sym new file mode 100644 index 0000000..cfe0fc8 Binary files /dev/null and b/si4/ps5ws.si4project/soft_ps5ws.sip_sym differ diff --git a/si4/ps5ws.si4project/soft_ps5ws.sip_xab b/si4/ps5ws.si4project/soft_ps5ws.sip_xab new file mode 100644 index 0000000..55c3347 Binary files /dev/null and b/si4/ps5ws.si4project/soft_ps5ws.sip_xab differ diff --git a/si4/ps5ws.si4project/soft_ps5ws.sip_xad b/si4/ps5ws.si4project/soft_ps5ws.sip_xad new file mode 100644 index 0000000..70984d1 Binary files /dev/null and b/si4/ps5ws.si4project/soft_ps5ws.sip_xad differ diff --git a/si4/ps5ws.si4project/soft_ps5ws.sip_xc b/si4/ps5ws.si4project/soft_ps5ws.sip_xc new file mode 100644 index 0000000..84739e8 Binary files /dev/null and b/si4/ps5ws.si4project/soft_ps5ws.sip_xc differ diff --git a/si4/ps5ws.si4project/soft_ps5ws.sip_xf b/si4/ps5ws.si4project/soft_ps5ws.sip_xf new file mode 100644 index 0000000..b99922a Binary files /dev/null and b/si4/ps5ws.si4project/soft_ps5ws.sip_xf differ diff --git a/si4/ps5ws.si4project/soft_ps5ws.sip_xm b/si4/ps5ws.si4project/soft_ps5ws.sip_xm new file mode 100644 index 0000000..552e261 Binary files /dev/null and b/si4/ps5ws.si4project/soft_ps5ws.sip_xm differ diff --git a/si4/ps5ws.si4project/soft_ps5ws.sip_xr b/si4/ps5ws.si4project/soft_ps5ws.sip_xr new file mode 100644 index 0000000..94f09a5 Binary files /dev/null and b/si4/ps5ws.si4project/soft_ps5ws.sip_xr differ diff --git a/si4/ps5ws.si4project/soft_ps5ws.sip_xsb b/si4/ps5ws.si4project/soft_ps5ws.sip_xsb new file mode 100644 index 0000000..c75fa25 Binary files /dev/null and b/si4/ps5ws.si4project/soft_ps5ws.sip_xsb differ diff --git a/si4/ps5ws.si4project/soft_ps5ws.sip_xsd b/si4/ps5ws.si4project/soft_ps5ws.sip_xsd new file mode 100644 index 0000000..dfcc836 Binary files /dev/null and b/si4/ps5ws.si4project/soft_ps5ws.sip_xsd differ diff --git a/si4/ps5ws.si4project/soft_ps5ws.siproj b/si4/ps5ws.si4project/soft_ps5ws.siproj new file mode 100644 index 0000000..68ed112 Binary files /dev/null and b/si4/ps5ws.si4project/soft_ps5ws.siproj differ diff --git a/si4/ps5ws.si4project/soft_ps5ws.siproj_settings.xml b/si4/ps5ws.si4project/soft_ps5ws.siproj_settings.xml new file mode 100644 index 0000000..13b87cb --- /dev/null +++ b/si4/ps5ws.si4project/soft_ps5ws.siproj_settings.xml @@ -0,0 +1,22 @@ + + + + + + + + + diff --git a/source/app/app_config.c b/source/app/app_config.c new file mode 100644 index 0000000..7b12a8d --- /dev/null +++ b/source/app/app_config.c @@ -0,0 +1,108 @@ +#include "app_config.h" +#include "../bsp/cs1232.h" +#include "../bsp/chipid.h" +#include "../msp/eeprom.h" +#include "../clib/clib.h" +GlobalParam G; +GlobalRegister R; + +void L3_param_init(void) +{ + + //station模式状态 + G.st_status = 0; //0:none 1:wifi_ok 2:tcp_connect_ok + //station模式sid + Lc_strcpy(G.st_sid,"ccsens"); + //station模式pwd + Lc_strcpy(G.st_pwd,"ccsens123"); + //ap模式状态 + G.ap_status = 0;//0: none 1: ap_ok 2:tcp_server_ok + //ap模式sid + Lc_strcpy(G.ap_sid,"cc_pen_ap"); + //ap模式pwd + Lc_strcpy(G.ap_pwd,"ccsens123"); +} + + +//读取reg内容，写入iap +void L3_reg_2_iap(void) +{ +#if 0 + iapData.slaver_id = R.p.slaver_id; + iapData.adc_ch_status = R.p.adc_ch_status; + iapData.weight_max = R.p.weight_max; + iapData.lmd = R.p.lmd; + iapData.adc_blur_mid = R.p.adc_blur_mid; + iapData.adc_blur_avg = R.p.adc_blur_avg; + iapData.adc_blur_shift[0] = R.p.adc_blur_shift[0]; + iapData.adc_blur_shift[1] = R.p.adc_blur_shift[1]; + iapData.adc_blur_shift[2] = R.p.adc_blur_shift[2]; + iapData.adc_blur_threshold[0] = R.p.adc_blur_threshold[0]; + iapData.adc_blur_threshold[1] = R.p.adc_blur_threshold[1]; + //写入eeprom + if(L1_eep_write_block(D_EEP_PARAM_IN_SECTOR, D_EEP_PARAM_IN_BLOCK, (U8*)&iapData,sizeof(IapData),TRUE) == 0) + { + L0_uart0_sendstr("e2p write success"); + } +#endif + if(L1_eep_write_block(D_EEP_PARAM_IN_SECTOR, D_EEP_PARAM_IN_BLOCK, D_EEP_SECTOR_BLOCK_SIZE, (U8*)&R.p,sizeof(R.p),TRUE) == 0) + { + L0_uart0_sendstr("e2p write success"); + return; + } + L0_uart0_sendstr("e2p write failed"); +} + +//读取iap内容，写入reg +void L3_iap_2_reg(void) +{ +#if 0 + if(L1_eep_read_block(D_EEP_PARAM_IN_SECTOR, D_EEP_PARAM_IN_BLOCK, (U8*)&iapData, NULL) == 1) + { + L0_uart0_sendstr("e2p read failed"); + } + L0_uart0_sendstr("e2p read success"); + R.p.slaver_id = iapData.slaver_id; + R.p.adc_ch_status = iapData.adc_ch_status; + R.p.weight_max = iapData.weight_max ; + R.p.lmd = iapData.lmd; + R.p.adc_blur_mid = iapData.adc_blur_mid; + R.p.adc_blur_avg = iapData.adc_blur_avg; + R.p.adc_blur_shift[0] = iapData.adc_blur_shift[0]; + R.p.adc_blur_shift[1] = iapData.adc_blur_shift[1]; + R.p.adc_blur_shift[2] = iapData.adc_blur_shift[2]; + R.p.adc_blur_threshold[0] = iapData.adc_blur_threshold[0]; + R.p.adc_blur_threshold[1] = iapData.adc_blur_threshold[1]; +#endif + if(L1_eep_read_block(D_EEP_PARAM_IN_SECTOR, D_EEP_PARAM_IN_BLOCK, D_EEP_SECTOR_BLOCK_SIZE, (U8*)&R.p, NULL) == 0) + { + L0_uart0_sendstr("e2p read success"); + return; + } + L0_uart0_sendstr("e2p read failed"); +} + +void L3_reg_reset(void) +{ + R.p.adc_ch_status = ADC_status_ch2_Ready | ADC_status_ch3_Ready | ADC_status_ch4_Ready; //修改采集通道 + R.p.slaver_id = D_UART0_485_SLAVER_ID; + R.p.weight_max = 500; //500kg + R.p.lmd = 2; //2mv/v + R.p.adc_blur_mid = 1; + R.p.adc_blur_avg = 6; + R.p.adc_blur_shift[0] = 0; + R.p.adc_blur_shift[1] = 2; + R.p.adc_blur_shift[2] = 4; + R.p.adc_blur_threshold[0] = 1600; //g + R.p.adc_blur_threshold[1] = 700; //g +} + +void L3_reg_init(void) +{ + //R.reserved1 = R.reserved2 = R.reserved3 = 0x55; + //R.zero = 0; + //R.status_eep_save = 0; + L3_reg_reset(); + L3_iap_2_reg(); +} + diff --git a/source/app/app_config.h b/source/app/app_config.h new file mode 100644 index 0000000..02af46d --- /dev/null +++ b/source/app/app_config.h @@ -0,0 +1,96 @@ +#ifndef APP_COMMON_H +#define APP_COMMON_H + +#include "../clib/type.h" +#include "../bsp/bsp_config.h" + +#define APP_VERSION 0x10 + +#define D_COUNT_WEIGHT(adc) (U32)((adc) / D_ADS1213_GAIN_VAL / R.p.lmd * R.p.weight_max * 1000 / (2 * 0x7FFFFF / 1000 )) +#define D_COUNT_ADC(wInG) (U32)((wInG) * D_ADS1213_GAIN_VAL * R.p.lmd * (2 * 0x7FFFFF / 1000) / R.p.weight_max / 1000) + + +//STEP 1 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>Register CONFIG +//寄存器编号从1开始 +//#define D_COUNT_WEIGHT(adc) (U32)(1000.0 * R.p.weight_max * (adc) / (2 * 0x7FFFFF / 1000 * D_ADS1213_GAIN_VAL * R.p.lmd)) +//#define D_blur_threshold_2_1(threshold) (U32) ( 1.0 * threshold *(2 * 0x7FFFFF / 1000 * D_ADS1213_GAIN_VAL * R.p.lmd) / (1000.0 * R.p.weight_max )) +#define D_COUNT_WEIGHT(adc) (U32)((adc) / D_ADS1213_GAIN_VAL / R.p.lmd * R.p.weight_max * 1000 / (2 * 0x7FFFFF / 1000 )) +#define D_COUNT_ADC(wInG) (U32)((wInG) * D_ADS1213_GAIN_VAL * R.p.lmd * (2 * 0x7FFFFF / 1000) / R.p.weight_max / 1000) + +#define ADC_status_chx_Ready_BASE 0x01 +#define ADC_status_ch1_Ready 0x01 +#define ADC_status_ch2_Ready 0x02 +#define ADC_status_ch3_Ready 0x04 +#define ADC_status_ch4_Ready 0x08 +#define D_ADC_CHANNEL_NUM 4 +typedef struct global_register +{ + //RO Register + U16 reserved1; + U32 total_weight; //净重（显示重量）*100 + U32 total_zweight; //皮重*100 + //RW Register + U16 reserved2; + U16 zero; //清0标志，写入任何值清0（去皮） + U16 status_eep_save; //eep写入寄存器，1则写入eep并清0 + //U16 reset; //reset标志，写入任何值，所有参数恢复初始值 + struct + { //需要持久化的参数，不能超过72字节，否则会导致eeprom溢出 + U16 slaver_id; + U16 adc_ch_status; + U16 weight_max; //量程 + U16 lmd; //2mv/v + U16 adc_blur_mid; //中值滤波 + U16 adc_blur_avg; //均值滤波 + U16 adc_blur_shift[3]; //移位滤波点数 + U16 adc_blur_threshold[2]; //移位滤波阀值 + }p; + U16 reserved3; + U32 adval[D_ADC_CHANNEL_NUM]; //4路重量 + U32 ch_weight[D_ADC_CHANNEL_NUM]; //4路重量 + U32 rough_weight; // 毛重 +}GlobalRegister; + +extern GlobalRegister R; + +//寄存器内存基地址 +#define REG_MEM_BASE ((U16*)(&R)) //寄存器基础地址（本文件外部不应该使用该宏定义） +//变量地址转寄存器 +#define MEM_2_REG(mem) (((U16*)(mem) - REG_MEM_BASE) + 1) +//寄存器转变量地址 +#define REG_2_MEM(reg) (REG_MEM_BASE + (U16)((reg) - 1)) +//STEP 1 <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>Global Variables CONFIG +typedef struct global_param +{ + //station模式状态 + U8 st_status; //0:none 1:wifi_ok 2:tcp_connect_ok + //station模式sid + U8 st_sid[32]; + //station模式pwd + U8 st_pwd[32]; + //ap模式状态 + U8 ap_status; //0: none 1: ap_ok 2:tcp_server_ok + //ap模式sid + U8 ap_sid[32]; + //ap模式pwd + U8 ap_pwd[32]; +}GlobalParam; +extern struct global_param G; +//STEP 2 <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<> ch) & 0x1; + ts_adc_channel_samples[ch].pool = 0; + ts_adc_channel_samples[ch].adcval = 0; + ts_adc_channel_samples[ch].n = 0; + ts_adc_channel_samples[ch].ch = D_ADCCH_1 + ch; + +#if 0 + //通道中值滤波任务初始化 + L1_task_init(&ts_adc_blur_mid[ch].task); + L3_task_s_go(ts_adc_blur_mid[ch],D_task_init); + ts_adc_blur_mid[ch].n = 0; + ts_adc_blur_mid[ch].max = R.p.adc_blur_mid; + ts_adc_blur_mid[ch].ch = D_ADCCH_1 + ch; +#endif + + //通道均值滤波任务初始化 + L1_task_init(&ts_adc_blur_avg[ch].task); + L3_task_s_go(ts_adc_blur_avg[ch],D_task_init); + ts_adc_blur_avg[ch].max = R.p.adc_blur_avg; + ts_adc_blur_avg[ch].avgval = 0; + ts_adc_blur_avg[ch].n = 0; + ts_adc_blur_avg[ch].ch = D_ADCCH_1 + ch; + + //通道移位滤波任务初始化 + L1_task_init(&ts_adc_blur_shift[ch].task); + L3_task_s_go(ts_adc_blur_shift[ch],D_task_init); + ts_adc_blur_shift[ch].n = 0; + ts_adc_blur_shift[ch].h = 0; + ts_adc_blur_shift[ch].shiftreg[0] = R.p.adc_blur_shift[0]; + ts_adc_blur_shift[ch].shiftreg[1] = R.p.adc_blur_shift[1]; + ts_adc_blur_shift[ch].shiftreg[2] = R.p.adc_blur_shift[2]; + ts_adc_blur_shift[ch].sum[0] = 0; + ts_adc_blur_shift[ch].sum[1] = 0; + ts_adc_blur_shift[ch].sum[2] = 0; + ts_adc_blur_shift[ch].shiftval[0] = 0; + ts_adc_blur_shift[ch].shiftval[1] = 0; + ts_adc_blur_shift[ch].shiftval[2] = 0; + ts_adc_blur_shift[ch].ch = D_ADCCH_1 + ch; + + //输出判定任务初始化 + L1_task_init(&ts_adc_blur_out[ch].task); + L3_task_s_go(ts_adc_blur_out[ch],D_task_init); +// ts_adc_blur_out[ch].h= 0; +// ts_adc_blur_out[ch].threshold[0] = D_COUNT_ADC(R.p.adc_blur_threshold[0]); //2KG +// ts_adc_blur_out[ch].threshold[1] = D_COUNT_ADC(R.p.adc_blur_threshold[1]); //0.5KG +// ts_adc_blur_out[ch].newnum = 0; +// ts_adc_blur_out[ch].oldnum = 0; +// ts_adc_blur_out[ch].newout = 0; +// ts_adc_blur_out[ch].n = 0; +// ts_adc_blur_out[ch].ch = D_ADCCH_1 + ch; + +#if 0 + //通道切换任务初始化 + //L1_task_init(&ts_adc_channel_switch.task); + L3_task_s_go(ts_adc_channel_switch,D_task_init); +#endif + +} + + +void L3_task_show_init(void) +{ + //显示任务初始化 + L1_task_init(&ts_adc_blur_show.task); + L3_task_s_go(ts_adc_blur_show,D_task_init); + ts_adc_blur_show.rough_weight = 0; +} + + +//ADC Channel 采样任务 +#define D_task_ADC_CHx_SAMPLE_WAIT_LOW 0x53 +#define D_task_ADC_CHx_SAMPLE_READ 0x54 +#define D_task_ADC_CHx_SAMPLE_OUT 0x55 +void L3_task_adc_channel_sample(S_TASK_ADC_CHANNEL_SAMPLE *s) +{ + TTSS_Task_init() + L2_task_go(D_task_ADC_CHx_SAMPLE_WAIT_LOW); + + TTSS_Task_step(D_task_ADC_CHx_SAMPLE_WAIT_LOW) + if(s->status == ADC_CHANNEL_STATUS_READY) //需要判断status是否ready，ready则读取，否则使用pool值 + { + if(0 == L0_2dc_DOUT_AT(s->ch)) + { + L2_task_go(D_task_ADC_CHx_SAMPLE_READ); + } + } + else + { + s->adcval = s->pool; + L2_task_go_Tdelay(D_task_ADC_CHx_SAMPLE_OUT,D_Tdelay_Msec(15)); //延时15ms，模拟一次采样过程 + } + + TTSS_Task_step(D_task_ADC_CHx_SAMPLE_READ) + if(s->status == ADC_CHANNEL_STATUS_READY) //需要重新判断status是否ready，因为channel_switch任务随时可能修改status状态 + { + s->adcval = Abs(L0_ADS1231_readCH(s->ch)); + L2_task_go(D_task_ADC_CHx_SAMPLE_OUT); + } + else + { + L2_task_go(D_task_ADC_CHx_SAMPLE_WAIT_LOW); + } + + TTSS_Task_step(D_task_ADC_CHx_SAMPLE_OUT) + //不判断ready,不管是采集到的真实数据还是pool数据，都继续执行 + s->pool = s->adcval; + s->out[s->n] = s->adcval; + //R.adval[s->ch] = s->out[s->n]; + //L0_uart0_ulhex(R.adval[s->ch]);L0_uart0_0d0a(); + s->n++; + #if 0 + L0_uart0_ulhex(s->out[count_n(s->n,1)]); + L0_uart0_uc(' '); + //L0_uart0_ulhex(ts_adc_blur_mid[s->ch].out[count_n(ts_adc_blur_mid[s->ch].n,1)]); + //L0_uart0_uc(' '); + L0_uart0_ulhex(ts_adc_blur_avg[s->ch].out[count_n(ts_adc_blur_avg[s->ch].n,1)]); + L0_uart0_uc(' '); + L0_uart0_ulhex(ts_adc_blur_shift[s->ch].shiftval[0]); + L0_uart0_uc(' '); + L0_uart0_ulhex(ts_adc_blur_shift[s->ch].shiftval[1]); + L0_uart0_uc(' '); + L0_uart0_ulhex(ts_adc_blur_shift[s->ch].shiftval[2]); + L0_uart0_uc(' '); + L0_uart0_ulhex(R.adval[s->ch]); + L0_uart0_uc(' '); + L0_uart0_ulhex(ts_adc_blur_out[s->ch].oldnum); + L0_uart0_0d0a(); + #endif + + if(s->n >= MAX_OUT_NUM) + { + s->n = 0; + } + L2_task_go(D_task_ADC_CHx_SAMPLE_WAIT_LOW); + + TTSS_Task_end(); +} + +#if 0 +//中值滤波任务 +#define D_task_ADC_CHx_FILTER_MID_GET 0x50 +#define D_task_ADC_CHx_FILTER_MID_COUNT 0x51 +#define D_task_ADC_CHx_FILTER_MID_OUT 0x52 +void L3_task_adc_filter_mid(S_TASK_ADC_BLUR_MID *s) +{ + TTSS_Task_init() + L2_task_go(D_task_ADC_CHx_FILTER_MID_GET); + + TTSS_Task_step(D_task_ADC_CHx_FILTER_MID_GET) + if(ts_adc_channel_samples[s->ch].n >= s->max) + { + U8 i = 0; + for(i=0;imax;i++) + { + s->in[i] = ts_adc_channel_samples[s->ch].out[i]; + } + ts_adc_channel_samples[s->ch].n = 0; + L2_task_go(D_task_ADC_CHx_FILTER_MID_COUNT); + } + + TTSS_Task_step(D_task_ADC_CHx_FILTER_MID_COUNT) + s->midval = Lc_vS32_media(s->in, s->max); + L2_task_go(D_task_ADC_CHx_FILTER_MID_OUT); + + TTSS_Task_step(D_task_ADC_CHx_FILTER_MID_OUT) + s->out[s->n] = s->midval; + //R.adval[s->ch] = s->out[s->n]; + s->n++; + if(s->n >= MAX_OUT_NUM) + { + s->n = 0; + } + L2_task_go(D_task_ADC_CHx_FILTER_MID_GET); + + TTSS_Task_end(); +} +#endif + + +//均值滤波任务 +#define D_task_ADC_CHx_FILTER_AVG_GET 0x50 +#define D_task_ADC_CHx_FILTER_AVG_COUNT 0x51 +#define D_task_ADC_CHx_FILTER_AVG_OUT 0x52 +void L3_task_adc_filter_avg(S_TASK_ADC_BLUR_AVG *s) +{ + TTSS_Task_init() + L2_task_go(D_task_ADC_CHx_FILTER_AVG_GET); + + TTSS_Task_step(D_task_ADC_CHx_FILTER_AVG_GET) + if(ts_adc_channel_samples[s->ch].n >= s->max) + { + U8 i = 0; + ts_adc_channel_samples[s->ch].n = 0; + for(i=0;imax;i++) + { + s->in[i] = ts_adc_channel_samples[s->ch].out[i]; + } + L2_task_go(D_task_ADC_CHx_FILTER_AVG_COUNT); + } + + TTSS_Task_step(D_task_ADC_CHx_FILTER_AVG_COUNT) + s->avgval = Lc_vU32_avg(s->in,s->max); + L2_task_go(D_task_ADC_CHx_FILTER_AVG_OUT); + + TTSS_Task_step(D_task_ADC_CHx_FILTER_AVG_OUT) + s->out[s->n] = s->avgval; + //R.adval[s->ch] = s->out[s->n]; + s->n++; + if(s->n >= MAX_OUT_NUM) + { + s->n = 0; + } + L2_task_go(D_task_ADC_CHx_FILTER_AVG_GET); + + TTSS_Task_end(); + + +} + + +//移位滤波任务 +#define D_task_ADC_CHx_FILTER_SHIFT_GET 0x50 +#define D_task_ADC_CHx_FILTER_SHIFT_COUNT 0x51 +#define D_task_ADC_CHx_FILTER_SHIFT_OUT 0x52 +void L3_task_adc_filter_shift(S_TASK_ADC_BLUR_SHIFT *s) +{ + TTSS_Task_init() + L2_task_go(D_task_ADC_CHx_FILTER_SHIFT_GET); + + TTSS_Task_step(D_task_ADC_CHx_FILTER_SHIFT_GET) + if(s->h != ts_adc_blur_avg[s->ch].n) + { + s->in = ts_adc_blur_avg[s->ch].out[count_n(ts_adc_blur_avg[s->ch].n,1)]; + s->h = ts_adc_blur_avg[s->ch].n; + L2_task_go(D_task_ADC_CHx_FILTER_SHIFT_COUNT); + } + + TTSS_Task_step(D_task_ADC_CHx_FILTER_SHIFT_COUNT) + s->sum[0] -= s->shiftval[0]; + s->sum[0] += s->in; + s->shiftval[0] = s->sum[0] >> s->shiftreg[0]; + s->sum[1] -= s->shiftval[1]; + s->sum[1] += s->in; + s->shiftval[1] = s->sum[1] >> s->shiftreg[1]; + s->sum[2] -= s->shiftval[2]; + s->sum[2] += s->in; + s->shiftval[2] = s->sum[2] >> s->shiftreg[2]; + L2_task_go(D_task_ADC_CHx_FILTER_SHIFT_OUT); + + TTSS_Task_step(D_task_ADC_CHx_FILTER_SHIFT_OUT) + s->out[0][s->n] = s->shiftval[0]; + s->out[1][s->n] = s->shiftval[1]; + s->out[2][s->n] = s->shiftval[2]; + + + //R.adval[s->ch] = s->out[0][s->n] = s->shiftval[0]; + s->n++; + if(s->n >= MAX_OUT_NUM) + { + s->n = 0; + } + L2_task_go(D_task_ADC_CHx_FILTER_SHIFT_GET); + + TTSS_Task_end(); + +} + +//输出判定任务 +#define D_task_ADC_CHx_FILTER_OUT_GET 0x50 +#define D_task_ADC_CHx_FILTER_OUT_COUNT 0x51 +#define D_task_ADC_CHx_FILTER_OUT_CHANGE 0x52 +#define D_task_ADC_CHx_FILTER_OUT_OUT 0x53 +void L3_task_adc_filter_out(S_TASK_ADC_BLUR_OUT *s) +{ + TTSS_Task_init() + L2_task_go(D_task_ADC_CHx_FILTER_OUT_GET); + + TTSS_Task_step(D_task_ADC_CHx_FILTER_OUT_GET) + if(s->h != ts_adc_blur_shift[s->ch].n) + { + s->h = ts_adc_blur_shift[s->ch].n; + s->in[0] = ts_adc_blur_avg[s->ch].out[count_n(ts_adc_blur_avg[s->ch].n, 1)]; + s->in[1] = ts_adc_blur_avg[s->ch].out[count_n(ts_adc_blur_avg[s->ch].n, 2)]; + //获取输出曲线val + s->newout = ts_adc_blur_shift[s->ch].out[s->oldnum][count_n(ts_adc_blur_shift[s->ch].n, 1)]; + L2_task_go(D_task_ADC_CHx_FILTER_OUT_COUNT); + } + + TTSS_Task_step(D_task_ADC_CHx_FILTER_OUT_COUNT) //根据阀值选择输出的曲线 + //判断选择新曲线 + if(Lc_abs(s->in[0] , s->in[1]) >= s->threshold[0])//2KG + { + s->newnum = 0; + } + else if(Lc_abs(s->in[0] , s->in[1]) >= s->threshold[1]) //0.5KG + { + s->newnum = 1; + } + else + { + s->newnum = 2; + } + //L2_task_go(D_task_ADC_CHx_FILTER_OUT_OUT); + L2_task_go(D_task_ADC_CHx_FILTER_OUT_CHANGE); + + TTSS_Task_step(D_task_ADC_CHx_FILTER_OUT_CHANGE) + if(s->newnum != s->oldnum)//切换移位滤波时调整其他滤波的SUM + { + s->oldnum = s->newnum; //不能只调整新值，所有曲线都要一起调整 + //ts_adc_blur_shift[s->ch].sum[1] = (ts_adc_blur_avg[s->ch].out[ts_adc_blur_avg[s->ch].n] * R.adc_blur_avg); + ts_adc_blur_shift[s->ch].sum[0] = s->newout << ts_adc_blur_shift[s->ch].shiftreg[0]; + ts_adc_blur_shift[s->ch].shiftval[0] = s->newout; + ts_adc_blur_shift[s->ch].sum[1] = s->newout << ts_adc_blur_shift[s->ch].shiftreg[1]; + ts_adc_blur_shift[s->ch].shiftval[1] = s->newout; + ts_adc_blur_shift[s->ch].sum[2] = s->newout << ts_adc_blur_shift[s->ch].shiftreg[2]; + ts_adc_blur_shift[s->ch].shiftval[2] = s->newout; + } + L2_task_go(D_task_ADC_CHx_FILTER_OUT_OUT); + + TTSS_Task_step(D_task_ADC_CHx_FILTER_OUT_OUT) + R.adval[s->ch] = s->newout; + //R.adval[s->ch] = ts_adc_channel_samples[s->ch].adcval; + L2_task_go(D_task_ADC_CHx_FILTER_OUT_GET); + + TTSS_Task_end(); + +} + + +//显示任务 +//#define D_task_ADC_CHx_SHOW 0x50 +//void L3_task_adc_filter_show(S_TASK_ADC_BLUR_SHOW *s) +//{ +// TTSS_Task_init() +// L2_task_go(D_task_ADC_CHx_SHOW); + +// TTSS_Task_step(D_task_ADC_CHx_SHOW) +// R.ch_weight[0] = D_COUNT_WEIGHT(R.adval[0]); +// R.ch_weight[1] = D_COUNT_WEIGHT(R.adval[1]); +// R.ch_weight[2] = D_COUNT_WEIGHT(R.adval[2]); +// R.ch_weight[3] = D_COUNT_WEIGHT(R.adval[3]); +// s->rough_weight = R.ch_weight[0] + R.ch_weight[1] + R.ch_weight[2] + R.ch_weight[3]; //毛重 +// if( ABS(R.rough_weight,s->rough_weight) >= 50) //变化超过0.05KG +// { +// R.rough_weight = s->rough_weight; +//// R.total_weight = (R.rough_weight > R.total_zweight) ? (R.rough_weight - R.total_zweight) : (0);//净重 +// } +// L2_task_go_Tdelay(D_task_ADC_CHx_SHOW,D_Tdelay_Msec(15)); //延时15ms +// +// TTSS_Task_end(); +//} + +void L3_task_adc_handler(u8 ch) +{ + L3_task_adc_channel_sample(&ts_adc_channel_samples[ch]); + //L3_task_adc_filter_mid(&ts_adc_blur_mid[ch]); + L3_task_adc_filter_avg(&ts_adc_blur_avg[ch]); + L3_task_adc_filter_shift(&ts_adc_blur_shift[ch]); + L3_task_adc_filter_out(&ts_adc_blur_out[ch]); +} + + + diff --git a/source/app/task_adc.h b/source/app/task_adc.h new file mode 100644 index 0000000..327b972 --- /dev/null +++ b/source/app/task_adc.h @@ -0,0 +1,119 @@ +//////////////////////////////////////////////////////////////////////////// +///@copyright Copyright (c) 2018, 传控科技 All rights reserved. +///------------------------------------------------------------------------- +/// @file bsp_drv.h +/// @brief bsp @ driver config +///------------------------------------------------------------------------- +/// @version 1.0 +/// @author CC +/// @date 20180331 +/// @note cc_AS_stc02 + +////////////////////////////////////////////////////////////////////////////// + +#ifndef _APP_TASK_ADC_H +#define _APP_TASK_ADC_H + +#include "../app/app_config.h" +#include "../ctask/task.h" +#include "../clib/clib.h" + + +#define ADC_CHANNEL_STATUS_UNREADY 0 //UnReady状态，不能读取 +#define ADC_CHANNEL_STATUS_READY 1 //ready状态，可以读取 + +//AD_CHANNEL_SAMPLE 采样 +#define MAX_OUT_NUM 6 +typedef struct _s_task_adc_channel_sample +{ + TS_task task; + vU8 status; + vU8 ch; + vU32 adcval; + vU32 pool; + vU8 n; + vU32 out[MAX_OUT_NUM]; +}S_TASK_ADC_CHANNEL_SAMPLE; + +//AD_BLUR_MID 中值滤波 +typedef struct _s_task_adc_blur_mid + +{ + TS_task task; + vU8 ch; + vU8 max; + vU32 in[MAX_OUT_NUM]; + vU32 midval; + vU8 n; + vU32 out[MAX_OUT_NUM]; +}S_TASK_ADC_BLUR_MID; + +//AD_BLUR_AVG 均值滤波 +typedef struct _s_task_adc_blur_avg +{ + TS_task task; + vU8 ch; + vU8 max; + vU32 in[MAX_OUT_NUM]; + vU32 avgval; + vU8 n; + vU32 out[MAX_OUT_NUM]; +}S_TASK_ADC_BLUR_AVG; + +//AD_BLUR_SHIFT 移位滤波 +typedef struct _s_task_adc_blur_shift +{ + TS_task task; + vU8 ch; + vU8 n; + vU8 h; + vU8 shiftreg[3]; + //vU8 max; + vU32 in; + vU32 sum[3]; + vU32 shiftval[3]; + vU32 out[3][MAX_OUT_NUM]; +}S_TASK_ADC_BLUR_SHIFT; + +//AD_BLUR_DECIDE 输出判定 +typedef struct _s_task_adc_blur_out +{ + TS_task task; + vU8 ch; + vU32 in[2]; + U32 threshold[2]; + vU8 h; + vU8 oldnum; + vU8 newnum; + vU32 newout; + vU8 n; +}S_TASK_ADC_BLUR_OUT; + +//AD_BLUR_SHOW 显示 +typedef struct _s_task_adc_blur_show +{ + TS_task task; + vU32 rough_weight; +}S_TASK_ADC_BLUR_SHOW; + + +extern S_TASK_ADC_CHANNEL_SAMPLE ts_adc_channel_samples[D_ADC_CHANNEL_NUM]; +//extern S_TASK_ADC_BLUR_MID ts_adc_blur_mid[D_ADC_CHANNEL_NUM]; +extern S_TASK_ADC_BLUR_AVG ts_adc_blur_avg[D_ADC_CHANNEL_NUM]; +extern S_TASK_ADC_BLUR_SHIFT ts_adc_blur_shift[D_ADC_CHANNEL_NUM]; +extern S_TASK_ADC_BLUR_OUT ts_adc_blur_out[D_ADC_CHANNEL_NUM]; +extern S_TASK_ADC_BLUR_SHOW ts_adc_blur_show; + + +extern void L3_task_adc_init(U8 ch); +extern void L3_task_show_init(void); +extern void L3_task_adc_handler(U8 ch); +extern void L3_task_adc_init_handler(void); +extern void L3_task_adc_channel_switch_handler(void); +extern void L3_task_adc_filter_show(S_TASK_ADC_BLUR_SHOW *s); + + + + +#endif // #ifndef _APP_TASK_ADC_H + diff --git a/source/app/task_debug.c b/source/app/task_debug.c new file mode 100644 index 0000000..fa2a8e3 --- /dev/null +++ b/source/app/task_debug.c @@ -0,0 +1,51 @@ +//////////////////////////////////////////////////////////////////////////// +///@copyright Copyright (c) 2018, 传控科技 All rights reserved. +///------------------------------------------------------------------------- +/// @file bsp_drv.c +/// @brief bsp @ driver config +///------------------------------------------------------------------------- +/// @version 1.0 +/// @author CC +/// @date 20180331 +/// @note cc_AS_stc02 +////////////////////////////////////////////////////////////////////////////// + +#include "task_debug.h" +#include "../app/app_config.h" +#include "../bsp/bsp_config.h" +#include "../msp/uart0.h" + +S_TASK_DEBUG _s_task_debug; + +//============================================= +void L3_task_debug_init(void) +{ + L1_task_init(&_s_task_debug.task); + L3_task_s_go(_s_task_debug,D_task_init); +} + +#define D_task_ADC_CHx_DEBUG 0x53 +void L3_task_debug(S_TASK_DEBUG *s) +{ + TTSS_Task_init() + L2_task_go(D_task_ADC_CHx_DEBUG); + + TTSS_Task_step(D_task_ADC_CHx_DEBUG) + /* L0_uart0_ulhex(R.adval[0]); + L0_uart0_uc(' '); + L0_uart0_ulhex(R.adval[1]); + L0_uart0_uc(' '); + L0_uart0_ulhex(R.adval[2]); + L0_uart0_uc(' '); + L0_uart0_ulhex(R.adval[3]); + L0_uart0_uc(' ');*/ +// L0_uart0_ulhex(R.total_weight); + L0_uart0_0d0a(); + L2_task_go_Tdelay(D_task_ADC_CHx_DEBUG,D_Tdelay_Msec(15)); //延时15ms + + TTSS_Task_end(); +} + + + + diff --git a/source/app/task_debug.h b/source/app/task_debug.h new file mode 100644 index 0000000..7e96363 --- /dev/null +++ b/source/app/task_debug.h @@ -0,0 +1,32 @@ +//////////////////////////////////////////////////////////////////////////// +///@copyright Copyright (c) 2018, 传控科技 All rights reserved. +///------------------------------------------------------------------------- +/// @file bsp_drv.h +/// @brief bsp @ driver config +///------------------------------------------------------------------------- +/// @version 1.0 +/// @author CC +/// @date 20180331 +/// @note cc_AS_stc02 + +////////////////////////////////////////////////////////////////////////////// + +#ifndef _APP_TASK_DEBUG_H +#define _APP_TASK_DEBUG_H + +#include "../ctask/task.h" +#include "../clib/clib.h" + +typedef struct _s_task_debug +{ + TS_task task; +}S_TASK_DEBUG; + +extern S_TASK_DEBUG _s_task_debug; + +extern void L3_task_debug_init(void); +extern void L3_task_debug(S_TASK_DEBUG *s); + + +#endif // #ifndef _APP_TASK_ADC_H + diff --git a/source/app/task_encrypt.c b/source/app/task_encrypt.c new file mode 100644 index 0000000..c7218ac --- /dev/null +++ b/source/app/task_encrypt.c @@ -0,0 +1,78 @@ +//////////////////////////////////////////////////////////////////////////// +///@copyright Copyright (c) 2018, 传控科技 All rights reserved. +///------------------------------------------------------------------------- +/// @file bsp_drv.c +/// @brief bsp @ driver config +///------------------------------------------------------------------------- +/// @version 1.0 +/// @author CC +/// @date 20180331 +/// @note cc_AS_stc02 +////////////////////////////////////////////////////////////////////////////// + +#include "task_encrypt.h" +#include "../bsp/bsp_config.h" +#include "../msp/uart0.h" +#include "../msp/eeprom.h" +#include "../bsp/chipid.h" + +struct ts_eeprom_enc eep_enc; +struct mcu_encrypt_info enc_info; + +/** + * + * @brief: eeprom的D_EEP_ENC_IN_SECTOR、D_EEP_ENC_IN_BLOCK中提前存放了加密信息: enc_key, enc_val(enc_key+chipid计算所得) + * @param: void + * @return: 1 is ok , 0 is failed + * + */ +int L3_mcu_id_ok(void) +{ + U8 i = 0; + + //1. 获取eeprom中存储的enc信息 + if(L1_eep_read_block(D_EEP_ENC_IN_SECTOR, D_EEP_ENC_IN_BLOCK, D_EEP_SECTOR_BLOCK_SIZE, (U8*)&eep_enc,NULL) == 1) + { + //L0_uart0_sendstr("e2p read enc failed"); + return 0; + } + //L0_uart0_sendstr("e2p read enc success"); + + //2.获取MCU_ID + L0_id_get_rom(enc_info.mcu_id); + //L0_uart0_sendArray(enc_info.mcu_id,MCU_ID_LEN); + + //3.根据mcu_id和enc_key计算enc_val + //enc_key = ((U32)eep_enc.enc_key[0] << 24) | (eep_enc.enc_key[1] << 16) | (eep_enc.enc_key[2] << 8) |(eep_enc.enc_key[3] << 0); + Lc_encrypt_id1((U8*)enc_info.mcu_enc_id, (U8*)enc_info.mcu_id, eep_enc.enc_key, MCU_ID_LEN); + +#if 1 + //4.判断enc_val是否一致 + for(i=0;i>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>Encryption CONFIG +#define MCU_ID_LEN 7 +#define MCU_ID_KEY_LEN 4 +#define EEPROM_ENC_DATA_MAX 64 +#define EEPROM_ENC_FILTER 0xAA +typedef struct ts_eeprom_enc +{ + U8 enc_key[MCU_ID_KEY_LEN]; + U8 enc_val[MCU_ID_LEN]; + //U8 crc[2]; +}EEPROM_ENC; + +typedef struct mcu_encrypt_info +{ + U8 enc_key[MCU_ID_KEY_LEN]; + U8 mcu_id[MCU_ID_LEN]; + U8 mcu_enc_id[MCU_ID_LEN]; +}McuEncryptInfo; + +extern struct ts_eeprom_enc eep_enc; +extern struct mcu_encrypt_info enc_info; +//STEP 2 <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<slaver = slaverId; + pmodbus->oper = MODBUS_OPER_READ; + pmodbus->buf[0] = reg >> 8 & 0xFF; + pmodbus->buf[1] = reg >> 0 & 0xFF; + pmodbus->buf[2] = num >> 8 * 0xFF; + pmodbus->buf[3] = num >> 0 & 0xFF; + crc16(pmodbus->crc,&pmodbus->slaver,2 + bufsize); + pmodbus->buf[bufsize] = pmodbus->crc[0]; + pmodbus->buf[bufsize + 1] = pmodbus->crc[1]; + + return bufsize + 2 + 2; +} + +U8 L3_pack_modbus_06(TS_PH4_modbus *pmodbus ,U8 slaverId, U16 reg, U8 *buf) +{ + U8 bufsize = 4; + pmodbus->slaver = slaverId; + pmodbus->oper = MODBUS_OPER_WRITE; + pmodbus->buf[0] = reg >> 8 & 0xFF; + pmodbus->buf[1] = reg >> 0 & 0xFF; + pmodbus->buf[2] = buf[0]; + pmodbus->buf[3] = buf[1]; + crc16(pmodbus->crc,&pmodbus->slaver,2 + bufsize); + pmodbus->buf[bufsize] = pmodbus->crc[0]; + pmodbus->buf[bufsize + 1] = pmodbus->crc[1]; + + return bufsize + 2 + 2; +} + +U8 L3_pack_modbus_10(TS_PH4_modbus *pmodbus ,U8 slaverId, U16 reg, U16 num, U8 bytes, U8 *buf) +{ + U8 bufsize = 5,i = 0; + pmodbus->slaver = slaverId; + pmodbus->oper = MODBUS_OPER_WRITE_M; + pmodbus->buf[0] = reg >> 8 & 0xFF; + pmodbus->buf[1] = reg >> 0 & 0xFF; + pmodbus->buf[2] = num >> 8 * 0xFF; + pmodbus->buf[3] = num >> 0 & 0xFF; + pmodbus->buf[4] = bytes; + + for(i=0;ibuf[5+i] = buf[i]; + } + crc16(pmodbus->crc,&pmodbus->slaver,2 + bufsize + bytes); + pmodbus->buf[bufsize + bytes] = pmodbus->crc[0]; + pmodbus->buf[bufsize + bytes + 1] = pmodbus->crc[1]; + + return bufsize + bytes + 2 + 2; +} + +U8 L3_pack_modbus(TS_PH4_modbus *pmodbus, MD_SLAVER_INFO *slaver_info) +{ + switch(slaver_info->oper) + { + case MODBUS_OPER_READ: + return L3_pack_modbus_03(pmodbus,slaver_info->slaver,slaver_info->reg,slaver_info->regnum); + case MODBUS_OPER_WRITE: + return L3_pack_modbus_06(pmodbus,slaver_info->slaver,slaver_info->reg,slaver_info->buf); + case MODBUS_OPER_WRITE_M: + return L3_pack_modbus_10(pmodbus,slaver_info->slaver,slaver_info->reg,slaver_info->regnum,slaver_info->bytes,slaver_info->buf); + default: + return 0; + } +} + +U8 L3_pack_modbusack(TS_PH4_modbus *pmodbus ,U8 slaver, U8 oper, U8 bufsize) +{ + pmodbus->slaver = slaver; + pmodbus->oper = oper; + crc16(pmodbus->crc,&pmodbus->slaver,2 + bufsize); + pmodbus->buf[bufsize] = pmodbus->crc[0]; + pmodbus->buf[bufsize + 1] = pmodbus->crc[1]; + + return bufsize + 2 + 2; +} + +//MODBUS从设备数据处理函数 +static Modbus03Ack *pModbus03Ack; +static Modbus06Ack *pModbus06Ack; +static Modbus10Ack *pModbus10Ack; +static U16 modbuslen = 0,reg,num,val,count; +U16 L3_modbus_slaver_ack(TS_PH4_modbus *pmodbus,TS_PH4_modbus *pModbusAck) +{ + switch(pmodbus->oper) + { + case MODBUS_OPER_READ: + case MODBUS_OPER_READCONFIG: + { + U16 i = 0,j = 0,regval = 0; + pModbus03Ack = (Modbus03Ack *)pModbusAck->buf; + reg = ((U16)pmodbus->buf[0]) << 8 | ((U16)pmodbus->buf[1]); + num = ((U16)pmodbus->buf[2]) << 8 | ((U16)pmodbus->buf[3]); + if((num <= D_MODBUS_REG_MAX_NUM) && (reg <= sizeof(R)/2)) //每次最多读取D_MODBUS_REG_MAX_NUM个寄存器.防止越界 + { + for(i=0; ibuf[j++] = regval >> 8 & 0xFF; + pModbus03Ack->buf[j++] = regval & 0xFF; + } + pModbus03Ack->bytes = num * 2; + modbuslen = L3_pack_modbusack(pModbusAck, pmodbus->slaver, pmodbus->oper, pModbus03Ack->bytes + 1); + } + break; + } +#if 0 + case MODBUS_OPER_WRITE: + { + pModbus06Ack = (Modbus06Ack *)pModbusAck->buf; + reg = ((U16)pmodbus->buf[0]) << 8 | ((U16)pmodbus->buf[1]); + val = ((U16)pmodbus->buf[2]) << 8 | ((U16)pmodbus->buf[3]); + if(reg <= sizeof(R)/2) + { + *(REG_2_MEM(reg)) = val; + pModbus06Ack->reg = reg; + pModbus06Ack->val = *(REG_2_MEM(reg)); + modbuslen = L3_pack_modbusack(pModbusAck, pmodbus->slaver, pmodbus->oper, 4); + } + break; + } +#endif + case MODBUS_OPER_WRITE_M: + { + U16 i = 0; + pModbus10Ack = (Modbus10Ack *)pModbusAck->buf; + reg = ((U16)pmodbus->buf[0]) << 8 | ((U16)pmodbus->buf[1]); + num = ((U16)pmodbus->buf[2]) << 8 | ((U16)pmodbus->buf[3]); + count = pmodbus->buf[4]; + if((num <= D_MODBUS_REG_MAX_NUM) && (reg < sizeof(R)/2)) //每次最多写入20个寄存器 40个字节，以防止越界 + { + for(i=0; ibuf[5+i*2]) << 8 | ((U16)pmodbus->buf[5+i*2+1]); + } + pModbus10Ack->reg = reg; + pModbus10Ack->num = num; + modbuslen = L3_pack_modbusack(pModbusAck, pmodbus->slaver, pmodbus->oper, 4); + } + break; + } + default:break; + } + return modbuslen; +} + +//MODBUS主设备轮询时，从设备返回数据处理函数 +//MD_SLAVER_INFO需要被正确定义 +void L3_modbus_master_handler(TS_PH4_modbus *pmodbus,MD_SLAVER_INFO *p_slaver_info) +{ + switch(pmodbus->oper) + { + case MODBUS_OPER_READ: + case MODBUS_OPER_READCONFIG: + { + U8 i = 0; + for(i=0;ibuf[0];i++) + { + //此处假设字节序一致 + p_slaver_info->buf[i] = pmodbus->buf[i + 1]; + //TODO 字节序不一致时的处理 + } + break; + } + case MODBUS_OPER_WRITE: + case MODBUS_OPER_WRITE_M: + default: break; + } +} + + +void L3_task_modbus_handler(TP_Handler_X *ph4) +{ + if(ph4->ok) + { + TS_PH4_modbus *ts_modbus = (TS_PH4_modbus *)ph4->buf; + //LED0 ^= 1; + ph4->ok = 0; + if(ts_modbus->slaver == R.p.slaver_id || ts_modbus->slaver == D_UART0_485_SLAVER_ID_BROADCAST) //从机 + { + U16 acklen = L3_modbus_slaver_ack(ts_modbus,&s_uart0_ack); + L0_uart0_sendArray((U8*)&s_uart0_ack, acklen); + } + else + { + //LED0 ^= 1; + L0_uart2_sendArray(s_uart0_rec.buf, s_uart0_rec.num); + } + } + if(ph4->yes) + { + ph4->yes=0; + L0_uart2_sendArray(s_uart0_rec.buf, s_uart0_rec.num); + } + +} +void L3_task_modbus_handler2(TP_Handler_X *ph4) +{ + if(s_uart2_rec.ok) + { + TS_PH4_modbus *ts_modbus = (TS_PH4_modbus *)ph4->buf; + //LED0 ^= 1; + s_uart2_rec.ok=0; + L0_uart0_sendArray(s_uart2_rec.buf, s_uart2_rec.num); + } + if(s_uart2_rec.yes) + { + s_uart2_rec.yes=0; + L0_uart0_sendArray(s_uart2_rec.buf, s_uart2_rec.num); + } + +} + + + + + + diff --git a/source/app/task_modbus.h b/source/app/task_modbus.h new file mode 100644 index 0000000..6d5bd52 --- /dev/null +++ b/source/app/task_modbus.h @@ -0,0 +1,9 @@ +#ifndef APP_TASK_UART0_H +#define APP_TASK_UART0_H + +#include "../ctask/task.h" +#include "../tpc/modbus.h" + +extern void L3_task_modbus_handler(TP_Handler_X *ph4); +extern void L3_task_modbus_handler2(TP_Handler_X *ph4); +#endif diff --git a/source/app/task_register.c b/source/app/task_register.c new file mode 100644 index 0000000..799f3ec --- /dev/null +++ b/source/app/task_register.c @@ -0,0 +1,63 @@ +//////////////////////////////////////////////////////////////////////////// +///@copyright Copyright (c) 2018, 传控科技 All rights reserved. +///------------------------------------------------------------------------- +/// @file bsp_drv.c +/// @brief bsp @ driver config +///------------------------------------------------------------------------- +/// @version 1.0 +/// @author CC +/// @date 20180331 +/// @note cc_AS_stc02 +////////////////////////////////////////////////////////////////////////////// + +#include "task_register.h" +#include "../app/app_config.h" +#include "../bsp/bsp_config.h" +#include "../msp/uart0.h" + +//============================================= + +S_TASK_REGVAL_LISTEN s_task_reglisten; + +void L3_task_reglisten_init(void) +{ + L1_task_init(&s_task_reglisten.task); + L3_task_s_go(s_task_reglisten,D_task_init); +} + +//配置模式任务 +#define D_task_WEIGHT_COUNT 0x50 +#define D_task_IAP 0x51 +void L3_task_reglisten_handle(S_TASK_REGVAL_LISTEN *s) +{ + + TTSS_Task_init() + L2_task_go(D_task_WEIGHT_COUNT); + + TTSS_Task_step(D_task_WEIGHT_COUNT) + if(R.zero != 0) + { + R.total_zweight = R.rough_weight; //皮重 = 毛重 + R.total_weight = (R.rough_weight > R.total_zweight) ? (R.rough_weight - R.total_zweight) : (0);//净重 + R.zero = 0; + } + L2_task_go(D_task_IAP); //延时100ms + + + TTSS_Task_step(D_task_IAP) + if(R.status_eep_save != 0) + { + R.status_eep_save = 0; + L3_reg_2_iap();//写入IAP + } + L2_task_go_Tdelay(D_task_WEIGHT_COUNT,D_Tdelay_Msec(100)); //延时100ms + + + TTSS_Task_end(); + +} + + + + + diff --git a/source/app/task_register.h b/source/app/task_register.h new file mode 100644 index 0000000..d675a43 --- /dev/null +++ b/source/app/task_register.h @@ -0,0 +1,32 @@ +//////////////////////////////////////////////////////////////////////////// +///@copyright Copyright (c) 2018, 传控科技 All rights reserved. +///------------------------------------------------------------------------- +/// @file bsp_drv.h +/// @brief bsp @ driver config +///------------------------------------------------------------------------- +/// @version 1.0 +/// @author CC +/// @date 20180331 +/// @note cc_AS_stc02 + +////////////////////////////////////////////////////////////////////////////// + +#ifndef _APP_TASK_REG_H +#define _APP_TASK_REG_H + +#include "../ctask/task.h" +#include "../clib/clib.h" + +typedef struct _s_task_reglisten +{ + TS_task task; +}S_TASK_REGVAL_LISTEN; + +extern S_TASK_REGVAL_LISTEN s_task_reglisten; + +extern void L3_task_reglisten_init(void); +extern void L3_task_reglisten_handle(S_TASK_REGVAL_LISTEN *s); + + +#endif // #ifndef _APP_TASK_ADC_H + diff --git a/source/bsp/868.c b/source/bsp/868.c new file mode 100644 index 0000000..139597f --- /dev/null +++ b/source/bsp/868.c @@ -0,0 +1,2 @@ + + diff --git a/source/bsp/868.h b/source/bsp/868.h new file mode 100644 index 0000000..e69de29 diff --git a/source/bsp/bsp_config.c b/source/bsp/bsp_config.c new file mode 100644 index 0000000..80b1a06 --- /dev/null +++ b/source/bsp/bsp_config.c @@ -0,0 +1,84 @@ +#include "bsp_config.h" +#include "../msp/UART0.h" +#include "../msp/eeprom.h" + +//////////////////////////////////////////////////////////////////////////// +///@copyright Copyright (c) 2018, 传控科技 All rights reserved. +///------------------------------------------------------------------------- +/// @file bsp_func.c +/// @brief bsp @ fuctiong ; io复用选择等，和cpu型号息息相关 +///------------------------------------------------------------------------- +/// @version 1.0 +/// @author CC +/// @date 20180308 +/// @note cc_AS_stc02 + +////////////////////////////////////////////////////////////////////////////// +//struct _s_sysclk s_sysclk; + +//========================================================== +//系统定时器回调 +//初始化为NULL，timer0_isr中判断为NULL则不调用 +//========================================================== + + +void L0_board_config(void) +{ +#if (PIN_UART0_Rxd_30_Txd_31 == D_PIN_UART0) + BITN_0(P_SW1 ,BITN7);// + BITN_0(P_SW1 ,BITN6);// rxd p3.0 txd p3.1 +#elif (PIN_UART0_Rxd_36_Txd_37 == D_PIN_UART0) + BITN_0(P_SW1 ,BITN7);// + BITN_1(P_SW1 ,BITN6);// rxd p3.6 txd p3.7 +#elif (PIN_UART0_Rxd_16_Txd_17 == D_PIN_UART0) + BITN_1(P_SW1 ,BITN7);// + BITN_0(P_SW1 ,BITN6);// rxd p1.6 txd p1.7 +#elif (PIN_UART0_Rxd_43_Txd_44 == D_PIN_UART0) + BITN_1(P_SW1 ,BITN7);// + BITN_1(P_SW1 ,BITN6);// rxd p4.3 txd p4.4 +#else + BITN_0(P_SW1 ,BITN7);// + BITN_0(P_SW1 ,BITN6);// rxd p3.0 txd p3.1 +#endif + + //uart2 + BITN_0(P_SW2 ,BITN0);// rxd2 p1.0 txd2 p1.1 + //BITN_1(P_SW2 ,BITN0);// rxd2 p4.0 txd2 p4.2 + + //uart3 + //P_SW2 = 0x02; // RXD3_2/P5.0, TXD3_2/P5.1 + + //uart4 + //BITN_1(P_SW2 ,BITN2);// rxd4 p5.2 txd4 p5.3 + //BITN_0(P_SW2 ,BITN2);// rxd4 p0.2 txd4 p0.3 + + //485 RE/DE 配置推完输出 P55 + //BITN_0(P5M1,BITN5);BITN_1(P5M0,BITN5); + + //LED + //D_stdIO_P1(BITN7); + //D_stdIO_P5(BITN5); + + //IO + D_stdIO_P1(BITN0); + D_stdIO_P1(BITN1); + D_stdIO_P1(BITN2); + D_stdIO_P1(BITN6); + D_stdIO_P3(BITN2); + D_stdIO_P3(BITN3); + D_stdIO_P3(BITN4); + D_stdIO_P3(BITN5); + D_stdIO_P3(BITN6); + D_stdIO_P3(BITN7); + + #if (TYPE_WDT_ENABLE == D_WDT_STATUS) + WDT_CONTR = 0x27; //使能看门狗,22M时钟下溢出时间约为5s，请注意添加喂狗程序 + #else + WDT_CONTR = 0x00; + #endif + + //Lp0_Sys_timer_extern_handler被timer0中断调用 + //Lp0_Sys_timer_extern_handler = L1_Sys_timer_extern_handler; +} + + diff --git a/source/bsp/bsp_config.h b/source/bsp/bsp_config.h new file mode 100644 index 0000000..36c2f38 --- /dev/null +++ b/source/bsp/bsp_config.h @@ -0,0 +1,238 @@ +//////////////////////////////////////////////////////////////////////////// +///@copyright Copyright (c) 2017, 传控科技 All rights reserved. +///------------------------------------------------------------------------- +/// @file bsp_config.h +/// @brief hard config include +/// @info FILE FOR HARDWARE SETUP AND SOFTWARE SETUP///FOR EXAMPLE: BAORD ,MCU,IDE +/// @info YOU CAN CHANGE OR ADD THE DEFINE IF YOU NEED +/// @info 整个嵌入式项目的入口 首先是确认电路板 然后确认cpu 芯片型号 然后确认编译器 之后是软件框架 最后是应用程序 +/// @info bsp_CONFIG 为其他头文件的始祖 TYPE_BOARD_xx +///------------------------------------------------------------------------- +/// @version 1.1 +/// @author CC +/// @date 20180308 +/// @note +////////////////////////////////////////////////////////////////////////////// +/// @version 5.1 +/// @author CC +/// @date 20200301 +/// @note +////////////////////////////////////////////////////////////////////////////// + + +////////////////////////////////////////////////////////////////////////// +///存储器中的特殊参数 +///全球唯一ID号 7FF9H~7FFFH BFF9H~BFFFH EFF9H~EFFFH FDF9H~FDFFH 7字节 +///内部1.19V参考信号源 7FF7H~7FF8H BFF7H~BFF8H EFF7H~EFF8H FDF7H~FDF8H 毫伏（高字节在前） +///32K掉电唤醒定时器的频率 7FF5H~7FF6H BFF5H~BFF6H EFF5H~EFF6H FDF5H~FDF6H Hz （高字节在前） +///22.1184MHz的IRC参数（20M频段） 7FF4H BFF4H EFF4H FDF4H － +///24MHz的IRC参数（20M频段） 7FF3H BFF3H EFF3H FDF3H － +///20MHz的IRC参数（20M频段） 7FF2H BFF2H EFF2H FDF2H +///固件版本为7.3.12U +///以及后续版本有效 +///27MHz的IRC参数（35M频段） 7FF1H BFF1H EFF1H FDF1H +///30MHz的IRC参数（35M频段） 7FF0H BFF0H EFF0H FDF0H +///33.1776MHz的IRC参数（35M频段） 7FEFH BFEFH EFEFH FDEFH +///35MHz的IRC参数（35M频段） 7FEEH BFEEH EFEEH FDEEH +///36.864MHz的IRC参数（35M频段） 7FEDH BFEDH EFEDH FDEDH +///保留 7FECH BFECH EFECH FDECH +///保留 7FEBH BFEBH EFEBH FDEBH +///20M频段的VRTRIM参数 7FEAH BFEAH EFEAH FDEAH +///35M频段的VRTRIM参数 7FE9H BFE9H EFE9H FDE9H +////////////////////////////////////////////////////////////////////////// + +#ifndef _BSP_CONFIG_H +#define _BSP_CONFIG_H + +#include +#include "../bsp/bsp_config_const.h" +#include "../clib/type.h" +#include "../clib/bit.h" + + +//STEP 1 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>TYPE_UASER_BOARD SELECT +#define TYPE_UASER_BOARD TYPE_BOARD_WEIGH_0B +//STEP 1 <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>TYPE_UASER_BOARD CONFIG +#if(TYPE_UASER_BOARD == TYPE_BOARD_WEIGH_0B) + #include + #include "../cpu/stc_stc8hxx.h" + #include "../cpu/stc_macro.h" + + //基本配置(工作频率、时钟、看门狗、字节序) + #define TYPE_MCU TYPE_MCU_STC_8H + #define TYPE_IDE TYPE_IDE_KEIL + #define D_CPUfamily_type D_CPUfamily_8bits + #define D_sys_MainFre MainFre_22M + #define D_sys_Jiffies TYPE_JIFFIES_10MS + #define D_WDT_STATUS TYPE_WDT_DISABLE //如果配置为enable，请在bsp_config.c中设置wdt溢出时间 + #define D_MCU_ENDIAN TYPE_MCU_BIGENDIAN + #define D_CODE_ENCRYPTION_TYPE TYPE_ENCRYPTION_ENABLE //是否代码加密 + + + #define D_MCU_NAME "STC8H3K64S4" + //存储器特殊参数地址配置 + #define D_MCU_SPEC_PARAM_CHIPID 0xBFF9 + //...其他参数 + + //串口配置 + #define D_uart0_BRT BRT_115200 + #define D_uart0_SBIT SBIT_1 + #define D_PIN_UART0 PIN_UART0_Rxd_30_Txd_31 + #define D_uart2_BRT BRT_115200 + #define D_uart2_SBIT SBIT_1 + #define D_PIN_UART2 PIN_UART2_Rxd_10_Txd_11 //wifi模块 + #define D_uart3_BRT BRT_115200 + #define D_PIN_UART3 PIN_UART3_Rxd_43_Txd_44 //声音模块 + #define D_uart4_BRT BRT_115200 + + //485配置 + #define D_UART0_485_TYPE TYPE_485_NONE //UART0启用485 + #define D_UART0_485_SLAVER_ID_BROADCAST 0xFF //485从机总是响应0xFF消息 + #define D_UART0_485_SLAVER_ID 0x01 //板卡作为485从机 slaverId + #define D_UART0_485_TX() P32 = 1; + #define D_UART0_485_RX() P32 = 0; + #define D_UART2_485_TYPE TYPE_485_NONE //UART2不启用485 + #define D_UART3_485_TYPE TYPE_485_NONE //UART2不启用485 + #define D_UART4_485_TYPE TYPE_485_NONE //UART2不启用485 + + //MODBUS协议配置 + #define D_MODBUS_ENABLE //MODBS启用开关，如果不使用modbus，可以注释掉本行 + #define D_MODBUS_SPLIT_ENTRY L1_modbus_split //modbus切割函数，在tpc_modbus.c中实现，依据实际情况修改 + #define D_MODBUS_REG_MAX_NUM 32 //每次最多读取/写入的寄存器数量，此处的数量要注意和 D_tp_handle_x_len 对应 + + //外设定义 + + #define LED1 P27 //D4 + #define LED2 P26 //D4 + #define LED3 P2 //D4 + #define LED4 P55 //D4 + //笔头 + #define SCK P34 + #define SDIO P50 + + + //EEP存储地址定义 + #define D_EEP_SECTOR_SIZE 0x200 //每个扇区0x200==512bytes + #define D_EEP_SECTOR_BLOCK_SIZE 0x40 //扇区中每个数据块0x40==64bytes，可选值[32,64,128]等 + #define D_EEP_SECTOR_BLOCK_NUM (D_EEP_SECTOR_SIZE / D_EEP_PARAM_BLOCK_SIZE) //每个扇区数据块的数量 + #define D_EEP_BLOCK_FILTER0 0xAA //扇区中每个数据块的Filter字段值 + #define D_EEP_BLOCK_FILTER1 0x55 + //EEP User Defined 参数区存储配置 + #define D_EEP_PARAM_IN_SECTOR 1 //eeprom参数区扇区地址，从0开始 + #define D_EEP_PARAM_IN_BLOCK 0 //eeprom参数区数据块地址，从0开始 + //#define D_EEP_PARAM_BLOCK_SIZE (D_EEP_SECTOR_BLOCK_SIZE) //参数区每个块大小，必须：D_EEP_PARAM_BLOCK_SIZE<=D_EEP_SECTOR_BLOCK_SIZE!!!，因为eeprom.h中是按照D_EEP_SECTOR_BLOCK_SIZE分配的buf + //#define D_EEP_PARAM_BLOCK_NUM (D_EEP_SECTOR_SIZE / D_EEP_PARAM_BLOCK_SIZE) //每个扇区数据块的数量 + //EEP 加密区存储配置 + #if(D_CODE_ENCRYPTION_TYPE == TYPE_ENCRYPTION_ENABLE) + #define D_EEP_ENC_IN_SECTOR 0 //eeprom加密区扇区地址，从0开始 + #define D_EEP_ENC_IN_BLOCK 0 //eeprom加密区数据块地址，从0开始 + //#define D_EEP_ENC_BLOCK_SIZE 0x20 //ENC_BLOCK_SIZE必须与加密程序中的ENC_BLOCK_SIZE匹配，此处不建议修改，如需修改，请同时修改加密程序 + #endif +#elif + xxx +#endif +//STEP 2 <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>IRQ Config +#if ((TYPE_MCU & TYPE_MCU_VENDOR_MSK) == TYPE_MCU_VENDOR_STC) +#define D_SERVE_INT0 interrupt 0 +#define D_SERVE_TIMER0 interrupt 1 +#define D_SERVE_INT1 interrupt 2 +#define D_SERVE_TIMER1 interrupt 3 +#define D_SERVE_UART interrupt 4 +#define D_SERVE_ADC interrupt 5 +#define D_SERVE_LVD interrupt 6 +#define D_SERVE_PCA interrupt 7 +#define D_SERVE_UART2 interrupt 8 +#define D_SERVE_SPI interrupt 9 +#define D_SERVE_INT2 interrupt 10 +#define D_SERVE_INT3 interrupt 11 +#define D_SERVE_TIMER2 interrupt 12 +#define D_SERVE_INT4 interrupt 16 +#define D_SERVE_UART3 interrupt 17 +#define D_SERVE_UART4 interrupt 18 +#define D_SERVE_TIMER3 interrupt 19 +#define D_SERVE_TIMER4 interrupt 20 +#define D_SERVE_CMP interrupt 21 +#define D_SERVE_PWM interrupt 22 +#define D_SERVE_PWMFD interrupt 23 +#define D_SERVE_I2C interrupt 24 +#endif +//STEP 3 <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Cdelay CONFIG +#if(MainFre_5M == D_sys_MainFre) +#define D_Cdelay_200us 20 +#define D_Cdelay_1us 1 ////while p21翻转时测定 500k 2us 一个指令 +#elif(MainFre_22M == D_sys_MainFre) +#define D_Cdelay_200us 20 +#define D_Cdelay_1us 1 ////while p21翻转时测定 500k 2us 一个指令 +#define D_Cdelay_1us 1 ////while p21翻转时测定 500k 2us 一个指令 +#define L0_delay_1us() Lc_delay_nop(0) // 5个nop() 100ns 50个nop() 1us (20)=10us (2)1.5us +#define L0_delay_10us() Lc_delay_nop(4) // 5个nop() 100ns 50个nop() 1us (20)=10us (2)1.5us +#define L0_delay_40us() Lc_delay_nop(18) // 5个nop() 100ns 50个nop() 1us (20)=10us (2)1.5us +#elif(MainFre_27M == D_sys_MainFre) +#define D_Cdelay_200us 20 +#define D_Cdelay_1us 1 ////while p21翻转时测定 500k 2us 一个指令 +#else ///MainFre_11M +#define D_Cdelay_200us 20 +#define D_Cdelay_1us 1 ////while p21翻转时测定 500k 2us 一个指令 +#define L0_delay_1us() Lc_delay_nop(0) // 5个nop() 100ns 50个nop() 1us (20)=10us (2)1.5us +#define L0_delay_10us() Lc_delay_nop(4) // 5个nop() 100ns 50个nop() 1us (20)=10us (2)1.5us +#define L0_delay_40us() Lc_delay_nop(18) // 5个nop() 100ns 50个nop() 1us (20)=10us (2)1.5us + //xx +#endif//D_sys_MainFre) +//STEP 4 <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< +#include "../clib/type.h" +#include "../clib/bit.h" + +//>>>>>>>>>>>>>>>>>>>>>>.BORAD TYPE +#define TYPE_BOARD_hhnew 1 +#define TYPE_BOARD_st_sleep04_01 4 +#define TYPE_BOARD_st_sleep03 5 +#define TYPE_BOARD_SMMM_MB_VH032_0E 6 +#define TYPE_BOARD_LPC17xx_ 8 +#define TYPE_BOARD_STM32F_103ZET6_READBULL 1036 +#define TYPE_BOARD_hh_CC_MD_VH05_anyriny_simple_m51 0x0551 +#define TYPE_BOARD_hh_CC_MD_VH06_asMain_m6a7 0x6a7 +#define TYPE_BOARD_TI26_MT01_M178 0x178 //会议计时器版v TI26_MT01-M178 +#define TYPE_BOARD_stc5as32_WIFIBV01 532 +#define TYPE_BOARD_SHC16LAXXQN32 1632 //SHC16LAXXQN32 +#define TYPE_BOARD_PAPER6133_M0A6 0xa6 //打印机纸张传感 +#define TYPE_BOARD_GSM_MAIN_V07 0xa7 //打印机运维板 +#define TYPE_BOARD_ADDA_MAIN_V02 0xa8 //ADDA +#define TYPE_BOARD_433_0A 0xa9 //433 +#define TYPE_BOARD_WEIGH_0B 0xaa //称重 +//<<<<<<<<<<<<<<<<<<<<<<<<<<<.BORAD TYPE end + +//>>>>>>>>>>>>>>>>>>>>>>MCU TYPE +#define TYPE_MCU_VENDOR_MSK 0xF0 +#define TYPE_MCU_VENDOR_STC 0x10 +#define TYPE_MCU_STC_8A 0x11 +#define TYPE_MCU_STC_8F 0x12 +#define TYPE_MCU_STC_8G 0x13 +#define TYPE_MCU_STC_8H 0x14 + +#define TYPE_MCU_VENDOR_TI 0x60 +#define TYPE_MCU_SHC6601 0x66 +#define TYPE_MCU_LPC17xx 0x67 +#define TYPE_MCU_STM32 0x68 + +#define D_CPUfamily_8bits 8 +#define D_CPUfamily_16bits 16 +#define D_CPUfamily_32bits 32 +//<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>IDE TYPE +#define TYPE_IDE_KEIL 1 +#define TYPE_IDE_MDK 2 +#define TYPE_IDE_IAR 3 +//<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>SysTimer TYPE +#define TYPE_JIFFIES_5MS 5 +#define TYPE_JIFFIES_10MS 10 +#define TYPE_JIFFIES_25MS 25 +//<<<<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>.WDT TYPE +#define TYPE_WDT_DISABLE 1 +#define TYPE_WDT_ENABLE 2 +//#define WDT_FEED() WDT_CONTR |= 0x10 +//<<<<<<<<<<<<<<<<<<<<<<<<<<<.SysTimer TYPE end + +//>>>>>>>>>>>>>>>>>>>>>>.ByteOrder TYPE +#define TYPE_MCU_BIGENDIAN 1 //大端字节序 +#define TYPE_MCU_LITENDIAN 2 //小端字节序 +//<<<<<<<<<<<<<<<<<<<<<<<<<<<.ByteOrder TYPE end + +//>>>>>>>>>>>>>>>>>>>>>>.代码加密 TYPE +#define TYPE_ENCRYPTION_ENABLE 1 //代码加密 +#define TYPE_ENCRYPTION_DISABLE 2 //代码不加密 +//<<<<<<<<<<<<<<<<<<<<<<<<<<<.ByteOrder TYPE end + +//>>>>>>>>>>>>>>>>>>>>>>BUADRATE & StopBit +#define SBIT_1 1 //1 stop bit +#define SBIT_2 2 //2 stop bit +#define BRT_115200 115200 +#define BRT_19200 19200 +#define BRT_9600 9600 +#define BRT_4800 4800 +//<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>MainFre +#define MainFre_5M 5529600L +#define MainFre_11M 11059200L +#define MainFre_22M 22118400L +#define MainFre_24M 24000000L +#define MainFre_27M 27000000L +//<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>UART0 PIN +#define PIN_UART0_Rxd_30_Txd_31 1 +#define PIN_UART0_Rxd_36_Txd_37 2 +#define PIN_UART0_Rxd_16_Txd_17 3 +#define PIN_UART0_Rxd_43_Txd_44 4 +//<<<<<<<<<<<<<<<<<<<<<<<<<<<.UART0 PIN +//>>>>>>>>>>>>>>>>>>>>>>UART2 PIN +#define PIN_UART2_Rxd_10_Txd_11 5 + +//<<<<<<<<<<<<<<<<<<<<<<<<<<<.UART2 PIN + +//>>>>>>>>>>>>>>>>>>>>>>485 Type +#define TYPE_485_NONE 0 +#define TYPE_485_MASTER 1 +#define TYPE_485_SLAVER 2 +//<<<<<<<<<<<<<<<<<<<<<<485 Type end + +//>>>>>>>>>>>>>>>>>>>>>>G-SENSOR TYPE +#define TYPE_ASENSOR_ADXL362 362 +#define TYPE_ASENSOR_MSA300 300 +#define TYPE_ASENSOR TYPE_ASENSOR_MSA300 +//<<<<<<<<<<<<<<<<<<<<<>>端口位定义，可修改!!!!!!>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> + +#include "../bsp/bsp_config.h" +#include "../msp/uart0.h" + +extern void L0_id_get(U8 *id); +extern void L0_id_get_rom(U8 *id); +extern void L0_id_main(void); + +#endif// #ifndef _msp_eeprom_H_ + + + diff --git a/source/bsp/cs1232.c b/source/bsp/cs1232.c new file mode 100644 index 0000000..9aa2073 --- /dev/null +++ b/source/bsp/cs1232.c @@ -0,0 +1,226 @@ +//////////////////////////////////////////////////////////////////////////// +///@copyright Copyright (c) 2020, 传控科技 All rights reserved. +///------------------------------------------------------------------------- +/// @file cs1232.h +/// @brief hard cs1232 include +/// @info FILE FOR HARDWARE cs1232 +///------------------------------------------------------------------------- + + +////////////////////////////////////////////////////////////////////////////// +/// @version 1.0 +/// @author CC +/// @date 20200530 +/// @note +////////////////////////////////////////////////////////////////////////////// + +#include "cs1232.h" +TSS_FLOW_ tss_ads; + +//#define D_ADC_GATHER_Way1 1 +#if 0 +u8 Read_byte_adcIC(void) +{ + u8 i; + u8 rdata = 0; //初始化返回值为 0 + for(i = 0; i < 8; i++) + { + D_ADC_SCLK1_ON(); + rdata <<= 1; //返回值左移 1 位 + /// CS1231_Clk(); //上升沿接收数据,下降沿更新数据 + + D_ADC_SCLK1_OFF(); + + + if(D_ADC_DOUT1_AT()) + { + rdata += 1; //若数据线上数据为 1，则返回值加 1 + } + } + return(rdata); +} + +void L0_ADS1213_CH(u8 ch) +{ + /// /// SPEED = 1 57--57 ms 硬件配置成高电平 + D_ADC_PDWN_OFF(); + switch(ch) + { + case D_ADCCH_T: + L0_ADS1213_T(1); + break; + case D_ADCCH_1: + D_ADC_CS_A0_OFF(); + break; + case D_ADCCH_2: + D_ADC_CS_A0_ON(); + break; + case D_ADCCH_3: + //D_ADC_CS2_A0_OFF(); + break; + case D_ADCCH_4: + //D_ADC_CS2_A0_ON(); + break; + default:/// + L0_ADS1213_T(0); + break; + }; + Lc_delay_us(50); + D_ADC_PDWN_ON(); +} + +//channel-温度 +void L0_ADS1213_T(u8 onff) +{ + if(onff) + { + D_ADC_PDWN_OFF(); + D_ADC_TEMP_ON(); + Lc_delay_us(50); + D_ADC_PDWN_ON(); + } + else + { + D_ADC_PDWN_OFF(); + D_ADC_TEMP_OFF(); + Lc_delay_us(50); + D_ADC_PDWN_ON(); + } +} + +#endif +void L0_ADS1213_INIT(void) +{ + D_ADS1213_INIT(); + D_stdIO_P3(BITN2); + D_stdIO_P3(BITN3); + + //L0_ADS1213_CH(D_ADCCH_1); //4个独立芯片，不需要切换 + Lc_delay_ms(100);///57ms 建立时间 + + //L0_ADS1213_CH(D_ADCCH_3); + //Lc_delay_ms(100);///57ms 建立时间 +} + + +void L0_2dc_SCLK(vtype ch,vtype onf) +{ + switch (ch) + { + case D_ADCCH_1: + if(onf){D_ADC_SCLK1_ON();}else{D_ADC_SCLK1_OFF();} + break; + case D_ADCCH_2: + if(onf){D_ADC_SCLK2_ON();}else{D_ADC_SCLK2_OFF();} + break; + case D_ADCCH_3: + if(onf){D_ADC_SCLK3_ON();}else{D_ADC_SCLK3_OFF();} + break; + case D_ADCCH_4: + if(onf){D_ADC_SCLK4_ON();}else{D_ADC_SCLK4_OFF();} + break; + default: + break; + } +} + +vtype L0_2dc_DOUT_AT(vtype ch) +{ + vtype r = 9; + + switch (ch) + { + case D_ADCCH_1: + r = D_ADC_DOUT1_AT(); + break; + case D_ADCCH_2: + r = D_ADC_DOUT2_AT(); + break; + case D_ADCCH_3: + r = D_ADC_DOUT3_AT(); + break; + case D_ADCCH_4: + r = D_ADC_DOUT4_AT(); + break; + default: + break; + } + return r; +} + +//任务读 +vS32 L0_ADS1231_readCH(vtype ch) +{ + vtype i; vU32 rdata = 0; + for(i = 0; i < 24; i++) + { + L0_2dc_SCLK(ch,1);/// D_ADC_SCLK1_ON(); + rdata <<= 1; + L0_2dc_SCLK(ch,0);///D_ADC_SCLK1_OFF(); + if(L0_2dc_DOUT_AT(ch)) + { + rdata += 1; + } + } + ///25 puls make DOUT high + L0_2dc_SCLK(ch,1); + if(rdata & 0x800000) //最高位为1，<0则 + { + rdata |= 0xFF000000; + } + L0_2dc_SCLK(ch,0); + + return rdata; +} + +//调试阻塞读 +vS32 L0_ADS1231_read(U8 ch) +{ + vU32 e = 0;u8 i;vS32 rdata = 0; + while(1 == L0_2dc_DOUT_AT(ch)) + { + if(e ++ > 100000) + { + //return 0; + } + } + for(i = 0; i < 24; i++) + { + L0_2dc_SCLK(ch,1); + rdata <<= 1; + L0_2dc_SCLK(ch,0); + if(L0_2dc_DOUT_AT(ch)) + { + rdata += 1; + } + } + L0_2dc_SCLK(ch,1); + if(rdata & 0x800000) //???λ?1??<0?? + { + rdata |= 0xFF000000; + } + return rdata; +} + + +void L1_ADS1213_main(void) +{ + U8 ch = D_ADCCH_2; + while(1) + { + while(1 == L0_2dc_DOUT_AT(ch)) + ; + tss_ads.u32_i = L0_ADS1231_readCH(ch); + tss_ads.u16_v = (vU16)( tss_ads.u32_i >> 16); + L0_uart0_ushex(tss_ads.u16_v); + tss_ads.u16_v = (vU16)(tss_ads.u32_i & 0x0000ffff); + L0_uart0_ushex(tss_ads.u16_v);//Lc_delay_us(500); + L0_uart0_uc(0x0d); L0_uart0_uc(0x0a); + } +} + + +/*********************************end file*********************************************/ + + + diff --git a/source/bsp/cs1232.h b/source/bsp/cs1232.h new file mode 100644 index 0000000..bab0040 --- /dev/null +++ b/source/bsp/cs1232.h @@ -0,0 +1,228 @@ +//////////////////////////////////////////////////////////////////////////// +///@copyright Copyright (c) 2020, 传控科技 All rights reserved. +///------------------------------------------------------------------------- +/// @file cs1232.h +/// @brief hard cs1232 include +/// @info FILE FOR HARDWARE cs1232 +///------------------------------------------------------------------------- + + +////////////////////////////////////////////////////////////////////////////// +/// @version 1.0 +/// @author CC +/// @date 20200530 +/// @note +////////////////////////////////////////////////////////////////////////////// + + +////////////////////////////////////////////////////////////////////////// +#ifndef _BSP_cs1232_H +#define _BSP_cs1232_H + +#include "../bsp/bsp_config.h" +#include "../msp/uart0.h" +#include "../ctask/task.h" + + + +#define D_ADCCH_1 0 +#define D_ADCCH_2 1 +#define D_ADCCH_3 2 +#define D_ADCCH_4 3 + +#define D_ADCCH_T 8 +#define D_ADCCH_Toff 9 + + ///数字部分需要有四个数据转换周期满足模拟输入信号的建立和滤波器的建立时间要求。芯 + ///片从外部差分输入信号切换到温度传感器、从温度传感器切换到外部差分输入信号，或通 + ///道间切换，到新的正确的数据到来都需要四个数据转换周期。整个建立过程如下图所示： + ///A0/TEMP _______________/```````` + ///'DRDY/DOUT----------------/``\' + ///改变 A0 或 TEMP 后的建立时间 40--50 us + //// 建立时间 ( 保持高电 平) + /// SPEED = 1 57--57 ms + /// SPEED = 0 407--407 ms + + ////值是在 fclk=4.9152MHz 时对应的值，不同的 fclk 频率，数值等比例变化 + +/// CS1232 在连续转换过程中，若外部差分输入信号发生突然变化，同样需要建立时间。突变 +///的信号需要 4 个转换周期进行建立，第 5 个转换周期得到最终的 AD 值。图 7 描述突变信 +///号建立的过程。若在建立的过程中，信号再发生突变，则忽略之前的建立，需要新的 4 个 +///转换周期进行建立，之后紧接着的第 5 个转换周期得到最终的 AD 值。 + +/// 内部振荡器频率 4.6 5 5.4 MHz +/// 内置时钟温漂 250 ppm/℃----40``85 125*250= 31250 /1000000 = 0.03125 变化为3.125% + +/// 电阻的2113温度系数值（TCR）的单位为PPM或者PPM/摄氏度5261。 + +/// 其含义为当温度上升或者下降1摄氏度时，电阻的41021653阻值的变化为百万分之几。 + +/// 例如15PPM 1kΩ的 0.1%精度的电阻，如下图。 + +/// 温漂的含义在这回里为，当温度上升或下降1摄氏度时，阻值上升或者降低，百万分之答15. + +//// 温度系数：±ppm/℃，bai即单位温度引起的电阻值的变化。ppm（Part Per Million）表示百万分之几， +////比如：标称阻值为1k的电du阻，温度系数为±100ppm/℃，意为温度变化一摄zhi氏度， +///电阻值的变化为1k±0.1Ω，变化100℃，阻值变化为1k±10Ω，精度非常高了。 +////电阻的温度系数精密级的在几十ppm，普通dao的是200～250ppm，最差的也不过500ppm。 +#define D_adc_delay() Lc_delay_nop(2) +#define D_adc_delay2() Lc_delay_nop(1) + +/************** + +IO DEFINE PIN +P1.0 DOUT2 1 +P1.6 SCLK2 2 +P1.7 LED1 3 +P5.4 LED2 7 +P5.5 485_RE 9 +P1.1 PDWN 20 +P1.2 GAIN0 19 +P3.7 DOUT3 18 +P3.6 DOUT1 17 +P3.5 SCLK1 16 +P3.4 SCLK3 15 +P3.3 DOUT4 14 +P3.2 SCLK4 13 +P3.1 TXD0 12 +P3.0 RXD0 11 +*****************/ + + +#define D_ADC_DOUT1_INIT() ///D_P17_INIT() +#define D_ADC_SCLK1_INIT() ///D_P16_INIT() +#define D_ADC_CS_A0_INIT() ///D_P55_INIT() +#define D_ADC_DOUT1_AT() D_P36_AT() +#define D_ADC_DOUT1_ON() D_P36_ON() +#define D_ADC_SCLK1_ON() D_P35_ON();D_adc_delay2(); +#define D_ADC_CS_A0_ON() //D_P55_ON() +#define D_ADC_DOUT1_OFF() D_P36_OFF() +#define D_ADC_SCLK1_OFF() D_P35_OFF();D_adc_delay(); +#define D_ADC_CS_A0_OFF() //D_P55_OFF() + + +//#define D_ADC_CS2_A0_ON() D_P13_ON() +#define D_ADC_DOUT2_ON() D_P10_ON() +#define D_ADC_DOUT2_AT() D_P10_AT() +#define D_ADC_SCLK2_ON() D_P16_ON();D_adc_delay2(); +//#define D_ADC_CS2_A0_INIT() ///D_P13_INIT() +#define D_ADC_DOUT2_INIT() ///D_P14_IN() ///D_P14_INIT() +#define D_ADC_SCLK2_INIT() ///D_P15_INIT() +//#define D_ADC_CS2_A0_OFF() D_P13_OFF() +#define D_ADC_DOUT2_OFF() D_P10_OFF() +#define D_ADC_SCLK2_OFF() D_P16_OFF();D_adc_delay(); + +#define D_ADC_DOUT3_INIT() ///D_P11_INIT() +#define D_ADC_SCLK3_INIT() ///D_P13_INIT() +#define D_ADC_DOUT3_AT() D_P37_AT() +#define D_ADC_DOUT3_ON() D_P37_ON() +#define D_ADC_SCLK3_ON() D_P34_ON();D_adc_delay2(); +#define D_ADC_DOUT3_OFF() D_P37_OFF() +#define D_ADC_SCLK3_OFF() D_P34_OFF();D_adc_delay(); + +#define D_ADC_DOUT4_INIT() ///D_P34_INIT() +#define D_ADC_SCLK4_INIT() ///D_P33_INIT() +#define D_ADC_DOUT4_AT() D_P33_AT() +#define D_ADC_DOUT4_ON() D_P33_ON() +#define D_ADC_SCLK4_ON() D_P32_ON();D_adc_delay2(); +#define D_ADC_DOUT4_OFF() D_P33_OFF() +#define D_ADC_SCLK4_OFF() D_P32_OFF();D_adc_delay(); + + + + + + +#define D_ADC_TEMP_INIT() ///D_P12_INIT() + +#define D_ADC_TEMP_ON() //D_P12_ON() +#define D_ADC_TEMP_OFF() //D_P12_OFF() + + +#define D_ADC_PDWN_INIT() ///D_P54_INIT() + +#define D_ADC_PDWN_OFF() D_P11_OFF() +#define D_ADC_PDWN_ON() D_P11_ON() + + + + +#define D_ADC_GAIN1_INIT() ///D_P37_INIT() +#define D_ADC_GAIN0_INIT() ///D_P36_INIT() + +#define D_ADC_GAIN1_OFF() //D_P37_OFF() +#define D_ADC_GAIN0_OFF() D_P12_OFF() +#define D_ADC_GAIN1_ON() //D_P37_ON() +#define D_ADC_GAIN0_ON() D_P12_ON() + +// #define D_ADS1213_GAIN_VAL 1 +// #define D_ADS1213_GAIN_VAL 2 +#define D_ADS1213_GAIN_VAL 64 +//#define D_ADS1213_GAIN_VAL 128 + +#if (D_ADS1213_GAIN_VAL == 128) +#define D_ADS1213_INIT() D_ADC_GAIN1_ON();D_ADC_GAIN0_ON();\ + D_ADC_TEMP_OFF();\ + D_ADC_CS_A0_ON();\ + D_ADC_SCLK1_OFF();D_ADC_SCLK2_OFF();\ + D_ADC_SCLK3_OFF();D_ADC_SCLK4_OFF(); + +#elif (D_ADS1213_GAIN_VAL == 64) +#define D_ADS1213_INIT() D_ADC_GAIN1_ON();D_ADC_GAIN0_OFF();\ + D_ADC_TEMP_OFF();\ + D_ADC_CS_A0_ON();\ + D_ADC_SCLK1_OFF();D_ADC_SCLK2_OFF();\ + D_ADC_SCLK3_OFF();D_ADC_SCLK4_OFF(); +#elif (D_ADS1213_GAIN_VAL == 2)//浠呴檺U1ADS1232浣跨敤 +xx +#define D_ADS1213_INIT() D_ADC_GAIN1_OFF();D_ADC_GAIN0_ON();\ + D_ADC_TEMP_OFF();\ + D_ADC_CS_A0_ON();D_ADC_CS2_A0_ON();\ + D_ADC_SCLK1_OFF();D_ADC_SCLK2_OFF(); +#elif (D_ADS1213_GAIN_VAL == 1) +xx +#define D_ADS1213_INIT() D_ADC_GAIN1_OFF();D_ADC_GAIN0_OFF();\ + D_ADC_TEMP_OFF();\ + D_ADC_CS_A0_ON();D_ADC_CS2_A0_ON();\ + D_ADC_SCLK1_OFF();D_ADC_SCLK2_OFF(); +#endif + +extern void L0_ADS1213_INIT(void); +extern void L0_ADS1213_T(u8 onff); +extern void L0_ADS1213_CH(u8 ch); +//extern vS32 L0_ADS1213_read1(U8 *error); +//extern vS32 L0_ADS1213_read2(U8 *error); +//extern vS32 L0_ADS1213_read(U8 ch,U8 *error); +//extern U8 L0_ADS1213_is_low(U8 ch); +//extern U8 L0_ADS1213_is_high(U8 ch); +extern void L0_2dc_SCLK(vtype ch,vtype onf); +extern vtype L0_2dc_DOUT_AT(vtype ch); +extern vS32 L0_ADS1231_readCH(vtype ch); +extern vS32 L0_ADS1231_read(U8 ch); + +typedef struct +{ + TS_task task; + vU8 t_stamp; + vU16 t_stamp2; + vU16 wakeup_timer; + + vU8 long_hit; +// vU8 first_run; +vU32 u32_i;// +vU32 u32_m;// +vU16 u16_v;// +// unsigned char status;// +// unsigned char key;// +}TSS_FLOW_; +extern TSS_FLOW_ tss_ads; + +extern void L1_ADS1213_main(void); + + + +#endif//_BSP_cs1232_H +/*********************************end file*********************************************/ + + + diff --git a/source/bsp/rs485.c b/source/bsp/rs485.c new file mode 100644 index 0000000..b58709f --- /dev/null +++ b/source/bsp/rs485.c @@ -0,0 +1,8 @@ +#include "rs485.h" + +void L2_485_init(void) +{ + //485配置强推挽输出 P33 P32 + //BITN_0(P3M1,BITN3);BITN_1(P3M0,BITN3); + BITN_0(P3M1,BITN2);BITN_1(P3M0,BITN2); +} \ No newline at end of file diff --git a/source/bsp/rs485.h b/source/bsp/rs485.h new file mode 100644 index 0000000..e3629e4 --- /dev/null +++ b/source/bsp/rs485.h @@ -0,0 +1,13 @@ +#ifndef BSP_485_H +#define BSP_485_H + +#include "../bsp/bsp_config.h" +#include "../msp/uart0.h" + +//485_RE P33 +//485_DE P32 +#define D_485_TX() P32 = 1;// >750us +#define D_485_RX() P32 = 0; + +extern void L2_485_init(void); +#endif \ No newline at end of file diff --git a/source/bsp/w600.c b/source/bsp/w600.c new file mode 100644 index 0000000..5632d71 --- /dev/null +++ b/source/bsp/w600.c @@ -0,0 +1,5 @@ +#include "w600.h" +void L1_w600_init(U8 mode) +{ + s->mode = mode; +} \ No newline at end of file diff --git a/source/bsp/w600.h b/source/bsp/w600.h new file mode 100644 index 0000000..e6aa257 --- /dev/null +++ b/source/bsp/w600.h @@ -0,0 +1,2 @@ +#ifndef __W600_H__ +#define __W600_H__ diff --git a/source/clib/bit.h b/source/clib/bit.h new file mode 100644 index 0000000..62cb578 --- /dev/null +++ b/source/clib/bit.h @@ -0,0 +1,405 @@ +////////////////////////////////////////////////////////////////////////// +/// COPYRIGHT NOTICE +/// Copyright (c) 2015, ؿƼ +/// All rights reserved. +/// +/// @file main.c +/// @brief main app +/// +///ļʵֵĹܵ +/// +/// @version 1.1 CCsens technology +/// @author CC +/// @date 20150102 +/// +/// +/// ޶˵汾 +/// Modified by: +/// Modified date: +/// Version: +/// Descriptions: +////////////////////////////////////////////////////////////////////////// + + +#ifndef __BIT_H__ +#define __BIT_H__ + +#define cSetb0 0x01 +#define cSetb1 0x02 +#define cSetb2 0x04 +#define cSetb3 0x08 +#define cSetb4 0x10 +#define cSetb5 0x20 +#define cSetb6 0x40 +#define cSetb7 0x80 + +#define cClrb0 0xfe +#define cClrb1 0xfd +#define cClrb2 0xfb +#define cClrb3 0xf7 +#define cClrb4 0xef +#define cClrb5 0xdf +#define cClrb6 0xbf +#define cClrb7 0x7f + +#define cTestb0 0x01 +#define cTestb1 0x02 +#define cTestb2 0x04 +#define cTestb3 0x08 +#define cTestb4 0x10 +#define cTestb5 0x20 +#define cTestb6 0x40 +#define cTestb7 0x80 + +#define true 1 +#define false 0 + +#define B0000_0000 0x00 +#define B0000_0001 0x01 +#define B0000_0010 0x02 +#define B0000_0011 0x03 +#define B0000_0100 0x04 +#define B0000_0101 0x05 +#define B0000_0110 0x06 +#define B0000_0111 0x07 +#define B0000_1000 0x08 +#define B0000_1001 0x09 +#define B0000_1010 0x0A +#define B0000_1011 0x0B +#define B0000_1100 0x0C +#define B0000_1101 0x0D +#define B0000_1110 0x0E +#define B0000_1111 0x0F + +#define B0001_0000 0x10 +#define B0001_0001 0x11 +#define B0001_0010 0x12 +#define B0001_0011 0x13 +#define B0001_0100 0x14 +#define B0001_0101 0x15 +#define B0001_0110 0x16 +#define B0001_0111 0x17 +#define B0001_1000 0x18 +#define B0001_1001 0x19 +#define B0001_1010 0x1A +#define B0001_1011 0x1B +#define B0001_1100 0x1C +#define B0001_1101 0x1D +#define B0001_1110 0x1E +#define B0001_1111 0x1F + +#define B0010_0000 0x20 +#define B0010_0001 0x21 +#define B0010_0010 0x22 +#define B0010_0011 0x23 +#define B0010_0100 0x24 +#define B0010_0101 0x25 +#define B0010_0110 0x26 +#define B0010_0111 0x27 +#define B0010_1000 0x28 +#define B0010_1001 0x29 +#define B0010_1010 0x2A +#define B0010_1011 0x2B +#define B0010_1100 0x2C +#define B0010_1101 0x2D +#define B0010_1110 0x2E +#define B0010_1111 0x2F + +#define B0011_0000 0x30 +#define B0011_0001 0x31 +#define B0011_0010 0x32 +#define B0011_0011 0x33 +#define B0011_0100 0x34 +#define B0011_0101 0x35 +#define B0011_0110 0x36 +#define B0011_0111 0x37 +#define B0011_1000 0x38 +#define B0011_1001 0x39 +#define B0011_1010 0x3A +#define B0011_1011 0x3B +#define B0011_1100 0x3C +#define B0011_1101 0x3D +#define B0011_1110 0x3E +#define B0011_1111 0x3F + +#define B0100_0000 0x40 +#define B0100_0001 0x41 +#define B0100_0010 0x42 +#define B0100_0011 0x43 +#define B0100_0100 0x44 +#define B0100_0101 0x45 +#define B0100_0110 0x46 +#define B0100_0111 0x47 +#define B0100_1000 0x48 +#define B0100_1001 0x49 +#define B0100_1010 0x4A +#define B0100_1011 0x4B +#define B0100_1100 0x4C +#define B0100_1101 0x4D +#define B0100_1110 0x4E +#define B0100_1111 0x4F + +#define B0101_0000 0x50 +#define B0101_0001 0x51 +#define B0101_0010 0x52 +#define B0101_0011 0x53 +#define B0101_0100 0x54 +#define B0101_0101 0x55 +#define B0101_0110 0x56 +#define B0101_0111 0x57 +#define B0101_1000 0x58 +#define B0101_1001 0x59 +#define B0101_1010 0x5A +#define B0101_1011 0x5B +#define B0101_1100 0x5C +#define B0101_1101 0x5D +#define B0101_1110 0x5E +#define B0101_1111 0x5F + +#define B0110_0000 0x60 +#define B0110_0001 0x61 +#define B0110_0010 0x62 +#define B0110_0011 0x63 +#define B0110_0100 0x64 +#define B0110_0101 0x65 +#define B0110_0110 0x66 +#define B0110_0111 0x67 +#define B0110_1000 0x68 +#define B0110_1001 0x69 +#define B0110_1010 0x6A +#define B0110_1011 0x6B +#define B0110_1100 0x6C +#define B0110_1101 0x6D +#define B0110_1110 0x6E +#define B0110_1111 0x6F + +#define B0111_0000 0x70 +#define B0111_0001 0x71 +#define B0111_0010 0x72 +#define B0111_0011 0x73 +#define B0111_0100 0x74 +#define B0111_0101 0x75 +#define B0111_0110 0x76 +#define B0111_0111 0x77 +#define B0111_1000 0x78 +#define B0111_1001 0x79 +#define B0111_1010 0x7A +#define B0111_1011 0x7B +#define B0111_1100 0x7C +#define B0111_1101 0x7D +#define B0111_1110 0x7E +#define B0111_1111 0x7F + +#define B1000_0000 0x80 +#define B1000_0001 0x81 +#define B1000_0010 0x82 +#define B1000_0011 0x83 +#define B1000_0100 0x84 +#define B1000_0101 0x85 +#define B1000_0110 0x86 +#define B1000_0111 0x87 +#define B1000_1000 0x88 +#define B1000_1001 0x89 +#define B1000_1010 0x8A +#define B1000_1011 0x8B +#define B1000_1100 0x8C +#define B1000_1101 0x8D +#define B1000_1110 0x8E +#define B1000_1111 0x8F + +#define B1001_0000 0x90 +#define B1001_0001 0x91 +#define B1001_0010 0x92 +#define B1001_0011 0x93 +#define B1001_0100 0x94 +#define B1001_0101 0x95 +#define B1001_0110 0x96 +#define B1001_0111 0x97 +#define B1001_1000 0x98 +#define B1001_1001 0x99 +#define B1001_1010 0x9A +#define B1001_1011 0x9B +#define B1001_1100 0x9C +#define B1001_1101 0x9D +#define B1001_1110 0x9E +#define B1001_1111 0x9F + +#define B1010_0000 0xA0 +#define B1010_0001 0xA1 +#define B1010_0010 0xA2 +#define B1010_0011 0xA3 +#define B1010_0100 0xA4 +#define B1010_0101 0xA5 +#define B1010_0110 0xA6 +#define B1010_0111 0xA7 +#define B1010_1000 0xA8 +#define B1010_1001 0xA9 +#define B1010_1010 0xAA +#define B1010_1011 0xAB +#define B1010_1100 0xAC +#define B1010_1101 0xAD +#define B1010_1110 0xAE +#define B1010_1111 0xAF + +#define B1011_0000 0xB0 +#define B1011_0001 0xB1 +#define B1011_0010 0xB2 +#define B1011_0011 0xB3 +#define B1011_0100 0xB4 +#define B1011_0101 0xB5 +#define B1011_0110 0xB6 +#define B1011_0111 0xB7 +#define B1011_1000 0xB8 +#define B1011_1001 0xB9 +#define B1011_1010 0xBA +#define B1011_1011 0xBB +#define B1011_1100 0xBC +#define B1011_1101 0xBD +#define B1011_1110 0xBE +#define B1011_1111 0xBF + +#define B1100_0000 0xC0 +#define B1100_0001 0xC1 +#define B1100_0010 0xC2 +#define B1100_0011 0xC3 +#define B1100_0100 0xC4 +#define B1100_0101 0xC5 +#define B1100_0110 0xC6 +#define B1100_0111 0xC7 +#define B1100_1000 0xC8 +#define B1100_1001 0xC9 +#define B1100_1010 0xCA +#define B1100_1011 0xCB +#define B1100_1100 0xCC +#define B1100_1101 0xCD +#define B1100_1110 0xCE +#define B1100_1111 0xCF + +#define B1101_0000 0xD0 +#define B1101_0001 0xD1 +#define B1101_0010 0xD2 +#define B1101_0011 0xD3 +#define B1101_0100 0xD4 +#define B1101_0101 0xD5 +#define B1101_0110 0xD6 +#define B1101_0111 0xD7 +#define B1101_1000 0xD8 +#define B1101_1001 0xD9 +#define B1101_1010 0xDA +#define B1101_1011 0xDB +#define B1101_1100 0xDC +#define B1101_1101 0xDD +#define B1101_1110 0xDE +#define B1101_1111 0xDF + +#define B1110_0000 0xE0 +#define B1110_0001 0xE1 +#define B1110_0010 0xE2 +#define B1110_0011 0xE3 +#define B1110_0100 0xE4 +#define B1110_0101 0xE5 +#define B1110_0110 0xE6 +#define B1110_0111 0xE7 +#define B1110_1000 0xE8 +#define B1110_1001 0xE9 +#define B1110_1010 0xEA +#define B1110_1011 0xEB +#define B1110_1100 0xEC +#define B1110_1101 0xED +#define B1110_1110 0xEE +#define B1110_1111 0xEF + +#define B1111_0000 0xF0 +#define B1111_0001 0xF1 +#define B1111_0010 0xF2 +#define B1111_0011 0xF3 +#define B1111_0100 0xF4 +#define B1111_0101 0xF5 +#define B1111_0110 0xF6 +#define B1111_0111 0xF7 +#define B1111_1000 0xF8 +#define B1111_1001 0xF9 +#define B1111_1010 0xFA +#define B1111_1011 0xFB +#define B1111_1100 0xFC +#define B1111_1101 0xFD +#define B1111_1110 0xFE +#define B1111_1111 0xFF +/************************************************* +׼λ +*************************************************/ +#define BIT0 0 +#define BIT1 1 +#define BIT2 2 +#define BIT3 3 +#define BIT4 4 +#define BIT5 5 +#define BIT6 6 +#define BIT7 7 + +///-------------------------------------- +#define BITN0 0X01 +#define BITN1 0X02 +#define BITN2 0X04 +#define BITN3 0X08 +#define BITN4 0X10 +#define BITN5 0X20 +#define BITN6 0X40 +#define BITN7 0X80 + +/// BITNx = { 0x40 0x80} +#define BITN_1(X,BITNx) (X)|= (BITNx) +#define BITN_0(X,BITNx) (X)&=~(BITNx) +#define BITN_G(X,BITNx) ((X)&(BITNx)) +//BITN_1(reg,BITN0) +#define BITS_1(X,BITx) (X)|= (BITx) +#define BITS_0(X,BITx) (X)&=~(BITx) + + + +#define BITC_1 0X01 +#define BITC_2 0X03 +#define BITC_3 0X07 +#define BITC_4 0X0F +#define BITC_5 0X1F +#define BITC_6 0X3F +#define BITC_7 0X7F +#define BITC_8 0XFF + +//// λãһҪʹãá +/// REG BITxʼ Nλ +#define BITS_CLR(REG,BITC_N,BITx) (REG)&= ~((BITC_N)<<(BITx)) +////REG BITxʼ ֵ,С һҪʹãá +#define BITS_SET(REG,VAL) (REG) |= (VAL) //ֱӲ ֮ǰ +///BITS_CLR(REG,BITC_2,BIT0)/// reg.0 reg.1 λ +///BITS_CLR(REG,BITC_3,BIT5)/// reg.5 reg.6 reg.7 3λ + + +#define BITS_SET_SHIFT(REG,VAL,BITx) (REG)|= ((VAL)<<(BITx))///Ҫλ һֳ + + + +#if 0 + +/// b = {0,1,2,3,4,5,6,7} +#define BIT_1(X,b) (X)|= (1<<(b)) +#define BIT_0(X,b) (X)&=~(1<<(b)) +#define BIT_G(X,b) ((X)&(1<<(b))) +#define SETBIT(regVal, bitN) ((regVal) |= (1<<(bitN))) // λ +#define CLRBIT(regVal, bitN) ((regVal) &= ~(1<<(bitN))) // λ +#define GETBIT(regVal, bitN) ((regVal) & (1<<(bitN)) ) // ȡλֵ + + +// ԭ˼˫λλ͸ֵ 0b0000 0011 // fixme +#define BITD_CLR(regVal,D,bitN) (regVal)&=~((D)<<(bitN)) +#define BITD_SET(regVal,D,bitN) BITD_CLR((regVal),3,(bitN));(regVal)|= ((D)<<(bitN)) + +///----------------------------------- + + +#define IO_OUT_HIGH(PORT, PIN) SETBIT(PORT, PIN) +#define IO_OUT_LOW(PORT, PIN) CLRBIT(PORT, PIN) + + +#endif +#endif /* __BIT_H__ */ diff --git a/source/clib/clib.c b/source/clib/clib.c new file mode 100644 index 0000000..805329f --- /dev/null +++ b/source/clib/clib.c @@ -0,0 +1,1785 @@ +/***************************************************************************** + * uart.c: UART API file for NXP LPC17xx Family Microprocessors + * + * Copyright(C) 2009, NXP Semiconductor + * All rights reserved. + * + * History + * 2009.05.27 ver 1.00 Prelimnary version, first Release + * +******************************************************************************/ + + +#include "type.h" +#include "clib.h" +#include "../msp/uart0.h" +#include "../msp/time.h" +U8* Lc_strcpy(U8* dst,const char* str) +{ + U8 *p = dst; + while(*dst++ = *str++); + return p; +} + +#if 0 + +vU16 us2fun2[5] +={ +1, //0 +10,// 1 +100,// 2 +1000,// 3 +10000// 4 + +}; + + + +vU32 ul2fun2[10] +={ +1, //0 +10,// 1 +100,// 2 +1000,// 3 +10000,// 4 +100000, +1000000, +10000000, +100000000, +1000000000,//9 +}; + +同样是转义字符，\n 的作用相当于“Enter”键，而想退回去就可以用“Backspace”键，也就是\b +这里还有一个可能用到的转义字符是\r ：使光标回退到本行开头 + \b 退格 + \n 换行 0x0A + \f 走纸 + \t 水平制表 + \v 垂直制表 + +\r 0x0d + +//如果追求内存紧张加上const INT32U ul2fun2[10] + + +void Lc_float2str(float f,U8 *str,U8 point_num); +{ + S32 i = 0; U32 u32i = 0; + U8 n = 0;U8 m = 0;U8 d = 0; + switch(point_num) + { + case 0: + + break; + case 1: + f *= 10.; + + break; + case 2: + f *= 100.; + + break; + case 3: + f *= 1000.; + + break; + default: + + break; + }; + i = (S32)f; +// Lc_float2str(1.23,&d,2) +// Lc_float2str(0.23,&d,2) +// Lc_float2str(23.4,&d,1) +// Lc_float2str(-12345.236,&d,2) + // 1,1.2 12.3 240 0.12 + if(i < 0) + { + str[n] = '-'; + n ++; + i *= -1; + } + u32i = (U32)i; + m = 4; + if(u32i >= ul2fun2[m]) u32i = ul2fun2[m] - 1; + for(m = 0;m > 4;m ++) + {// 43210 + d = (u32i /ul2fun2[m])%10; + if (d > 0) + str[n] = d; + n ++; + } + + if (n == point_num) + { + str[n] ='.'; + n ++; + } + + + str[n] = i%10 + +} + +void L0_Delay_ms(unsigned int time) +{ + unsigned int j; + for(;time > 0;time --) + { + j = D_l0_delay_ms; + while(j--) + ; + } +} + + +//22m 50ms --delay ms 100 j=150 +void L1_delay_test(void) +{ + while(9) + { + L0_Delay_ms(100); + P2 = !P2; + } + +}void Lc_delay_us(unsigned int n) +{ +// unsigned char j; + for(;n > 0;n --) + { + //j = 2; + // while(j--) + // ; + }65 300 +} +#endif + +void Lc_delay_us(vU16 i) +{ + vU16 m; + i=i/10; + for(m=i;m>0;m--) + { + Lc_delay_1us(); + } +} + +void Lc_delay_nop(U8 i) +{ + U8 m; + for(m=i;m>0;m--) + { + NOP(); + } +} + + + + +// D_1ms_delay_para +///22m 300 +/// 22M 100ns 5个100ns 20ns +void Lc_delay_ms(vU16 i) +{ + vU16 m,n; + for(m=i;m>0;m--) + { + #ifdef D_debug_time + ; + #else + //D_debug_time_using + for(n= 85;n > 0;n--) + { + L0_delay_10us();//10us + } + #endif + } +} + +void Lc_buf_copy_uc(U8 *d,const U8 *s,U16 num) +{ + U16 i; + for(i = 0; i < num; i ++) + { + *(d+i) = *(s+i); + } + +} + +vU8 Lc_U8_media3(vU8 a,vU8 b,vU8 c) +{ + if(a > b) + { + if(b > c) + { + return b; + }else + {// b a) + {/// a a) + {// a b) + { + if(b > c) + { + return b; + } + else + {// b a) + {/// a a) + {// a arr[j+1]) + { + ok = 0; + tmp = arr[j]; + arr[j] = arr[j+1]; + arr[j+1] = tmp; + } + } + if(ok) + { + break; + } + } +} + +vS32 Lc_S32_media(vS32 val[],S16 num) +{ + if(num <= 1) + { + return val[0]; + } + else + { + Lc_array_sort(val,num); + return val[num/2]; + } +} +U32 Lc_vS32_media(U32 *d, U8 n) +{ + U8 i = 0,j = 0; + U32 h = 0; + if(n == 1) + { + return d[0]; + } + for(i=0;i d[j]) + { + h = d[i]; + d[i] = d[j]; + d[j] = h; + } + } + } + if(n%2 != 0) //奇数 + { + return d[n/2]; + } + else//偶数 + { + return ((d[n/2] + d[n/2-1])/2); + } +} + + +U32 Lc_vU32_avg(U32 *d, U8 n) +{ + U8 i = 0; + U32 sum = 0; + if(n == 1) + { + return d[0]; + } + for(i=0;i 0x31 0x31 0x32 0x32 '1' '1' '2' '2' +void Lc_hex2ascii(U8 *buf,U16 len,U8 *ascii) +{ + vU16 t = 0,m = 0; + for(t = 0;t < len;t ++) + { + + #if 1 + ascii[m] = cguHex2Char[D_uc_high(buf[t])][1]; + m ++; + ascii[m] = cguHex2Char[D_uc_low (buf[t])][1]; + m ++; + ascii[m] =0x20; + m ++; + #else + + ascii[m] = 0x30+m; + m++; + ascii[m] = 0x30+m; + m++; + ascii[m] = 0x30+m; + m++; + + + #endif + } +} + +/// cguHex2Char[0][0] = 0x00 cguHex2Char[0][1] = 0x30 +unsigned char code cguHex2Char[16][2] +={ + 0x00,'0', + 0x01,'1', + 0x02,'2', + 0x03,'3', + 0x04,'4', + 0x05,'5', + 0x06,'6', + 0x07,'7', + 0x08,'8', + 0x09,'9', + 0x0A,'A', + 0x0B,'B', + 0x0C,'C', + 0x0D,'D', + 0x0E,'E', + 0x0F,'F' +}; + + +void crc16(unsigned char *CRC,void *dat,unsigned int len) /*reentrant*/ +{ + unsigned char *ptr = (unsigned char *)dat; + unsigned long wcrc=0XFFFF;//预置16位crc寄存器，初值全部为1 + unsigned char temp;//定义中间变量 + int i=0,j=0;//定义计数 + for(i=0;i>=1;//先将数据右移一位 + wcrc^=0XA001;//与上面的多项式进行异或 + } + else//如果不是1，则直接移出 + { + wcrc>>=1;//直接移出 + } + } + } + temp=wcrc;//crc的值 + CRC[0]=wcrc;//crc的低八位 + CRC[1]=wcrc>>8;//crc的高八位 +} + +#if 0 +void crc16_irq(unsigned char *CRC,void *dat,unsigned int len) +{ + unsigned char *ptr = (unsigned char *)dat; + unsigned long wcrc=0XFFFF;//预置16位crc寄存器，初值全部为1 + unsigned char temp;//定义中间变量 + int i=0,j=0;//定义计数 + for(i=0;i>=1;//先将数据右移一位 + wcrc^=0XA001;//与上面的多项式进行异或 + } + else//如果不是1，则直接移出 + { + wcrc>>=1;//直接移出 + } + } + } + temp=wcrc;//crc的值 + CRC[0]=wcrc;//crc的低八位 + CRC[1]=wcrc>>8;//crc的高八位 +} +#endif + + +U32 Lc_abs(vS32 a,vS32 b) +{ + if(a >= b) + { + return a - b; + } + return b - a; +} + +void Lc_encrypt_id(U8 *enc_dst, U8 *enc_src, U32 enc_key, U8 src_len) +{ + U8 i = 0,key0,key1,key2,key3; + key0 = enc_key >> 24 & 0xFF; + key1 = enc_key >> 16 & 0xFF; + key2 = enc_key >> 8 & 0xFF; + key3 = enc_key >> 0 & 0xFF; + + for(i=0;i> 0) & 0xFF) << 24) | (((dat >> 8) & 0xFF) << 16) | (((dat >> 16) & 0xFF) << 8) | (((dat >> 24) & 0xFF) << 0); + } + return res; +} + +U32 htonl(U32 dat) +{ + U32 res = 0; + if(dat == 0 || isBigEndianOrder()){ + res = dat; + }else{ + res = (((dat >> 0) & 0xFF) << 24) | (((dat >> 8) & 0xFF) << 16) | (((dat >> 16) & 0xFF) << 8) | (((dat >> 24) & 0xFF) << 0); + } + return res; +} + +U16 ntohs(U16 dat) +{ + U16 res = 0; + if(dat == 0 || isBigEndianOrder()){ + res = dat; + }else{ + res = (((dat >> 0) & 0xFF) << 8) | (((dat >> 8) & 0xFF) << 0) ; + } + return res; +} + +U16 htons(U16 dat) +{ + U16 res = 0; + if(dat == 0 || isBigEndianOrder()){ + res = dat; + }else{ + res = (((dat >> 0) & 0xFF) << 8) | (((dat >> 8) & 0xFF) << 0) ; + } + return res; +} +#endif + +#if 0///#ifdef D_flash_max + + +// 0--9 '0' +// ABCEDF------0X41-- 87-6= 81 +U8 Lc_Hex2Char(U8 CharStr) +{ + U8 rd; + if (CharStr >9)//A 10-9+ + { + rd = (CharStr - 10 + 'A') ; + } + else + { + rd = (CharStr + '0') ; + } + return rd; +} +// 0x30'0'----'9'--> 0x0----0x09 +//0x61--'a'---'f'--> 0x0a---0x0f +//0x41 'A'--'F'--> 0x0a---0x0f +U8 Lc_Char2Hex(U8 CharStr) +{ + U8 rd; + if (CharStr >= 'a')//0x61--'a'---'f'--> 0x0a---0x0f + { + rd = (CharStr - 'a' + 0x0a) ; + } + else if (CharStr >= 'A')//0x61--'a'---'f'--> 0x0a---0x0f + { + rd = (CharStr - 'A' + 0x0a) ; + } + else + { + rd = (CharStr - '0') ; + } + return rd; +} +//catch_protocol(s,d); +// 从 d中提取出协议,一般用于协议打包后的调试和透传, +// *s="iicsend:12 34 56 78 9a \r\n"; +// i: 012345678 +// 返回协议字节数量 +// extern int strpos (const char *s, char c); +unsigned char catch_protocol (const char *d_src,char d_protocol[]) +{ + unsigned char n = 0,len = 0;//,i = 0; + int i = 0; + i = strpos(d_src, (char)':'); + i ++; + len = strlen (d_src) - 2; + while(i < len) + { + d_protocol[n] = Lc_Char2Hex(*(d_src+i))*16; + i ++; + d_protocol[n] += Lc_Char2Hex(*(d_src+i)); + i ++;i ++; + n ++; + } + return n; +} + +/* + * 函数名：itoa 不同类型的cpu不一样 并且支持的最大数据取决于i = 1000000;D_value_max + * 描述 ：将整形数据转换成字符串 + * 输入 ：-radix =10 表示10进制，其他结果为0 + * -value 要转换的整形数 + * -buf 转换后的字符串 + * -radix = 10 + * 输出 ：无 + * 返回 ：无 + * 调用 ：被USART1_printf()调用 + + Lc_int2a + + + */ + #define D_value_max 100000 +char *Lc_int2a(vS32 value, char *string, UN_TYPE radix) +{ + vS32 i, d; + UN_TYPE flag = 0; + vU16 U16temp = 0; + char *ptr = string; + + /* This implementation only works for decimal numbers. */ + //value + if (!value) + { + *ptr++ = 0x30; + *ptr = 0; + return string; + } + U16temp = value; + switch(radix) + {//%X2 %X4 %X6 + case '2': + *ptr++ = Lc_Hex2Char((U16temp>>4)&0x0f); + *ptr++ = Lc_Hex2Char((U16temp)&0x0f); + *ptr = 0; + return string; + break; + case '4': + *ptr++ = Lc_Hex2Char((U16temp>>12)&0x0f); + *ptr++ = Lc_Hex2Char((U16temp>>8)&0x0f); + *ptr++ = Lc_Hex2Char((U16temp>>12)&0x0f); + *ptr++ = Lc_Hex2Char((U16temp>>8)&0x0f); + *ptr++ = Lc_Hex2Char((U16temp>>4)&0x0f); + *ptr++ = Lc_Hex2Char((U16temp)&0x0f); + *ptr = 0; + return string; + break; + #if 0 + case '8': + *ptr++ = Lc_HexToChar((value>>24)&0x0f); + *ptr++ = Lc_HexToChar((value>>20)&0x0f); + *ptr++ = Lc_HexToChar((value>>16)&0x0f); + *ptr++ = Lc_HexToChar((value>>12)&0x0f); + *ptr++ = Lc_HexToChar((value>>8 )&0x0f); + *ptr++ = Lc_HexToChar((value>>4 )&0x0f); + *ptr++ = Lc_HexToChar((value)&0x0f); + *ptr = 0; + return string; + break; + #endif + case 10: + /* if this is a negative value insert the minus sign. */ + if (value < 0) + { + *ptr++ = '-'; + + /* Make the value positive. */ + value *= -1; + } + i = D_value_max; + if (value > i) + { + value = i; + } + for (;i > 0; i /= 10) + { + d = value / i; + + if (d || flag) + { + *ptr++ = (char)(d + 0x30); + value -= (d * i); + flag = 1; + } + } + + /* Null terminate the string. */ + *ptr = 0; + + return string; + break; + default: + *ptr++ = 0x30; + *ptr = 0; + return string; + break; + } + + +} /* NCL_Itoa */ +/// bits:生成的字符共几位数据 +void Lc_int2D(vS16 value, char *string,char bits) +{ + vS16 i, d; + UN_TYPE flag = 0; +// vU16 U16temp = 0; + char *ptr = string; + + /* This implementation only works for decimal numbers. */ + //value + +// U16temp = value; + /* if this is a negative value insert the minus sign. */ + if (value < 0) + { + *ptr++ = '-'; + value *= -1; + }else + { + *ptr++ = ' '; + + } + + + + i = us2fun2[bits-1]; + for (;i > 0; i /= 10) + { + d = value / i; + if((0 == d)&&(0 == flag)&&(1 != i)) + {/// + *ptr++ = ' '; + + }else + { + flag = 1;///第一个非零的数据出现 + *ptr = (char)(d + 0x30); + *ptr++; + value -= (d * i); + } + } + +} /* NCL_Itoa */ + + +//void (*L0_uart0_uc)(U8 ww); + +// 带buf的printf fixme: 需要精简地方 +void Lc_print_buf(char *dat4,...) +{ + const char *s; + vS32 d; + char buf[64]; ///取决于cpu的内存大小，如果出现问题，请先定位到此处 +// char send[16]; + char n = 0; + char *dat = 0; + va_list ap;//va_list 是一个字符指针，可以理解为指向当前参数的一个指针， + //取参必须通过这个指针进行。 +// 在调用参数表之前，定义一个 va_list 类型的变量， +//(假设va_list 类型变量被定义为ap)； + va_start(ap, dat); +// 然后应该对ap 进行初始化，让它指向可变参数表里面的第一个参数， +//这是通过 va_start 来实现的，第一个参数是 ap 本身，第二个参数是在 +//变参表前面紧挨着的一个变量,即“...”之前的那个参数； + + dat = dat4; +// 然后是获取参数，调用va_arg，它的第一个参数是ap， +//第二个参数是要获取的参数的指定类型，然后返回这个指定类型的值， +//并且把 ap 的位置指向变参表的下一个变量位置； + //"e645654675y73\0" + while ( *dat != 0) // 判断是否到达字符串结束符 + { + if ( *dat == 0x5c ) //'\' + { + switch ( *++dat ) + { + case 'r': //回车符 + ts_uart_send_depot.buf[n ++] = 0x0d;//L0pf_send_uc(0x0d); + dat ++; + break; + + case 'n': //换行符 + ts_uart_send_depot.buf[n ++] = 0x0a;//L0pf_send_uc(0x0a); + dat ++; + break; + + case 't': // + ts_uart_send_depot.buf[n ++] = 0x09;//L0pf_send_uc(0x09); + dat ++; + break; + default: + dat ++; + break; + } + } + else if ( *dat == '%') + { // + switch ( *++dat ) + { + case 'C': + case 'c': //字符 + //va_arg()里的任务就是根据指定的参数类型 + //取得本参数的值，并且把指针调到下一 + //个参数的起始地址 + //#define va_arg(ap,t) + //( *(t *)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)) ) + + //char *ap; %c " , 0x30, + s = va_arg(ap, const char *); // 0x30 + ts_uart_send_depot.buf[n ++] = (char)s;// L0pf_send_uc((char)s); // '0' + dat++; + break; + case 'd': //十进制 + //" %d",0x30, + //" %d",48, + // int i = 48; + //" %d",i, + + d = va_arg(ap, int); // 0x30 =48d + Lc_int2a(d, buf, 10); //"buf="48" buf[0]='4' buf[1]='8' + for (s = buf; *s; s++) // "48"----'4'--'8' '\0'--*s + { //\0 + ts_uart_send_depot.buf[n ++] = *s;//L0pf_send_uc(*s); + //printf("%c",*s); + } + dat++; + break; + case 'X': + case 'x': //字符串 + d = va_arg(ap, int); // 0x30 =48d + dat++;//%X2 %X4 %X8 + Lc_int2a(d, buf, *dat); //"buf="48" buf[0]='4' buf[1]='8' + for (s = buf; *s; s++) // "48"----'4'--'8' '\0'--*s + { //\0 + ts_uart_send_depot.buf[n ++] = *s;//L0pf_send_uc(*s); + } + dat++; + break; + case 'S': + case 's': //字符串 + s = va_arg(ap, const char *); + for ( ; *s; s++) + { + ts_uart_send_depot.buf[n ++] = *s;//L0pf_send_uc(*s); + } + dat++; + break; + case 'f': //十进制 + d = va_arg(ap, int); + Lc_int2a(d, buf, 10); + for (s = buf; *s; s++) + { + ts_uart_send_depot.buf[n ++] = *s;//L0pf_send_uc(*s); + + } + dat++; + break; + default: + dat++; + break; + } + } /* end of else if */ + else + { + ts_uart_send_depot.buf[n ++] = (*dat++);//L0pf_send_uc( *dat++); + } + }//end while.... + ts_uart_send_depot.max = n; + ts_uart_send_depot.p = ts_uart_send_depot.buf; + L0_uart0_sendbuf(); +}// +#endif + +#ifdef D_use_crc16 +/* +CRC码的步骤为： + +(1).预置16位寄存器为FFFFH。称此寄存器为CRC寄存器； + +(2).把第一个8位数据与CRC寄存器的低位相异或，把结果放于CRC寄存器； + +(3).把寄存器的内容右移一位(朝低位)，用0填补最高位，检查最低位； + +(4).如果最低位为0：重复第3步(再次移位)如果最低位为1：CRC寄存器与多项式A001（1010 0000 0000 0001）进行异或； + +(5).重复步骤3和4，直到右移8次，这样整个8位数据全部进行了处理； + +(6).重复步骤2到步骤5，进行下一个8位数据的处理； + +(7).最后得到的CRC寄存器即为CRC码。(CRC码 = CRC_L +CRC_H) + +*/ + + +/*****************crc校验**********************************************/ + +//crc生成函数，并将crc存储在预先定于的数组中 + +//调用方式crc16（指向数据的指针，需要校验的数据长度） + +unsigned char CRC[2];//定义数组 + +void crc16(unsigned char *ptr,unsigned int len) +{ + unsigned long wcrc=0XFFFF;//预置16位crc寄存器，初值全部为1 + unsigned char temp;//定义中间变量 + int i=0,j=0;//定义计数 + for(i=0;i>=1;//先将数据右移一位 + wcrc^=0XA001;//与上面的多项式进行异或 + } + else//如果不是1，则直接移出 + { + wcrc>>=1;//直接移出 + } + } + } + temp=wcrc;//crc的值 + CRC[0]=wcrc;//crc的低八位 + CRC[1]=wcrc>>8;//crc的高八位 +} +code U8 auchCRCHi[]= +{ +0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, +0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, +0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, +0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, +0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, +0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, +0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, +0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, +0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, +0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, +0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, +0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, +0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, +0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, +0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, +0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, +0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, +0x40 +}; + +code U8 auchCRCLo[] = +{ +0x00, 0xC0, 0xC1, 0x01, 0xC3, 0x03, 0x02, 0xC2, 0xC6, 0x06, 0x07, 0xC7, 0x05, 0xC5, 0xC4, +0x04, 0xCC, 0x0C, 0x0D, 0xCD, 0x0F, 0xCF, 0xCE, 0x0E, 0x0A, 0xCA, 0xCB, 0x0B, 0xC9, 0x09, +0x08, 0xC8, 0xD8, 0x18, 0x19, 0xD9, 0x1B, 0xDB, 0xDA, 0x1A, 0x1E, 0xDE, 0xDF, 0x1F, 0xDD, +0x1D, 0x1C, 0xDC, 0x14, 0xD4, 0xD5, 0x15, 0xD7, 0x17, 0x16, 0xD6, 0xD2, 0x12, 0x13, 0xD3, +0x11, 0xD1, 0xD0, 0x10, 0xF0, 0x30, 0x31, 0xF1, 0x33, 0xF3, 0xF2, 0x32, 0x36, 0xF6, 0xF7, +0x37, 0xF5, 0x35, 0x34, 0xF4, 0x3C, 0xFC, 0xFD, 0x3D, 0xFF, 0x3F, 0x3E, 0xFE, 0xFA, 0x3A, +0x3B, 0xFB, 0x39, 0xF9, 0xF8, 0x38, 0x28, 0xE8, 0xE9, 0x29, 0xEB, 0x2B, 0x2A, 0xEA, 0xEE, +0x2E, 0x2F, 0xEF, 0x2D, 0xED, 0xEC, 0x2C, 0xE4, 0x24, 0x25, 0xE5, 0x27, 0xE7, 0xE6, 0x26, +0x22, 0xE2, 0xE3, 0x23, 0xE1, 0x21, 0x20, 0xE0, 0xA0, 0x60, 0x61, 0xA1, 0x63, 0xA3, 0xA2, +0x62, 0x66, 0xA6, 0xA7, 0x67, 0xA5, 0x65, 0x64, 0xA4, 0x6C, 0xAC, 0xAD, 0x6D, 0xAF, 0x6F, +0x6E, 0xAE, 0xAA, 0x6A, 0x6B, 0xAB, 0x69, 0xA9, 0xA8, 0x68, 0x78, 0xB8, 0xB9, 0x79, 0xBB, +0x7B, 0x7A, 0xBA, 0xBE, 0x7E, 0x7F, 0xBF, 0x7D, 0xBD, 0xBC, 0x7C, 0xB4, 0x74, 0x75, 0xB5, +0x77, 0xB7, 0xB6, 0x76, 0x72, 0xB2, 0xB3, 0x73, 0xB1, 0x71, 0x70, 0xB0, 0x50, 0x90, 0x91, +0x51, 0x93, 0x53, 0x52, 0x92, 0x96, 0x56, 0x57, 0x97, 0x55, 0x95, 0x94, 0x54, 0x9C, 0x5C, +0x5D, 0x9D, 0x5F, 0x9F, 0x9E, 0x5E, 0x5A, 0x9A, 0x9B, 0x5B, 0x99, 0x59, 0x58, 0x98, 0x88, +0x48, 0x49, 0x89, 0x4B, 0x8B, 0x8A, 0x4A, 0x4E, 0x8E, 0x8F, 0x4F, 0x8D, 0x4D, 0x4C, 0x8C, +0x44, 0x84, 0x85, 0x45, 0x87, 0x47, 0x46, 0x86, 0x82, 0x42, 0x43, 0x83, 0x41, 0x81, 0x80, +0x40 +}; + +U16 N_CRC16(U8 *updata,U8 len) +{ + U8 uchCRCHi=0xff; + U8 uchCRCLo=0xff; + U8 uindex; + while(len--) + { + uindex = uchCRCHi^*updata++; + uchCRCHi = uchCRCLo^auchCRCHi[uindex]; + uchCRCLo = auchCRCLo[uindex]; + } + return (uchCRCHi<<8 | uchCRCLo); +} + +#endif +#if 0 //5436345673456 +/******************************************************************** +* +* 名称: L0_Usend_uc_hex +* 说明: 例如:L0_Usend_uc_hex(0x0c); output " 0c " +* 功能: 发送数据 +* 调用: SendHUc（）Lc_HexToChar（） +* 输入: +* 返回值: 无 +***********************************************************************/ +void Lc_uc_hex(char ww) +{ + L0_uart0_uc(Lc_Hex2Char((ww>>4)&0x0f)); + L0_uart0_uc(Lc_Hex2Char(ww&0x0f)); +} + +void Lc_us_hex(U16 ww) +{// + U8 t; + t = (U8)(((ww >> 8)&0x00ff)); + Lcp_uc_hex(t); + t = (U8)(((ww )&0x00ff)); + Lcp_uc_hex(t); +} + +void Lc_print_NC(char *dat,...) +{ + +} +// 非缓存模式的打印 fixme: 发送16进制数据时有bug +void Lc_print33333(char *dat4,...) +{ + const char *s; + vS32 d; + char buf[16];//char t; + char *dat = NULL; + va_list ap;//va_list 是一个字符指针，可以理解为指向当前参数的一个指针， + //取参必须通过这个指针进行。 +// 在调用参数表之前，定义一个 va_list 类型的变量， +//(假设va_list 类型变量被定义为ap)； + va_start(ap, dat4); +// 然后应该对ap 进行初始化，让它指向可变参数表里面的第一个参数， +//这是通过 va_start 来实现的，第一个参数是 ap 本身，第二个参数是在 +//变参表前面紧挨着的一个变量,即“...”之前的那个参数； +dat =dat4; +// 然后是获取参数，调用va_arg，它的第一个参数是ap， +//第二个参数是要获取的参数的指定类型，然后返回这个指定类型的值， +//并且把 ap 的位置指向变参表的下一个变量位置； + //"e645654675y73\0" + while ( *dat != 0) // 判断是否到达字符串结束符 + { + if ( *dat == 0x5c ) //'\' + { + switch ( *++dat ) + { + case 'r': //回车符 + L0_uart0_uc(0x0d); + dat ++; + break; + + case 'n': //换行符 + L0_uart0_uc(0x0a); + dat ++; + break; + + case 't': // + L0_uart0_uc(0x09); + dat ++; + break; + default: + dat ++; + break; + } + } + else if ( *dat == '%') + { // + switch ( *++dat ) + { + case 'C': + case 'c': //字符 + //va_arg()里的任务就是根据指定的参数类型 + //取得本参数的值，并且把指针调到下一 + //个参数的起始地址 + //#define va_arg(ap,t) + //( *(t *)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)) ) + + //char *ap; %c " , 0x30, + s = va_arg(ap, const char *); // 0x30 + L0_uart0_uc((char)s); // '0' + dat++; + break; + case 'd': //十进制 + //" %d",0x30, + //" %d",48, + // int i = 48; + //" %d",i, //#define va_arg(ap,t) (((t *)ap)++[0]) //(((int *)ap)++[0]) + + d = va_arg(ap, int); // 0x30 =48d + d >>= 8; + Lc_int2a(d, buf, 10); //"buf="48" buf[0]='4' buf[1]='8' + for (s = buf; *s; s++) // "48"----'4'--'8' '\0'--*s + { //\0 + L0_uart0_uc(*s); + //printf("%c",*s); + } + dat++; + break; + case 'X': + case 'x': //字符串 + d = va_arg(ap, int); // 0x30 =48d + d >>= 8; + dat++;//%X2 %X4 %X8 + Lc_int2a(d, buf, *dat); //"buf="48" buf[0]='4' buf[1]='8' + for (s = buf; *s; s++) // "48"----'4'--'8' '\0'--*s + { //\0 + L0_uart0_uc(*s); + } + dat++; + break; + case 'S': + case 's': //字符串 + s = va_arg(ap, const char *); + for ( ; *s; s++) + { + L0_uart0_uc(*s); + } + dat++; + break; + case 'f': //十进制 + d = va_arg(ap, int); + Lc_int2a(d, buf, 10); + for (s = buf; *s; s++) + { + L0_uart0_uc(*s); + + } + dat++; + break; + default: + dat++; + break; + } + } /* end of else if */ + else + { + L0_uart0_uc(*dat ++); + //t = *dat; + //L0pf_send_uc = L0_uart0_uc; + //L0pf_send_uc(t); + //L0_uart0_uc(t); + //dat++; + } + }//end while....斯蒂芬 +}// + + + + + +///计算CRC校验码 +unsigned int CRC16(unsigned char *ptr, unsigned char len) +{ + unsigned int crc=0xffff; + unsigned char i; + while(len--) + { + crc ^=*ptr++; + for(i=0;i<8;i++) + { + if(crc & 0x1) + { + crc>>=1; + crc^=0xa001; + } + else + { + crc>>=1; + } + } + } + return crc; +} + + + +///检测CRC校验码是否正确 +unsigned char CheckCRC(unsigned char *ptr,unsigned char len) +{ + unsigned int crc; + crc = (unsigned int)CRC16(ptr,(len-2)); + if(ptr[len-1]==(crc>>8) && ptr[len-2]==(crc & 0x00ff)) + { + return 0xff; + } + else + { + return 0x0; + } +} + + +char *strstr(const char *str1, const char *str2) +{ + char *cp = (char*)str1; + char *s1, *s2; + + if (!*str2) + return((char *)str1); + + while (*cp) + { + s1 = cp; + s2 = (char *)str2; + + while (*s1 && *s2 && !(*s1 - *s2)) + s1++, s2++; + + if (!*s2) + return(cp); + + cp++; + } + return(NULL); +} + + + +//12,34 +void Lc_int2str_2_2(U32 ui_in,char *d) +{ + U8 m = 0;//,i; + + if (ui_in >= ul2fun2[4])// 1000 123456 + { + *(d+m) = 0x30 + Lc_WEI(ui_in,(4));// (unsigned char)((ui_in/ul2fun2[len-i])%10); + m ++; + } + else + { + *(d+m) = ' '; + m ++; + } + if (ui_in >= ul2fun2[3])// 1000 12345 + { + *(d+m) = 0x30 + Lc_WEI(ui_in,(3));// (unsigned char)((ui_in/ul2fun2[len-i])%10); + m ++; + } + else + { + *(d+m) = ' '; + m ++; + } + + if (ui_in >= ul2fun2[2])// 100 12345 + { + *(d+m) = 0x30 + Lc_WEI(ui_in,(2));// (unsigned char)((ui_in/ul2fun2[len-i])%10); + m ++; + } + else + { + *(d+m) = '0'; + m ++; + } + + *(d+m) = '.'; + m ++; + if (ui_in >= ul2fun2[1])// 10 12345 + { + *(d+m) = 0x30 + Lc_WEI(ui_in,(1));// (unsigned char)((ui_in/ul2fun2[len-i])%10); + m ++; + } + else + { + *(d+m) = '0'; + m ++; + } + *(d+m) = 0x30 + Lc_WEI(ui_in,0); + +} + + + +// 123.4 + +void Lc_int2str_3_1(U32 ui_in,char *d) +{ + U8 m = 0;//,i; + if (ui_in >= ul2fun2[4])// 1000 12345 + { + *(d+m) = 0x30 + Lc_WEI(ui_in,(4));// (unsigned char)((ui_in/ul2fun2[len-i])%10); + m ++; + } + else + { + *(d+m) = ' '; + m ++; + } + + + if (ui_in >= ul2fun2[3])// 1000 12345 + { + *(d+m) = 0x30 + Lc_WEI(ui_in,(3));// (unsigned char)((ui_in/ul2fun2[len-i])%10); + m ++; + } + else + { + *(d+m) = ' '; + m ++; + } + + if (ui_in >= ul2fun2[2])// 100 12345 + { + *(d+m) = 0x30 + Lc_WEI(ui_in,(2));// (unsigned char)((ui_in/ul2fun2[len-i])%10); + m ++; + } + else + { + *(d+m) = ' '; + m ++; + } + + if (ui_in >= ul2fun2[1])// 10 12345 + { + *(d+m) = 0x30 + Lc_WEI(ui_in,(1));// (unsigned char)((ui_in/ul2fun2[len-i])%10); + m ++; + } + else + { + *(d+m) = '0'; + m ++; + } + *(d+m) = '.'; + m ++; + *(d+m) = 0x30 + Lc_WEI(ui_in,0); + +} + + +//-123 +void Lc_sint2str_3(int i_in,char *d) +{ + U8 m = 0;//,i; + U32 ui_in; + if(i_in < 0) + { + ui_in = (U32)(0-i_in); + *(d+m) = '-'; + }else + { + ui_in = (U32)(i_in); + *(d+m) = ' '; + } + m ++; + + if (ui_in >= ul2fun2[2])// 100 12345 + { + *(d+m) = 0x30 + Lc_WEI(ui_in,(2));// (unsigned char)((ui_in/ul2fun2[len-i])%10); + m ++; + } + else + { + *(d+m) = ' '; + m ++; + } + + if (ui_in >= ul2fun2[1])// 10 12345 + { + *(d+m) = 0x30 + Lc_WEI(ui_in,(1));// (unsigned char)((ui_in/ul2fun2[len-i])%10); + m ++; + } + else + { + *(d+m) = ' '; + m ++; + } + *(d+m) = 0x30 + Lc_WEI(ui_in,0); +} + + +// 12345 + +void Lc_int2str_5(U32 ui_in,char *d) +{ + U8 m = 1;//,i; + *(d+0) = ' '; + if (ui_in >= ul2fun2[4])// 10,000 12345 + { + *(d+m) = 0x30 + Lc_WEI(ui_in,(4));// (unsigned char)((ui_in/ul2fun2[len-i])%10); + m ++; + } + else + { + *(d+m) = ' '; + m ++; + } + + + if (ui_in >= ul2fun2[3])// 1,000 12345 + { + *(d+m) = 0x30 + Lc_WEI(ui_in,(3));// (unsigned char)((ui_in/ul2fun2[len-i])%10); + m ++; + } + else + { + *(d+m) = ' '; + m ++; + } + + if (ui_in >= ul2fun2[2])// 100 12345 + { + *(d+m) = 0x30 + Lc_WEI(ui_in,(2));// (unsigned char)((ui_in/ul2fun2[len-i])%10); + m ++; + } + else + { + *(d+m) = ' '; + m ++; + } + + if (ui_in >= ul2fun2[1])// 10 12345 + { + *(d+m) = 0x30 + Lc_WEI(ui_in,(1));// (unsigned char)((ui_in/ul2fun2[len-i])%10); + m ++; + } + else + { + *(d+m) = ' '; + m ++; + } + + *(d+m) = 0x30 + Lc_WEI(ui_in,0); + +} +//40 +void Lc_int2str_4(U32 ui_in,char *d) +{ + U8 m = 0;//,i; + + if (ui_in >= ul2fun2[3])// 1,000 12345 + { + *(d+m) = 0x30 + Lc_WEI(ui_in,(3));// (unsigned char)((ui_in/ul2fun2[len-i])%10); + m ++; + } + else + { + *(d+m) = ' '; + m ++; + } + + if (ui_in >= ul2fun2[2])// 100 12345 + { + *(d+m) = 0x30 + Lc_WEI(ui_in,(2));// (unsigned char)((ui_in/ul2fun2[len-i])%10); + m ++; + } + else + { + *(d+m) = ' '; + m ++; + } + + if (ui_in >= ul2fun2[1])// 10 12345 + { + *(d+m) = 0x30 + Lc_WEI(ui_in,(1));// (unsigned char)((ui_in/ul2fun2[len-i])%10); + m ++; + } + else + { + *(d+m) = ' '; + m ++; + } + *(d+m) = 0x30 + Lc_WEI(ui_in,0); +} + + +// 123 +void Lc_int2str_3(U32 ui_in,char *d) +{ + U8 m = 0;//,i; + + if (ui_in >= ul2fun2[2])// 100 12345 + { + *(d+m) = 0x30 + Lc_WEI(ui_in,(2));// (unsigned char)((ui_in/ul2fun2[len-i])%10); + m ++; + } + else + { + *(d+m) = ' '; + m ++; + } + + if (ui_in >= ul2fun2[1])// 10 12345 + { + *(d+m) = 0x30 + Lc_WEI(ui_in,(1));// (unsigned char)((ui_in/ul2fun2[len-i])%10); + m ++; + } + else + { + *(d+m) = ' '; + m ++; + } + *(d+m) = 0x30 + Lc_WEI(ui_in,0); +} + + +//Lc_int2str(123456, 5,3,&str[0]'); +/* + + +blank 填充字符 ' '或者其他unsigned char *blank)//保留以后使用 + + +*/ + + + +void Lc_int2str(U32 ui_in,UN_TYPE len,UN_TYPE point,char *d) +{ + U8 m = 0,i; + for(i = 0;i < len;i++) + { + if(point != 0) + { + if(point == (len-i+1)) + { + *(d+m) = '.'; + m ++; + } + } + if (ui_in>=ul2fun2[len-i]) + { + *(d+m) = 0x30 + Lc_WEI(ui_in,(len-i));// (unsigned char)((ui_in/ul2fun2[len-i])%10); + m ++; + } + else + { + *(d+m) = ' '; + m ++; + } + } + *(d+m) = 0x30 + Lc_WEI(ui_in,1); + m++; + *(d+m) = 0x00; + //*(d+m) = 'e'; +} + + +// input: 123456d +// output: '1' '2' '3'.... +//对应的点阵 为 0123456789. ，最后为空格，专为显示点阵类的数值使用 +void Lc_int2number(U32 ui_in,UN_TYPE len,UN_TYPE point,char *d) +{ + U8 i,m = 0; //uc_temp, + for(i = len+1;i != 0;i--)// len + 1 point 占用一位 + { + if(point == (len-i)) + { + d[len-m] = '.';//'.' + m ++; + } + { + if (ui_in>=ul2fun2[i-1]) + { + d[len-m] = (U8)((ui_in/ul2fun2[i-1])%10); + + } + else + { + d[len-m] = ' ';//' ' + } + m ++; + } + } + d[len-m] = (U8)(ui_in%10); +} + +void Lc_Byte_cp(BYTE *src,BYTE *dis, int len) +{ + int i; + for(i = 0; i < len ;i ++) + { + *dis = *src; + dis ++; + src ++; + } + //return 0; +} +/* +void Lc_Byte_print(BYTE *src,int len) +{ + int i, d; + for(i = 0; i < len ;i ++) + { + *dis = *src; + dis ++; + src ++; + } + //return 0; +} +*/ + + +// -10........+10 + +U32 L2_fun_number_show(int i,char str[4]) +{ + U8 c; + int cint; + + if(i >= 0) + { + cint = i; + str[0] =' '; + + } + else + { + cint = 0 - i; + str[0] ='-'; + + + } + c = Lc_WEI(cint,1); + if(0 == c) + { + str[1] =' '; + } + else + { + str[1] = 0x30+ c; + + } + str[2] = 0x30+ Lc_WEI(cint,0); + return 0; +} + +//L1_lkt_write(s_room_val.ui_t3,s_room_val.ui_t3,s_task_lkt.din); +//U_uluiuc + +void Lc_2ui2buf(vU32 ui_t2,vU32 ui_t3,volatile BYTE out[]) +{ +#if 0 + volatile U_uluiuc t; + //s_temp[] + t.uiv[0] = ui_t2; + t.uiv[1] = ui_t3; + + + Lc_Byte_cp(t.dv,out,8); + + out[3] = D_ul2uc_0( ui_t2); + ui_t2 >>= 8; + out[2] = D_ul2uc_0( ui_t2); + ui_t2 >>= 8; + out[1] = D_ul2uc_0( ui_t2); + ui_t2 >>= 8; + out[0] = D_ul2uc_0( ui_t2); + + + out[7] = D_ul2uc_0( ui_t3); + ui_t2 >>= 8; + out[6] = D_ul2uc_0( ui_t3); + ui_t2 >>= 8; + out[5] = D_ul2uc_0( ui_t3); + ui_t2 >>= 8; + out[4] = D_ul2uc_0( ui_t3); + + + #else + out[0] = D_ul2uc_0( ui_t2); + ui_t2 >>= 8; + out[1] = D_ul2uc_0( ui_t2); + ui_t2 >>= 8; + out[2] = D_ul2uc_0( ui_t2); + ui_t2 >>= 8; + out[3] = D_ul2uc_0( ui_t2); + +/* + out[4] = D_ul2uc_0( ui_t3); + ui_t2 >>= 8; + out[5] = D_ul2uc_0( ui_t3); + ui_t2 >>= 8; + out[6] = D_ul2uc_0( ui_t3); + ui_t2 >>= 8; + out[7] = D_ul2uc_0( ui_t3); +*/ +#endif + +} + +void L1_buf22ui(volatile BYTE in[],vU32 *ui_t2,vU32 *ui_t3) +{ + #if 0 + volatile U_uluiuc t; + Lc_Byte_cp(in,t.dv,8); + *ui_t2 = t.uiv[0]; + *ui_t3 = t.uiv[1]; + *ui_t2 = 0; + *ui_t2|= (U32)in[3]; + *ui_t2|= (U32)(in[2]<<8); + *ui_t2|= (U32)(in[1]<<16); + *ui_t2|= (U32)(in[0]<<24); + + *ui_t3 = 0; + *ui_t3|= (U32)in[7]; + *ui_t3|= (U32)(in[6]<<8); + *ui_t3|= (U32)(in[5]<<16); + *ui_t3|= (U32)(in[4]<<24); + + #else + + + *ui_t2 = 0; + *ui_t2|= (U32)in[0]; + *ui_t2|= (U32)(in[1]<<8); + *ui_t2|= (U32)(in[2]<<16); + *ui_t2|= (U32)(in[3]<<24); + /* + *ui_t3 = 0; + *ui_t3|= (INT32U)in[4]; + *ui_t3|= (INT32U)(in[5]<<8); + *ui_t3|= (INT32U)(in[6]<<16); + *ui_t3|= (INT32U)(in[7]<<24); + */ + #endif +} + +U32 Lc_abs(vU32 a,vU32 b,vU32 *diff) +{ + if(a >= b) + { + *diff = a-b; + return 1; + }else + { + *diff = b-a; + return 0; + } +} + + + + + +#endif //#if 0 //5436345673456 + +/****************************************************************************** +** End Of File +******************************************************************************/ + diff --git a/source/clib/clib.h b/source/clib/clib.h new file mode 100644 index 0000000..3809441 --- /dev/null +++ b/source/clib/clib.h @@ -0,0 +1,121 @@ +/***************************************************************************** + * uart.h: Header file for NXP LPC17xx Family Microprocessors + * + * Copyright(C) 2009, NXP Semiconductor + * All rights reserved. + * + * History + * 2009.05.27 ver 1.00 Prelimnary version, first Release + * +******************************************************************************/ +#ifndef _CLIB_H_ +#define _CLIB_H_ + + +#include +#include +#include "../clib/type.h" +//#include "../clib/Clib.h" +//#include "../debug/debug_drv.h" +//extern char guc_send[128]; +extern unsigned char code cguHex2Char[16][2]; +typedef struct +{ + vU16 up_point; + vU16 down_point; + + +}TS_up_down_p_; + +extern U8 Lc_Hex2Char(U8 CharStr); +extern U8* Lc_strcpy(U8* dst,const char* str); +//extern void Lc_int2str(U32 ui_in,UN_TYPE len,UN_TYPE point,char *d); +// input: 123456d +// output: '1' '2' '3'.... +//Ӧĵ Ϊ 0123456789. ΪոרΪʾֵʹ +//extern void Lc_int2number(U32 ui_in,UN_TYPE len,UN_TYPE point,char *d); +//extern U32 L2_fun_number_show(int i,char str[4]); +#if 0 + +struct _s_temp_ +{ + U8 d[16]; + +}; + +extern struct _s_temp_ s_temp22; +extern U8 s_temp[16]; + +extern U32 ul2fun2[10]; +extern void Lc_Byte_cp(BYTE *src,BYTE *dis, int len); + +extern void L1_buf22ui(volatile BYTE in[],vU32 *ui_t2,vU32 *ui_t3); + +extern void Lc_2ui2buf(vU32 ui_t2,vU32 ui_t3,volatile BYTE out[]); +extern void Lc_int2str_3(U32 ui_in,char *d); +extern U32 Lc_abs(vU32 a,vU32 b,vU32 *diff); +extern void Lc_int2str_4(U32 ui_in,char *d); + +extern void Lc_sint2str_3(int i_in,char *d); +#define Lc_WEI(WEIx,WEIn) (U8)((WEIx/ul2fun2[WEIn])%10); +#define Lc_eee(WEIn) ul2fun2[WEIn] + + +#endif + +extern char *Lc_int2a(vS32 value, char *string, UN_TYPE radix); + +extern void Lc_int2D(vS16 value, char *string,char bits); + +extern char *strstr(const char *str1, const char *str2); +extern unsigned char catch_protocol (const char d_src[],char d_protocol[]) ; +#define Lc_delay_1us() L0_delay_1us() + + +extern void Lc_delay_us(vU16 i); +extern void Lc_delay_ms(vU16 i); +extern void Lc_delay_nop(U8 i); + +//////////////// + +extern void Lc_uc_hex(char ww); +extern void Lc_us_hex(U16 ww); +//extern void Lc_print(void (*L0pf_send_uc)(char ww), char *dat,...); +extern void Lc_print(char *dat4,...); +extern void Lc_print_NC(char *dat,...); +extern void Lc_print_buf(char *dat4,...); + + +extern void L3_us_big(U16 *d); +extern void L3_ui_big(vU32 *d); +extern void Lc_buf_copy_uc(U8 *d,const U8 *s,U16 num); + +///void L2_line_algo_media(U8 *buf,vU16 len); +extern vU8 Lc_U8_media3(vU8 a,vU8 b,vU8 c); +extern vS32 Lc_S32_media3(vS32 a,vS32 b,vS32 c); +extern vS32 Lc_S32_media(vS32 val[],S16 num); +extern void Lc_array_sort(S32 arr[],int n); + +/// 0x11 0x22 ---> 0x31 0x31 0x32 0x32 '1' '1' '2' '2' +extern void Lc_hex2ascii(U8 *buf,U16 len,U8 *ascii); +extern void crc16(unsigned char *CRC,void *dat,unsigned int len) /*reentrant*/; +//extern void crc16_irq(unsigned char *CRC,void *dat,unsigned int len); +extern int isBigEndianOrder(void); +extern U32 ntohl(U32 dat); +extern U32 htonl(U32 dat); +extern U16 ntohs(U16 dat); +extern U16 htons(U16 dat); +extern U32 Lc_abs(vS32 a,vS32 b); +extern void Lc_encrypt_id(U8 *enc_dst, U8 *enc_src, U32 enc_key, U8 src_len); +extern void Lc_encrypt_id1(U8 *enc_dst, U8 *enc_src, U8 enc_key[], U8 src_len); +extern int Lc_strlen(char *str); +extern U32 Lc_vU32_avg(U32 *d, U8 n); +extern U32 Lc_vS32_media(U32 *d, U8 n); +extern int Lc_memset(U8 *buf,U8 c,U16 len); + + + +#endif /* end __UART_H */ +/***************************************************************************** +** End Of File +******************************************************************************/ diff --git a/source/clib/type.h b/source/clib/type.h new file mode 100644 index 0000000..439b662 --- /dev/null +++ b/source/clib/type.h @@ -0,0 +1,318 @@ +////////////////////////////////////////////////////////////////////////// +/// COPYRIGHT NOTICE +/// Copyright (c) 2020, ؿƼ +/// All rights reserved. +/// +/// @file main.c +/// @brief main app +/// +///ļʵֵĹܵ +/// +/// @version 1.1 CCsens technology +/// @author CC +/// @date 20150102 +/// +/// +/// ޶˵汾 +/// Modified by: cc +/// Modified date: 20200531 +/// Version: +/// Descriptions: add u8 +////////////////////////////////////////////////////////////////////////// + + +//#include + +#ifndef __TYPE_H__ +#define __TYPE_H__ + +#ifndef NULL +#define NULL ((void *)0) +#endif + +#ifndef FALSE +#define FALSE (0) +#endif + +#ifndef D_stop +#define D_stop (1) +#endif + +#ifndef D_run +#define D_run (0) +#endif + +#ifndef D_ready +#define D_ready (1) +#endif + +#ifndef D_ready2 +#define D_ready2 (2) +#endif + + +#ifndef D_max +#define D_max (3) +#endif + + + +#ifndef D_diff +#define D_diff (4) +#endif + +#ifndef D_set +#define D_set (1) +#endif + + + +#ifndef D_clear +#define D_clear (0) +#endif +#define D_ON 1 +#define D_OFF 0 + +#define D_sleep_wakeup 3 +#define D_sleep 1 +#define D_wakeup 0 + +#ifndef TRUE +#define TRUE (1) +#endif + +/********************************************************************************************************* + ޹ص +*********************************************************************************************************/ + +typedef unsigned char U8; +typedef unsigned char u8; +typedef volatile U8 vU8; + + + +typedef U8 BOOLEAN; /* */ +typedef U8 *PU8; +typedef U8 BYTE; +typedef signed char S8; +typedef volatile signed char vS8; +typedef signed char *PS8; + + + +#define bit char +//#define code + +typedef unsigned short u16; +typedef unsigned short U16; /* ޷16λͱ */ +typedef volatile U16 vU16; /* ޷16λͱ */ +typedef signed short S16; +typedef volatile S16 vS16; /* з16λͱ */ + +typedef signed long S32; +typedef unsigned long U32; /* ޷32λͱ */ +typedef volatile U32 vU32; /* з32λͱ */ +typedef volatile signed long vS32; + +typedef float FP32; /* ȸ32λȣ */ +typedef double FP64; /* ˫ȸ64λȣ */ + + +//typedef unsigned char BOOLEAN; // +typedef unsigned char INT8U; // ޷8λͱ +typedef signed char INT8S; // з8λͱ +typedef unsigned short INT16U; // ޷16λͱ +typedef signed short INT16S; // з16λͱ +typedef unsigned long INT32U; // ޷32λͱ + +typedef signed long INT32S; // з32λͱ +//typedef float FP32; // ȸ32λȣ +//typedef double FP64; // ˫ȸ64λȣ + +typedef unsigned int FLAG_P; // ׼ +//typedef unsigned char INTU; // ׼8BIT MCU +typedef unsigned int INTU; // ׼32BIT MCU +/****************** +**************************/ + + + +/********************************************************************************************************* + ֵ +*********************************************************************************************************/ +#define ZY_OK 0 /* ɹ */ +#define ZY_NOT_OK 1 /* ʧ */ +#define ZY_PARAMETER_ERR 2 /* */ +#define ZY_NO_FIND_FUNCTION 6 /* ûзָ */ +#define ZY_NO_MEMORY 12 /* ڴ治 */ +#define ZY_TIME_OUT 13 /* ʱ */ +#define ZY_NO_FIND_OBJECT 16 /* ûзֶ */ + +/********************************************************************************************************* + realViewҪӵͷļ +*********************************************************************************************************/ +#include +#include +#include +//#include +#define D_flag_lock 2 +#define D_flag_clear 0 +#define D_flag_CanUse 1 + + +typedef enum {RESET = 0, SET = !RESET} FlagStatus, ITStatus; +typedef enum {DISABLE = 0, ENABLE = !DISABLE} FunctionalState; + +typedef U8 UN_TYPE; +typedef U8 vtype; + + + +/************* + +******************/ + +//>>>>> + + +typedef union +{ + vU32 ui; + vU16 s[2]; + vU8 d[4]; +}tu_ui4uc; + +typedef union +{ + vU16 word; + struct + { + vU8 h; + vU8 l; + }BYTE2; +}U_U16; + +typedef union +{ + vU32 dWord; + ///High 0123 Low + struct + { + vU8 byte0; + vU8 byte1; + vU8 byte2; + vU8 byte3; + }BYTE4; +}U_U32; +typedef union +{ + vU16 us; + vU8 uc[2]; + struct + { + vU8 H; + vU8 L; + }BYTE2; +}U_F16; +/********** +k.us = 0x1234 +uc + [0]=0x12 + [1]=0x34 +byte2 + H=0x12 + L=0x34 + +**********/ + + + +typedef union +{ + float fl; + vU8 uc[4]; + +}U_F32; + +typedef struct +{ + vU8 *buffer; + vU8 wpt; + vU8 rpt; + vU8 cnt; +}byte_len_fifo_struct; + +typedef struct +{ + vU16 *buffer; + vU16 wpt; + vU16 rpt; + vU16 cnt; +}word_len_fifo_struct; + +typedef struct +{ + vU16 x; + vU16 y; +}point_struct; + + +typedef struct +{ + vU16 x; + vU16 y; + vU16 width; + vU16 height; +}rect_struct; + + +#define HIGHT 1 +#define LOW 0 +#if 0 +#ifndef MIN +#define MIN(a,b) (((a) < (b)) ? (a) : (b)) +#endif + +#ifndef MAX +#define MAX(a, b) (((a) > (b)) ? (a) : (b)) +#endif +#endif +#ifndef ABS +#define ABS(a, b) (((a) > (b)) ? ((a) - (b)) : ((b) - (a))) +#endif + + +#define F_FINSIH 1 +#define F_WORKING 0 +#define F_WAITINGKEY 2 + + +#define DF_var_up(v,step,max,init) (v) += (step);if((v) > (max)) (v) = (init); +//if step > 1 bug warning!! +#define DF_var_down(v,step,min,init) \ +if((v) < ((min) + (step))) \ +{ \ + (v) = (init); \ +}else \ +{ \ + (v) -= (step); \ +} + +#define D_us2uc_H(x) (U8)(0x00ff&((x)>>8)) +#define D_us2uc_L(x) (U8)(0x00ff&(x)) + + +#define D_ul2uc_0(xx) (U8)(0x000000ff&(xx)) +#define D_uc_high(ww) ((ww)>>4) +#define D_uc_low(ww) ((ww)&0x0f) + +#define L0_type_byte(x) ((U8 *) &(x)) + + +//#define _nop_ __NOP +// #define _nop_ + + +extern void L3_us_big(U16 *d); +extern void L3_ui_big(vU32 *d); +#endif /* __TYPE_H__ */ diff --git a/source/cpu/STARTUP.A51 b/source/cpu/STARTUP.A51 new file mode 100644 index 0000000..65daedc --- /dev/null +++ b/source/cpu/STARTUP.A51 @@ -0,0 +1,198 @@ +$NOMOD51 +;------------------------------------------------------------------------------ +; This file is part of the C51 Compiler package +; Copyright (c) 1988-2005 Keil Elektronik GmbH and Keil Software, Inc. +; Version 8.01 +; +; *** <<< Use Configuration Wizard in Context Menu >>> *** +;------------------------------------------------------------------------------ +; STARTUP.A51: This code is executed after processor reset. +; +; To translate this file use A51 with the following invocation: +; +; A51 STARTUP.A51 +; +; To link the modified STARTUP.OBJ file to your application use the following +; Lx51 invocation: +; +; Lx51 your object file list, STARTUP.OBJ controls +; +;------------------------------------------------------------------------------ +; +; User-defined Power-On Initialization of Memory +; +; With the following EQU statements the initialization of memory +; at processor reset can be defined: +; +; IDATALEN: IDATA memory size <0x0-0x100> +; Note: The absolute start-address of IDATA memory is always 0 +; The IDATA space overlaps physically the DATA and BIT areas. +IDATALEN EQU 80H +; +; XDATASTART: XDATA memory start address <0x0-0xFFFF> +; The absolute start address of XDATA memory +XDATASTART EQU 0 +; +; XDATALEN: XDATA memory size <0x0-0xFFFF> +; The length of XDATA memory in bytes. +XDATALEN EQU 3072 +; +; PDATASTART: PDATA memory start address <0x0-0xFFFF> +; The absolute start address of PDATA memory +PDATASTART EQU 0H +; +; PDATALEN: PDATA memory size <0x0-0xFF> +; The length of PDATA memory in bytes. +PDATALEN EQU 0H +; +; +;------------------------------------------------------------------------------ +; +; Reentrant Stack Initialization +; +; The following EQU statements define the stack pointer for reentrant +; functions and initialized it: +; +; Stack Space for reentrant functions in the SMALL model. +; IBPSTACK: Enable SMALL model reentrant stack +; Stack space for reentrant functions in the SMALL model. +IBPSTACK EQU 0 ; set to 1 if small reentrant is used. +; IBPSTACKTOP: End address of SMALL model stack <0x0-0xFF> +; Set the top of the stack to the highest location. +IBPSTACKTOP EQU 0xFF +1 ; default 0FFH+1 +; +; +; Stack Space for reentrant functions in the LARGE model. +; XBPSTACK: Enable LARGE model reentrant stack +; Stack space for reentrant functions in the LARGE model. +XBPSTACK EQU 1 ; set to 1 if large reentrant is used. +; XBPSTACKTOP: End address of LARGE model stack <0x0-0xFFFF> +; Set the top of the stack to the highest location. +XBPSTACKTOP EQU 0xFFFF +1 ; default 0FFFFH+1 +; +; +; Stack Space for reentrant functions in the COMPACT model. +; PBPSTACK: Enable COMPACT model reentrant stack +; Stack space for reentrant functions in the COMPACT model. +PBPSTACK EQU 0 ; set to 1 if compact reentrant is used. +; +; PBPSTACKTOP: End address of COMPACT model stack <0x0-0xFFFF> +; Set the top of the stack to the highest location. +PBPSTACKTOP EQU 0xFF +1 ; default 0FFH+1 +; +; +;------------------------------------------------------------------------------ +; +; Memory Page for Using the Compact Model with 64 KByte xdata RAM +; Compact Model Page Definition +; +; Define the XDATA page used for PDATA variables. +; PPAGE must conform with the PPAGE set in the linker invocation. +; +; Enable pdata memory page initalization +PPAGEENABLE EQU 0 ; set to 1 if pdata object are used. +; +; PPAGE number <0x0-0xFF> +; uppermost 256-byte address of the page used for PDATA variables. +PPAGE EQU 0 +; +; SFR address which supplies uppermost address byte <0x0-0xFF> +; most 8051 variants use P2 as uppermost address byte +PPAGE_SFR DATA 0A0H +; +; +;------------------------------------------------------------------------------ + +; Standard SFR Symbols +ACC DATA 0E0H +B DATA 0F0H +SP DATA 81H +DPL DATA 82H +DPH DATA 83H + + NAME ?C_STARTUP + + +?C_C51STARTUP SEGMENT CODE +?STACK SEGMENT IDATA + + RSEG ?STACK + DS 1 + + EXTRN CODE (?C_START) + PUBLIC ?C_STARTUP + + CSEG AT 0 +?C_STARTUP: LJMP STARTUP1 + + RSEG ?C_C51STARTUP + +STARTUP1: + +IF IDATALEN <> 0 + MOV R0,#IDATALEN - 1 + CLR A +IDATALOOP: MOV @R0,A + DJNZ R0,IDATALOOP +ENDIF + +IF XDATALEN <> 0 + MOV DPTR,#XDATASTART + MOV R7,#LOW (XDATALEN) + IF (LOW (XDATALEN)) <> 0 + MOV R6,#(HIGH (XDATALEN)) +1 + ELSE + MOV R6,#HIGH (XDATALEN) + ENDIF + CLR A +XDATALOOP: MOVX @DPTR,A + INC DPTR + DJNZ R7,XDATALOOP + DJNZ R6,XDATALOOP +ENDIF + +IF PPAGEENABLE <> 0 + MOV PPAGE_SFR,#PPAGE +ENDIF + +IF PDATALEN <> 0 + MOV R0,#LOW (PDATASTART) + MOV R7,#LOW (PDATALEN) + CLR A +PDATALOOP: MOVX @R0,A + INC R0 + DJNZ R7,PDATALOOP +ENDIF + +IF IBPSTACK <> 0 +EXTRN DATA (?C_IBP) + + MOV ?C_IBP,#LOW IBPSTACKTOP +ENDIF + +IF XBPSTACK <> 0 +EXTRN DATA (?C_XBP) + + MOV ?C_XBP,#HIGH XBPSTACKTOP + MOV ?C_XBP+1,#LOW XBPSTACKTOP +ENDIF + +IF PBPSTACK <> 0 +EXTRN DATA (?C_PBP) + MOV ?C_PBP,#LOW PBPSTACKTOP +ENDIF + + MOV SP,#?STACK-1 + +; This code is required if you use L51_BANK.A51 with Banking Mode 4 +; Code Banking +; Select Bank 0 for L51_BANK.A51 Mode 4 +#if 0 +; Initialize bank mechanism to code bank 0 when using L51_BANK.A51 with Banking Mode 4. +EXTRN CODE (?B_SWITCH0) + CALL ?B_SWITCH0 ; init bank mechanism to code bank 0 +#endif +; + LJMP ?C_START + + END diff --git a/source/cpu/STC_stc8a8k.H b/source/cpu/STC_stc8a8k.H new file mode 100644 index 0000000..79da822 --- /dev/null +++ b/source/cpu/STC_stc8a8k.H @@ -0,0 +1,589 @@ +#ifndef __STC_stc8a8k_H_ +#define __STC_stc8a8k_H_ +// STC_stc8a8k.h +#include + +///////////////////////////////////////////////// +//注意: STC15W4K32S4系列的芯片,上电后所有与PWM相关的IO口均为 +// 高阻态,需将这些口设置为准双向口或强推挽模式方可正常使用 +//相关IO: P0.6/P0.7/P1.6/P1.7/P2.1/P2.2 +// P2.3/P2.7/P3.7/P4.2/P4.4/P4.5 +///////////////////////////////////////////////// + +///////////////////////////////////////////////// + +//包含本头文件后,不用另外再包含"REG51.H" + +//内核特殊功能寄存器 // 复位值 描述 +sfr ACC = 0xE0; //0000,0000 累加器Accumulator +sfr B = 0xF0; //0000,0000 B寄存器 +sfr PSW = 0xD0; //0000,0000 程序状态字 +sbit CY = PSW^7; +sbit AC = PSW^6; +sbit F0 = PSW^5; +sbit RS1 = PSW^4; +sbit RS0 = PSW^3; +sbit OV = PSW^2; +sbit P = PSW^0; +sfr SP = 0x81; //0000,0111 堆栈指针 +sfr DPL = 0x82; //0000,0000 数据指针低字节 +sfr DPH = 0x83; //0000,0000 数据指针高字节 + +//I/O 口特殊功能寄存器 +sfr P0 = 0x80; //1111,1111 端口0 +sbit P00 = P0^0; +sbit P01 = P0^1; +sbit P02 = P0^2; +sbit P03 = P0^3; +sbit P04 = P0^4; +sbit P05 = P0^5; +sbit P06 = P0^6; +sbit P07 = P0^7; +sfr P1 = 0x90; //1111,1111 端口1 +sbit P10 = P1^0; +sbit P11 = P1^1; +sbit P12 = P1^2; +sbit P13 = P1^3; +sbit P14 = P1^4; +sbit P15 = P1^5; +sbit P16 = P1^6; +sbit P17 = P1^7; +sfr P2 = 0xA0; //1111,1111 端口2 +sbit P20 = P2^0; +sbit P21 = P2^1; +sbit P22 = P2^2; +sbit P23 = P2^3; +sbit P24 = P2^4; +sbit P25 = P2^5; +sbit P26 = P2^6; +sbit P27 = P2^7; +sfr P3 = 0xB0; //1111,1111 端口3 +sbit P30 = P3^0; +sbit P31 = P3^1; +sbit P32 = P3^2; +sbit P33 = P3^3; +sbit P34 = P3^4; +sbit P35 = P3^5; +sbit P36 = P3^6; +sbit P37 = P3^7; +sfr P4 = 0xC0; //1111,1111 端口4 +sbit P40 = P4^0; +sbit P41 = P4^1; +sbit P42 = P4^2; +sbit P43 = P4^3; +sbit P44 = P4^4; +sbit P45 = P4^5; +sbit P46 = P4^6; +sbit P47 = P4^7; +sfr P5 = 0xC8; //xxxx,1111 端口5 +sbit P50 = P5^0; +sbit P51 = P5^1; +sbit P52 = P5^2; +sbit P53 = P5^3; +sbit P54 = P5^4; +sbit P55 = P5^5; +sbit P56 = P5^6; +sbit P57 = P5^7; +sfr P6 = 0xE8; //0000,0000 端口6 +sbit P60 = P6^0; +sbit P61 = P6^1; +sbit P62 = P6^2; +sbit P63 = P6^3; +sbit P64 = P6^4; +sbit P65 = P6^5; +sbit P66 = P6^6; +sbit P67 = P6^7; +sfr P7 = 0xF8; //0000,0000 端口7 +sbit P70 = P7^0; +sbit P71 = P7^1; +sbit P72 = P7^2; +sbit P73 = P7^3; +sbit P74 = P7^4; +sbit P75 = P7^5; +sbit P76 = P7^6; +sbit P77 = P7^7; + + +///00 准双向口 灌电流20mA 拉电流270-150uS +///01 推挽输出 20mA 加限流 +///10 高阻 +///11 开漏 open-Drain 内部上拉电阻断开 开漏模式既可以度外部状态也可以对外输出高低电平 + + +sfr P0M0 = 0x94; //0000,0000 端口0模式寄存器0 +sfr P0M1 = 0x93; //0000,0000 端口0模式寄存器1 +sfr P1M0 = 0x92; //0000,0000 端口1模式寄存器0 +sfr P1M1 = 0x91; //0000,0000 端口1模式寄存器1 +sfr P2M0 = 0x96; //0000,0000 端口2模式寄存器0 +sfr P2M1 = 0x95; //0000,0000 端口2模式寄存器1 +sfr P3M0 = 0xB2; //0000,0000 端口3模式寄存器0 +sfr P3M1 = 0xB1; //0000,0000 端口3模式寄存器1 +sfr P4M0 = 0xB4; //0000,0000 端口4模式寄存器0 +sfr P4M1 = 0xB3; //0000,0000 端口4模式寄存器1 +sfr P5M0 = 0xCA; //0000,0000 端口5模式寄存器0 +sfr P5M1 = 0xC9; //0000,0000 端口5模式寄存器1 +sfr P6M0 = 0xCC; //0000,0000 端口6模式寄存器0 +sfr P6M1 = 0xCB; //0000,0000 端口6模式寄存器1 +sfr P7M0 = 0xE2; //0000,0000 端口7模式寄存器0 +sfr P7M1 = 0xE1; //0000,0000 端口7模式寄存器1 + +//系统管理特殊功能寄存器 +sfr PCON = 0x87; //0001,0000 电源控制寄存器 +sfr AUXR = 0x8E; //0000,0000 辅助寄存器 + +#define TOx12 BITN7 +#define T1x12 BITN6 +#define UART_M0x6 BITN5 //串口1模式0速度 =0 12倍 = 1 两倍 +#define T2R BITN4 //定时器2 运行 =1 +#define T2_C BITN3 //定时器/计数器选择 +#define T2x12 BITN2 +#define EXTRAM BITN1 +#define S1ST2 BITN0 //串口1选择定时器1 =0 选择定时器2 =1 + + + + +sfr AUXR1 = 0xA2; //0000,0000 辅助寄存器1 +sfr P_SW1 = 0xA2; //0000,0000 外设端口切换寄存器1 +sfr CLK_DIV = 0x97; //0000,0000 时钟分频控制寄存器 +sfr BUS_SPEED = 0xA1; //xx10,x011 总线速度控制寄存器 +sfr P1ASF = 0x9D; //0000,0000 端口1模拟功能配置寄存器 +//----------------------------------------------------------------- +sfr P_SW2 = 0xBA; //0xxx,x000 外设端口切换寄存器 +#define EAXFR BITN7 +#define I2C_S1 BITN5 +#define I2C_S2 BITN4 +#define CMPO_S BITN3 +#define S4_S BITN2 +#define S3_S BITN1 +#define S2_S BITN0 + +//----------------------------------------------------------------- + +//中断特殊功能寄存器 +sfr IE = 0xA8; //0000,0000 中断控制寄存器 +sbit EA = IE^7; +sbit ELVD = IE^6; +sbit EADC = IE^5; +sbit ES = IE^4; +sbit ET1 = IE^3; +sbit EX1 = IE^2; +sbit ET0 = IE^1; +sbit EX0 = IE^0; +sfr IP = 0xB8; //0000,0000 中断优先级寄存器 +sbit PPCA = IP^7; +sbit PLVD = IP^6; +sbit PADC = IP^5; +sbit PS = IP^4; +sbit PT1 = IP^3; +sbit PX1 = IP^2; +sbit PT0 = IP^1; +sbit PX0 = IP^0; +sfr IE2 = 0xAF; //0000,0000 中断控制寄存器2 +/// 不可位寻址 +#define ET4 BITN6 +#define ET3 BITN5 +#define ES4 BITN4 +#define ES3 BITN3 +#define ET2 BITN2 +#define ESPI BITN1 +#define ES2 BITN0 + +sfr IP2 = 0xB5; //xxxx,xx00 中断优先级寄存器2 +sfr INT_CLKO = 0x8F; //0000,0000 外部中断与时钟输出控制寄存器 + +//定时器特殊功能寄存器 +sfr TCON = 0x88; //0000,0000 T0/T1控制寄存器 +sbit TF1 = TCON^7; +sbit TR1 = TCON^6; +sbit TF0 = TCON^5; +sbit TR0 = TCON^4; +sbit IE1 = TCON^3; +sbit IT1 = TCON^2; +sbit IE0 = TCON^1; +sbit IT0 = TCON^0; +sfr TMOD = 0x89; //0000,0000 T0/T1模式寄存器 +sfr TL0 = 0x8A; //0000,0000 T0低字节 +sfr TL1 = 0x8B; //0000,0000 T1低字节 +sfr TH0 = 0x8C; //0000,0000 T0高字节 +sfr TH1 = 0x8D; //0000,0000 T1高字节 +sfr T4T3M = 0xD1; //0000,0000 T3/T4模式寄存器 +sfr T3T4M = 0xD1; //0000,0000 T3/T4模式寄存器 +sfr T4H = 0xD2; //0000,0000 T4高字节 +sfr T4L = 0xD3; //0000,0000 T4低字节 +sfr T3H = 0xD4; //0000,0000 T3高字节 +sfr T3L = 0xD5; //0000,0000 T3低字节 +sfr T2H = 0xD6; //0000,0000 T2高字节 +sfr T2L = 0xD7; //0000,0000 T2低字节 +sfr WKTCL = 0xAA; //0000,0000 掉电唤醒定时器低字节 +sfr WKTCH = 0xAB; //0000,0000 掉电唤醒定时器高字节 +sfr WDT_CONTR = 0xC1; //0000,0000 看门狗控制寄存器 + +//串行口特殊功能寄存器 +sfr SCON = 0x98; //0000,0000 串口1控制寄存器 +sbit SM0 = SCON^7; +sbit SM1 = SCON^6; +sbit SM2 = SCON^5; +sbit REN = SCON^4; +sbit TB8 = SCON^3; +sbit RB8 = SCON^2; +sbit TI = SCON^1; +sbit RI = SCON^0; +//sfr SBUF = 0x99; //xxxx,xxxx 串口1数据寄存器 +//sfr S2CON = 0x9A; //0000,0000 串口2控制寄存器 +//sfr S2BUF = 0x9B; //xxxx,xxxx 串口2数据寄存器 +//sfr SADDR = 0xA9; //0000,0000 从机地址寄存器 +//sfr SADEN = 0xB9; //0000,0000 从机地址屏蔽寄存器 + +sfr SBUF = 0x99; //Serial Data Buffer +sfr SBUF0 = 0x99; //Serial Data Buffer xxxx,xxxx +sfr SADEN = 0xB9; //Slave Address Mask 0000,0000 +sfr SADDR = 0xA9; //Slave Address 0000,0000 +//----------------------------------- +// 7 6 5 4 3 2 1 0 Reset Value +sfr S2CON = 0x9A; //S2 Control S2SM0 S2SM1 S2SM2 S2REN S2TB8 S2RB8 S2TI S2RI 00000000B +#define S2SM0 BITN7 +#define S2ST4 BITN6 +#define S2SM2 BITN5 +#define S2REN BITN4 +#define S2TB8 BITN3 +#define S2RB8 BITN2 +#define S2TI BITN1 +#define S2RI BITN0 + +sfr S2BUF = 0x9B; //S2 Serial Buffer xxxx,xxxx +//sfr BRT = 0x9C; //S2 Baud-Rate Timer 0000,0000 + +//--------------------------------------------------------------- +sfr S3CON = 0xAC; //0000,0000 串口3控制寄存器 +#define S3SM0 BITN7 +#define S3ST4 BITN6 +#define S3SM2 BITN5 +#define S3REN BITN4 +#define S3TB8 BITN3 +#define S3RB8 BITN2 +#define S3TI BITN1 +#define S3RI BITN0 + +sfr S3BUF = 0xAD; //xxxx,xxxx 串口3数据寄存器 +//--------------------------------------------------------------- +sfr S4CON = 0x84; //0000,0000 串口4控制寄存器 +#define S4SM0 BITN7 +#define S4ST4 BITN6 +#define S4SM2 BITN5 +#define S4REN BITN4 +#define S4TB8 BITN3 +#define S4RB8 BITN2 +#define S4TI BITN1 +#define S4RI BITN0 + +sfr S4BUF = 0x85; //xxxx,xxxx 串口4数据寄存器 + +//ADC 特殊功能寄存器 +sfr ADC_CONTR = 0xBC; //0000,0000 A/D转换控制寄存器 +sfr ADC_RES = 0xBD; //0000,0000 A/D转换结果高8位 +sfr ADC_RESL = 0xBE; //0000,0000 A/D转换结果低2位 + +//SPI 特殊功能寄存器 +sfr SPSTAT = 0xCD; //00xx,xxxx SPI状态寄存器 +sfr SPCTL = 0xCE; //0000,0100 SPI控制寄存器 +sfr SPDAT = 0xCF; //0000,0000 SPI数据寄存器 + +//IAP/ISP 特殊功能寄存器 +sfr IAP_DATA = 0xC2; //0000,0000 EEPROM数据寄存器 +sfr IAP_ADDRH = 0xC3; //0000,0000 EEPROM地址高字节 +sfr IAP_ADDRL = 0xC4; //0000,0000 EEPROM地址第字节 +sfr IAP_CMD = 0xC5; //xxxx,xx00 EEPROM命令寄存器 +sfr IAP_TRIG = 0xC6; //0000,0000 EEPRPM命令触发寄存器 +sfr IAP_CONTR = 0xC7; //0000,x000 EEPROM控制寄存器 + +//PCA/PWM 特殊功能寄存器 +sfr CCON = 0xD8; //00xx,xx00 PCA控制寄存器 +sbit CF = CCON^7; +sbit CR = CCON^6; +sbit CCF2 = CCON^2; +sbit CCF1 = CCON^1; +sbit CCF0 = CCON^0; +sfr CMOD = 0xD9; //0xxx,x000 PCA 工作模式寄存器 +sfr CL = 0xE9; //0000,0000 PCA计数器低字节 +sfr CH = 0xF9; //0000,0000 PCA计数器高字节 +sfr CCAPM0 = 0xDA; //0000,0000 PCA模块0的PWM寄存器 +sfr CCAPM1 = 0xDB; //0000,0000 PCA模块1的PWM寄存器 +sfr CCAPM2 = 0xDC; //0000,0000 PCA模块2的PWM 寄存器 +sfr CCAP0L = 0xEA; //0000,0000 PCA模块0的捕捉/比较寄存器低字节 +sfr CCAP1L = 0xEB; //0000,0000 PCA模块1的捕捉/比较寄存器低字节 +sfr CCAP2L = 0xEC; //0000,0000 PCA模块2的捕捉/比较寄存器低字节 +sfr PCA_PWM0 = 0xF2; //xxxx,xx00 PCA模块0的PWM寄存器 +sfr PCA_PWM1 = 0xF3; //xxxx,xx00 PCA模块1的PWM寄存器 +sfr PCA_PWM2 = 0xF4; //xxxx,xx00 PCA模块1的PWM寄存器 +sfr CCAP0H = 0xFA; //0000,0000 PCA模块0的捕捉/比较寄存器高字节 +sfr CCAP1H = 0xFB; //0000,0000 PCA模块1的捕捉/比较寄存器高字节 +sfr CCAP2H = 0xFC; //0000,0000 PCA模块2的捕捉/比较寄存器高字节 + +//比较器特殊功能寄存器 +sfr CMPCR1 = 0xE6; //0000,0000 比较器控制寄存器1 +sfr CMPCR2 = 0xE7; //0000,0000 比较器控制寄存器2 + + +//sfr P_SW2 = 0xba; +sfr PWMCFG = 0xf1; +sfr PWMIF = 0xf6; +sfr PWMFDCR = 0xf7; +sfr PWMCR = 0xfe; + +#define PWMC (*(unsigned int volatile xdata *)0xfff0) +#define PWMCKS (*(unsigned char volatile xdata *)0xfff2) +#define TADCP (*(unsigned int volatile xdata *)0xfff3) +#define PWM0T1 (*(unsigned int volatile xdata *)0xff00) +#define PWM0T2 (*(unsigned int volatile xdata *)0xff02) +#define PWM0CR (*(unsigned char volatile xdata *)0xff04) +#define PWM0HLD (*(unsigned char volatile xdata *)0xff05) +#define PWM1T1 (*(unsigned int volatile xdata *)0xff10) +#define PWM1T2 (*(unsigned int volatile xdata *)0xff12) +#define PWM1CR (*(unsigned char volatile xdata *)0xff14) +#define PWM1HLD (*(unsigned char volatile xdata *)0xff15) +#define PWM2T1 (*(unsigned int volatile xdata *)0xff20) +#define PWM2T2 (*(unsigned int volatile xdata *)0xff22) +#define PWM2CR (*(unsigned char volatile xdata *)0xff24) +#define PWM2HLD (*(unsigned char volatile xdata *)0xff25) +#define PWM3T1 (*(unsigned int volatile xdata *)0xff30) +#define PWM3T2 (*(unsigned int volatile xdata *)0xff32) +#define PWM3CR (*(unsigned char volatile xdata *)0xff34) +#define PWM3HLD (*(unsigned char volatile xdata *)0xff35) +#define PWM4T1 (*(unsigned int volatile xdata *)0xff40) +#define PWM4T2 (*(unsigned int volatile xdata *)0xff42) +#define PWM4CR (*(unsigned char volatile xdata *)0xff44) +#define PWM4HLD (*(unsigned char volatile xdata *)0xff45) +#define PWM5T1 (*(unsigned int volatile xdata *)0xff50) +#define PWM5T2 (*(unsigned int volatile xdata *)0xff52) +#define PWM5CR (*(unsigned char volatile xdata *)0xff54) +#define PWM5HLD (*(unsigned char volatile xdata *)0xff55) +#define PWM6T1 (*(unsigned int volatile xdata *)0xff60) +#define PWM6T2 (*(unsigned int volatile xdata *)0xff62) +#define PWM6CR (*(unsigned char volatile xdata *)0xff64) +#define PWM6HLD (*(unsigned char volatile xdata *)0xff65) +#define PWM7T1 (*(unsigned int volatile xdata *)0xff70) +#define PWM7T2 (*(unsigned int volatile xdata *)0xff72) +#define PWM7CR (*(unsigned char volatile xdata *)0xff74) +#define PWM7HLD (*(unsigned char volatile xdata *)0xff75) + + +#define CKSEL (*(unsigned char volatile xdata *)0xfE00)//108@ST8.PDF +#define MCLKODIV BIT4 +#define MCLKO_S BITN3 +#define MCLKSEL BIT0 + +#define CLKDIV (*(unsigned char volatile xdata *)0xfE01)//108@ST8.PDF +#define IRC24MCR (*(unsigned char volatile xdata *)0xfE02)//108@ST8.PDF +#define XOSCCR (*(unsigned char volatile xdata *)0xfE03)//108@ST8.PDF +#define IRC32KCR (*(unsigned char volatile xdata *)0xfE04)//108@ST8.PDF + + + +///////////////////////////////////////////////// + + + +/* P3 */ +sbit RD = 0xB7; +sbit WR = 0xB6; +sbit T1 = 0xB5; +sbit T0 = 0xB4; +sbit INT1 = 0xB3; +sbit INT0 = 0xB2; +sbit TXD = 0xB1; +sbit RXD = 0xB0; + + + + +#if 0 +/// >>>>> add by cc + + +//sbit P34=P3^4; //定义SDA数据线 +//sbit P35=P3^5; //定义SCL时钟线 +#define mBIT_1(X,N) X|= (1< +#include "../clib/bit.h" + +#define NOP() _nop_() + +#define D_P07_ON() P07 = 1 +#define D_P06_ON() P06 = 1 +#define D_P05_ON() P05 = 1 +#define D_P04_ON() P04 = 1 +#define D_P03_ON() P03 = 1 +#define D_P02_ON() P02 = 1 +#define D_P01_ON() P01 = 1 +#define D_P00_ON() P00 = 1 +#define D_P07_OFF() P07 = 0 +#define D_P06_OFF() P06 = 0 +#define D_P05_OFF() P05 = 0 +#define D_P04_OFF() P04 = 0 +#define D_P03_OFF() P03 = 0 +#define D_P02_OFF() P02 = 0 +#define D_P01_OFF() P01 = 0 +#define D_P00_OFF() P00 = 0 +#define D_P07_AT() (P07) +#define D_P06_AT() (P06) +#define D_P05_AT() (P05) +#define D_P04_AT() (P04) +#define D_P03_AT() (P03) +#define D_P02_AT() (P02) +#define D_P01_AT() (P01) +#define D_P00_AT() (P00) +#define D_P07_REV() P07 = ~P07 +#define D_P06_REV() P06 = ~P06 +#define D_P05_REV() P05 = ~P05 +#define D_P04_REV() P04 = ~P04 +#define D_P03_REV() P03 = ~P03 +#define D_P02_REV() P02 = ~P02 +#define D_P01_REV() P01 = ~P01 +#define D_P00_REV() P00 = ~P00 + + +#define D_P17_ON() P17 = 1 +#define D_P16_ON() P16 = 1 +#define D_P15_ON() P15 = 1 +#define D_P14_ON() P14 = 1 +#define D_P13_ON() P13 = 1 +#define D_P12_ON() P12 = 1 +#define D_P11_ON() P11 = 1 +#define D_P10_ON() P10 = 1 +#define D_P17_OFF() P17 = 0 +#define D_P16_OFF() P16 = 0 +#define D_P15_OFF() P15 = 0 +#define D_P14_OFF() P14 = 0 +#define D_P13_OFF() P13 = 0 +#define D_P12_OFF() P12 = 0 +#define D_P11_OFF() P11 = 0 +#define D_P10_OFF() P10 = 0 +#define D_P17_AT() (P17) +#define D_P16_AT() (P16) +#define D_P15_AT() (P15) +#define D_P14_AT() (P14) +#define D_P13_AT() (P13) +#define D_P12_AT() (P12) +#define D_P11_AT() (P11) +#define D_P10_AT() (P10) +#define D_P17_REV() P17 = ~P17 +#define D_P16_REV() P16 = ~P16 +#define D_P15_REV() P15 = ~P15 +#define D_P14_REV() P14 = ~P14 +#define D_P13_REV() P13 = ~P13 +#define D_P12_REV() P12 = ~P12 +#define D_P11_REV() P11 = ~P11 +#define D_P10_REV() P10 = ~P10 + +#define D_P27_ON() P27 = 1 +#define D_P26_ON() P26 = 1 +#define D_P25_ON() P25 = 1 +#define D_P24_ON() P24 = 1 +#define D_P23_ON() P23 = 1 +#define D_P22_ON() P22 = 1 +#define D_P21_ON() P21 = 1 +#define D_P20_ON() P20 = 1 +#define D_P27_OFF() P27 = 0 +#define D_P26_OFF() P26 = 0 +#define D_P25_OFF() P25 = 0 +#define D_P24_OFF() P24 = 0 +#define D_P23_OFF() P23 = 0 +#define D_P22_OFF() P22 = 0 +#define D_P21_OFF() P21 = 0 +#define D_P20_OFF() P20 = 0 +#define D_P27_AT() (P27) +#define D_P26_AT() (P26) +#define D_P25_AT() (P25) +#define D_P24_AT() (P24) +#define D_P23_AT() (P23) +#define D_P22_AT() (P22) +#define D_P21_AT() (P21) +#define D_P20_AT() (P20) +#define D_P27_REV() P27 = ~P27 +#define D_P26_REV() P26 = ~P26 +#define D_P25_REV() P25 = ~P25 +#define D_P24_REV() P24 = ~P24 +#define D_P23_REV() P23 = ~P23 +#define D_P22_REV() P22 = ~P22 +#define D_P21_REV() P21 = ~P21 +#define D_P20_REV() P20 = ~P20 + + +#define D_P37_ON() P37 = 1 +#define D_P36_ON() P36 = 1 +#define D_P35_ON() P35 = 1 +#define D_P34_ON() P34 = 1 +#define D_P33_ON() P33 = 1 +#define D_P32_ON() P32 = 1 +#define D_P31_ON() P31 = 1 +#define D_P30_ON() P30 = 1 +#define D_P37_OFF() P37 = 0 +#define D_P36_OFF() P36 = 0 +#define D_P35_OFF() P35 = 0 +#define D_P34_OFF() P34 = 0 +#define D_P33_OFF() P33 = 0 +#define D_P32_OFF() P32 = 0 +#define D_P31_OFF() P31 = 0 +#define D_P30_OFF() P30 = 0 +#define D_P37_AT() (P37) +#define D_P36_AT() (P36) +#define D_P35_AT() (P35) +#define D_P34_AT() (P34) +#define D_P33_AT() (P33) +#define D_P32_AT() (P32) +#define D_P31_AT() (P31) +#define D_P30_AT() (P30) +#define D_P37_REV() P37 = ~P37 +#define D_P36_REV() P36 = ~P36 +#define D_P35_REV() P35 = ~P35 +#define D_P34_REV() P34 = ~P34 +#define D_P33_REV() P33 = ~P33 +#define D_P32_REV() P32 = ~P32 +#define D_P31_REV() P31 = ~P31 +#define D_P30_REV() P30 = ~P30 + + +#define D_P47_ON() P47 = 1 +#define D_P46_ON() P46 = 1 +#define D_P45_ON() P45 = 1 +#define D_P44_ON() P44 = 1 +#define D_P43_ON() P43 = 1 +#define D_P42_ON() P42 = 1 +#define D_P41_ON() P41 = 1 +#define D_P40_ON() P40 = 1 +#define D_P47_OFF() P47 = 0 +#define D_P46_OFF() P46 = 0 +#define D_P45_OFF() P45 = 0 +#define D_P44_OFF() P44 = 0 +#define D_P43_OFF() P43 = 0 +#define D_P42_OFF() P42 = 0 +#define D_P41_OFF() P41 = 0 +#define D_P40_OFF() P40 = 0 +#define D_P47_AT() (P47) +#define D_P46_AT() (P46) +#define D_P45_AT() (P45) +#define D_P44_AT() (P44) +#define D_P43_AT() (P43) +#define D_P42_AT() (P42) +#define D_P41_AT() (P41) +#define D_P40_AT() (P40) +#define D_P47_REV() P47 = ~P47 +#define D_P46_REV() P46 = ~P46 +#define D_P45_REV() P45 = ~P45 +#define D_P44_REV() P44 = ~P44 +#define D_P43_REV() P43 = ~P43 +#define D_P42_REV() P42 = ~P42 +#define D_P41_REV() P41 = ~P41 +#define D_P40_REV() P40 = ~P40 + +#define D_P57_ON() P57 = 1 +#define D_P56_ON() P56 = 1 +#define D_P55_ON() P55 = 1 +#define D_P54_ON() P54 = 1 +#define D_P53_ON() P53 = 1 +#define D_P52_ON() P52 = 1 +#define D_P51_ON() P51 = 1 +#define D_P50_ON() P50 = 1 +#define D_P57_OFF() P57 = 0 +#define D_P56_OFF() P56 = 0 +#define D_P55_OFF() P55 = 0 +#define D_P54_OFF() P54 = 0 +#define D_P53_OFF() P53 = 0 +#define D_P52_OFF() P52 = 0 +#define D_P51_OFF() P51 = 0 +#define D_P50_OFF() P50 = 0 +#define D_P57_AT() (P57) +#define D_P56_AT() (P56) +#define D_P55_AT() (P55) +#define D_P54_AT() (P54) +#define D_P53_AT() (P53) +#define D_P52_AT() (P52) +#define D_P51_AT() (P51) +#define D_P50_AT() (P50) +#define D_P57_REV() P57 = ~P57 +#define D_P56_REV() P56 = ~P56 +#define D_P55_REV() P55 = ~P55 +#define D_P54_REV() P54 = ~P54 +#define D_P53_REV() P53 = ~P53 +#define D_P52_REV() P52 = ~P52 +#define D_P51_REV() P51 = ~P51 +#define D_P50_REV() P50 = ~P50 + +#define D_P67_ON() P67 = 1 +#define D_P66_ON() P66 = 1 +#define D_P65_ON() P65 = 1 +#define D_P64_ON() P64 = 1 +#define D_P63_ON() P63 = 1 +#define D_P62_ON() P62 = 1 +#define D_P61_ON() P61 = 1 +#define D_P60_ON() P60 = 1 +#define D_P67_OFF() P67 = 0 +#define D_P66_OFF() P66 = 0 +#define D_P65_OFF() P65 = 0 +#define D_P64_OFF() P64 = 0 +#define D_P63_OFF() P63 = 0 +#define D_P62_OFF() P62 = 0 +#define D_P61_OFF() P61 = 0 +#define D_P60_OFF() P60 = 0 +#define D_P67_AT() (P67) +#define D_P66_AT() (P66) +#define D_P65_AT() (P65) +#define D_P64_AT() (P64) +#define D_P63_AT() (P63) +#define D_P62_AT() (P62) +#define D_P61_AT() (P61) +#define D_P60_AT() (P60) +#define D_P67_REV() P67 = ~P67 +#define D_P66_REV() P66 = ~P66 +#define D_P65_REV() P65 = ~P65 +#define D_P64_REV() P64 = ~P64 +#define D_P63_REV() P63 = ~P63 +#define D_P62_REV() P62 = ~P62 +#define D_P61_REV() P61 = ~P61 +#define D_P60_REV() P60 = ~P60 + +#define D_P77_ON() P77 = 1 +#define D_P76_ON() P76 = 1 +#define D_P75_ON() P75 = 1 +#define D_P74_ON() P74 = 1 +#define D_P73_ON() P73 = 1 +#define D_P72_ON() P72 = 1 +#define D_P71_ON() P71 = 1 +#define D_P70_ON() P70 = 1 +#define D_P77_OFF() P77 = 0 +#define D_P76_OFF() P76 = 0 +#define D_P75_OFF() P75 = 0 +#define D_P74_OFF() P74 = 0 +#define D_P73_OFF() P73 = 0 +#define D_P72_OFF() P72 = 0 +#define D_P71_OFF() P71 = 0 +#define D_P70_OFF() P70 = 0 +#define D_P77_AT() (P77) +#define D_P76_AT() (P76) +#define D_P75_AT() (P75) +#define D_P74_AT() (P74) +#define D_P73_AT() (P73) +#define D_P72_AT() (P72) +#define D_P71_AT() (P71) +#define D_P70_AT() (P70) +#define D_P77_REV() P77 = ~P77 +#define D_P76_REV() P76 = ~P76 +#define D_P75_REV() P75 = ~P75 +#define D_P74_REV() P74 = ~P74 +#define D_P73_REV() P73 = ~P73 +#define D_P72_REV() P72 = ~P72 +#define D_P71_REV() P71 = ~P71 +#define D_P70_REV() P70 = ~P70 + + +#define D_stdIO_P0_ALL() P0M1=0;P0M0=0; +#define D_HighI_P0_ALL() P0M1=0;P0M0=0XFF; +#define D_HighR_P0_ALL() P0M1=0XFF;P0M0=0; +#define D_OpenD_P0_ALL() P0M1=0XFF;P0M0=0XFF; + +#define D_stdIO_P1_ALL() P1M1=0;P1M0=0; +#define D_HighI_P1_ALL() P1M1=0;P1M0=0XFF; +#define D_HighR_P1_ALL() P1M1=0XFF;P1M0=0; +#define D_OpenD_P1_ALL() P1M1=0XFF;P1M0=0XFF; + +#define D_stdIO_P2_ALL() P2M1=0;P2M0=0; +#define D_HighI_P2_ALL() P2M1=0;P2M0=0XFF; +#define D_HighR_P2_ALL() P2M1=0XFF;P2M0=0; +#define D_OpenD_P2_ALL() P2M1=0XFF;P2M0=0XFF; + +#define D_stdIO_P3_ALL() P3M1=0;P3M0=0; +#define D_HighI_P3_ALL() P3M1=0;P3M0=0XFF; +#define D_HighR_P3_ALL() P3M1=0XFF;P3M0=0; +#define D_OpenD_P3_ALL() P3M1=0XFF;P3M0=0XFF; + +#define D_stdIO_P4_ALL() P4M1=0;P4M0=0; +#define D_HighI_P4_ALL() P4M1=0;P4M0=0XFF; +#define D_HighR_P4_ALL() P4M1=0XFF;P4M0=0; +#define D_OpenD_P4_ALL() P4M1=0XFF;P4M0=0XFF; + +#define D_stdIO_P5_ALL() P5M1=0;P5M0=0; +#define D_HighI_P5_ALL() P5M1=0;P5M0=0XFF; +#define D_HighR_P5_ALL() P5M1=0XFF;P5M0=0; +#define D_OpenD_P5_ALL() P5M1=0XFF;P5M0=0XFF; + +#define D_stdIO_P6_ALL() P6M1=0;P6M0=0; +#define D_HighI_P6_ALL() P6M1=0;P6M0=0XFF; +#define D_HighR_P6_ALL() P6M1=0XFF;P6M0=0; +#define D_OpenD_P6_ALL() P6M1=0XFF;P6M0=0XFF; + +#define D_stdIO_P7_ALL() P7M1=0;P7M0=0; +#define D_HighI_P7_ALL() P7M1=0;P7M0=0XFF; +#define D_HighR_P7_ALL() P7M1=0XFF;P7M0=0; +#define D_OpenD_P7_ALL() P7M1=0XFF;P7M0=0XFF; + +////Notice: n: BITN0---BITN7 不是0-7 eg:D_stdIO_P0(BITN0) +#define D_stdIO_P0(n) BITN_0(P0M1,n);BITN_0(P0M0,n); //////00 准双向口 灌电流20mA 拉电流270-150uS +#define D_HighI_P0(n) BITN_0(P0M1,n);BITN_1(P0M0,n); //////01 推挽输出 20mA 加限流 +#define D_HighR_P0(n) BITN_1(P0M1,n);BITN_0(P0M0,n); /////////10 高阻 +#define D_OpenD_P0(n) BITN_1(P0M1,n);BITN_1(P0M0,n); /////11 开漏 open-Drain 内部上拉电阻断开 开漏模式既可以度外部状态也可以对外输出高低电平 + +#define D_stdIO_P1(n) BITN_0(P1M1,n);BITN_0(P1M0,n); //////00 准双向口 灌电流20mA 拉电流270-150uS +#define D_HighI_P1(n) BITN_0(P1M1,n);BITN_1(P1M0,n); //////01 推挽输出 20mA 加限流 +#define D_HighR_P1(n) BITN_1(P1M1,n);BITN_0(P1M0,n); /////////10 高阻 +#define D_OpenD_P1(n) BITN_1(P1M1,n);BITN_1(P1M0,n); /////11 开漏 open-Drain 内部上拉电阻断开 开漏模式既可以度外部状态也可以对外输出高低电平 + +#define D_stdIO_P2(n) BITN_0(P2M1,n);BITN_0(P2M0,n); //////00 准双向口 灌电流20mA 拉电流270-150uS +#define D_HighI_P2(n) BITN_0(P2M1,n);BITN_1(P2M0,n); //////01 推挽输出 20mA 加限流 +#define D_HighR_P2(n) BITN_1(P2M1,n);BITN_0(P2M0,n); /////////10 高阻 +#define D_OpenD_P2(n) BITN_1(P2M1,n);BITN_1(P2M0,n); /////11 开漏 open-Drain 内部上拉电阻断开 开漏模式既可以度外部状态也可以对外输出高低电平 + +#define D_stdIO_P3(n) BITN_0(P3M1,n);BITN_0(P3M0,n); //////00 准双向口 灌电流20mA 拉电流270-150uS +#define D_HighI_P3(n) BITN_0(P3M1,n);BITN_1(P3M0,n); //////01 推挽输出 20mA 加限流 +#define D_HighR_P3(n) BITN_1(P3M1,n);BITN_0(P3M0,n); /////////10 高阻 +#define D_OpenD_P3(n) BITN_1(P3M1,n);BITN_1(P3M0,n); /////11 开漏 open-Drain 内部上拉电阻断开 开漏模式既可以度外部状态也可以对外输出高低电平 + +#define D_stdIO_P4(n) BITN_0(P4M1,n);BITN_0(P4M0,n); //////00 准双向口 灌电流20mA 拉电流270-150uS +#define D_HighI_P4(n) BITN_0(P4M1,n);BITN_1(P4M0,n); //////01 推挽输出 20mA 加限流 +#define D_HighR_P4(n) BITN_1(P4M1,n);BITN_0(P4M0,n); /////////10 高阻 +#define D_OpenD_P4(n) BITN_1(P4M1,n);BITN_1(P4M0,n); /////11 开漏 open-Drain 内部上拉电阻断开 开漏模式既可以度外部状态也可以对外输出高低电平 + +#define D_stdIO_P5(n) BITN_0(P5M1,n);BITN_0(P5M0,n); //////00 准双向口 灌电流20mA 拉电流270-150uS +#define D_HighI_P5(n) BITN_0(P5M1,n);BITN_1(P5M0,n); //////01 推挽输出 20mA 加限流 +#define D_HighR_P5(n) BITN_1(P5M1,n);BITN_0(P5M0,n); /////////10 高阻 +#define D_OpenD_P5(n) BITN_1(P5M1,n);BITN_1(P5M0,n); /////11 开漏 open-Drain 内部上拉电阻断开 开漏模式既可以度外部状态也可以对外输出高低电平 + +#define D_stdIO_P6(n) BITN_0(P6M1,n);BITN_0(P6M0,n); //////00 准双向口 灌电流20mA 拉电流270-150uS +#define D_HighI_P6(n) BITN_0(P6M1,n);BITN_1(P6M0,n); //////01 推挽输出 20mA 加限流 +#define D_HighR_P6(n) BITN_1(P6M1,n);BITN_0(P6M0,n); /////////10 高阻 +#define D_OpenD_P6(n) BITN_1(P6M1,n);BITN_1(P6M0,n); /////11 开漏 open-Drain 内部上拉电阻断开 开漏模式既可以度外部状态也可以对外输出高低电平 + +#define D_stdIO_P7(n) BITN_0(P7M1,n);BITN_0(P7M0,n); //////00 准双向口 灌电流20mA 拉电流270-150uS +#define D_HighI_P7(n) BITN_0(P7M1,n);BITN_1(P7M0,n); //////01 推挽输出 20mA 加限流 +#define D_HighR_P7(n) BITN_1(P7M1,n);BITN_0(P7M0,n); /////////10 高阻 +#define D_OpenD_P7(n) BITN_1(P7M1,n);BITN_1(P7M0,n); /////11 开漏 open-Drain 内部上拉电阻断开 开漏模式既可以度外部状态也可以对外输出高低电平 + +#endif //__STC_MACRO_H_ + + + + + + + diff --git a/source/cpu/stc_stc15w.H b/source/cpu/stc_stc15w.H new file mode 100644 index 0000000..9c2f57d --- /dev/null +++ b/source/cpu/stc_stc15w.H @@ -0,0 +1,466 @@ +#ifndef __STC15F2K60S2_H_ +#define __STC15F2K60S2_H_ +// stc_stc15w.h +#include + +///////////////////////////////////////////////// +//注意: STC15W4K32S4系列的芯片,上电后所有与PWM相关的IO口均为 +// 高阻态,需将这些口设置为准双向口或强推挽模式方可正常使用 +//相关IO: P0.6/P0.7/P1.6/P1.7/P2.1/P2.2 +// P2.3/P2.7/P3.7/P4.2/P4.4/P4.5 +///////////////////////////////////////////////// + +///////////////////////////////////////////////// + +//包含本头文件后,不用另外再包含"REG51.H" + +//内核特殊功能寄存器 // 复位值 描述 +sfr ACC = 0xE0; //0000,0000 累加器Accumulator +sfr B = 0xF0; //0000,0000 B寄存器 +sfr PSW = 0xD0; //0000,0000 程序状态字 +sbit CY = PSW^7; +sbit AC = PSW^6; +sbit F0 = PSW^5; +sbit RS1 = PSW^4; +sbit RS0 = PSW^3; +sbit OV = PSW^2; +sbit P = PSW^0; +sfr SP = 0x81; //0000,0111 堆栈指针 +sfr DPL = 0x82; //0000,0000 数据指针低字节 +sfr DPH = 0x83; //0000,0000 数据指针高字节 + +//I/O 口特殊功能寄存器 +sfr P0 = 0x80; //1111,1111 端口0 +sbit P00 = P0^0; +sbit P01 = P0^1; +sbit P02 = P0^2; +sbit P03 = P0^3; +sbit P04 = P0^4; +sbit P05 = P0^5; +sbit P06 = P0^6; +sbit P07 = P0^7; +sfr P1 = 0x90; //1111,1111 端口1 +sbit P10 = P1^0; +sbit P11 = P1^1; +sbit P12 = P1^2; +sbit P13 = P1^3; +sbit P14 = P1^4; +sbit P15 = P1^5; +sbit P16 = P1^6; +sbit P17 = P1^7; +sfr P2 = 0xA0; //1111,1111 端口2 +sbit P20 = P2^0; +sbit P21 = P2^1; +sbit P22 = P2^2; +sbit P23 = P2^3; +sbit P24 = P2^4; +sbit P25 = P2^5; +sbit P26 = P2^6; +sbit P27 = P2^7; +sfr P3 = 0xB0; //1111,1111 端口3 +sbit P30 = P3^0; +sbit P31 = P3^1; +sbit P32 = P3^2; +sbit P33 = P3^3; +sbit P34 = P3^4; +sbit P35 = P3^5; +sbit P36 = P3^6; +sbit P37 = P3^7; +sfr P4 = 0xC0; //1111,1111 端口4 +sbit P40 = P4^0; +sbit P41 = P4^1; +sbit P42 = P4^2; +sbit P43 = P4^3; +sbit P44 = P4^4; +sbit P45 = P4^5; +sbit P46 = P4^6; +sbit P47 = P4^7; +sfr P5 = 0xC8; //xxxx,1111 端口5 +sbit P50 = P5^0; +sbit P51 = P5^1; +sbit P52 = P5^2; +sbit P53 = P5^3; +sbit P54 = P5^4; +sbit P55 = P5^5; +sbit P56 = P5^6; +sbit P57 = P5^7; +sfr P6 = 0xE8; //0000,0000 端口6 +sbit P60 = P6^0; +sbit P61 = P6^1; +sbit P62 = P6^2; +sbit P63 = P6^3; +sbit P64 = P6^4; +sbit P65 = P6^5; +sbit P66 = P6^6; +sbit P67 = P6^7; +sfr P7 = 0xF8; //0000,0000 端口7 +sbit P70 = P7^0; +sbit P71 = P7^1; +sbit P72 = P7^2; +sbit P73 = P7^3; +sbit P74 = P7^4; +sbit P75 = P7^5; +sbit P76 = P7^6; +sbit P77 = P7^7; +sfr P0M0 = 0x94; //0000,0000 端口0模式寄存器0 +sfr P0M1 = 0x93; //0000,0000 端口0模式寄存器1 +sfr P1M0 = 0x92; //0000,0000 端口1模式寄存器0 +sfr P1M1 = 0x91; //0000,0000 端口1模式寄存器1 +sfr P2M0 = 0x96; //0000,0000 端口2模式寄存器0 +sfr P2M1 = 0x95; //0000,0000 端口2模式寄存器1 +sfr P3M0 = 0xB2; //0000,0000 端口3模式寄存器0 +sfr P3M1 = 0xB1; //0000,0000 端口3模式寄存器1 +sfr P4M0 = 0xB4; //0000,0000 端口4模式寄存器0 +sfr P4M1 = 0xB3; //0000,0000 端口4模式寄存器1 +sfr P5M0 = 0xCA; //0000,0000 端口5模式寄存器0 +sfr P5M1 = 0xC9; //0000,0000 端口5模式寄存器1 +sfr P6M0 = 0xCC; //0000,0000 端口6模式寄存器0 +sfr P6M1 = 0xCB; //0000,0000 端口6模式寄存器1 +sfr P7M0 = 0xE2; //0000,0000 端口7模式寄存器0 +sfr P7M1 = 0xE1; //0000,0000 端口7模式寄存器1 + +//系统管理特殊功能寄存器 +sfr PCON = 0x87; //0001,0000 电源控制寄存器 +sfr AUXR = 0x8E; //0000,0000 辅助寄存器 + +#define TOx12 BITN7 +#define T1x12 BITN6 +#define UART_M0x6 BITN5 //串口1模式0速度 =0 12倍 = 1 两倍 +#define T2R BITN4 //定时器2 运行 =1 +#define T2_C BITN3 //定时器/计数器选择 +#define T2x12 BITN2 +#define EXTRAM BITN1 +#define S1ST2 BITN0 //串口1选择定时器1 =0 选择定时器2 =1 + + + + +sfr AUXR1 = 0xA2; //0000,0000 辅助寄存器1 +sfr P_SW1 = 0xA2; //0000,0000 外设端口切换寄存器1 +sfr CLK_DIV = 0x97; //0000,0000 时钟分频控制寄存器 +sfr BUS_SPEED = 0xA1; //xx10,x011 总线速度控制寄存器 +sfr P1ASF = 0x9D; //0000,0000 端口1模拟功能配置寄存器 +sfr P_SW2 = 0xBA; //0xxx,x000 外设端口切换寄存器 + +//中断特殊功能寄存器 +sfr IE = 0xA8; //0000,0000 中断控制寄存器 +sbit EA = IE^7; +sbit ELVD = IE^6; +sbit EADC = IE^5; +sbit ES = IE^4; +sbit ET1 = IE^3; +sbit EX1 = IE^2; +sbit ET0 = IE^1; +sbit EX0 = IE^0; +sfr IP = 0xB8; //0000,0000 中断优先级寄存器 +sbit PPCA = IP^7; +sbit PLVD = IP^6; +sbit PADC = IP^5; +sbit PS = IP^4; +sbit PT1 = IP^3; +sbit PX1 = IP^2; +sbit PT0 = IP^1; +sbit PX0 = IP^0; +sfr IE2 = 0xAF; //0000,0000 中断控制寄存器2 +/// 不可位寻址 +#define ET4 BITN6 +#define ET3 BITN5 +#define ES4 BITN4 +#define ES3 BITN3 +#define ET2 BITN2 +#define ESPI BITN1 +#define ES2 BITN0 + +sfr IP2 = 0xB5; //xxxx,xx00 中断优先级寄存器2 +sfr INT_CLKO = 0x8F; //0000,0000 外部中断与时钟输出控制寄存器 + +//定时器特殊功能寄存器 +sfr TCON = 0x88; //0000,0000 T0/T1控制寄存器 +sbit TF1 = TCON^7; +sbit TR1 = TCON^6; +sbit TF0 = TCON^5; +sbit TR0 = TCON^4; +sbit IE1 = TCON^3; +sbit IT1 = TCON^2; +sbit IE0 = TCON^1; +sbit IT0 = TCON^0; +sfr TMOD = 0x89; //0000,0000 T0/T1模式寄存器 +sfr TL0 = 0x8A; //0000,0000 T0低字节 +sfr TL1 = 0x8B; //0000,0000 T1低字节 +sfr TH0 = 0x8C; //0000,0000 T0高字节 +sfr TH1 = 0x8D; //0000,0000 T1高字节 +sfr T4T3M = 0xD1; //0000,0000 T3/T4模式寄存器 +sfr T3T4M = 0xD1; //0000,0000 T3/T4模式寄存器 +sfr T4H = 0xD2; //0000,0000 T4高字节 +sfr T4L = 0xD3; //0000,0000 T4低字节 +sfr T3H = 0xD4; //0000,0000 T3高字节 +sfr T3L = 0xD5; //0000,0000 T3低字节 +sfr T2H = 0xD6; //0000,0000 T2高字节 +sfr T2L = 0xD7; //0000,0000 T2低字节 +sfr WKTCL = 0xAA; //0000,0000 掉电唤醒定时器低字节 +sfr WKTCH = 0xAB; //0000,0000 掉电唤醒定时器高字节 +sfr WDT_CONTR = 0xC1; //0000,0000 看门狗控制寄存器 + +//串行口特殊功能寄存器 +sfr SCON = 0x98; //0000,0000 串口1控制寄存器 +sbit SM0 = SCON^7; +sbit SM1 = SCON^6; +sbit SM2 = SCON^5; +sbit REN = SCON^4; +sbit TB8 = SCON^3; +sbit RB8 = SCON^2; +sbit TI = SCON^1; +sbit RI = SCON^0; +//sfr SBUF = 0x99; //xxxx,xxxx 串口1数据寄存器 +//sfr S2CON = 0x9A; //0000,0000 串口2控制寄存器 +//sfr S2BUF = 0x9B; //xxxx,xxxx 串口2数据寄存器 +//sfr SADDR = 0xA9; //0000,0000 从机地址寄存器 +//sfr SADEN = 0xB9; //0000,0000 从机地址屏蔽寄存器 + +sfr SBUF = 0x99; //Serial Data Buffer +sfr SBUF0 = 0x99; //Serial Data Buffer xxxx,xxxx +sfr SADEN = 0xB9; //Slave Address Mask 0000,0000 +sfr SADDR = 0xA9; //Slave Address 0000,0000 +//----------------------------------- +// 7 6 5 4 3 2 1 0 Reset Value +sfr S2CON = 0x9A; //S2 Control S2SM0 S2SM1 S2SM2 S2REN S2TB8 S2RB8 S2TI S2RI 00000000B +#define S2SM0 BITN7 +#define S2ST4 BITN6 +#define S2SM2 BITN5 +#define S2REN BITN4 +#define S2TB8 BITN3 +#define S2RB8 BITN2 +#define S2TI BITN1 +#define S2RI BITN0 + +sfr S2BUF = 0x9B; //S2 Serial Buffer xxxx,xxxx +//sfr BRT = 0x9C; //S2 Baud-Rate Timer 0000,0000 + +//--------------------------------------------------------------- +sfr S3CON = 0xAC; //0000,0000 串口3控制寄存器 +#define S3SM0 BITN7 +#define S3ST4 BITN6 +#define S3SM2 BITN5 +#define S3REN BITN4 +#define S3TB8 BITN3 +#define S3RB8 BITN2 +#define S3TI BITN1 +#define S3RI BITN0 + +sfr S3BUF = 0xAD; //xxxx,xxxx 串口3数据寄存器 +//--------------------------------------------------------------- +sfr S4CON = 0x84; //0000,0000 串口4控制寄存器 +#define S4SM0 BITN7 +#define S4ST4 BITN6 +#define S4SM2 BITN5 +#define S4REN BITN4 +#define S4TB8 BITN3 +#define S4RB8 BITN2 +#define S4TI BITN1 +#define S4RI BITN0 + +sfr S4BUF = 0x85; //xxxx,xxxx 串口4数据寄存器 + +//ADC 特殊功能寄存器 +sfr ADC_CONTR = 0xBC; //0000,0000 A/D转换控制寄存器 +sfr ADC_RES = 0xBD; //0000,0000 A/D转换结果高8位 +sfr ADC_RESL = 0xBE; //0000,0000 A/D转换结果低2位 + +//SPI 特殊功能寄存器 +sfr SPSTAT = 0xCD; //00xx,xxxx SPI状态寄存器 +sfr SPCTL = 0xCE; //0000,0100 SPI控制寄存器 +sfr SPDAT = 0xCF; //0000,0000 SPI数据寄存器 + +//IAP/ISP 特殊功能寄存器 +sfr IAP_DATA = 0xC2; //0000,0000 EEPROM数据寄存器 +sfr IAP_ADDRH = 0xC3; //0000,0000 EEPROM地址高字节 +sfr IAP_ADDRL = 0xC4; //0000,0000 EEPROM地址第字节 +sfr IAP_CMD = 0xC5; //xxxx,xx00 EEPROM命令寄存器 +sfr IAP_TRIG = 0xC6; //0000,0000 EEPRPM命令触发寄存器 +sfr IAP_CONTR = 0xC7; //0000,x000 EEPROM控制寄存器 + +//PCA/PWM 特殊功能寄存器 +sfr CCON = 0xD8; //00xx,xx00 PCA控制寄存器 +sbit CF = CCON^7; +sbit CR = CCON^6; +sbit CCF2 = CCON^2; +sbit CCF1 = CCON^1; +sbit CCF0 = CCON^0; +sfr CMOD = 0xD9; //0xxx,x000 PCA 工作模式寄存器 +sfr CL = 0xE9; //0000,0000 PCA计数器低字节 +sfr CH = 0xF9; //0000,0000 PCA计数器高字节 +sfr CCAPM0 = 0xDA; //0000,0000 PCA模块0的PWM寄存器 +sfr CCAPM1 = 0xDB; //0000,0000 PCA模块1的PWM寄存器 +sfr CCAPM2 = 0xDC; //0000,0000 PCA模块2的PWM 寄存器 +sfr CCAP0L = 0xEA; //0000,0000 PCA模块0的捕捉/比较寄存器低字节 +sfr CCAP1L = 0xEB; //0000,0000 PCA模块1的捕捉/比较寄存器低字节 +sfr CCAP2L = 0xEC; //0000,0000 PCA模块2的捕捉/比较寄存器低字节 +sfr PCA_PWM0 = 0xF2; //xxxx,xx00 PCA模块0的PWM寄存器 +sfr PCA_PWM1 = 0xF3; //xxxx,xx00 PCA模块1的PWM寄存器 +sfr PCA_PWM2 = 0xF4; //xxxx,xx00 PCA模块1的PWM寄存器 +sfr CCAP0H = 0xFA; //0000,0000 PCA模块0的捕捉/比较寄存器高字节 +sfr CCAP1H = 0xFB; //0000,0000 PCA模块1的捕捉/比较寄存器高字节 +sfr CCAP2H = 0xFC; //0000,0000 PCA模块2的捕捉/比较寄存器高字节 + +//比较器特殊功能寄存器 +sfr CMPCR1 = 0xE6; //0000,0000 比较器控制寄存器1 +sfr CMPCR2 = 0xE7; //0000,0000 比较器控制寄存器2 + +//增强型PWM波形发生器特殊功能寄存器 +sfr PWMCFG = 0xf1; //x000,0000 PWM配置寄存器 +sfr PWMCR = 0xf5; //0000,0000 PWM控制寄存器 +sfr PWMIF = 0xf6; //x000,0000 PWM中断标志寄存器 +sfr PWMFDCR = 0xf7; //xx00,0000 PWM外部异常检测控制寄存器 + +//如下特殊功能寄存器位于扩展RAM区域 +//访问这些寄存器,需先将P_SW2的BIT7设置为1,才可正常读写 +#define PWMC (*(unsigned int volatile xdata *)0xfff0) +#define PWMCH (*(unsigned char volatile xdata *)0xfff0) +#define PWMCL (*(unsigned char volatile xdata *)0xfff1) +#define PWMCKS (*(unsigned char volatile xdata *)0xfff2) +#define PWM2T1 (*(unsigned int volatile xdata *)0xff00) +#define PWM2T1H (*(unsigned char volatile xdata *)0xff00) +#define PWM2T1L (*(unsigned char volatile xdata *)0xff01) +#define PWM2T2 (*(unsigned int volatile xdata *)0xff02) +#define PWM2T2H (*(unsigned char volatile xdata *)0xff02) +#define PWM2T2L (*(unsigned char volatile xdata *)0xff03) +#define PWM2CR (*(unsigned char volatile xdata *)0xff04) +#define PWM3T1 (*(unsigned int volatile xdata *)0xff10) +#define PWM3T1H (*(unsigned char volatile xdata *)0xff10) +#define PWM3T1L (*(unsigned char volatile xdata *)0xff11) +#define PWM3T2 (*(unsigned int volatile xdata *)0xff12) +#define PWM3T2H (*(unsigned char volatile xdata *)0xff12) +#define PWM3T2L (*(unsigned char volatile xdata *)0xff13) +#define PWM3CR (*(unsigned char volatile xdata *)0xff14) +#define PWM4T1 (*(unsigned int volatile xdata *)0xff20) +#define PWM4T1H (*(unsigned char volatile xdata *)0xff20) +#define PWM4T1L (*(unsigned char volatile xdata *)0xff21) +#define PWM4T2 (*(unsigned int volatile xdata *)0xff22) +#define PWM4T2H (*(unsigned char volatile xdata *)0xff22) +#define PWM4T2L (*(unsigned char volatile xdata *)0xff23) +#define PWM4CR (*(unsigned char volatile xdata *)0xff24) +#define PWM5T1 (*(unsigned int volatile xdata *)0xff30) +#define PWM5T1H (*(unsigned char volatile xdata *)0xff30) +#define PWM5T1L (*(unsigned char volatile xdata *)0xff31) +#define PWM5T2 (*(unsigned int volatile xdata *)0xff32) +#define PWM5T2H (*(unsigned char volatile xdata *)0xff32) +#define PWM5T2L (*(unsigned char volatile xdata *)0xff33) +#define PWM5CR (*(unsigned char volatile xdata *)0xff34) +#define PWM6T1 (*(unsigned int volatile xdata *)0xff40) +#define PWM6T1H (*(unsigned char volatile xdata *)0xff40) +#define PWM6T1L (*(unsigned char volatile xdata *)0xff41) +#define PWM6T2 (*(unsigned int volatile xdata *)0xff42) +#define PWM6T2H (*(unsigned char volatile xdata *)0xff42) +#define PWM6T2L (*(unsigned char volatile xdata *)0xff43) +#define PWM6CR (*(unsigned char volatile xdata *)0xff44) +#define PWM7T1 (*(unsigned int volatile xdata *)0xff50) +#define PWM7T1H (*(unsigned char volatile xdata *)0xff50) +#define PWM7T1L (*(unsigned char volatile xdata *)0xff51) +#define PWM7T2 (*(unsigned int volatile xdata *)0xff52) +#define PWM7T2H (*(unsigned char volatile xdata *)0xff52) +#define PWM7T2L (*(unsigned char volatile xdata *)0xff53) +#define PWM7CR (*(unsigned char volatile xdata *)0xff54) + +///////////////////////////////////////////////// + + + +/* P3 */ +sbit RD = 0xB7; +sbit WR = 0xB6; +sbit T1 = 0xB5; +sbit T0 = 0xB4; +sbit INT1 = 0xB3; +sbit INT0 = 0xB2; +sbit TXD = 0xB1; +sbit RXD = 0xB0; + + + + + +/// >>>>> add by cc + + +//sbit P34=P3^4; //定义SDA数据线 +//sbit P35=P3^5; //定义SCL时钟线 +#define mBIT_1(X,N) X|= (1< +///////////////////////////////////////////////// +//注意: STC15W4K32S4系列的芯片,上电后所有与PWM相关的IO口均为 +// 高阻态,需将这些口设置为准双向口或强推挽模式方可正常使用 +//相关IO: P0.6/P0.7/P1.6/P1.7/P2.1/P2.2 +// P2.3/P2.7/P3.7/P4.2/P4.4/P4.5 +///////////////////////////////////////////////// + +///////////////////////////////////////////////// + +//包含本头文件后,不用另外再包含"REG51.H" + + +///////////////////////////////////////////////// + +//包含本头文件后,不用另外再包含"REG51.H" + +sfr P0 = 0x80; +sbit P00 = P0^0; +sbit P01 = P0^1; +sbit P02 = P0^2; +sbit P03 = P0^3; +sbit P04 = P0^4; +sbit P05 = P0^5; +sbit P06 = P0^6; +sbit P07 = P0^7; +sfr SP = 0x81; +sfr DPL = 0x82; +sfr DPH = 0x83; +sfr S4CON = 0x84; +sfr S4BUF = 0x85; +sfr PCON = 0x87; +sfr TCON = 0x88; +sbit TF1 = TCON^7; +sbit TR1 = TCON^6; +sbit TF0 = TCON^5; +sbit TR0 = TCON^4; +sbit IE1 = TCON^3; +sbit IT1 = TCON^2; +sbit IE0 = TCON^1; +sbit IT0 = TCON^0; +sfr TMOD = 0x89; +sfr TL0 = 0x8A; +sfr TL1 = 0x8B; +sfr TH0 = 0x8C; +sfr TH1 = 0x8D; +sfr AUXR = 0x8E; +sfr INTCLKO = 0x8F; +sfr P1 = 0x90; +sbit P10 = P1^0; +sbit P11 = P1^1; +sbit P12 = P1^2; +sbit P13 = P1^3; +sbit P14 = P1^4; +sbit P15 = P1^5; +sbit P16 = P1^6; +sbit P17 = P1^7; +sfr P1M1 = 0x91; +sfr P1M0 = 0x92; +sfr P0M1 = 0x93; +sfr P0M0 = 0x94; +sfr P2M1 = 0x95; +sfr P2M0 = 0x96; +sfr SCON = 0x98; +sbit SM0 = SCON^7; +sbit SM1 = SCON^6; +sbit SM2 = SCON^5; +sbit REN = SCON^4; +sbit TB8 = SCON^3; +sbit RB8 = SCON^2; +sbit TI = SCON^1; +sbit RI = SCON^0; +sfr SBUF = 0x99; +sfr S2CON = 0x9A; +sfr S2BUF = 0x9B; +sfr IRCBAND = 0x9D; +sfr LIRTRIM = 0x9E; +sfr IRTRIM = 0x9F; +sfr P2 = 0xA0; +sbit P20 = P2^0; +sbit P21 = P2^1; +sbit P22 = P2^2; +sbit P23 = P2^3; +sbit P24 = P2^4; +sbit P25 = P2^5; +sbit P26 = P2^6; +sbit P27 = P2^7; +sfr P_SW1 = 0xA2; +sfr IE = 0xA8; +sbit EA = IE^7; +sbit ELVD = IE^6; +sbit EADC = IE^5; +sbit ES = IE^4; +sbit ET1 = IE^3; +sbit EX1 = IE^2; +sbit ET0 = IE^1; +sbit EX0 = IE^0; +sfr SADDR = 0xA9; +sfr WKTCL = 0xAA; +sfr WKTCH = 0xAB; +sfr S3CON = 0xAC; +sfr S3BUF = 0xAD; +sfr TA = 0xAE; +sfr IE2 = 0xAF; +sfr P3 = 0xB0; +sbit P30 = P3^0; +sbit P31 = P3^1; +sbit P32 = P3^2; +sbit P33 = P3^3; +sbit P34 = P3^4; +sbit P35 = P3^5; +sbit P36 = P3^6; +sbit P37 = P3^7; +sfr P3M1 = 0xB1; +sfr P3M0 = 0xB2; +sfr P4M1 = 0xB3; +sfr P4M0 = 0xB4; +sfr IP2 = 0xB5; +sfr IP2H = 0xB6; +sfr IPH = 0xB7; +sfr IP = 0xB8; +sbit PPCA = IP^7; +sbit PLVD = IP^6; +sbit PADC = IP^5; +sbit PS = IP^4; +sbit PT1 = IP^3; +sbit PX1 = IP^2; +sbit PT0 = IP^1; +sbit PX0 = IP^0; +sfr SADEN = 0xB9; +sfr P_SW2 = 0xBA; +sfr ADC_CONTR = 0xBC; +sfr ADC_RES = 0xBD; +sfr ADC_RESL = 0xBE; +sfr P4 = 0xC0; +sbit P40 = P4^0; +sbit P41 = P4^1; +sbit P42 = P4^2; +sbit P43 = P4^3; +sbit P44 = P4^4; +sbit P45 = P4^5; +sbit P46 = P4^6; +sbit P47 = P4^7; +sfr WDT_CONTR = 0xC1; +sfr IAP_DATA = 0xC2; +sfr IAP_ADDRH = 0xC3; +sfr IAP_ADDRL = 0xC4; +sfr IAP_CMD = 0xC5; +sfr IAP_TRIG = 0xC6; +sfr IAP_CONTR = 0xC7; +sfr P5 = 0xC8; +sbit P50 = P5^0; +sbit P51 = P5^1; +sbit P52 = P5^2; +sbit P53 = P5^3; +sbit P54 = P5^4; +sbit P55 = P5^5; +sbit P56 = P5^6; +sbit P57 = P5^7; +sfr P5M1 = 0xC9; +sfr P5M0 = 0xCA; +sfr SPSTAT = 0xCD; +sfr SPCTL = 0xCE; +sfr SPDAT = 0xCF; +sfr PSW = 0xD0; +sbit CY = PSW^7; +sbit AC = PSW^6; +sbit F0 = PSW^5; +sbit RS1 = PSW^4; +sbit RS0 = PSW^3; +sbit OV = PSW^2; +sbit P = PSW^0; +sfr T4T3M = 0xD1; +sfr T4H = 0xD2; +sfr T4L = 0xD3; +sfr T3H = 0xD4; +sfr T3L = 0xD5; +sfr T2H = 0xD6; +sfr T2L = 0xD7; +sfr CCON = 0xD8; +sbit CF = CCON^7; +sbit CR = CCON^6; +sbit CCF2 = CCON^2; +sbit CCF1 = CCON^1; +sbit CCF0 = CCON^0; +sfr CMOD = 0xD9; +sfr CCAPM0 = 0xDA; +sfr CCAPM1 = 0xDB; +sfr CCAPM2 = 0xDC; +sfr ADCCFG = 0xDE; +sfr IP3 = 0xDF; +sfr ACC = 0xE0; +sfr DPS = 0xE3; +sfr DPL1 = 0xE4; +sfr DPH1 = 0xE5; +sfr CMPCR1 = 0xE6; +sfr CMPCR2 = 0xE7; +sfr CL = 0xE9; +sfr CCAP0L = 0xEA; +sfr CCAP1L = 0xEB; +sfr CCAP2L = 0xEC; +sfr IP3H = 0xEE; +sfr AUXINTIF = 0xEF; +sfr B = 0xF0; +sfr PWMSET = 0xF1; +sfr PCA_PWM0 = 0xF2; +sfr PCA_PWM1 = 0xF3; +sfr PCA_PWM2 = 0xF4; +sfr IAP_TPS = 0xF5; +sfr PWMCFG01 = 0xF6; +sfr PWMCFG23 = 0xF7; +sfr CH = 0xF9; +sfr CCAP0H = 0xFA; +sfr CCAP1H = 0xFB; +sfr CCAP2H = 0xFC; +sfr PWMCFG45 = 0xFE; +sfr RSTCFG = 0xFF; + +//如下特殊功能寄存器位于扩展RAM区域 +//访问这些寄存器,需先将P_SW2的BIT7设置为1,才可正常读写 + +#define CKSEL (*(unsigned char volatile xdata *)0xFE00) +#define CLKDIV (*(unsigned char volatile xdata *)0xFE01) +#define HIRCCR (*(unsigned char volatile xdata *)0xFE02) +#define XOSCCR (*(unsigned char volatile xdata *)0xFE03) +#define IRC32KCR (*(unsigned char volatile xdata *)0xFE04) +#define MCLKOCR (*(unsigned char volatile xdata *)0xFE05) +#define IRCDB (*(unsigned char volatile xdata *)0xFE06) + +#define P0PU (*(unsigned char volatile xdata *)0xFE10) +#define P1PU (*(unsigned char volatile xdata *)0xFE11) +#define P2PU (*(unsigned char volatile xdata *)0xFE12) +#define P3PU (*(unsigned char volatile xdata *)0xFE13) +#define P4PU (*(unsigned char volatile xdata *)0xFE14) +#define P5PU (*(unsigned char volatile xdata *)0xFE15) +#define P0NCS (*(unsigned char volatile xdata *)0xFE18) +#define P1NCS (*(unsigned char volatile xdata *)0xFE19) +#define P2NCS (*(unsigned char volatile xdata *)0xFE1A) +#define P3NCS (*(unsigned char volatile xdata *)0xFE1B) +#define P4NCS (*(unsigned char volatile xdata *)0xFE1C) +#define P5NCS (*(unsigned char volatile xdata *)0xFE1D) +#define P0SR (*(unsigned char volatile xdata *)0xFE20) +#define P1SR (*(unsigned char volatile xdata *)0xFE21) +#define P2SR (*(unsigned char volatile xdata *)0xFE22) +#define P3SR (*(unsigned char volatile xdata *)0xFE23) +#define P4SR (*(unsigned char volatile xdata *)0xFE24) +#define P5SR (*(unsigned char volatile xdata *)0xFE25) +#define P0DR (*(unsigned char volatile xdata *)0xFE28) +#define P1DR (*(unsigned char volatile xdata *)0xFE29) +#define P2DR (*(unsigned char volatile xdata *)0xFE2A) +#define P3DR (*(unsigned char volatile xdata *)0xFE2B) +#define P4DR (*(unsigned char volatile xdata *)0xFE2C) +#define P5DR (*(unsigned char volatile xdata *)0xFE2D) +#define P0IE (*(unsigned char volatile xdata *)0xFE30) +#define P1IE (*(unsigned char volatile xdata *)0xFE31) +#define P3IE (*(unsigned char volatile xdata *)0xFE33) + +#define I2CCFG (*(unsigned char volatile xdata *)0xFE80) +#define I2CMSCR (*(unsigned char volatile xdata *)0xFE81) +#define I2CMSST (*(unsigned char volatile xdata *)0xFE82) +#define I2CSLCR (*(unsigned char volatile xdata *)0xFE83) +#define I2CSLST (*(unsigned char volatile xdata *)0xFE84) +#define I2CSLADR (*(unsigned char volatile xdata *)0xFE85) +#define I2CTXD (*(unsigned char volatile xdata *)0xFE86) +#define I2CRXD (*(unsigned char volatile xdata *)0xFE87) +#define I2CMSAUX (*(unsigned char volatile xdata *)0xFE88) + +#define TM2PS (*(unsigned char volatile xdata *)0xFEA2) +#define TM3PS (*(unsigned char volatile xdata *)0xFEA3) +#define TM4PS (*(unsigned char volatile xdata *)0xFEA4) +#define ADCTIM (*(unsigned char volatile xdata *)0xFEA8) + +#define PWM0CH (*(unsigned char volatile xdata *)0xFF00) +#define PWM0CL (*(unsigned char volatile xdata *)0xFF01) +#define PWM0CKS (*(unsigned char volatile xdata *)0xFF02) +#define PWM0TADCH (*(unsigned char volatile xdata *)0xFF03) +#define PWM0TADCL (*(unsigned char volatile xdata *)0xFF04) +#define PWM0IF (*(unsigned char volatile xdata *)0xFF05) +#define PWM0FDCR (*(unsigned char volatile xdata *)0xFF06) +#define PWM00T1H (*(unsigned char volatile xdata *)0xFF10) +#define PWM00T1L (*(unsigned char volatile xdata *)0xFF11) +#define PWM00T2H (*(unsigned char volatile xdata *)0xFF12) +#define PWM00T2L (*(unsigned char volatile xdata *)0xFF13) +#define PWM00CR (*(unsigned char volatile xdata *)0xFF14) +#define PWM00HLD (*(unsigned char volatile xdata *)0xFF15) +#define PWM01T1H (*(unsigned char volatile xdata *)0xFF18) +#define PWM01T1L (*(unsigned char volatile xdata *)0xFF19) +#define PWM01T2H (*(unsigned char volatile xdata *)0xFF1A) +#define PWM01T2L (*(unsigned char volatile xdata *)0xFF1B) +#define PWM01CR (*(unsigned char volatile xdata *)0xFF1C) +#define PWM01HLD (*(unsigned char volatile xdata *)0xFF1D) +#define PWM02T1H (*(unsigned char volatile xdata *)0xFF20) +#define PWM02T1L (*(unsigned char volatile xdata *)0xFF21) +#define PWM02T2H (*(unsigned char volatile xdata *)0xFF22) +#define PWM02T2L (*(unsigned char volatile xdata *)0xFF23) +#define PWM02CR (*(unsigned char volatile xdata *)0xFF24) +#define PWM02HLD (*(unsigned char volatile xdata *)0xFF25) +#define PWM03T1H (*(unsigned char volatile xdata *)0xFF28) +#define PWM03T1L (*(unsigned char volatile xdata *)0xFF29) +#define PWM03T2H (*(unsigned char volatile xdata *)0xFF2A) +#define PWM03T2L (*(unsigned char volatile xdata *)0xFF2B) +#define PWM03CR (*(unsigned char volatile xdata *)0xFF2C) +#define PWM03HLD (*(unsigned char volatile xdata *)0xFF2D) +#define PWM04T1H (*(unsigned char volatile xdata *)0xFF30) +#define PWM04T1L (*(unsigned char volatile xdata *)0xFF31) +#define PWM04T2H (*(unsigned char volatile xdata *)0xFF32) +#define PWM04T2L (*(unsigned char volatile xdata *)0xFF33) +#define PWM04CR (*(unsigned char volatile xdata *)0xFF34) +#define PWM04HLD (*(unsigned char volatile xdata *)0xFF35) +#define PWM05T1H (*(unsigned char volatile xdata *)0xFF38) +#define PWM05T1L (*(unsigned char volatile xdata *)0xFF39) +#define PWM05T2H (*(unsigned char volatile xdata *)0xFF3A) +#define PWM05T2L (*(unsigned char volatile xdata *)0xFF3B) +#define PWM05CR (*(unsigned char volatile xdata *)0xFF3C) +#define PWM05HLD (*(unsigned char volatile xdata *)0xFF3D) +#define PWM06T1H (*(unsigned char volatile xdata *)0xFF40) +#define PWM06T1L (*(unsigned char volatile xdata *)0xFF41) +#define PWM06T2H (*(unsigned char volatile xdata *)0xFF42) +#define PWM06T2L (*(unsigned char volatile xdata *)0xFF43) +#define PWM06CR (*(unsigned char volatile xdata *)0xFF44) +#define PWM06HLD (*(unsigned char volatile xdata *)0xFF45) +#define PWM07T1H (*(unsigned char volatile xdata *)0xFF48) +#define PWM07T1L (*(unsigned char volatile xdata *)0xFF49) +#define PWM07T2H (*(unsigned char volatile xdata *)0xFF4A) +#define PWM07T2L (*(unsigned char volatile xdata *)0xFF4B) +#define PWM07CR (*(unsigned char volatile xdata *)0xFF4C) +#define PWM07HLD (*(unsigned char volatile xdata *)0xFF4D) +#define PWM1CH (*(unsigned char volatile xdata *)0xFF50) +#define PWM1CL (*(unsigned char volatile xdata *)0xFF51) +#define PWM1CKS (*(unsigned char volatile xdata *)0xFF52) +#define PWM1IF (*(unsigned char volatile xdata *)0xFF55) +#define PWM1FDCR (*(unsigned char volatile xdata *)0xFF56) +#define PWM10T1H (*(unsigned char volatile xdata *)0xFF60) +#define PWM10T1L (*(unsigned char volatile xdata *)0xFF61) +#define PWM10T2H (*(unsigned char volatile xdata *)0xFF62) +#define PWM10T2L (*(unsigned char volatile xdata *)0xFF63) +#define PWM10CR (*(unsigned char volatile xdata *)0xFF64) +#define PWM10HLD (*(unsigned char volatile xdata *)0xFF65) +#define PWM11T1H (*(unsigned char volatile xdata *)0xFF68) +#define PWM11T1L (*(unsigned char volatile xdata *)0xFF69) +#define PWM11T2H (*(unsigned char volatile xdata *)0xFF6A) +#define PWM11T2L (*(unsigned char volatile xdata *)0xFF6B) +#define PWM11CR (*(unsigned char volatile xdata *)0xFF6C) +#define PWM11HLD (*(unsigned char volatile xdata *)0xFF6D) +#define PWM12T1H (*(unsigned char volatile xdata *)0xFF70) +#define PWM12T1L (*(unsigned char volatile xdata *)0xFF71) +#define PWM12T2H (*(unsigned char volatile xdata *)0xFF72) +#define PWM12T2L (*(unsigned char volatile xdata *)0xFF73) +#define PWM12CR (*(unsigned char volatile xdata *)0xFF74) +#define PWM12HLD (*(unsigned char volatile xdata *)0xFF75) +#define PWM13T1H (*(unsigned char volatile xdata *)0xFF78) +#define PWM13T1L (*(unsigned char volatile xdata *)0xFF79) +#define PWM13T2H (*(unsigned char volatile xdata *)0xFF7A) +#define PWM13T2L (*(unsigned char volatile xdata *)0xFF7B) +#define PWM13CR (*(unsigned char volatile xdata *)0xFF7C) +#define PWM13HLD (*(unsigned char volatile xdata *)0xFF7D) +#define PWM14T1H (*(unsigned char volatile xdata *)0xFF80) +#define PWM14T1L (*(unsigned char volatile xdata *)0xFF81) +#define PWM14T2H (*(unsigned char volatile xdata *)0xFF82) +#define PWM14T2L (*(unsigned char volatile xdata *)0xFF83) +#define PWM14CR (*(unsigned char volatile xdata *)0xFF84) +#define PWM14HLD (*(unsigned char volatile xdata *)0xFF85) +#define PWM15T1H (*(unsigned char volatile xdata *)0xFF88) +#define PWM15T1L (*(unsigned char volatile xdata *)0xFF89) +#define PWM15T2H (*(unsigned char volatile xdata *)0xFF8A) +#define PWM15T2L (*(unsigned char volatile xdata *)0xFF8B) +#define PWM15CR (*(unsigned char volatile xdata *)0xFF8C) +#define PWM15HLD (*(unsigned char volatile xdata *)0xFF8D) +#define PWM16T1H (*(unsigned char volatile xdata *)0xFF90) +#define PWM16T1L (*(unsigned char volatile xdata *)0xFF91) +#define PWM16T2H (*(unsigned char volatile xdata *)0xFF92) +#define PWM16T2L (*(unsigned char volatile xdata *)0xFF93) +#define PWM16CR (*(unsigned char volatile xdata *)0xFF94) +#define PWM16HLD (*(unsigned char volatile xdata *)0xFF95) +#define PWM17T1H (*(unsigned char volatile xdata *)0xFF98) +#define PWM17T1L (*(unsigned char volatile xdata *)0xFF99) +#define PWM17T2H (*(unsigned char volatile xdata *)0xFF9A) +#define PWM17T2L (*(unsigned char volatile xdata *)0xFF9B) +#define PWM17CR (*(unsigned char volatile xdata *)0xFF9C) +#define PWM17HLD (*(unsigned char volatile xdata *)0xFF9D) +#define PWM2CH (*(unsigned char volatile xdata *)0xFFA0) +#define PWM2CL (*(unsigned char volatile xdata *)0xFFA1) +#define PWM2CKS (*(unsigned char volatile xdata *)0xFFA2) +#define PWM2TADCH (*(unsigned char volatile xdata *)0xFFA3) +#define PWM2TADCL (*(unsigned char volatile xdata *)0xFFA4) +#define PWM2IF (*(unsigned char volatile xdata *)0xFFA5) +#define PWM2FDCR (*(unsigned char volatile xdata *)0xFFA6) +#define PWM20T1H (*(unsigned char volatile xdata *)0xFFB0) +#define PWM20T1L (*(unsigned char volatile xdata *)0xFFB1) +#define PWM20T2H (*(unsigned char volatile xdata *)0xFFB2) +#define PWM20T2L (*(unsigned char volatile xdata *)0xFFB3) +#define PWM20CR (*(unsigned char volatile xdata *)0xFFB4) +#define PWM20HLD (*(unsigned char volatile xdata *)0xFFB5) +#define PWM21T1H (*(unsigned char volatile xdata *)0xFFB8) +#define PWM21T1L (*(unsigned char volatile xdata *)0xFFB9) +#define PWM21T2H (*(unsigned char volatile xdata *)0xFFBA) +#define PWM21T2L (*(unsigned char volatile xdata *)0xFFBB) +#define PWM21CR (*(unsigned char volatile xdata *)0xFFBC) +#define PWM21HLD (*(unsigned char volatile xdata *)0xFFBD) +#define PWM22T1H (*(unsigned char volatile xdata *)0xFFC0) +#define PWM22T1L (*(unsigned char volatile xdata *)0xFFC1) +#define PWM22T2H (*(unsigned char volatile xdata *)0xFFC2) +#define PWM22T2L (*(unsigned char volatile xdata *)0xFFC3) +#define PWM22CR (*(unsigned char volatile xdata *)0xFFC4) +#define PWM22HLD (*(unsigned char volatile xdata *)0xFFC5) +#define PWM23T1H (*(unsigned char volatile xdata *)0xFFC8) +#define PWM23T1L (*(unsigned char volatile xdata *)0xFFC9) +#define PWM23T2H (*(unsigned char volatile xdata *)0xFFCA) +#define PWM23T2L (*(unsigned char volatile xdata *)0xFFCB) +#define PWM23CR (*(unsigned char volatile xdata *)0xFFCC) +#define PWM23HLD (*(unsigned char volatile xdata *)0xFFCD) +#define PWM24T1H (*(unsigned char volatile xdata *)0xFFD0) +#define PWM24T1L (*(unsigned char volatile xdata *)0xFFD1) +#define PWM24T2H (*(unsigned char volatile xdata *)0xFFD2) +#define PWM24T2L (*(unsigned char volatile xdata *)0xFFD3) +#define PWM24CR (*(unsigned char volatile xdata *)0xFFD4) +#define PWM24HLD (*(unsigned char volatile xdata *)0xFFD5) +#define PWM25T1H (*(unsigned char volatile xdata *)0xFFD8) +#define PWM25T1L (*(unsigned char volatile xdata *)0xFFD9) +#define PWM25T2H (*(unsigned char volatile xdata *)0xFFDA) +#define PWM25T2L (*(unsigned char volatile xdata *)0xFFDB) +#define PWM25CR (*(unsigned char volatile xdata *)0xFFDC) +#define PWM25HLD (*(unsigned char volatile xdata *)0xFFDD) +#define PWM26T1H (*(unsigned char volatile xdata *)0xFFE0) +#define PWM26T1L (*(unsigned char volatile xdata *)0xFFE1) +#define PWM26T2H (*(unsigned char volatile xdata *)0xFFE2) +#define PWM26T2L (*(unsigned char volatile xdata *)0xFFE3) +#define PWM26CR (*(unsigned char volatile xdata *)0xFFE4) +#define PWM26HLD (*(unsigned char volatile xdata *)0xFFE5) +#define PWM27T1H (*(unsigned char volatile xdata *)0xFFE8) +#define PWM27T1L (*(unsigned char volatile xdata *)0xFFE9) +#define PWM27T2H (*(unsigned char volatile xdata *)0xFFEA) +#define PWM27T2L (*(unsigned char volatile xdata *)0xFFEB) +#define PWM27CR (*(unsigned char volatile xdata *)0xFFEC) +#define PWM27HLD (*(unsigned char volatile xdata *)0xFFED) +#define PWM3CH (*(unsigned char volatile xdata *)0xFC00) +#define PWM3CL (*(unsigned char volatile xdata *)0xFC01) +#define PWM3CKS (*(unsigned char volatile xdata *)0xFC02) +#define PWM3IF (*(unsigned char volatile xdata *)0xFC05) +#define PWM3FDCR (*(unsigned char volatile xdata *)0xFC06) +#define PWM30T1H (*(unsigned char volatile xdata *)0xFC10) +#define PWM30T1L (*(unsigned char volatile xdata *)0xFC11) +#define PWM30T2H (*(unsigned char volatile xdata *)0xFC12) +#define PWM30T2L (*(unsigned char volatile xdata *)0xFC13) +#define PWM30CR (*(unsigned char volatile xdata *)0xFC14) +#define PWM30HLD (*(unsigned char volatile xdata *)0xFC15) +#define PWM31T1H (*(unsigned char volatile xdata *)0xFC18) +#define PWM31T1L (*(unsigned char volatile xdata *)0xFC19) +#define PWM31T2H (*(unsigned char volatile xdata *)0xFC1A) +#define PWM31T2L (*(unsigned char volatile xdata *)0xFC1B) +#define PWM31CR (*(unsigned char volatile xdata *)0xFC1C) +#define PWM31HLD (*(unsigned char volatile xdata *)0xFC1D) +#define PWM32T1H (*(unsigned char volatile xdata *)0xFC20) +#define PWM32T1L (*(unsigned char volatile xdata *)0xFC21) +#define PWM32T2H (*(unsigned char volatile xdata *)0xFC22) +#define PWM32T2L (*(unsigned char volatile xdata *)0xFC23) +#define PWM32CR (*(unsigned char volatile xdata *)0xFC24) +#define PWM32HLD (*(unsigned char volatile xdata *)0xFC25) +#define PWM33T1H (*(unsigned char volatile xdata *)0xFC28) +#define PWM33T1L (*(unsigned char volatile xdata *)0xFC29) +#define PWM33T2H (*(unsigned char volatile xdata *)0xFC2A) +#define PWM33T2L (*(unsigned char volatile xdata *)0xFC2B) +#define PWM33CR (*(unsigned char volatile xdata *)0xFC2C) +#define PWM33HLD (*(unsigned char volatile xdata *)0xFC2D) +#define PWM34T1H (*(unsigned char volatile xdata *)0xFC30) +#define PWM34T1L (*(unsigned char volatile xdata *)0xFC31) +#define PWM34T2H (*(unsigned char volatile xdata *)0xFC32) +#define PWM34T2L (*(unsigned char volatile xdata *)0xFC33) +#define PWM34CR (*(unsigned char volatile xdata *)0xFC34) +#define PWM34HLD (*(unsigned char volatile xdata *)0xFC35) +#define PWM35T1H (*(unsigned char volatile xdata *)0xFC38) +#define PWM35T1L (*(unsigned char volatile xdata *)0xFC39) +#define PWM35T2H (*(unsigned char volatile xdata *)0xFC3A) +#define PWM35T2L (*(unsigned char volatile xdata *)0xFC3B) +#define PWM35CR (*(unsigned char volatile xdata *)0xFC3C) +#define PWM35HLD (*(unsigned char volatile xdata *)0xFC3D) +#define PWM36T1H (*(unsigned char volatile xdata *)0xFC40) +#define PWM36T1L (*(unsigned char volatile xdata *)0xFC41) +#define PWM36T2H (*(unsigned char volatile xdata *)0xFC42) +#define PWM36T2L (*(unsigned char volatile xdata *)0xFC43) +#define PWM36CR (*(unsigned char volatile xdata *)0xFC44) +#define PWM36HLD (*(unsigned char volatile xdata *)0xFC45) +#define PWM37T1H (*(unsigned char volatile xdata *)0xFC48) +#define PWM37T1L (*(unsigned char volatile xdata *)0xFC49) +#define PWM37T2H (*(unsigned char volatile xdata *)0xFC4A) +#define PWM37T2L (*(unsigned char volatile xdata *)0xFC4B) +#define PWM37CR (*(unsigned char volatile xdata *)0xFC4C) +#define PWM37HLD (*(unsigned char volatile xdata *)0xFC4D) +#define PWM4CH (*(unsigned char volatile xdata *)0xFC50) +#define PWM4CL (*(unsigned char volatile xdata *)0xFC51) +#define PWM4CKS (*(unsigned char volatile xdata *)0xFC52) +#define PWM4TADCH (*(unsigned char volatile xdata *)0xFC53) +#define PWM4TADCL (*(unsigned char volatile xdata *)0xFC54) +#define PWM4IF (*(unsigned char volatile xdata *)0xFC55) +#define PWM4FDCR (*(unsigned char volatile xdata *)0xFC56) +#define PWM40T1H (*(unsigned char volatile xdata *)0xFC60) +#define PWM40T1L (*(unsigned char volatile xdata *)0xFC61) +#define PWM40T2H (*(unsigned char volatile xdata *)0xFC62) +#define PWM40T2L (*(unsigned char volatile xdata *)0xFC63) +#define PWM40CR (*(unsigned char volatile xdata *)0xFC64) +#define PWM40HLD (*(unsigned char volatile xdata *)0xFC65) +#define PWM41T1H (*(unsigned char volatile xdata *)0xFC68) +#define PWM41T1L (*(unsigned char volatile xdata *)0xFC69) +#define PWM41T2H (*(unsigned char volatile xdata *)0xFC6A) +#define PWM41T2L (*(unsigned char volatile xdata *)0xFC6B) +#define PWM41CR (*(unsigned char volatile xdata *)0xFC6C) +#define PWM41HLD (*(unsigned char volatile xdata *)0xFC6D) +#define PWM42T1H (*(unsigned char volatile xdata *)0xFC70) +#define PWM42T1L (*(unsigned char volatile xdata *)0xFC71) +#define PWM42T2H (*(unsigned char volatile xdata *)0xFC72) +#define PWM42T2L (*(unsigned char volatile xdata *)0xFC73) +#define PWM42CR (*(unsigned char volatile xdata *)0xFC74) +#define PWM42HLD (*(unsigned char volatile xdata *)0xFC75) +#define PWM43T1H (*(unsigned char volatile xdata *)0xFC78) +#define PWM43T1L (*(unsigned char volatile xdata *)0xFC79) +#define PWM43T2H (*(unsigned char volatile xdata *)0xFC7A) +#define PWM43T2L (*(unsigned char volatile xdata *)0xFC7B) +#define PWM43CR (*(unsigned char volatile xdata *)0xFC7C) +#define PWM43HLD (*(unsigned char volatile xdata *)0xFC7D) +#define PWM44T1H (*(unsigned char volatile xdata *)0xFC80) +#define PWM44T1L (*(unsigned char volatile xdata *)0xFC81) +#define PWM44T2H (*(unsigned char volatile xdata *)0xFC82) +#define PWM44T2L (*(unsigned char volatile xdata *)0xFC83) +#define PWM44CR (*(unsigned char volatile xdata *)0xFC84) +#define PWM44HLD (*(unsigned char volatile xdata *)0xFC85) +#define PWM45T1H (*(unsigned char volatile xdata *)0xFC88) +#define PWM45T1L (*(unsigned char volatile xdata *)0xFC89) +#define PWM45T2H (*(unsigned char volatile xdata *)0xFC8A) +#define PWM45T2L (*(unsigned char volatile xdata *)0xFC8B) +#define PWM45CR (*(unsigned char volatile xdata *)0xFC8C) +#define PWM45HLD (*(unsigned char volatile xdata *)0xFC8D) +#define PWM46T1H (*(unsigned char volatile xdata *)0xFC90) +#define PWM46T1L (*(unsigned char volatile xdata *)0xFC91) +#define PWM46T2H (*(unsigned char volatile xdata *)0xFC92) +#define PWM46T2L (*(unsigned char volatile xdata *)0xFC93) +#define PWM46CR (*(unsigned char volatile xdata *)0xFC94) +#define PWM46HLD (*(unsigned char volatile xdata *)0xFC95) +#define PWM47T1H (*(unsigned char volatile xdata *)0xFC98) +#define PWM47T1L (*(unsigned char volatile xdata *)0xFC99) +#define PWM47T2H (*(unsigned char volatile xdata *)0xFC9A) +#define PWM47T2L (*(unsigned char volatile xdata *)0xFC9B) +#define PWM47CR (*(unsigned char volatile xdata *)0xFC9C) +#define PWM47HLD (*(unsigned char volatile xdata *)0xFC9D) +#define PWM5CH (*(unsigned char volatile xdata *)0xFCA0) +#define PWM5CL (*(unsigned char volatile xdata *)0xFCA1) +#define PWM5CKS (*(unsigned char volatile xdata *)0xFCA2) +#define PWM5IF (*(unsigned char volatile xdata *)0xFCA5) +#define PWM5FDCR (*(unsigned char volatile xdata *)0xFCA6) +#define PWM50T1H (*(unsigned char volatile xdata *)0xFCB0) +#define PWM50T1L (*(unsigned char volatile xdata *)0xFCB1) +#define PWM50T2H (*(unsigned char volatile xdata *)0xFCB2) +#define PWM50T2L (*(unsigned char volatile xdata *)0xFCB3) +#define PWM50CR (*(unsigned char volatile xdata *)0xFCB4) +#define PWM50HLD (*(unsigned char volatile xdata *)0xFCB5) +#define PWM51T1H (*(unsigned char volatile xdata *)0xFCB8) +#define PWM51T1L (*(unsigned char volatile xdata *)0xFCB9) +#define PWM51T2H (*(unsigned char volatile xdata *)0xFCBA) +#define PWM51T2L (*(unsigned char volatile xdata *)0xFCBB) +#define PWM51CR (*(unsigned char volatile xdata *)0xFCBC) +#define PWM51HLD (*(unsigned char volatile xdata *)0xFCBD) +#define PWM52T1H (*(unsigned char volatile xdata *)0xFCC0) +#define PWM52T1L (*(unsigned char volatile xdata *)0xFCC1) +#define PWM52T2H (*(unsigned char volatile xdata *)0xFCC2) +#define PWM52T2L (*(unsigned char volatile xdata *)0xFCC3) +#define PWM52CR (*(unsigned char volatile xdata *)0xFCC4) +#define PWM52HLD (*(unsigned char volatile xdata *)0xFCC5) +#define PWM53T1H (*(unsigned char volatile xdata *)0xFCC8) +#define PWM53T1L (*(unsigned char volatile xdata *)0xFCC9) +#define PWM53T2H (*(unsigned char volatile xdata *)0xFCCA) +#define PWM53T2L (*(unsigned char volatile xdata *)0xFCCB) +#define PWM53CR (*(unsigned char volatile xdata *)0xFCCC) +#define PWM53HLD (*(unsigned char volatile xdata *)0xFCCD) +#define PWM54T1H (*(unsigned char volatile xdata *)0xFCD0) +#define PWM54T1L (*(unsigned char volatile xdata *)0xFCD1) +#define PWM54T2H (*(unsigned char volatile xdata *)0xFCD2) +#define PWM54T2L (*(unsigned char volatile xdata *)0xFCD3) +#define PWM54CR (*(unsigned char volatile xdata *)0xFCD4) +#define PWM54HLD (*(unsigned char volatile xdata *)0xFCD5) +#define PWM55T1H (*(unsigned char volatile xdata *)0xFCD8) +#define PWM55T1L (*(unsigned char volatile xdata *)0xFCD9) +#define PWM55T2H (*(unsigned char volatile xdata *)0xFCDA) +#define PWM55T2L (*(unsigned char volatile xdata *)0xFCDB) +#define PWM55CR (*(unsigned char volatile xdata *)0xFCDC) +#define PWM55HLD (*(unsigned char volatile xdata *)0xFCDD) +#define PWM56T1H (*(unsigned char volatile xdata *)0xFCE0) +#define PWM56T1L (*(unsigned char volatile xdata *)0xFCE1) +#define PWM56T2H (*(unsigned char volatile xdata *)0xFCE2) +#define PWM56T2L (*(unsigned char volatile xdata *)0xFCE3) +#define PWM56CR (*(unsigned char volatile xdata *)0xFCE4) +#define PWM56HLD (*(unsigned char volatile xdata *)0xFCE5) +#define PWM57T1H (*(unsigned char volatile xdata *)0xFCE8) +#define PWM57T1L (*(unsigned char volatile xdata *)0xFCE9) +#define PWM57T2H (*(unsigned char volatile xdata *)0xFCEA) +#define PWM57T2L (*(unsigned char volatile xdata *)0xFCEB) +#define PWM57CR (*(unsigned char volatile xdata *)0xFCEC) +#define PWM57HLD (*(unsigned char volatile xdata *)0xFCED) + +///////////////////////////////////////////////// + + +/// >>>>> add by cc + +#include "../clib/bit.h" + +#define D_stdIO_P0_ALL() P0M1=0;P0M0=0; +#define D_HighI_P0_ALL() P0M1=0;P0M0=0XFF; +#define D_HighR_P0_ALL() P0M1=0XFF;P0M0=0; +#define D_OpenD_P0_ALL() P0M1=0XFF;P0M0=0XFF; + +#define D_stdIO_P1_ALL() P1M1=0;P1M0=0; +#define D_HighI_P1_ALL() P1M1=0;P1M0=0XFF; +#define D_HighR_P1_ALL() P1M1=0XFF;P1M0=0; +#define D_OpenD_P1_ALL() P1M1=0XFF;P1M0=0XFF; + + +#define D_stdIO_P0(n) BITN_0(P0M1,n);BITN_0(P0M0,n); //////00 准双向口 灌电流20mA 拉电流270-150uS +#define D_HighI_P0(n) BITN_0(P0M1,n);BITN_1(P0M0,n); //////01 推挽输出 20mA 加限流 +#define D_HighR_P0(n) BITN_1(P0M1,n);BITN_0(P0M0,n); /////////10 高阻 +#define D_OpenD_P0(n) BITN_1(P0M1,n);BITN_1(P0M0,n); /////11 开漏 open-Drain 内部上拉电阻断开 开漏模式既可以度外部状态也可以对外输出高低电平 + +#define D_stdIO_P1(n) BITN_0(P1M1,n);BITN_0(P1M0,n); //////00 准双向口 灌电流20mA 拉电流270-150uS +#define D_HighI_P1(n) BITN_0(P1M1,n);BITN_1(P1M0,n); //////01 推挽输出 20mA 加限流 +#define D_HighR_P1(n) BITN_1(P1M1,n);BITN_0(P1M0,n); /////////10 高阻 +#define D_OpenD_P1(n) BITN_1(P1M1,n);BITN_1(P1M0,n); /////11 开漏 open-Drain 内部上拉电阻断开 开漏模式既可以度外部状态也可以对外输出高低电平 + +#define D_stdIO_P2(n) BITN_0(P2M1,n);BITN_0(P2M0,n); //////00 准双向口 灌电流20mA 拉电流270-150uS +#define D_HighI_P2(n) BITN_0(P2M1,n);BITN_1(P2M0,n); //////01 推挽输出 20mA 加限流 +#define D_HighR_P2(n) BITN_1(P2M1,n);BITN_0(P2M0,n); /////////10 高阻 +#define D_OpenD_P2(n) BITN_1(P2M1,n);BITN_1(P2M0,n); /////11 开漏 open-Drain 内部上拉电阻断开 开漏模式既可以度外部状态也可以对外输出高低电平 + +#define D_stdIO_P3(n) BITN_0(P3M1,n);BITN_0(P3M0,n); //////00 准双向口 灌电流20mA 拉电流270-150uS +#define D_HighI_P3(n) BITN_0(P3M1,n);BITN_1(P3M0,n); //////01 推挽输出 20mA 加限流 +#define D_HighR_P3(n) BITN_1(P3M1,n);BITN_0(P3M0,n); /////////10 高阻 +#define D_OpenD_P3(n) BITN_1(P3M1,n);BITN_1(P3M0,n); /////11 开漏 open-Drain 内部上拉电阻断开 开漏模式既可以度外部状态也可以对外输出高低电平 + +#define D_stdIO_P4(n) BITN_0(P4M1,n);BITN_0(P4M0,n); //////00 准双向口 灌电流20mA 拉电流270-150uS +#define D_HighI_P4(n) BITN_0(P4M1,n);BITN_1(P4M0,n); //////01 推挽输出 20mA 加限流 +#define D_HighR_P4(n) BITN_1(P4M1,n);BITN_0(P4M0,n); /////////10 高阻 +#define D_OpenD_P4(n) BITN_1(P4M1,n);BITN_1(P4M0,n); /////11 开漏 open-Drain 内部上拉电阻断开 开漏模式既可以度外部状态也可以对外输出高低电平 + +#define D_stdIO_P5(n) BITN_0(P5M1,n);BITN_0(P5M0,n); //////00 准双向口 灌电流20mA 拉电流270-150uS +#define D_HighI_P5(n) BITN_0(P5M1,n);BITN_1(P5M0,n); //////01 推挽输出 20mA 加限流 +#define D_HighR_P5(n) BITN_1(P5M1,n);BITN_0(P5M0,n); /////////10 高阻 +#define D_OpenD_P5(n) BITN_1(P5M1,n);BITN_1(P5M0,n); /////11 开漏 open-Drain 内部上拉电阻断开 开漏模式既可以度外部状态也可以对外输出高低电平 + +#define D_stdIO_P6(n) BITN_0(P6M1,n);BITN_0(P6M0,n); //////00 准双向口 灌电流20mA 拉电流270-150uS +#define D_HighI_P6(n) BITN_0(P6M1,n);BITN_1(P6M0,n); //////01 推挽输出 20mA 加限流 +#define D_HighR_P6(n) BITN_1(P6M1,n);BITN_0(P6M0,n); /////////10 高阻 +#define D_OpenD_P6(n) BITN_1(P6M1,n);BITN_1(P6M0,n); /////11 开漏 open-Drain 内部上拉电阻断开 开漏模式既可以度外部状态也可以对外输出高低电平 + +#define D_stdIO_P7(n) BITN_0(P7M1,n);BITN_0(P7M0,n); //////00 准双向口 灌电流20mA 拉电流270-150uS +#define D_HighI_P7(n) BITN_0(P7M1,n);BITN_1(P7M0,n); //////01 推挽输出 20mA 加限流 +#define D_HighR_P7(n) BITN_1(P7M1,n);BITN_0(P7M0,n); /////////10 高阻 +#define D_OpenD_P7(n) BITN_1(P7M1,n);BITN_1(P7M0,n); /////11 开漏 open-Drain 内部上拉电阻断开 开漏模式既可以度外部状态也可以对外输出高低电平 + +/*** + +#define P0_conf_in(n) BITN_1(P0M1,n);BITN_0(P0M0,n); +#define P1_conf_in(n) BITN_1(P1M1,n);BITN_0(P1M0,n); +#define P2_conf_in(n) BITN_1(P2M1,n);BITN_0(P2M0,n); +#define P2_conf_port(n) BITN_0(P2M1,n);BITN_0(P2M0,n); + + +#define P3_conf_in(n) BITN_1(P3M1,n);BITN_0(P3M0,n); +#define P3_conf_port(n) BITN_0(P3M1,n);BITN_0(P3M0,n); + +#define P4_conf_in(n) BITN_1(P4M1,n);BITN_0(P4M0,n); +#define P5_conf_in(n) BITN_1(P5M1,n);BITN_0(P5M0,n); + +***/ + + + +#define NOP() _nop_() + +#define L0_INT4_OPEN() BITN_1(INT_CLKO, INT_EX4) +#define L0_INT4_CLOSE() BITN_0(INT_CLKO, INT_EX4) + +#define L0_INT4_AT() BITN_G(INT_CLKO, INT_EX4) + + + + +#define L0_INT4_CLEAR() BITN_0(AUXINTIF, INT4IF) +#define L0_INT3_CLEAR() BITN_0(AUXINTIF, INT3IF) +#define L0_INT2_CLEAR() BITN_0(AUXINTIF, INT2IF) + + + + +////// + +#define L0_INT3_OPEN() BITN_1(INT_CLKO, INT_EX3); +#define L0_INT3_CLOSE() BITN_0(INT_CLKO, INT_EX3); +#define L0_INT2_OPEN() BITN_1(INT_CLKO, INT_EX2); +#define L0_INT2_CLOSE() BITN_0(INT_CLKO, INT_EX2); +#define L0_INT1_OPEN() EX1 = 1; +#define L0_INT1_CLOSE() EX1 = 0; +#define L0_INT0_OPEN() EX0 = 1; +#define L0_INT0_CLOSE() EX0 = 0; + +#define D_ISR_int0 0 ///int0 下降沿触发 = 0 上下沿均可触发 +#define D_ISR_timer0 1 +#define D_ISR_int1 2 ///int1 下降沿触发 = 0 上下沿均可触发 +#define D_ISR_timer1 3 +#define D_ISR_int2 10 /////只有下降沿 +#define D_ISR_int3 11 /////只有下降沿 +#define D_SERVE_UART 4 +#define D_ISR_int4 16 /////只有下降沿 + +#if 0 +#define L0_TIMER1_start() TR1 = 1; +#define L0_TIMER1_end() TR1 = 0; + + +#define L0_TIMER1_isr_OPEN() ET1 = 1; +#define L0_TIMER1_isr_CLOSE() ET1 = 0; + + +#else + +#define L0_TIMER1_start() ET1 = 1; +#define L0_TIMER1_end() ET1 = 0; + + +#define L0_TIMER1_isr_OPEN() TR1 = 1; +#define L0_TIMER1_isr_CLOSE() TR1 = 0; + + +#endif + +/// fixme 颠倒定义会让c51锁死#define _nop_() NOP() + +///#define L0_INT3_OPEN() BITN_1(INT_CLKO,INT_EX3); //使能INT3中断 +///#define L0_INT3_CLOSE() BITN_0(INT_CLKO,INT_EX3); +#endif //STC_stc8a8k + + + + + + diff --git a/source/cpu/stc_stc8f.h b/source/cpu/stc_stc8f.h new file mode 100644 index 0000000..79b0ce8 --- /dev/null +++ b/source/cpu/stc_stc8f.h @@ -0,0 +1,593 @@ +#ifndef __STC8F_H_ +#define __STC8F_H_ + +///////////////////////////////////////////////// + +//包含本头文件后,不用另外再包含"REG51.H" + +//内核特殊功能寄存器 +sfr ACC = 0xe0; +sfr B = 0xf0; +sfr PSW = 0xd0; +sbit CY = PSW^7; +sbit AC = PSW^6; +sbit F0 = PSW^5; +sbit RS1 = PSW^4; +sbit RS0 = PSW^3; +sbit OV = PSW^2; +sbit F1 = PSW^1; +sbit P = PSW^0; +sfr SP = 0x81; +sfr DPL = 0x82; +sfr DPH = 0x83; +sfr TA = 0xae; +sfr DPS = 0xe3; +sfr DPL1 = 0xe4; +sfr DPH1 = 0xe5; + + +//I/O 口特殊功能寄存器 +sfr P0 = 0x80; +sfr P1 = 0x90; +sfr P2 = 0xa0; +sfr P3 = 0xb0; +sfr P4 = 0xc0; +sfr P5 = 0xc8; +sfr P6 = 0xe8; +sfr P7 = 0xf8; +sfr P0M0 = 0x94; +sfr P0M1 = 0x93; +sfr P1M0 = 0x92; +sfr P1M1 = 0x91; +sfr P2M0 = 0x96; +sfr P2M1 = 0x95; +sfr P3M0 = 0xb2; +sfr P3M1 = 0xb1; +sfr P4M0 = 0xb4; +sfr P4M1 = 0xb3; +sfr P5M0 = 0xca; +sfr P5M1 = 0xc9; +sfr P6M0 = 0xcc; +sfr P6M1 = 0xcb; +sfr P7M0 = 0xe2; +sfr P7M1 = 0xe1; + +sbit P00 = P0^0; +sbit P01 = P0^1; +sbit P02 = P0^2; +sbit P03 = P0^3; +sbit P04 = P0^4; +sbit P05 = P0^5; +sbit P06 = P0^6; +sbit P07 = P0^7; +sbit P10 = P1^0; +sbit P11 = P1^1; +sbit P12 = P1^2; +sbit P13 = P1^3; +sbit P14 = P1^4; +sbit P15 = P1^5; +sbit P16 = P1^6; +sbit P17 = P1^7; +sbit P20 = P2^0; +sbit P21 = P2^1; +sbit P22 = P2^2; +sbit P23 = P2^3; +sbit P24 = P2^4; +sbit P25 = P2^5; +sbit P26 = P2^6; +sbit P27 = P2^7; +sbit P30 = P3^0; +sbit P31 = P3^1; +sbit P32 = P3^2; +sbit P33 = P3^3; +sbit P34 = P3^4; +sbit P35 = P3^5; +sbit P36 = P3^6; +sbit P37 = P3^7; +sbit P40 = P4^0; +sbit P41 = P4^1; +sbit P42 = P4^2; +sbit P43 = P4^3; +sbit P44 = P4^4; +sbit P45 = P4^5; +sbit P46 = P4^6; +sbit P47 = P4^7; +sbit P50 = P5^0; +sbit P51 = P5^1; +sbit P52 = P5^2; +sbit P53 = P5^3; +sbit P54 = P5^4; +sbit P55 = P5^5; +sbit P56 = P5^6; +sbit P57 = P5^7; +sbit P60 = P6^0; +sbit P61 = P6^1; +sbit P62 = P6^2; +sbit P63 = P6^3; +sbit P64 = P6^4; +sbit P65 = P6^5; +sbit P66 = P6^6; +sbit P67 = P6^7; +sbit P70 = P7^0; +sbit P71 = P7^1; +sbit P72 = P7^2; +sbit P73 = P7^3; +sbit P74 = P7^4; +sbit P75 = P7^5; +sbit P76 = P7^6; +sbit P77 = P7^7; + +//如下特殊功能寄存器位于扩展RAM区域 +//访问这些寄存器,需先将P_SW2的BIT7设置为1,才可正常读写 +#define P0PU (*(unsigned char volatile xdata *)0xfe10) +#define P1PU (*(unsigned char volatile xdata *)0xfe11) +#define P2PU (*(unsigned char volatile xdata *)0xfe12) +#define P3PU (*(unsigned char volatile xdata *)0xfe13) +#define P4PU (*(unsigned char volatile xdata *)0xfe14) +#define P5PU (*(unsigned char volatile xdata *)0xfe15) +#define P6PU (*(unsigned char volatile xdata *)0xfe16) +#define P7PU (*(unsigned char volatile xdata *)0xfe17) +#define P0NCS (*(unsigned char volatile xdata *)0xfe18) +#define P1NCS (*(unsigned char volatile xdata *)0xfe19) +#define P2NCS (*(unsigned char volatile xdata *)0xfe1a) +#define P3NCS (*(unsigned char volatile xdata *)0xfe1b) +#define P4NCS (*(unsigned char volatile xdata *)0xfe1c) +#define P5NCS (*(unsigned char volatile xdata *)0xfe1d) +#define P6NCS (*(unsigned char volatile xdata *)0xfe1e) +#define P7NCS (*(unsigned char volatile xdata *)0xfe1f) + +//系统管理特殊功能寄存器 +sfr PCON = 0x87; +#define SMOD 0x80 +#define SMOD0 0x40 +#define LVDF 0x20 +#define POF 0x10 +#define GF1 0x08 +#define GF0 0x04 +#define PD 0x02 +#define IDL 0x01 +sfr AUXR = 0x8e; +#define T0x12 0x80 +#define T1x12 0x40 +#define UART_M0x6 0x20 +#define T2R 0x10 +#define T2_CT 0x08 +#define T2x12 0x04 +#define EXTRAM 0x02 +#define S1ST2 0x01 +sfr AUXR2 = 0x97; +#define TXLNRX 0x10 +sfr BUS_SPEED = 0xa1; +sfr P_SW1 = 0xa2; +sfr P_SW2 = 0xba; +#define EAXFR 0x80 +sfr VOCTRL = 0xbb; +sfr RSTCFG = 0xff; + +//如下特殊功能寄存器位于扩展RAM区域 +//访问这些寄存器,需先将P_SW2的BIT7设置为1,才可正常读写 +#define CKSEL (*(unsigned char volatile xdata *)0xfe00) +#define CLKDIV (*(unsigned char volatile xdata *)0xfe01) +#define IRC24MCR (*(unsigned char volatile xdata *)0xfe02) +#define XOSCCR (*(unsigned char volatile xdata *)0xfe03) +#define IRC32KCR (*(unsigned char volatile xdata *)0xfe04) + +//中断特殊功能寄存器 +sfr IE = 0xa8; +sbit EA = IE^7; +sbit ELVD = IE^6; +sbit EADC = IE^5; +sbit ES = IE^4; +sbit ET1 = IE^3; +sbit EX1 = IE^2; +sbit ET0 = IE^1; +sbit EX0 = IE^0; +sfr IE2 = 0xaf; +#define ET4 0x40 +#define ET3 0x20 +#define ES4 0x10 +#define ES3 0x08 +#define ET2 0x04 +#define ESPI 0x02 +#define ES2 0x01 + +sfr IP = 0xb8; +sbit PPCA = IP^7; +sbit PLVD = IP^6; +sbit PADC = IP^5; +sbit PS = IP^4; +sbit PT1 = IP^3; +sbit PX1 = IP^2; +sbit PT0 = IP^1; +sbit PX0 = IP^0; +sfr IP2 = 0xb5; +#define PI2C 0x40 +#define PCMP 0x20 +#define PX4 0x10 +#define PPWMFD 0x08 +#define PPWM 0x04 +#define PSPI 0x02 +#define PS2 0x01 +sfr IPH = 0xb7; +#define PPCAH 0x80 +#define PLVDH 0x40 +#define PADCH 0x20 +#define PSH 0x10 +#define PT1H 0x08 +#define PX1H 0x04 +#define PT0H 0x02 +#define PX0H 0x01 +sfr IP2H = 0xb6; +#define PI2CH 0x40 +#define PCMPH 0x20 +#define PX4H 0x10 +#define PPWMFDH 0x08 +#define PPWMH 0x04 +#define PSPIH 0x02 +#define PS2H 0x01 +sfr INTCLKO = 0x8f; +#define EX4 0x40 +#define EX3 0x20 +#define EX2 0x10 +#define T2CLKO 0x04 +#define T1CLKO 0x02 +#define T0CLKO 0x01 +sfr AUXINTIF = 0xef; +#define INT4IF 0x40 +#define INT3IF 0x20 +#define INT2IF 0x10 +#define T4IF 0x04 +#define T3IF 0x02 +#define T2IF 0x01 + +//定时器特殊功能寄存器 +sfr TCON = 0x88; +sbit TF1 = TCON^7; +sbit TR1 = TCON^6; +sbit TF0 = TCON^5; +sbit TR0 = TCON^4; +sbit IE1 = TCON^3; +sbit IT1 = TCON^2; +sbit IE0 = TCON^1; +sbit IT0 = TCON^0; +sfr TMOD = 0x89; +#define T1_GATE 0x80 +#define T1_CT 0x40 +#define T1_M1 0x20 +#define T1_M0 0x10 +#define T0_GATE 0x08 +#define T0_CT 0x04 +#define T0_M1 0x02 +#define T0_M0 0x01 +sfr TL0 = 0x8a; +sfr TL1 = 0x8b; +sfr TH0 = 0x8c; +sfr TH1 = 0x8d; +sfr T4T3M = 0xd1; +#define T4R 0x80 +#define T4_CT 0x40 +#define T4x12 0x20 +#define T4CLKO 0x10 +#define T3R 0x08 +#define T3_CT 0x04 +#define T3x12 0x02 +#define T3CLKO 0x01 +sfr T4H = 0xd2; +sfr T4L = 0xd3; +sfr T3H = 0xd4; +sfr T3L = 0xd5; +sfr T2H = 0xd6; +sfr T2L = 0xd7; +sfr TH4 = 0xd2; +sfr TL4 = 0xd3; +sfr TH3 = 0xd4; +sfr TL3 = 0xd5; +sfr TH2 = 0xd6; +sfr TL2 = 0xd7; +sfr WKTCL = 0xaa; +sfr WKTCH = 0xab; +#define WKTEN 0x80 +sfr WDT_CONTR = 0xc1; +#define WDT_FLAG 0x80 +#define EN_WDT 0x20 +#define CLR_WDT 0x10 +#define IDL_WDT 0x08 + +//串行口特殊功能寄存器 +sfr SCON = 0x98; +sbit SM0 = SCON^7; +sbit SM1 = SCON^6; +sbit SM2 = SCON^5; +sbit REN = SCON^4; +sbit TB8 = SCON^3; +sbit RB8 = SCON^2; +sbit TI = SCON^1; +sbit RI = SCON^0; +sfr SBUF = 0x99; +sfr S2CON = 0x9a; +#define S2SM0 0x80 +#define S2ST4 0x40 +#define S2SM2 0x20 +#define S2REN 0x10 +#define S2TB8 0x08 +#define S2RB8 0x04 +#define S2TI 0x02 +#define S2RI 0x01 +sfr S2BUF = 0x9b; +sfr S3CON = 0xac; +#define S3SM0 0x80 +#define S3ST4 0x40 +#define S3SM2 0x20 +#define S3REN 0x10 +#define S3TB8 0x08 +#define S3RB8 0x04 +#define S3TI 0x02 +#define S3RI 0x01 +sfr S3BUF = 0xad; +sfr S4CON = 0x84; +#define S4SM0 0x80 +#define S4ST4 0x40 +#define S4SM2 0x20 +#define S4REN 0x10 +#define S4TB8 0x08 +#define S4RB8 0x04 +#define S4TI 0x02 +#define S4RI 0x01 +sfr S4BUF = 0x85; +sfr SADDR = 0xa9; +sfr SADEN = 0xb9; + +//ADC 特殊功能寄存器 +sfr ADC_CONTR = 0xbc; +#define ADC_POWER 0x80 +#define ADC_START 0x40 +#define ADC_FLAG 0x20 +sfr ADC_RES = 0xbd; +sfr ADC_RESL = 0xbe; +sfr ADCCFG = 0xde; +#define ADC_RESFMT 0x20 + +//SPI 特殊功能寄存器 +sfr SPSTAT = 0xcd; +#define SPIF 0x80 +#define WCOL 0x40 +sfr SPCTL = 0xce; +#define SSIG 0x80 +#define SPEN 0x40 +#define DORD 0x20 +#define MSTR 0x10 +#define CPOL 0x08 +#define CPHA 0x04 +sfr SPDAT = 0xcf; + +//IAP/ISP 特殊功能寄存器 +sfr IAP_DATA = 0xc2; +sfr IAP_ADDRH = 0xc3; +sfr IAP_ADDRL = 0xc4; +sfr IAP_CMD = 0xc5; +#define IAP_IDL 0x00 +#define IAP_READ 0x01 +#define IAP_WRITE 0x02 +#define IAP_ERASE 0x03 +sfr IAP_TRIG = 0xc6; +sfr IAP_CONTR = 0xc7; +#define IAPEN 0x80 +#define SWBS 0x40 +#define SWRST 0x20 +#define CMD_FAIL 0x10 +sfr ISP_DATA = 0xc2; +sfr ISP_ADDRH = 0xc3; +sfr ISP_ADDRL = 0xc4; +sfr ISP_CMD = 0xc5; +sfr ISP_TRIG = 0xc6; +sfr ISP_CONTR = 0xc7; + +//比较器特殊功能寄存器 +sfr CMPCR1 = 0xe6; +#define CMPEN 0x80 +#define CMPIF 0x40 +#define PIE 0x20 +#define NIE 0x10 +#define PIS 0x08 +#define NIS 0x04 +#define CMPOE 0x02 +#define CMPRES 0x01 +sfr CMPCR2 = 0xe7; +#define INVCMPO 0x80 +#define DISFLT 0x40 + +//PCA/PWM 特殊功能寄存器 +sfr CCON = 0xd8; +sbit CF = CCON^7; +sbit CR = CCON^6; +sbit CCF3 = CCON^3; +sbit CCF2 = CCON^2; +sbit CCF1 = CCON^1; +sbit CCF0 = CCON^0; +sfr CMOD = 0xd9; +#define CIDL 0x80 +#define ECF 0x01 +sfr CL = 0xe9; +sfr CH = 0xf9; +sfr CCAPM0 = 0xda; +#define ECOM0 0x40 +#define CCAPP0 0x20 +#define CCAPN0 0x10 +#define MAT0 0x08 +#define TOG0 0x04 +#define PWM0 0x02 +#define ECCF0 0x01 +sfr CCAPM1 = 0xdb; +#define ECOM1 0x40 +#define CCAPP1 0x20 +#define CCAPN1 0x10 +#define MAT1 0x08 +#define TOG1 0x04 +#define PWM1 0x02 +#define ECCF1 0x01 +sfr CCAPM2 = 0xdc; +#define ECOM2 0x40 +#define CCAPP2 0x20 +#define CCAPN2 0x10 +#define MAT2 0x08 +#define TOG2 0x04 +#define PWM2 0x02 +#define ECCF2 0x01 +sfr CCAPM3 = 0xdd; +#define ECOM3 0x40 +#define CCAPP3 0x20 +#define CCAPN3 0x10 +#define MAT3 0x08 +#define TOG3 0x04 +#define PWM3 0x02 +#define ECCF3 0x01 +sfr CCAP0L = 0xea; +sfr CCAP1L = 0xeb; +sfr CCAP2L = 0xec; +sfr CCAP3L = 0xed; +sfr CCAP0H = 0xfa; +sfr CCAP1H = 0xfb; +sfr CCAP2H = 0xfc; +sfr CCAP3H = 0xfd; +sfr PCA_PWM0 = 0xf2; +sfr PCA_PWM1 = 0xf3; +sfr PCA_PWM2 = 0xf4; +sfr PCA_PWM3 = 0xf5; + +//增强型PWM波形发生器特殊功能寄存器 +sfr PWMCFG = 0xf1; +#define CBIF 0x80 +#define ETADC 0x40 +sfr PWMIF = 0xf6; +#define C7IF 0x80 +#define C6IF 0x40 +#define C5IF 0x20 +#define C4IF 0x10 +#define C3IF 0x08 +#define C2IF 0x04 +#define C1IF 0x02 +#define C0IF 0x01 +sfr PWMFDCR = 0xf7; +#define INVCMP 0x80 +#define INVIO 0x40 +#define ENFD 0x20 +#define FLTFLIO 0x10 +#define EFDI 0x08 +#define FDCMP 0x04 +#define FDIO 0x02 +#define FDIF 0x01 +sfr PWMCR = 0xfe; +#define ENPWM 0x80 +#define ECBI 0x40 + +//如下特殊功能寄存器位于扩展RAM区域 +//访问这些寄存器,需先将P_SW2的BIT7设置为1,才可正常读写 +#define PWMC (*(unsigned int volatile xdata *)0xfff0) +#define PWMCH (*(unsigned char volatile xdata *)0xfff0) +#define PWMCL (*(unsigned char volatile xdata *)0xfff1) +#define PWMCKS (*(unsigned char volatile xdata *)0xfff2) +#define TADCP (*(unsigned char volatile xdata *)0xfff3) +#define TADCPH (*(unsigned char volatile xdata *)0xfff3) +#define TADCPL (*(unsigned char volatile xdata *)0xfff4) +#define PWM0T1 (*(unsigned int volatile xdata *)0xff00) +#define PWM0T1H (*(unsigned char volatile xdata *)0xff00) +#define PWM0T1L (*(unsigned char volatile xdata *)0xff01) +#define PWM0T2 (*(unsigned int volatile xdata *)0xff02) +#define PWM0T2H (*(unsigned char volatile xdata *)0xff02) +#define PWM0T2L (*(unsigned char volatile xdata *)0xff03) +#define PWM0CR (*(unsigned char volatile xdata *)0xff04) +#define PWM0HLD (*(unsigned char volatile xdata *)0xff05) +#define PWM1T1 (*(unsigned int volatile xdata *)0xff10) +#define PWM1T1H (*(unsigned char volatile xdata *)0xff10) +#define PWM1T1L (*(unsigned char volatile xdata *)0xff11) +#define PWM1T2 (*(unsigned int volatile xdata *)0xff12) +#define PWM1T2H (*(unsigned char volatile xdata *)0xff12) +#define PWM1T2L (*(unsigned char volatile xdata *)0xff13) +#define PWM1CR (*(unsigned char volatile xdata *)0xff14) +#define PWM1HLD (*(unsigned char volatile xdata *)0xff15) +#define PWM2T1 (*(unsigned int volatile xdata *)0xff20) +#define PWM2T1H (*(unsigned char volatile xdata *)0xff20) +#define PWM2T1L (*(unsigned char volatile xdata *)0xff21) +#define PWM2T2 (*(unsigned int volatile xdata *)0xff22) +#define PWM2T2H (*(unsigned char volatile xdata *)0xff22) +#define PWM2T2L (*(unsigned char volatile xdata *)0xff23) +#define PWM2CR (*(unsigned char volatile xdata *)0xff24) +#define PWM2HLD (*(unsigned char volatile xdata *)0xff25) +#define PWM3T1 (*(unsigned int volatile xdata *)0xff30) +#define PWM3T1H (*(unsigned char volatile xdata *)0xff30) +#define PWM3T1L (*(unsigned char volatile xdata *)0xff31) +#define PWM3T2 (*(unsigned int volatile xdata *)0xff32) +#define PWM3T2H (*(unsigned char volatile xdata *)0xff32) +#define PWM3T2L (*(unsigned char volatile xdata *)0xff33) +#define PWM3CR (*(unsigned char volatile xdata *)0xff34) +#define PWM3HLD (*(unsigned char volatile xdata *)0xff35) +#define PWM4T1 (*(unsigned int volatile xdata *)0xff40) +#define PWM4T1H (*(unsigned char volatile xdata *)0xff40) +#define PWM4T1L (*(unsigned char volatile xdata *)0xff41) +#define PWM4T2 (*(unsigned int volatile xdata *)0xff42) +#define PWM4T2H (*(unsigned char volatile xdata *)0xff42) +#define PWM4T2L (*(unsigned char volatile xdata *)0xff43) +#define PWM4CR (*(unsigned char volatile xdata *)0xff44) +#define PWM4HLD (*(unsigned char volatile xdata *)0xff45) +#define PWM5T1 (*(unsigned int volatile xdata *)0xff50) +#define PWM5T1H (*(unsigned char volatile xdata *)0xff50) +#define PWM5T1L (*(unsigned char volatile xdata *)0xff51) +#define PWM5T2 (*(unsigned int volatile xdata *)0xff52) +#define PWM5T2H (*(unsigned char volatile xdata *)0xff52) +#define PWM5T2L (*(unsigned char volatile xdata *)0xff53) +#define PWM5CR (*(unsigned char volatile xdata *)0xff54) +#define PWM5HLD (*(unsigned char volatile xdata *)0xff55) +#define PWM6T1 (*(unsigned int volatile xdata *)0xff60) +#define PWM6T1H (*(unsigned char volatile xdata *)0xff60) +#define PWM6T1L (*(unsigned char volatile xdata *)0xff61) +#define PWM6T2 (*(unsigned int volatile xdata *)0xff62) +#define PWM6T2H (*(unsigned char volatile xdata *)0xff62) +#define PWM6T2L (*(unsigned char volatile xdata *)0xff63) +#define PWM6CR (*(unsigned char volatile xdata *)0xff64) +#define PWM6HLD (*(unsigned char volatile xdata *)0xff65) +#define PWM7T1 (*(unsigned int volatile xdata *)0xff70) +#define PWM7T1H (*(unsigned char volatile xdata *)0xff70) +#define PWM7T1L (*(unsigned char volatile xdata *)0xff71) +#define PWM7T2 (*(unsigned int volatile xdata *)0xff72) +#define PWM7T2H (*(unsigned char volatile xdata *)0xff72) +#define PWM7T2L (*(unsigned char volatile xdata *)0xff73) +#define PWM7CR (*(unsigned char volatile xdata *)0xff74) +#define PWM7HLD (*(unsigned char volatile xdata *)0xff75) + +//I2C特殊功能寄存器 +//如下特殊功能寄存器位于扩展RAM区域 +//访问这些寄存器,需先将P_SW2的BIT7设置为1,才可正常读写 +#define I2CCFG (*(unsigned char volatile xdata *)0xfe80) +#define ENI2C 0x80 +#define MSSL 0x40 +#define I2CMSCR (*(unsigned char volatile xdata *)0xfe81) +#define EMSI 0x80 +#define I2CMSST (*(unsigned char volatile xdata *)0xfe82) +#define MSBUSY 0x80 +#define MSIF 0x40 +#define MSACKI 0x02 +#define MSACKO 0x01 +#define I2CSLCR (*(unsigned char volatile xdata *)0xfe83) +#define ESTAI 0x40 +#define ERXI 0x20 +#define ETXI 0x10 +#define ESTOI 0x08 +#define SLRST 0x01 +#define I2CSLST (*(unsigned char volatile xdata *)0xfe84) +#define SLBUSY 0x80 +#define STAIF 0x40 +#define RXIF 0x20 +#define TXIF 0x10 +#define STOIF 0x08 +#define TXING 0x04 +#define SLACKI 0x02 +#define SLACKO 0x01 +#define I2CSLADR (*(unsigned char volatile xdata *)0xfe85) +#define I2CTXD (*(unsigned char volatile xdata *)0xfe86) +#define I2CRXD (*(unsigned char volatile xdata *)0xfe87) + +///////////////////////////////////////////////// + +#endif + + diff --git a/source/cpu/stc_stc8hxx.h b/source/cpu/stc_stc8hxx.h new file mode 100644 index 0000000..c3000ee --- /dev/null +++ b/source/cpu/stc_stc8hxx.h @@ -0,0 +1,648 @@ +#ifndef __STC8H_H__ +#define __STC8H_H__ + +///////////////////////////////////////////////// + +//ͷļ,ٰ"REG51.H" + +sfr P0 = 0x80; +sbit P00 = P0^0; +sbit P01 = P0^1; +sbit P02 = P0^2; +sbit P03 = P0^3; +sbit P04 = P0^4; +sbit P05 = P0^5; +sbit P06 = P0^6; +sbit P07 = P0^7; +sfr SP = 0x81; +sfr DPL = 0x82; +sfr DPH = 0x83; +sfr S4CON = 0x84; +sfr S4BUF = 0x85; +sfr PCON = 0x87; +sfr TCON = 0x88; +sbit TF1 = TCON^7; +sbit TR1 = TCON^6; +sbit TF0 = TCON^5; +sbit TR0 = TCON^4; +sbit IE1 = TCON^3; +sbit IT1 = TCON^2; +sbit IE0 = TCON^1; +sbit IT0 = TCON^0; +sfr TMOD = 0x89; +sfr TL0 = 0x8a; +sfr TL1 = 0x8b; +sfr TH0 = 0x8c; +sfr TH1 = 0x8d; +sfr AUXR = 0x8e; +sfr INTCLKO = 0x8f; +sfr P1 = 0x90; +sbit P10 = P1^0; +sbit P11 = P1^1; +sbit P12 = P1^2; +sbit P13 = P1^3; +sbit P14 = P1^4; +sbit P15 = P1^5; +sbit P16 = P1^6; +sbit P17 = P1^7; +sfr P1M1 = 0x91; +sfr P1M0 = 0x92; +sfr P0M1 = 0x93; +sfr P0M0 = 0x94; +sfr P2M1 = 0x95; +sfr P2M0 = 0x96; +sfr SCON = 0x98; +sbit SM0 = SCON^7; +sbit SM1 = SCON^6; +sbit SM2 = SCON^5; +sbit REN = SCON^4; +sbit TB8 = SCON^3; +sbit RB8 = SCON^2; +sbit TI = SCON^1; +sbit RI = SCON^0; +sfr SBUF = 0x99; +sfr S2CON = 0x9a; +sfr S2BUF = 0x9b; +sfr IRCBAND = 0x9d; +sfr LIRTRIM = 0x9e; +sfr IRTRIM = 0x9f; +sfr P2 = 0xa0; +sbit P20 = P2^0; +sbit P21 = P2^1; +sbit P22 = P2^2; +sbit P23 = P2^3; +sbit P24 = P2^4; +sbit P25 = P2^5; +sbit P26 = P2^6; +sbit P27 = P2^7; +sfr P_SW1 = 0xa2; +sfr IE = 0xa8; +sbit EA = IE^7; +sbit ELVD = IE^6; +sbit EADC = IE^5; +sbit ES = IE^4; +sbit ET1 = IE^3; +sbit EX1 = IE^2; +sbit ET0 = IE^1; +sbit EX0 = IE^0; +sfr SADDR = 0xa9; +sfr WKTCL = 0xaa; +sfr WKTCH = 0xab; +sfr S3CON = 0xac; +sfr S3BUF = 0xad; +sfr TA = 0xae; +sfr IE2 = 0xaf; +sfr P3 = 0xb0; +sbit P30 = P3^0; +sbit P31 = P3^1; +sbit P32 = P3^2; +sbit P33 = P3^3; +sbit P34 = P3^4; +sbit P35 = P3^5; +sbit P36 = P3^6; +sbit P37 = P3^7; +sfr P3M1 = 0xb1; +sfr P3M0 = 0xb2; +sfr P4M1 = 0xb3; +sfr P4M0 = 0xb4; +sfr IP2 = 0xb5; +sfr IP2H = 0xb6; +sfr IPH = 0xb7; +sfr IP = 0xb8; +sbit PPCA = IP^7; +sbit PLVD = IP^6; +sbit PADC = IP^5; +sbit PS = IP^4; +sbit PT1 = IP^3; +sbit PX1 = IP^2; +sbit PT0 = IP^1; +sbit PX0 = IP^0; +sfr SADEN = 0xb9; +sfr P_SW2 = 0xba; +sfr ADC_CONTR = 0xbc; +sfr ADC_RES = 0xbd; +sfr ADC_RESL = 0xbe; +sfr P4 = 0xc0; +sbit P40 = P4^0; +sbit P41 = P4^1; +sbit P42 = P4^2; +sbit P43 = P4^3; +sbit P44 = P4^4; +sbit P45 = P4^5; +sbit P46 = P4^6; +sbit P47 = P4^7; +sfr WDT_CONTR = 0xc1; +sfr IAP_DATA = 0xc2; +sfr IAP_ADDRH = 0xc3; +sfr IAP_ADDRL = 0xc4; +sfr IAP_CMD = 0xc5; +sfr IAP_TRIG = 0xc6; +sfr IAP_CONTR = 0xc7; +sfr P5 = 0xc8; +sbit P50 = P5^0; +sbit P51 = P5^1; +sbit P52 = P5^2; +sbit P53 = P5^3; +sbit P54 = P5^4; +sbit P55 = P5^5; +sbit P56 = P5^6; +sbit P57 = P5^7; +sfr P5M1 = 0xc9; +sfr P5M0 = 0xca; +sfr P6M1 = 0xcb; +sfr P6M0 = 0xcc; +sfr SPSTAT = 0xcd; +sfr SPCTL = 0xce; +sfr SPDAT = 0xcf; +sfr PSW = 0xd0; +sbit CY = PSW^7; +sbit AC = PSW^6; +sbit F0 = PSW^5; +sbit RS1 = PSW^4; +sbit RS0 = PSW^3; +sbit OV = PSW^2; +sbit F1 = PSW^1; +sbit P = PSW^0; +sfr T4T3M = 0xd1; +sfr T4H = 0xd2; +sfr T4L = 0xd3; +sfr T3H = 0xd4; +sfr T3L = 0xd5; +#define ET3 0x20 +#define T3IF 0x02 +sfr T2H = 0xd6; +sfr T2L = 0xd7; +#define ES2 0x01 +sfr USBCLK = 0xdc; +sfr ADCCFG = 0xde; +sfr IP3 = 0xdf; +sfr ACC = 0xe0; +sfr P7M1 = 0xe1; +sfr P7M0 = 0xe2; +sfr DPS = 0xe3; +sfr DPL1 = 0xe4; +sfr DPH1 = 0xe5; +sfr CMPCR1 = 0xe6; +sfr CMPCR2 = 0xe7; +sfr P6 = 0xe8; +sfr USBDAT = 0xec; +sfr IP3H = 0xee; +sfr AUXINTIF = 0xef; +sfr B = 0xf0; +sfr USBCON = 0xf4; +sfr IAP_TPS = 0xf5; +sfr P7 = 0xf8; +sfr USBADR = 0xfc; +sfr RSTCFG = 0xff; +#define S2TI 0x02 +#define S2RI 0x01 +#define ES3 0x08 +#define S3TI 0x02 +#define S3RI 0x01 +#define ET4 0x40 +//⹦ܼĴλչRAM +//ЩĴ,ȽP_SW2BIT7Ϊ1,ſд + +///////////////////////////////////////////////// +//FF00H-FFFFH +///////////////////////////////////////////////// + + + +///////////////////////////////////////////////// +//FE00H-FEFFH +///////////////////////////////////////////////// + +#define CKSEL (*(unsigned char volatile xdata *)0xfe00) +#define CLKDIV (*(unsigned char volatile xdata *)0xfe01) +#define HIRCCR (*(unsigned char volatile xdata *)0xfe02) +#define XOSCCR (*(unsigned char volatile xdata *)0xfe03) +#define IRC32KCR (*(unsigned char volatile xdata *)0xfe04) +#define MCLKOCR (*(unsigned char volatile xdata *)0xfe05) +#define IRCDB (*(unsigned char volatile xdata *)0xfe06) +#define X32KCR (*(unsigned char volatile xdata *)0xfe08) + +#define P0PU (*(unsigned char volatile xdata *)0xfe10) +#define P1PU (*(unsigned char volatile xdata *)0xfe11) +#define P2PU (*(unsigned char volatile xdata *)0xfe12) +#define P3PU (*(unsigned char volatile xdata *)0xfe13) +#define P4PU (*(unsigned char volatile xdata *)0xfe14) +#define P5PU (*(unsigned char volatile xdata *)0xfe15) +#define P6PU (*(unsigned char volatile xdata *)0xfe16) +#define P7PU (*(unsigned char volatile xdata *)0xfe17) +#define P0NCS (*(unsigned char volatile xdata *)0xfe18) +#define P1NCS (*(unsigned char volatile xdata *)0xfe19) +#define P2NCS (*(unsigned char volatile xdata *)0xfe1a) +#define P3NCS (*(unsigned char volatile xdata *)0xfe1b) +#define P4NCS (*(unsigned char volatile xdata *)0xfe1c) +#define P5NCS (*(unsigned char volatile xdata *)0xfe1d) +#define P6NCS (*(unsigned char volatile xdata *)0xfe1e) +#define P7NCS (*(unsigned char volatile xdata *)0xfe1f) +#define P0SR (*(unsigned char volatile xdata *)0xfe20) +#define P1SR (*(unsigned char volatile xdata *)0xfe21) +#define P2SR (*(unsigned char volatile xdata *)0xfe22) +#define P3SR (*(unsigned char volatile xdata *)0xfe23) +#define P4SR (*(unsigned char volatile xdata *)0xfe24) +#define P5SR (*(unsigned char volatile xdata *)0xfe25) +#define P6SR (*(unsigned char volatile xdata *)0xfe26) +#define P7SR (*(unsigned char volatile xdata *)0xfe27) +#define P0DR (*(unsigned char volatile xdata *)0xfe28) +#define P1DR (*(unsigned char volatile xdata *)0xfe29) +#define P2DR (*(unsigned char volatile xdata *)0xfe2a) +#define P3DR (*(unsigned char volatile xdata *)0xfe2b) +#define P4DR (*(unsigned char volatile xdata *)0xfe2c) +#define P5DR (*(unsigned char volatile xdata *)0xfe2d) +#define P6DR (*(unsigned char volatile xdata *)0xfe2e) +#define P7DR (*(unsigned char volatile xdata *)0xfe2f) +#define P0IE (*(unsigned char volatile xdata *)0xfe30) +#define P1IE (*(unsigned char volatile xdata *)0xfe31) +#define P2IE (*(unsigned char volatile xdata *)0xfe32) +#define P3IE (*(unsigned char volatile xdata *)0xfe33) +#define P4IE (*(unsigned char volatile xdata *)0xfe34) +#define P5IE (*(unsigned char volatile xdata *)0xfe35) +#define P6IE (*(unsigned char volatile xdata *)0xfe36) +#define P7IE (*(unsigned char volatile xdata *)0xfe37) + +#define RTCCR (*(unsigned char volatile xdata *)0xfe60) +#define RTCCFG (*(unsigned char volatile xdata *)0xfe61) +#define RTCIEN (*(unsigned char volatile xdata *)0xfe62) +#define RTCIF (*(unsigned char volatile xdata *)0xfe63) +#define ALAHOUR (*(unsigned char volatile xdata *)0xfe64) +#define ALAMIN (*(unsigned char volatile xdata *)0xfe65) +#define ALASEC (*(unsigned char volatile xdata *)0xfe66) +#define ALASSEC (*(unsigned char volatile xdata *)0xfe67) +#define INIYEAR (*(unsigned char volatile xdata *)0xfe68) +#define INIMONTH (*(unsigned char volatile xdata *)0xfe69) +#define INIDAY (*(unsigned char volatile xdata *)0xfe6a) +#define INIHOUR (*(unsigned char volatile xdata *)0xfe6b) +#define INIMIN (*(unsigned char volatile xdata *)0xfe6c) +#define INISEC (*(unsigned char volatile xdata *)0xfe6d) +#define INISSEC (*(unsigned char volatile xdata *)0xfe6e) +#define YEAR (*(unsigned char volatile xdata *)0xfe70) +#define MONTH (*(unsigned char volatile xdata *)0xfe71) +#define DAY (*(unsigned char volatile xdata *)0xfe72) +#define HOUR (*(unsigned char volatile xdata *)0xfe73) +#define MIN (*(unsigned char volatile xdata *)0xfe74) +#define SEC (*(unsigned char volatile xdata *)0xfe75) +#define SSEC (*(unsigned char volatile xdata *)0xfe76) + +#define I2CCFG (*(unsigned char volatile xdata *)0xfe80) +#define I2CMSCR (*(unsigned char volatile xdata *)0xfe81) +#define I2CMSST (*(unsigned char volatile xdata *)0xfe82) +#define I2CSLCR (*(unsigned char volatile xdata *)0xfe83) +#define I2CSLST (*(unsigned char volatile xdata *)0xfe84) +#define I2CSLADR (*(unsigned char volatile xdata *)0xfe85) +#define I2CTXD (*(unsigned char volatile xdata *)0xfe86) +#define I2CRXD (*(unsigned char volatile xdata *)0xfe87) +#define I2CMSAUX (*(unsigned char volatile xdata *)0xfe88) +#define TM2PS (*(unsigned char volatile xdata *)0xfea2) +#define TM3PS (*(unsigned char volatile xdata *)0xfea3) +#define TM4PS (*(unsigned char volatile xdata *)0xfea4) +#define ADCTIM (*(unsigned char volatile xdata *)0xfea8) + +#define PWM1_ETRPS (*(unsigned char volatile xdata *)0xfeb0) +#define PWM1_ENO (*(unsigned char volatile xdata *)0xfeb1) +#define PWM1_PS (*(unsigned char volatile xdata *)0xfeb2) +#define PWM1_IOAUX (*(unsigned char volatile xdata *)0xfeb3) +#define PWM2_ETRPS (*(unsigned char volatile xdata *)0xfeb4) +#define PWM2_ENO (*(unsigned char volatile xdata *)0xfeb5) +#define PWM2_PS (*(unsigned char volatile xdata *)0xfeb6) +#define PWM2_IOAUX (*(unsigned char volatile xdata *)0xfeb7) +#define PWM1_CR1 (*(unsigned char volatile xdata *)0xfec0) +#define PWM1_CR2 (*(unsigned char volatile xdata *)0xfec1) +#define PWM1_SMCR (*(unsigned char volatile xdata *)0xfec2) +#define PWM1_ETR (*(unsigned char volatile xdata *)0xfec3) +#define PWM1_IER (*(unsigned char volatile xdata *)0xfec4) +#define PWM1_SR1 (*(unsigned char volatile xdata *)0xfec5) +#define PWM1_SR2 (*(unsigned char volatile xdata *)0xfec6) +#define PWM1_EGR (*(unsigned char volatile xdata *)0xfec7) +#define PWM1_CCMR1 (*(unsigned char volatile xdata *)0xfec8) +#define PWM1_CCMR2 (*(unsigned char volatile xdata *)0xfec9) +#define PWM1_CCMR3 (*(unsigned char volatile xdata *)0xfeca) +#define PWM1_CCMR4 (*(unsigned char volatile xdata *)0xfecb) +#define PWM1_CCER1 (*(unsigned char volatile xdata *)0xfecc) +#define PWM1_CCER2 (*(unsigned char volatile xdata *)0xfecd) +#define PWM1_CNTR (*(unsigned int volatile xdata *)0xfece) +#define PWM1_CNTRH (*(unsigned char volatile xdata *)0xfece) +#define PWM1_CNTRL (*(unsigned char volatile xdata *)0xfecf) +#define PWM1_PSCR (*(unsigned int volatile xdata *)0xfed0) +#define PWM1_PSCRH (*(unsigned char volatile xdata *)0xfed0) +#define PWM1_PSCRL (*(unsigned char volatile xdata *)0xfed1) +#define PWM1_ARR (*(unsigned int volatile xdata *)0xfed2) +#define PWM1_ARRH (*(unsigned char volatile xdata *)0xfed2) +#define PWM1_ARRL (*(unsigned char volatile xdata *)0xfed3) +#define PWM1_RCR (*(unsigned char volatile xdata *)0xfed4) +#define PWM1_CCR1 (*(unsigned int volatile xdata *)0xfed5) +#define PWM1_CCR1H (*(unsigned char volatile xdata *)0xfed5) +#define PWM1_CCR1L (*(unsigned char volatile xdata *)0xfed6) +#define PWM1_CCR2 (*(unsigned int volatile xdata *)0xfed7) +#define PWM1_CCR2H (*(unsigned char volatile xdata *)0xfed7) +#define PWM1_CCR2L (*(unsigned char volatile xdata *)0xfed8) +#define PWM1_CCR3 (*(unsigned int volatile xdata *)0xfed9) +#define PWM1_CCR3H (*(unsigned char volatile xdata *)0xfed9) +#define PWM1_CCR3L (*(unsigned char volatile xdata *)0xfeda) +#define PWM1_CCR4 (*(unsigned int volatile xdata *)0xfedb) +#define PWM1_CCR4H (*(unsigned char volatile xdata *)0xfedb) +#define PWM1_CCR4L (*(unsigned char volatile xdata *)0xfedc) +#define PWM1_BKR (*(unsigned char volatile xdata *)0xfedd) +#define PWM1_DTR (*(unsigned char volatile xdata *)0xfede) +#define PWM1_OISR (*(unsigned char volatile xdata *)0xfedf) +#define PWM2_CR1 (*(unsigned char volatile xdata *)0xfee0) +#define PWM2_CR2 (*(unsigned char volatile xdata *)0xfee1) +#define PWM2_SMCR (*(unsigned char volatile xdata *)0xfee2) +#define PWM2_ETR (*(unsigned char volatile xdata *)0xfee3) +#define PWM2_IER (*(unsigned char volatile xdata *)0xfee4) +#define PWM2_SR1 (*(unsigned char volatile xdata *)0xfee5) +#define PWM2_SR2 (*(unsigned char volatile xdata *)0xfee6) +#define PWM2_EGR (*(unsigned char volatile xdata *)0xfee7) +#define PWM2_CCMR1 (*(unsigned char volatile xdata *)0xfee8) +#define PWM2_CCMR2 (*(unsigned char volatile xdata *)0xfee9) +#define PWM2_CCMR3 (*(unsigned char volatile xdata *)0xfeea) +#define PWM2_CCMR4 (*(unsigned char volatile xdata *)0xfeeb) +#define PWM2_CCER1 (*(unsigned char volatile xdata *)0xfeec) +#define PWM2_CCER2 (*(unsigned char volatile xdata *)0xfeed) +#define PWM2_CNTR (*(unsigned int volatile xdata *)0xfeee) +#define PWM2_CNTRH (*(unsigned char volatile xdata *)0xfeee) +#define PWM2_CNTRL (*(unsigned char volatile xdata *)0xfeef) +#define PWM2_PSCR (*(unsigned int volatile xdata *)0xfef0) +#define PWM2_PSCRH (*(unsigned char volatile xdata *)0xfef0) +#define PWM2_PSCRL (*(unsigned char volatile xdata *)0xfef1) +#define PWM2_ARR (*(unsigned int volatile xdata *)0xfef2) +#define PWM2_ARRH (*(unsigned char volatile xdata *)0xfef2) +#define PWM2_ARRL (*(unsigned char volatile xdata *)0xfef3) +#define PWM2_RCR (*(unsigned char volatile xdata *)0xfef4) +#define PWM2_CCR1 (*(unsigned int volatile xdata *)0xfef5) +#define PWM2_CCR1H (*(unsigned char volatile xdata *)0xfef5) +#define PWM2_CCR1L (*(unsigned char volatile xdata *)0xfef6) +#define PWM2_CCR2 (*(unsigned int volatile xdata *)0xfef7) +#define PWM2_CCR2H (*(unsigned char volatile xdata *)0xfef7) +#define PWM2_CCR2L (*(unsigned char volatile xdata *)0xfef8) +#define PWM2_CCR3 (*(unsigned int volatile xdata *)0xfef9) +#define PWM2_CCR3H (*(unsigned char volatile xdata *)0xfef9) +#define PWM2_CCR3L (*(unsigned char volatile xdata *)0xfefa) +#define PWM2_CCR4 (*(unsigned int volatile xdata *)0xfefb) +#define PWM2_CCR4H (*(unsigned char volatile xdata *)0xfefb) +#define PWM2_CCR4L (*(unsigned char volatile xdata *)0xfefc) +#define PWM2_BKR (*(unsigned char volatile xdata *)0xfefd) +#define PWM2_DTR (*(unsigned char volatile xdata *)0xfefe) +#define PWM2_OISR (*(unsigned char volatile xdata *)0xfeff) + +#define PWMA_ETRPS (*(unsigned char volatile xdata *)0xfeb0) +#define PWMA_ENO (*(unsigned char volatile xdata *)0xfeb1) +#define PWMA_PS (*(unsigned char volatile xdata *)0xfeb2) +#define PWMA_IOAUX (*(unsigned char volatile xdata *)0xfeb3) +#define PWMB_ETRPS (*(unsigned char volatile xdata *)0xfeb4) +#define PWMB_ENO (*(unsigned char volatile xdata *)0xfeb5) +#define PWMB_PS (*(unsigned char volatile xdata *)0xfeb6) +#define PWMB_IOAUX (*(unsigned char volatile xdata *)0xfeb7) +#define PWMA_CR1 (*(unsigned char volatile xdata *)0xfec0) +#define PWMA_CR2 (*(unsigned char volatile xdata *)0xfec1) +#define PWMA_SMCR (*(unsigned char volatile xdata *)0xfec2) +#define PWMA_ETR (*(unsigned char volatile xdata *)0xfec3) +#define PWMA_IER (*(unsigned char volatile xdata *)0xfec4) +#define PWMA_SR1 (*(unsigned char volatile xdata *)0xfec5) +#define PWMA_SR2 (*(unsigned char volatile xdata *)0xfec6) +#define PWMA_EGR (*(unsigned char volatile xdata *)0xfec7) +#define PWMA_CCMR1 (*(unsigned char volatile xdata *)0xfec8) +#define PWMA_CCMR2 (*(unsigned char volatile xdata *)0xfec9) +#define PWMA_CCMR3 (*(unsigned char volatile xdata *)0xfeca) +#define PWMA_CCMR4 (*(unsigned char volatile xdata *)0xfecb) +#define PWMA_CCER1 (*(unsigned char volatile xdata *)0xfecc) +#define PWMA_CCER2 (*(unsigned char volatile xdata *)0xfecd) +#define PWMA_CNTR (*(unsigned int volatile xdata *)0xfece) +#define PWMA_CNTRH (*(unsigned char volatile xdata *)0xfece) +#define PWMA_CNTRL (*(unsigned char volatile xdata *)0xfecf) +#define PWMA_PSCR (*(unsigned int volatile xdata *)0xfed0) +#define PWMA_PSCRH (*(unsigned char volatile xdata *)0xfed0) +#define PWMA_PSCRL (*(unsigned char volatile xdata *)0xfed1) +#define PWMA_ARR (*(unsigned int volatile xdata *)0xfed2) +#define PWMA_ARRH (*(unsigned char volatile xdata *)0xfed2) +#define PWMA_ARRL (*(unsigned char volatile xdata *)0xfed3) +#define PWMA_RCR (*(unsigned char volatile xdata *)0xfed4) +#define PWMA_CCR1 (*(unsigned int volatile xdata *)0xfed5) +#define PWMA_CCR1H (*(unsigned char volatile xdata *)0xfed5) +#define PWMA_CCR1L (*(unsigned char volatile xdata *)0xfed6) +#define PWMA_CCR2 (*(unsigned int volatile xdata *)0xfed7) +#define PWMA_CCR2H (*(unsigned char volatile xdata *)0xfed7) +#define PWMA_CCR2L (*(unsigned char volatile xdata *)0xfed8) +#define PWMA_CCR3 (*(unsigned int volatile xdata *)0xfed9) +#define PWMA_CCR3H (*(unsigned char volatile xdata *)0xfed9) +#define PWMA_CCR3L (*(unsigned char volatile xdata *)0xfeda) +#define PWMA_CCR4 (*(unsigned int volatile xdata *)0xfedb) +#define PWMA_CCR4H (*(unsigned char volatile xdata *)0xfedb) +#define PWMA_CCR4L (*(unsigned char volatile xdata *)0xfedc) +#define PWMA_BKR (*(unsigned char volatile xdata *)0xfedd) +#define PWMA_DTR (*(unsigned char volatile xdata *)0xfede) +#define PWMA_OISR (*(unsigned char volatile xdata *)0xfedf) +#define PWMB_CR1 (*(unsigned char volatile xdata *)0xfee0) +#define PWMB_CR2 (*(unsigned char volatile xdata *)0xfee1) +#define PWMB_SMCR (*(unsigned char volatile xdata *)0xfee2) +#define PWMB_ETR (*(unsigned char volatile xdata *)0xfee3) +#define PWMB_IER (*(unsigned char volatile xdata *)0xfee4) +#define PWMB_SR1 (*(unsigned char volatile xdata *)0xfee5) +#define PWMB_SR2 (*(unsigned char volatile xdata *)0xfee6) +#define PWMB_EGR (*(unsigned char volatile xdata *)0xfee7) +#define PWMB_CCMR1 (*(unsigned char volatile xdata *)0xfee8) +#define PWMB_CCMR2 (*(unsigned char volatile xdata *)0xfee9) +#define PWMB_CCMR3 (*(unsigned char volatile xdata *)0xfeea) +#define PWMB_CCMR4 (*(unsigned char volatile xdata *)0xfeeb) +#define PWMB_CCER1 (*(unsigned char volatile xdata *)0xfeec) +#define PWMB_CCER2 (*(unsigned char volatile xdata *)0xfeed) +#define PWMB_CNTR (*(unsigned int volatile xdata *)0xfeee) +#define PWMB_CNTRH (*(unsigned char volatile xdata *)0xfeee) +#define PWMB_CNTRL (*(unsigned char volatile xdata *)0xfeef) +#define PWMB_PSCR (*(unsigned int volatile xdata *)0xfef0) +#define PWMB_PSCRH (*(unsigned char volatile xdata *)0xfef0) +#define PWMB_PSCRL (*(unsigned char volatile xdata *)0xfef1) +#define PWMB_ARR (*(unsigned int volatile xdata *)0xfef2) +#define PWMB_ARRH (*(unsigned char volatile xdata *)0xfef2) +#define PWMB_ARRL (*(unsigned char volatile xdata *)0xfef3) +#define PWMB_RCR (*(unsigned char volatile xdata *)0xfef4) +#define PWMB_CCR5 (*(unsigned int volatile xdata *)0xfef5) +#define PWMB_CCR5H (*(unsigned char volatile xdata *)0xfef5) +#define PWMB_CCR5L (*(unsigned char volatile xdata *)0xfef6) +#define PWMB_CCR6 (*(unsigned int volatile xdata *)0xfef7) +#define PWMB_CCR6H (*(unsigned char volatile xdata *)0xfef7) +#define PWMB_CCR6L (*(unsigned char volatile xdata *)0xfef8) +#define PWMB_CCR7 (*(unsigned int volatile xdata *)0xfef9) +#define PWMB_CCR7H (*(unsigned char volatile xdata *)0xfef9) +#define PWMB_CCR7L (*(unsigned char volatile xdata *)0xfefa) +#define PWMB_CCR8 (*(unsigned int volatile xdata *)0xfefb) +#define PWMB_CCR8H (*(unsigned char volatile xdata *)0xfefb) +#define PWMB_CCR8L (*(unsigned char volatile xdata *)0xfefc) +#define PWMB_BKR (*(unsigned char volatile xdata *)0xfefd) +#define PWMB_DTR (*(unsigned char volatile xdata *)0xfefe) +#define PWMB_OISR (*(unsigned char volatile xdata *)0xfeff) + +///////////////////////////////////////////////// +//FD00H-FDFFH +///////////////////////////////////////////////// + +#define P0INTE (*(unsigned char volatile xdata *)0xfd00) +#define P1INTE (*(unsigned char volatile xdata *)0xfd01) +#define P2INTE (*(unsigned char volatile xdata *)0xfd02) +#define P3INTE (*(unsigned char volatile xdata *)0xfd03) +#define P4INTE (*(unsigned char volatile xdata *)0xfd04) +#define P5INTE (*(unsigned char volatile xdata *)0xfd05) +#define P6INTE (*(unsigned char volatile xdata *)0xfd06) +#define P7INTE (*(unsigned char volatile xdata *)0xfd07) +#define P0INTF (*(unsigned char volatile xdata *)0xfd10) +#define P1INTF (*(unsigned char volatile xdata *)0xfd11) +#define P2INTF (*(unsigned char volatile xdata *)0xfd12) +#define P3INTF (*(unsigned char volatile xdata *)0xfd13) +#define P4INTF (*(unsigned char volatile xdata *)0xfd14) +#define P5INTF (*(unsigned char volatile xdata *)0xfd15) +#define P6INTF (*(unsigned char volatile xdata *)0xfd16) +#define P7INTF (*(unsigned char volatile xdata *)0xfd17) +#define P0IM0 (*(unsigned char volatile xdata *)0xfd20) +#define P1IM0 (*(unsigned char volatile xdata *)0xfd21) +#define P2IM0 (*(unsigned char volatile xdata *)0xfd22) +#define P3IM0 (*(unsigned char volatile xdata *)0xfd23) +#define P4IM0 (*(unsigned char volatile xdata *)0xfd24) +#define P5IM0 (*(unsigned char volatile xdata *)0xfd25) +#define P6IM0 (*(unsigned char volatile xdata *)0xfd26) +#define P7IM0 (*(unsigned char volatile xdata *)0xfd27) +#define P0IM1 (*(unsigned char volatile xdata *)0xfd30) +#define P1IM1 (*(unsigned char volatile xdata *)0xfd31) +#define P2IM1 (*(unsigned char volatile xdata *)0xfd32) +#define P3IM1 (*(unsigned char volatile xdata *)0xfd33) +#define P4IM1 (*(unsigned char volatile xdata *)0xfd34) +#define P5IM1 (*(unsigned char volatile xdata *)0xfd35) +#define P6IM1 (*(unsigned char volatile xdata *)0xfd36) +#define P7IM1 (*(unsigned char volatile xdata *)0xfd37) +#define P0WKUE (*(unsigned char volatile xdata *)0xfd40) +#define P1WKUE (*(unsigned char volatile xdata *)0xfd41) +#define P2WKUE (*(unsigned char volatile xdata *)0xfd42) +#define P3WKUE (*(unsigned char volatile xdata *)0xfd43) +#define P4WKUE (*(unsigned char volatile xdata *)0xfd44) +#define P5WKUE (*(unsigned char volatile xdata *)0xfd45) +#define P6WKUE (*(unsigned char volatile xdata *)0xfd46) +#define P7WKUE (*(unsigned char volatile xdata *)0xfd47) +#define PIN_IP (*(unsigned char volatile xdata *)0xfd60) +#define PIN_IPH (*(unsigned char volatile xdata *)0xfd61) + +///////////////////////////////////////////////// +//FC00H-FCFFH +///////////////////////////////////////////////// + +#define MD3 (*(unsigned char volatile xdata *)0xfcf0) +#define MD2 (*(unsigned char volatile xdata *)0xfcf1) +#define MD1 (*(unsigned char volatile xdata *)0xfcf2) +#define MD0 (*(unsigned char volatile xdata *)0xfcf3) +#define MD5 (*(unsigned char volatile xdata *)0xfcf4) +#define MD4 (*(unsigned char volatile xdata *)0xfcf5) +#define ARCON (*(unsigned char volatile xdata *)0xfcf6) +#define OPCON (*(unsigned char volatile xdata *)0xfcf7) + +///////////////////////////////////////////////// +//FB00H-FBFFH +///////////////////////////////////////////////// + +#define COMEN (*(unsigned char volatile xdata *)0xfb00) +#define SEGENL (*(unsigned char volatile xdata *)0xfb01) +#define SEGENH (*(unsigned char volatile xdata *)0xfb02) +#define LEDCTRL (*(unsigned char volatile xdata *)0xfb03) +#define LEDCKS (*(unsigned char volatile xdata *)0xfb04) +#define COM0_DA_L (*(unsigned char volatile xdata *)0xfb10) +#define COM1_DA_L (*(unsigned char volatile xdata *)0xfb11) +#define COM2_DA_L (*(unsigned char volatile xdata *)0xfb12) +#define COM3_DA_L (*(unsigned char volatile xdata *)0xfb13) +#define COM4_DA_L (*(unsigned char volatile xdata *)0xfb14) +#define COM5_DA_L (*(unsigned char volatile xdata *)0xfb15) +#define COM6_DA_L (*(unsigned char volatile xdata *)0xfb16) +#define COM7_DA_L (*(unsigned char volatile xdata *)0xfb17) +#define COM0_DA_H (*(unsigned char volatile xdata *)0xfb18) +#define COM1_DA_H (*(unsigned char volatile xdata *)0xfb19) +#define COM2_DA_H (*(unsigned char volatile xdata *)0xfb1a) +#define COM3_DA_H (*(unsigned char volatile xdata *)0xfb1b) +#define COM4_DA_H (*(unsigned char volatile xdata *)0xfb1c) +#define COM5_DA_H (*(unsigned char volatile xdata *)0xfb1d) +#define COM6_DA_H (*(unsigned char volatile xdata *)0xfb1e) +#define COM7_DA_H (*(unsigned char volatile xdata *)0xfb1f) +#define COM0_DC_L (*(unsigned char volatile xdata *)0xfb20) +#define COM1_DC_L (*(unsigned char volatile xdata *)0xfb21) +#define COM2_DC_L (*(unsigned char volatile xdata *)0xfb22) +#define COM3_DC_L (*(unsigned char volatile xdata *)0xfb23) +#define COM4_DC_L (*(unsigned char volatile xdata *)0xfb24) +#define COM5_DC_L (*(unsigned char volatile xdata *)0xfb25) +#define COM6_DC_L (*(unsigned char volatile xdata *)0xfb26) +#define COM7_DC_L (*(unsigned char volatile xdata *)0xfb27) +#define COM0_DC_H (*(unsigned char volatile xdata *)0xfb28) +#define COM1_DC_H (*(unsigned char volatile xdata *)0xfb29) +#define COM2_DC_H (*(unsigned char volatile xdata *)0xfb2a) +#define COM3_DC_H (*(unsigned char volatile xdata *)0xfb2b) +#define COM4_DC_H (*(unsigned char volatile xdata *)0xfb2c) +#define COM5_DC_H (*(unsigned char volatile xdata *)0xfb2d) +#define COM6_DC_H (*(unsigned char volatile xdata *)0xfb2e) +#define COM7_DC_H (*(unsigned char volatile xdata *)0xfb2f) + +#define TSCHEN1 (*(unsigned char volatile xdata *)0xfb40) +#define TSCHEN2 (*(unsigned char volatile xdata *)0xfb41) +#define TSCFG1 (*(unsigned char volatile xdata *)0xfb42) +#define TSCFG2 (*(unsigned char volatile xdata *)0xfb43) +#define TSWUTC (*(unsigned char volatile xdata *)0xfb44) +#define TSCTRL (*(unsigned char volatile xdata *)0xfb45) +#define TSSTA1 (*(unsigned char volatile xdata *)0xfb46) +#define TSSTA2 (*(unsigned char volatile xdata *)0xfb47) +#define TSRT (*(unsigned char volatile xdata *)0xfb48) +#define TSDAT (*(unsigned int volatile xdata *)0xfb49) +#define TSDATH (*(unsigned char volatile xdata *)0xfb49) +#define TSDATL (*(unsigned char volatile xdata *)0xfb4A) +#define TSTH00 (*(unsigned int volatile xdata *)0xfb50) +#define TSTH00H (*(unsigned char volatile xdata *)0xfb50) +#define TSTH00L (*(unsigned char volatile xdata *)0xfb51) +#define TSTH01 (*(unsigned int volatile xdata *)0xfb52) +#define TSTH01H (*(unsigned char volatile xdata *)0xfb52) +#define TSTH01L (*(unsigned char volatile xdata *)0xfb53) +#define TSTH02 (*(unsigned int volatile xdata *)0xfb54) +#define TSTH02H (*(unsigned char volatile xdata *)0xfb54) +#define TSTH02L (*(unsigned char volatile xdata *)0xfb55) +#define TSTH03 (*(unsigned int volatile xdata *)0xfb56) +#define TSTH03H (*(unsigned char volatile xdata *)0xfb56) +#define TSTH03L (*(unsigned char volatile xdata *)0xfb57) +#define TSTH04 (*(unsigned int volatile xdata *)0xfb58) +#define TSTH04H (*(unsigned char volatile xdata *)0xfb58) +#define TSTH04L (*(unsigned char volatile xdata *)0xfb59) +#define TSTH05 (*(unsigned int volatile xdata *)0xfb5a) +#define TSTH05H (*(unsigned char volatile xdata *)0xfb5a) +#define TSTH05L (*(unsigned char volatile xdata *)0xfb5b) +#define TSTH06 (*(unsigned int volatile xdata *)0xfb5c) +#define TSTH06H (*(unsigned char volatile xdata *)0xfb5c) +#define TSTH06L (*(unsigned char volatile xdata *)0xfb5d) +#define TSTH07 (*(unsigned int volatile xdata *)0xfb5e) +#define TSTH07H (*(unsigned char volatile xdata *)0xfb5e) +#define TSTH07L (*(unsigned char volatile xdata *)0xfb5f) +#define TSTH08 (*(unsigned int volatile xdata *)0xfb60) +#define TSTH08H (*(unsigned char volatile xdata *)0xfb60) +#define TSTH08L (*(unsigned char volatile xdata *)0xfb61) +#define TSTH09 (*(unsigned int volatile xdata *)0xfb62) +#define TSTH09H (*(unsigned char volatile xdata *)0xfb62) +#define TSTH09L (*(unsigned char volatile xdata *)0xfb63) +#define TSTH10 (*(unsigned int volatile xdata *)0xfb64) +#define TSTH10H (*(unsigned char volatile xdata *)0xfb64) +#define TSTH10L (*(unsigned char volatile xdata *)0xfb65) +#define TSTH11 (*(unsigned int volatile xdata *)0xfb66) +#define TSTH11H (*(unsigned char volatile xdata *)0xfb66) +#define TSTH11L (*(unsigned char volatile xdata *)0xfb67) +#define TSTH12 (*(unsigned int volatile xdata *)0xfb68) +#define TSTH12H (*(unsigned char volatile xdata *)0xfb68) +#define TSTH12L (*(unsigned char volatile xdata *)0xfb69) +#define TSTH13 (*(unsigned int volatile xdata *)0xfb6a) +#define TSTH13H (*(unsigned char volatile xdata *)0xfb6a) +#define TSTH13L (*(unsigned char volatile xdata *)0xfb6b) +#define TSTH14 (*(unsigned int volatile xdata *)0xfb6c) +#define TSTH14H (*(unsigned char volatile xdata *)0xfb6c) +#define TSTH14L (*(unsigned char volatile xdata *)0xfb6d) +#define TSTH15 (*(unsigned int volatile xdata *)0xfb6e) +#define TSTH15H (*(unsigned char volatile xdata *)0xfb6e) +#define TSTH15L (*(unsigned char volatile xdata *)0xfb6f) + +///////////////////////////////////////////////// +//FA00H-FAFFH +///////////////////////////////////////////////// + + +///////////////////////////////////////////////// + +#endif + diff --git a/source/ctask/task.c b/source/ctask/task.c new file mode 100644 index 0000000..0835750 --- /dev/null +++ b/source/ctask/task.c @@ -0,0 +1,234 @@ +/***************************************************** +*============================================================================ +* HISTORY +* Below this line, this part is controlled by TSTS. DO NOT MODIFY!! +伪时间片嵌入式平台(Task Step by Step Turn by Turn Structure，简称TSTS） +*============================================================================ +****************************************************************************/ + +#include "task.h" +//任务命名规则: +// 1:第一层 +/// 0驱动芯片级 flash +/// 1芯片应用级 save +/// 2任务应用级 jilu_save +// +// 2:第二层/flash/i2c/7290/等各类芯片 +// 3:任务序号/不同的芯片/ +// + +void L1_task_init(TS_task *s) +{ + s->en = 1; + s->sh = 0; + s->sh_next= 0; + s->n= 0; +} + +#if 0 + + +//L2_task_voice_handle(&s_task_music.task); +//L1_task_go(D_task_close); +//if(L1_task_busy(s)){ L1_task_goout(s_task_music.task,D_task_voice_send_single) } +void L2_task_voice_handle(struct _s_task_music_ *s) +{ //s_task_music.task.sh + switch(s->task.sh) + { + + case D_task_voice_init:// + + s->sector = 0; + break; + case D_task_voice_cuimian : + s->sector = D_voice_music_wantsleep; + L2_task_go_son(D_task_voice_play,D_task_voice_cuimian1); + break; + case D_task_voice_cuimian1:// + L2_task_go(D_task_voice_cuimian2); + + break; + case D_task_voice_cuimian2:// + + if(0 == s->volume_change) + { + //L3_voice_stop(); + s->sector = D_voice_stop; + s->status = D_voice_status_stop; + //L2_task_go(D_task_voice_play); + L2_task_go_son(D_task_voice_play,0); + }else + { + s->volume_change --; + s->volume_temp = s->volume; + s->volume = s->volume_change*s->volume_shop/20;// + if (s->volume_temp != s->volume) + { + s->sector = D_voice_volume|s->volume; + //s->status = D_voice_status_stop; + //L2_task_go(D_task_voice_volume3); + L2_task_go_son(D_task_voice_play,D_task_voice_cuimian2); + } + //else + { + L2_task_delay(D_task_delay_1m); + } + } + break; + + //>>>>>>>>>>>>>>>>>> son function + case D_task_voice_play:// + if(L3_task_s_busy(s_task_wt558d)) + { + }else + { + s_task_wt558d.reg = s_task_music.sector; + L3_task_s_go(s_task_wt558d,D_task_wt558d_fun); + + L2_task_go(D_task_voice_ask); + } + break; + case D_task_voice_ask:// + if(L3_task_s_busy(s_task_wt558d)) + { + + }else + { + + L2_task_go_father();//回到 + } + break; + //<<<<<<<<<<<<<<<<<<<<<< son function + //-----------------------task standerd code + case D_task_Tdelay://---- + s->task.n--; + if (s->task.n == 0) + { + s->task.n = 0; + L2_task_delay_over(); + } + break; + + default : + break; + } + L2_task_wt558d_handle(&s_task_wt558d); +} + + +void L2_task_voice_handle(struct _s_task_music_ *s) +{ //s_task_music.task.sh + switch(s->task.sh) + { + + case D_task_voice_init:// + + s->sector = 0; + break; + case D_task_voice_cuimian : + s->sector = D_voice_music_wantsleep; + L2_task_go_son(D_task_voice_play,D_task_voice_cuimian1); + break; + case D_task_voice_cuimian1:// + L2_task_go(D_task_voice_cuimian2); + + break; + + //-----------------------task standerd code + case D_task_Tdelay://---- + s->task.n--; + if (s->task.n == 0) + { + s->task.n = 0; + L2_task_delay_over(); + } + break; + + default : + break; + } + L2_task_wt558d_handle(&s_task_wt558d); +} + +//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> +//>>>>>>>>>>>>>>>>>>>>>记录task +struct _s_task_4ChuShengRiQi_ +{ + TS_task task; + unsigned char pic_id;//画面ID + + +}; +extern struct _s_task_4ChuShengRiQi_ s_task_4ChuShengRiQi_; + +#define D_task_4ChuShengRiQi_init 0x10 +#define D_task_4ChuShengRiQi_key 0x11 + + +extern void L2_task_4ChuShengRiQi_handle(struct _s_task_4ChuShengRiQi_ *s); + +void L2_task_4ChuShengRiQi_handle(struct _s_task_4ChuShengRiQi_ *s) +{ + switch(s->task.sh) + { + + case D_task_4ChuShengRiQi_init:// + + s->pic_id= 0; + break; + case D_task_4ChuShengRiQi_key : + if(1 == s_task_keyx1.down ) + { + s_task_keyx1.down = 0; + + if(D_keyx_left == s_task_keyx1.key_value) + {} + + + }else if(1 == s_task_keyx_4.down) + { + s_task_keyx_4.down = 0; + + + } + else {} + + //L2_task_go_son(D_task_4ChuShengRiQi_play,D_task_4ChuShengRiQi_cuimian1); + break; + + L0_task_delay(); + } +} + + + +//<<<<<<<<<<<<<<<<<<<记录task + + + + + +//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< + + + + + + + +/***************************************************** +*============================================================== +* HISTORYmm +* Below this line, this part is controlled by TSTS. DO NOT MODIFY!! +伪时间片嵌入式平台(Task Step by Step Turn by Turn Structure，简称TSTS） +*============================================================== +****************************************************************************/ + + + + + + +#endif + + diff --git a/source/ctask/task.h b/source/ctask/task.h new file mode 100644 index 0000000..33cde0e --- /dev/null +++ b/source/ctask/task.h @@ -0,0 +1,160 @@ +/******************************** +2013.7.23 add dictionary and task step by cc + +任务:task +任务段:task step +任务标志:sh ( struct handle) + +下一个任务段sh_next +缓存的任务段,sh_next执行完后执行sh_pre + +***************************/ +/***************************************************** +*============================================================== +* HISTORY +* Below this line, this part is controlled by TSTS. DO NOT MODIFY!! +伪时间片嵌入式平台(Task Step by Step Turn by Turn Structure，简称TSTS） +*============================================================== +****************************************************************************/ + +#ifndef _TASK_H_ +#define _TASK_H_ +#include "../clib/type.h" +#include "../msp/time.h" +#include "task.h" +#include "tick.h" + +typedef struct _ts_task +{ + volatile UN_TYPE en; //关闭任务,也可以理解为暂停,但是使用idelay的地方时间在后台计数任务在延时到了后才暂停,而的delay相当于暂停 + volatile UN_TYPE sh; //当前任务段 + volatile UN_TYPE sh_next; //下一个任务段,并不代表一定下一任务段一定是他,有可能中间插入延时等任务段 + volatile UN_TYPE sh_pre; //前一个任务段,一般为调出缓存任务段使用 + vU32 n; +}TS_task; + +#define D_task_close 0 +#if 0 +#define D_task_Tdelay 0x01 +#define D_task_stop 0x04 +#define D_task_Cdelay 0x09 +#define D_task_init 0x10 +#define D_task_quit 0xf0 +#else + +#define D_task_init 0xf0 +#define D_task_Tdelay 0xf1 +#define D_task_Cdelay 0xf2 +#define D_task_stop 0xf3 +#define D_task_quit 0xf4 +#endif + +//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>内部调用 s->task +#define L2_task_delay_over() s->task.sh = s->task.sh_next +#define L2_task_go(next) s->task.sh = next; +//#define L2_task_gogogo(next) s->task.sh = next; +#define L2_task_en(onf) s->task.en = onf; + +#define L2_task_busy(s) (D_task_close != s.task.sh) +#define L2_task_free(s) (D_task_close == s.task.sh) + +#define L2_task_go_father() s->task.sh = s->task.sh_pre; +#define L2_task_go_son(fun,pre) s->task.sh = fun;s->task.sh_pre = pre; + +/// task 定时>>>>>>>>>>>>>>TTSS +/// D_task_Tdelay == task timer delay 需要额外有个定时单元 和time0定时器设置相关 +/// Delay_cycle适用于 时间短的,其一次循环取决于主循环的时间,和Tdelay比,Cdelay长时间计时误差大 +#define L2_task_switch_default_idelay(); \ + case D_task_Tdelay:\ + if (s_nos_tick.jiffies >= s->task.n)\ + {\ + L2_task_delay_over();\ + }\ + break; \ + case D_task_Cdelay:\ + s->task.n--; \ + if (s->task.n == 0) \ + { \ + s->task.n = 0; \ + L2_task_delay_over();\ + } \ + break;\ + default : \ + break; + +//if(delay_n+s_time0.t_10ms > 655340) +//{s_time0.t_10ms = 0;} +//fix 201312 防止s_time0.t_10ms 溢出 +// 但是有风险 +//>>L2_task_delay一定要放在L2_task_go之后 +#define L1_task_Tdelay(delay_n) s->task.sh_next = s->task.sh;\ + s->task.sh = D_task_Tdelay;\ + s->task.n = delay_n + s_nos_tick.jiffies; + + +//>>L2_task_delay一定要放在L2_task_go之后 +#define L1_task_Cdelay(delay_n) s->task.sh_next = s->task.sh;\ + s->task.sh = D_task_Cdelay;\ + s->task.n = delay_n + +#define L2_task_go_Tdelay(next,delay_n) do{ \ + if(delay_n) \ + { \ + s->task.sh_next = next;\ + s->task.sh = D_task_Tdelay;\ + s->task.n = (delay_n) + s_nos_tick.jiffies; \ + } \ + else \ + { \ + s->task.sh = next; \ + } \ + }while(0) + +#define L2_task_go_Cdelay(next,delay_n) do{ \ + if(delay_n) \ + { \ + s->task.sh_next = next;\ + s->task.sh = D_task_Cdelay;\ + s->task.n = (delay_n); \ + } \ + else \ + { \ + s->task.sh = next; \ + } \ + }while(0) + +//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 外部调用 +#define L3_task_s_go(s,next) (s).task.sh = next; +#define L2_task_s_go_son(s,fun,pre) (s).task.sh = fun;(s).task.sh_pre = pre; +#define L3_task_s_time_start(s,delay) (s).task.n = delay+s_nos_tick.t_1s; +#define L3_task_s_en(s,onf) (s).task.en = onf; +#define L3_task_s_busy(s) (D_task_close != (s).task.sh) +#define L3_task_s_free(s) (D_task_close == (s).task.sh) +#define L3_task_s_step(s) ((s).task.sh) + +///>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> +#define TTSS_Task_init(); switch(s->task.sh)\ + {\ + case D_task_init:{\ + +#define TTSS_Task_step(step); break;}\ + case (step):{ +#define TTSS_Task_end(); break;}\ + L2_task_switch_default_idelay();} +#define TTSS_Task_fun(step); break;}\ + case (step):{ +//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< + +extern void L1_task_init(TS_task *s); + +#endif//_TASK_H_ +/***************************************************** +*============================================================== +* HISTORY +* Below this line, this part is controlled by TSTS. DO NOT MODIFY!! +伪时间片嵌入式平台(Task Step by Step Turn by Turn Structure，简称TSTS） +*============================================================== +****************************************************************************/ + + + diff --git a/source/ctask/tick.c b/source/ctask/tick.c new file mode 100644 index 0000000..fa4ee64 --- /dev/null +++ b/source/ctask/tick.c @@ -0,0 +1,51 @@ +/***************************************************************************** + * uart.h: Header file for NXP LPC17xx Family Microprocessors + * + * Copyright(C) 2017,SensorControl + * All rights reserved. + * + * History + * 2009.05.27 ver 1.00 Prelimnary version, first Release + *2017.01.10 ver 1.10 rename tick.h tick.c +****************************************************************************************/ +#include "tick.h" + +struct _s_nos_tick_ s_nos_tick; + +/********************************************************************************************************* +* Function Name: timer0Isr +* Description: TIMER0 中断处理函数 +* Input: ? +* Output: ? +* Return: ? +*********************************************************************************************************/ +void L1_tick_init(void) +{ + s_nos_tick.jiffies = 0; + s_nos_tick.t_1s = 0; + s_nos_tick.t1s_heatbeart= 0; + //s_nos_tick.t_10ms = 0; +} + + +//JIFFIES回绕问题没有解决 参见 linux time_after宏定义 +void L1_tick_tick (void) +{ + ///65535*65535/3600/24/365=139nian/s=1.39nian/10ms + ///相当于1.39年后t_10ms 溢出，对于电池供电的系统而言 完全可以满足 + // 4,294,836,225 = 65535*65535 ;3600*24*60*60 = 31,536,000秒/年 + //s_nos_tick.t_50ms ++;//D_led_D1_REV(); 20160522验证 + s_nos_tick.jiffies++; + //s_nos_tick.t_10ms = 1; + if(s_nos_tick.jiffies % HZ == 0) + { + // 65535*65535/24/60/60/356/10 =12.7年 + s_nos_tick.t_1s ++; + s_nos_tick.t1s_heatbeart = 1; + + } +} + + + + diff --git a/source/ctask/tick.h b/source/ctask/tick.h new file mode 100644 index 0000000..35a26d8 --- /dev/null +++ b/source/ctask/tick.h @@ -0,0 +1,89 @@ +/***************************************************************************** + * uart.h: Header file for NXP LPC17xx Family Microprocessors + * + * Copyright(C) 2017,SensorControl + * All rights reserved. + * + * History + * 2009.05.27 ver 1.00 Prelimnary version, first Release + *2017.01.10 ver 1.10 rename tick.h tick.c +******************************************************************************/ +#ifndef __tick_H +#define __tick_H +#include "../clib/Type.h" +#include "../msp/time.h" + +struct _s_nos_tick_ +{ + vU32 jiffies; // noos系统定时器最小计时单元 + vU32 t_1s; + vU8 t1s_heatbeart; //noos 系统定时器整秒时刻标志,需要软件清除 +// vU8 t_10ms; +}; +extern struct _s_nos_tick_ s_nos_tick; + +#if(TYPE_JIFFIES_5MS == D_sys_Jiffies) + #define HZ 200 +#elif(TYPE_JIFFIES_10MS == D_sys_Jiffies) + #define HZ 100 +#elif(TYPE_JIFFIES_25MS == D_sys_Jiffies) + #define HZ 40 +#endif +#define JIFFIES (1000/HZ) + +#define D_sys_now (s_nos_tick.jiffies) +//D_sys_delay_msec以jiffies为最小计时单位，jiffies是10ms为例，参数n=12ms时，最终延时了20ms +#define D_sys_delay_msec(n) do{ \ + if(n>0) \ + { \ + U32 mstmp = D_sys_now; \ + while(D_sys_now - mstmp < (((n)-1)/JIFFIES) + 1); \ + } \ + }while(0) + +#define D_Tdelay_Msec(n) (((n)-1) / JIFFIES + 1) +#define D_Tdelay_Sec(n) (((n)*1000-1) /JIFFIES + 1) +#define D_Tdelay_5ms ((5-1) / JIFFIES + 1) +#define D_Tdelay_10ms ((10-1) / JIFFIES + 1) +#define D_Tdelay_100ms ((100-1) / JIFFIES + 1) +#define D_Tdelay_200ms ((200-1) / JIFFIES+ 1) +#define D_Tdelay_300ms ((300-1) / JIFFIES + 1) +#define D_Tdelay_400ms ((400-1) / JIFFIES + 1) +#define D_Tdelay_1s (1 * HZ) +#define D_Tdelay_2s (2 * HZ) +#define D_Tdelay_3s (3 * HZ) +#define D_Tdelay_4s (4 * HZ) +#define D_Tdelay_5s (5 * HZ) +#define D_Tdelay_10s (10 * HZ) +#define D_Tdelay_15s (15 * HZ) + +#define D_Tdelay_1min (1 * 60 * HZ) +#define D_Tdelay_10min (10 * 60 * HZ) +#define D_Tdelay_1h (60 * 60 * HZ) +#define D_Tdelay_1day (24 * 60 * 60 * HZ) + + +//必须配对 +#define L0_nos_tick10ms_start(start_n) start_n = s_nos_tick.t_50ms +#define L0_nos_tick10ms_interval(start_n) (s_nos_tick.t_50ms - start_n) + + +#define L0_nos_tick1s_start(start_n) start_n = s_nos_tick.t_1s +#define L0_nos_tick1s_interval(start_n) (s_nos_tick.t_1s - start_n) + + +//>>>//必须配对 +#define L2_tick_time_stamp(time_stamp) time_stamp = s_nos_tick.t_50ms; +#define L2_tick_time_interval(time_stamp,time_overflow) (( s_nos_tick.t_50ms - time_stamp) > time_overflow) + + +#define L3_tick_interval(x) L2_tick_time_interval(s_nos_tick.n_stamp,x) +#define L2_tick_stamp() L2_tick_time_stamp(s_nos_tick.n_stamp); + +extern void L1_tick_init(void); +extern void L1_tick_tick (void); + +#endif /* end __tick_H */ +/***************************************************************************** +** End Of File +******************************************************************************/ diff --git a/source/msp/UART0.C b/source/msp/UART0.C new file mode 100644 index 0000000..0ba46d1 --- /dev/null +++ b/source/msp/UART0.C @@ -0,0 +1,193 @@ +////////////////////////////////////////////////////////////////////////// +/// COPYRIGHT NOTICE +/// Copyright (c) 2015, 传控科技 +/// All rights reserved. +/// +/// @file main.c +/// @brief main app +/// +///（本文件实现的功能的详述） +/// +/// @version 1.1 CCsens technology +/// @author CC +/// @date 20150102 +/// +/// +/// 修订说明：最初版本 +/// Modified by: +/// Modified date: +/// Version: +/// Descriptions: +// 20160413 CC-ACC-VH02 +// 连接至 J22 RXD0 TXD0 +//P5_DIR &= ~BITN1; //p5.1输出TXD +//P5_DIR |= BITN0; //p5.0输入RXD +//P5_SEL0 &= ~(BITN0 +BITN1); //设置P5.0 P5.1为UART0 RXD TXD +//P5_SEL1 |= BITN0 +BITN1; + +/***************************************************************************** +update by cc @201700110 +针对多串口 和 单一串口 有区别 每个串口是独立的还是分开的有讲究 程序是复杂的还是软件应用简单是 +个需要平衡的事情. + +clib/clib.c: +公用的函数 和硬件无关 +放置串行模式(串口等其他通讯总线类的输出)输出的函数, +一些覆盖模式输出的(lcd等固屏输出的)的也可使用 + void Lc_print(void (*L0pf_send_uc)(char ww), char *dat,...) +----------------------------------------------------------------------------------------- +uartcom/Uprotocol2app + 协议到应用 + 为了适应不同的通讯协议需要不同的uart口来对应 和应用相关 + +typedef struct _ts_lcm_pro_; 应用协议包的定义? LCM的协议------------ + L3_UARTcom0_exp_protocol 解析应用协议 +----------------------------------------------------------------------------------------- +uartcom/urec2protocol: 接收到的数据放入到指向特定协议的缓存中，和协议的格式有关 一般分为 标头式或者标尾式 +公用的串口通讯定义 + struct _s_uart_rec_ 的公共协议包(关键的结构体)的声明------struct _s_uart_rec_ + void L1_uart_2buf(struct _s_uart_rec_ *p)串行数据保存到指向特定协议的缓冲中 +-------------------------------------------------------------------------------------------- +msp/uartx.c 底层代码 和cpu相关 缓存发送也放在里面 + L0_UART0_Init + UART0_IRQHandler + L0_Usend_uc------UserDef +----------------------------------------------------------------------------------------- +********************************************************************************/ +#include "uart0.h" +#include "../msp/time.h" +//#define _USE_485 + +static volatile Ts_uart_send_buf idata ts_uart_send_shop; + +TP_Handler_X s_uart0_rec; +TS_PH4_modbus s_uart0_ack; + +void L0_uart0_init(void) +{ +// U16 val1= D_BRT_COUNT(12,D_sys_MainFre,D_uart0_BRT); +// SCON = 0x50; //8位数据,可变波特率 +// AUXR |= 0x01; //串口1选择定时器2为波特率发生器 +// AUXR &= 0xFB; //定时器2时钟为Fosc/12,即12T +// T2L = val1; +// T2H = val1 >> 8; +// AUXR |= 0x10; //启动定时器2 + SCON = 0x50; //8位数据,可变波特率 + AUXR &= 0xBF; //定时器时钟12T模式 + AUXR &= 0xFE; //串口1选择定时器1为波特率发生器 + TMOD &= 0x0F; //设置定时器模式 + TL1 = 0xFC; //设置定时初始值 + TH1 = 0xFF; //设置定时初始值 +//// TL1 = val1; //设置定时初始值 +//// TH1 = val1 >> 8; //设置定时初始值 + ET1 = 0; //禁止定时器%d中断 + TR1 = 1; //定时器1开始计时 +// SCON = 0x50; //8位数据,可变波特率 +// AUXR |= 0x01; //串口1选择定时器2为波特率发生器 +// AUXR &= 0xFB; //定时器时钟12T模式 +// T2L = 0xE8; //设置定时初始值 +// T2H = 0xFF; //设置定时初始值 +// AUXR |= 0x10; //定时器2开始计时 +} + +void L0_uart0_buf_init(void) +{ + ts_uart[uNum0].p = &ts_uart_send_shop; + ts_uart[uNum0].p->max = ts_uart[uNum0].p->now = 0; + ts_uart[uNum0].p->ok = D_ready; + ts_uart[uNum0].t = &s_uart0_rec; + ts_uart[uNum0].t->head = 0; + ts_uart[uNum0].t->ok = 0; + //ts_uart[uNum0].tp_handler = L1_s2b_PH4; + ts_uart[uNum0].tp_handler = NULL; //使用函数指针导致错误 + ts_uart[uNum0].ack = (U8*)&s_uart0_ack; + L0_uart0_init(); + D_uart0_ES_INT(1); //打开串口中断 + +#if (D_UART0_485_TYPE != TYPE_485_NONE) + D_UART0_485_RX() //默认处于接收状态 +#endif +} + +void L0_uart0_sendArray(U8 * buf, U16 len) +{ +#if (D_UART0_485_TYPE != TYPE_485_NONE) + D_UART0_485_TX() //切换到输出状态 +#endif + L0_uartN_sendArray(uNum0,buf,len); +} + +/************************************************* +UART 中断 +*************************************************/ +void INTERRUPT_UART(void) D_SERVE_UART +{ + //NOP(); NOP(); NOP(); + if(L0_uart0_IntRI()) //如果是U0接收中断 + { + // LED0 ^= 1; + L0_uart0_IntRIClear(); //清除接收中断标志 + ts_uart[uNum0].t->reg = L0_uartN_get(uNum0); + //ts_uart[uNum0].tp_handler(ts_uart[uNum0].t); + L1_s2b_PH4(ts_uart[uNum0].t); + L0_timer3_restart(); + } + if(L0_uart0_IntTI()) //如果是U0发送中断 + { + //LED0 ^= 1; + L0_uart0_IntTIClear(); //清除发送中断标志 + if(ts_uart[uNum0].p->max != ts_uart[uNum0].p->now) + { + L0_uartN_set(uNum0,ts_uart[uNum0].p->p[ts_uart[uNum0].p->now]); + ts_uart[uNum0].p->now ++; + } + else + { + ts_uart[uNum0].p->ok = D_ready; + ts_uart[uNum0].p->max = 0; + ts_uart[uNum0].p->now = 0;//可以发送下一个数据 +#if (D_UART0_485_TYPE != TYPE_485_NONE) + D_UART0_485_RX() //切换到接收状态 +#endif + } + } + //NOP(); NOP(); NOP(); +} + +void timer3_isrHanddle(void) D_SERVE_TIMER3 +{ + struct _tp_handler_x *p1 = &s_uart0_rec; + struct _tp_handler_x *p2 = &s_uart2_rec; + if((p1->head == 1) && (p1->num >= D_s_modbus_min)) + { + p1->head = 0; + crc16(p1->crc,p1->buf,p1->num - 2); //校验CRC + if(p1->crc[0] == p1->buf[p1->num-2] && p1->crc[1] == p1->buf[p1->num-1]) + { + p1->ok = 1; +// LED0 ^= 1; + } + else + { + p1->yes = 1; + } + } + if((p2->head == 1) && (p2->num >= D_s_modbus_min)) + { + p2->head = 0; + crc16(p2->crc,p2->buf,p2->num - 2); //校验CRC + if(p2->crc[0] == p2->buf[p2->num-2] && p2->crc[1] == p2->buf[p2->num-1]) + { + p2->ok = 1; + } + else + { + p2->yes = 1; + } + } + + L0_timer3_stop(); +} + + + diff --git a/source/msp/UART0.h b/source/msp/UART0.h new file mode 100644 index 0000000..29caea2 --- /dev/null +++ b/source/msp/UART0.h @@ -0,0 +1,89 @@ +////////////////////////////////////////////////////////////////////////// +/// COPYRIGHT NOTICE +/// Copyright (c) 2015, 传控科技 +/// All rights reserved. +/// +/// @file main.c +/// @brief main app +/// +///（本文件实现的功能的详述） +/// +/// @version 1.1 CCsens technology +/// @author CC +/// @date 20150102 +/// +/// +/// 修订说明：最初版本 +/// Modified by: +/// Modified date: +/// Version: +/// Descriptions: +////////////////////////////////////////////////////////////////////////// +/***************************************************************************** +update by cc @201700110 +针对多串口 和 单一串口 有区别 每个串口是独立的还是分开的有讲究 程序是复杂的还是软件应用简单是 +个需要平衡的事情. + +clib/clib.c: +公用的函数 和硬件无关 +放置串行模式(串口等其他通讯总线类的输出)输出的函数, +一些覆盖模式输出的(lcd等固屏输出的)的也可使用 + void Lc_print(void (*L0pf_send_uc)(char ww), char *dat,...) +----------------------------------------------------------------------------------------- +uartcom/Uprotocol2app + 协议到应用 + 为了适应不同的通讯协议需要不同的uart口来对应 和应用相关 + +typedef struct _ts_lcm_pro_; 应用协议包的定义? LCM的协议------------ + L3_UARTcom0_exp_protocol 解析应用协议 +----------------------------------------------------------------------------------------- +uartcom/urec2protocol: 接收到的数据放入到指向特定协议的缓存中，和协议的格式有关 一般分为 标头式或者标尾式 +公用的串口通讯定义 + struct _s_uart_rec_ 的公共协议包(关键的结构体)的声明------struct _s_uart_rec_ + void L1_uart_2buf(struct _s_uart_rec_ *p)串行数据保存到指向特定协议的缓冲中 +-------------------------------------------------------------------------------------------- +msp/uartx.c 底层代码 和cpu相关 缓存发送也放在里面 + L0_UART0_Init + UART0_IRQHandler + L0_Usend_uc------UserDef +----------------------------------------------------------------------------------------- +********************************************************************************/ + + +#ifndef _uart0_H +#define _uart0_H +#include "../bsp/bsp_config.h" +#include "../tpc/modbus.h" +#include "uart_x.h" +#include "../msp/uart2.h" +#include "../msp/uart3.h" +//#include "../tpc/tpc_x.h" + +#define uNum0 0 + +#define D_uart0_ES_INT(x) ES = (x) +#define L0_uart0_IntRI() (RI)//BITN_G(SCON,U0RI) +#define L0_uart0_IntTI() (TI)//BITN_G(SCON,U0TI) +#define L0_uart0_IntRIClear(); RI = 0;//BITN_0(SCON,U0RI) +#define L0_uart0_IntTIClear(); TI = 0;//BITN_0(SCON,U0TI) + +//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< + +void L0_uart0_buf_init(void); +void L0_uart0_sendArray(U8 * buf, U16 len); + +#define L0_uart0_uc(X) L0_uartN_uc(uNum0,X) +#define L0_uart0_us(X) L0_uartN_us(uNum0,X) +#define L0_uart0_ul(X) L0_uartN_ul(uNum0,X) +#define L0_uart0_0d0a() L0_uartN_0d0a(0) +#define L0_uart0_uchex(X) L0_uartN_uchex(uNum0,X) +#define L0_uart0_ushex(X) L0_uartN_ushex(uNum0,X) +#define L0_uart0_ulhex(X) L0_uartN_ulhex(uNum0,X) +#define L0_uart0_sendstr(buf) L0_uartN_sendstr(uNum0,buf) +#define L1_uart0_uchexArray(buf) L1_uartN_uchexArray(uNum0,buf) + +extern TP_Handler_X s_uart0_rec; +extern TS_PH4_modbus s_uart0_ack; + +#endif //#ifndef _uart0_H + diff --git a/source/msp/UART2.C b/source/msp/UART2.C new file mode 100644 index 0000000..ed62c36 --- /dev/null +++ b/source/msp/UART2.C @@ -0,0 +1,168 @@ +////////////////////////////////////////////////////////////////////////// +/// COPYRIGHT NOTICE +/// Copyright (c) 2015, 传控科技 +/// All rights reserved. +/// +/// @file main.c +/// @brief main app +/// +///（本文件实现的功能的详述） +/// +/// @version 1.1 CCsens technology +/// @author CC +/// @date 20150102 +/// +/// +/// 修订说明：最初版本 +/// Modified by: +/// Modified date: +/// Version: +/// Descriptions: +// 20160413 CC-ACC-VH02 +// 连接至 J22 RXD0 TXD0 +//P5_DIR &= ~BITN1; //p5.1输出TXD +//P5_DIR |= BITN0; //p5.0输入RXD +//P5_SEL0 &= ~(BITN0 +BITN1); //设置P5.0 P5.1为UART0 RXD TXD +//P5_SEL1 |= BITN0 +BITN1; + +/***************************************************************************** +update by cc @201700110 +针对多串口 和 单一串口 有区别 每个串口是独立的还是分开的有讲究 程序是复杂的还是软件应用简单是 +个需要平衡的事情. + +clib/clib.c: +公用的函数 和硬件无关 +放置串行模式(串口等其他通讯总线类的输出)输出的函数, +一些覆盖模式输出的(lcd等固屏输出的)的也可使用 + void Lc_print(void (*L0pf_send_uc)(char ww), char *dat,...) +----------------------------------------------------------------------------------------- +uartcom/Uprotocol2app + 协议到应用 + 为了适应不同的通讯协议需要不同的uart口来对应 和应用相关 + +typedef struct _ts_lcm_pro_; 应用协议包的定义? LCM的协议------------ + L3_UARTcom0_exp_protocol 解析应用协议 +----------------------------------------------------------------------------------------- +uartcom/urec2protocol: 接收到的数据放入到指向特定协议的缓存中，和协议的格式有关 一般分为 标头式或者标尾式 +公用的串口通讯定义 + struct _s_uart_rec_ 的公共协议包(关键的结构体)的声明------struct _s_uart_rec_ + void L1_uart_2buf(struct _s_uart_rec_ *p)串行数据保存到指向特定协议的缓冲中 +-------------------------------------------------------------------------------------------- +msp/uartx.c 底层代码 和cpu相关 缓存发送也放在里面 + L0_UART0_Init + UART0_IRQHandler + L0_Usend_uc------UserDef +----------------------------------------------------------------------------------------- +********************************************************************************/ +#include "uart2.h" +#include "../app/app_config.h" +#include "../msp/time.h" + +//#define _USE_485 + +static volatile Ts_uart_send_buf idata ts_uart_send_shop; +TP_Handler_X s_uart2_rec; +TS_PH4_modbus s_uart2_ack; + +void L0_uart2_init(void) +{ +//#if(MainFre_11M == D_sys_MainFre) //115200bps@11.0592MHz +// S2CON = 0x50; //8位数据,可变波特率 +// AUXR |= 0x04; //定时器2时钟为Fosc,即1T +// T2L = 0xE8; //设定定时初值 +// T2H = 0xFF; //设定定时初值 +// AUXR |= 0x10; //启动定时器2 +// +//#elif (MainFre_22M == D_sys_MainFre) //115200bps@22.1184MHz +// S2CON = 0x50; //8位数据,可变波特率 +// AUXR |= 0x04; //定时器2时钟为Fosc,即1T +// T2L = 0xE0; //设定定时初值 +// T2H = 0xFE; //设定定时初值 +// AUXR |= 0x10; //启动定时器2 +//#endif +// S2CON = 0x50; //8位数据,可变波特率 +// AUXR |= 0x04; //定时器时钟1T模式 +// T2L = 0xE0; //设置定时初始值 +// T2H = 0xFE; //设置定时初始值 +// AUXR |= 0x10; //定时器2开始计时 + S2CON = 0x50; //8位数据,可变波特率 + AUXR &= 0xFB; //定时器时钟12T模式 + T2L = 0xFC; //设置定时初始值 + T2H = 0xFF; //设置定时初始值 + AUXR |= 0x10; //定时器2开始计时 + +} + +void L0_uart2_buf_init(void) +{ + ts_uart[uNum2].p = &ts_uart_send_shop; + ts_uart[uNum2].p->now = 0; + ts_uart[uNum2].p->ok = D_ready; + ts_uart[uNum2].t = &s_uart2_rec; + ts_uart[uNum2].t->head = 0; + ts_uart[uNum2].t->ok = 0; + ts_uart[uNum2].tp_handler = NULL; + ts_uart[uNum2].ack = (U8*)&s_uart2_ack; + L0_uart2_init(); + D_uart2_ES_INT(1); //打开串口中断 + +#if (D_UART2_485_TYPE != TYPE_485_NONE) + D_UART2_485_RX() //默认处于接收状态 +#endif +} + +void L0_uart2_sendArray(U8 * buf, U16 len) +{ +#if (D_UART2_485_TYPE != TYPE_485_NONE) + D_UART2_485_TX() //切换到输出状态 +#endif + L0_uartN_sendArray(uNum2,buf,len); +} + +/************************************************* +UART 中断 +*************************************************/ +#define D_SERVE_uart2 interrupt 8 +void INTERRUPT_uart2(void) D_SERVE_uart2// using 2 +{ + //NOP(); NOP(); NOP(); + if(L0_uart2_IntRI()) //如果是U2接收中断 + { + //LED0 ^= 1; + L0_uart2_IntRIClear(); //清除接收中断标志 + ts_uart[uNum2].t->reg = L0_uartN_get(uNum2); + //ts_uart[uNum2].tp_handler(ts_uart[uNum2].t); + L1_s2b_PH4(ts_uart[uNum2].t); + L0_timer3_restart(); + } + if(L0_uart2_IntTI()) //如果是U0发送中断 + { + L0_uart2_IntTIClear(); //清除发送中断标志 + if(ts_uart[uNum2].p->max != ts_uart[uNum2].p->now) + { + L0_uartN_set(uNum2,ts_uart[uNum2].p->p[ts_uart[uNum2].p->now]); + ts_uart[uNum2].p->now ++; + } + else + { + ts_uart[uNum2].p->ok = D_ready; + ts_uart[uNum2].p->max = 0; + ts_uart[uNum2].p->now = 0;//可以发送下一个数据 +#if (D_UART2_485_TYPE != TYPE_485_NONE) + D_UART2_485_RX() //切换到接收状态 +#endif + + } + } + //NOP(); NOP(); NOP(); +} + + + + + + + + + + diff --git a/source/msp/UART2.h b/source/msp/UART2.h new file mode 100644 index 0000000..97cc20b --- /dev/null +++ b/source/msp/UART2.h @@ -0,0 +1,85 @@ +////////////////////////////////////////////////////////////////////////// +/// COPYRIGHT NOTICE +/// Copyright (c) 2015, 传控科技 +/// All rights reserved. +/// +/// @file main.c +/// @brief main app +/// +///（本文件实现的功能的详述） +/// +/// @version 1.1 CCsens technology +/// @author CC +/// @date 20150102 +/// +/// +/// 修订说明：最初版本 +/// Modified by: +/// Modified date: +/// Version: +/// Descriptions: +////////////////////////////////////////////////////////////////////////// +/***************************************************************************** +update by cc @201700110 +针对多串口 和 单一串口 有区别 每个串口是独立的还是分开的有讲究 程序是复杂的还是软件应用简单是 +个需要平衡的事情. + +clib/clib.c: +公用的函数 和硬件无关 +放置串行模式(串口等其他通讯总线类的输出)输出的函数, +一些覆盖模式输出的(lcd等固屏输出的)的也可使用 + void Lc_print(void (*L0pf_send_uc)(char ww), char *dat,...) +----------------------------------------------------------------------------------------- +uartcom/Uprotocol2app + 协议到应用 + 为了适应不同的通讯协议需要不同的uart口来对应 和应用相关 + +typedef struct _ts_lcm_pro_; 应用协议包的定义? LCM的协议------------ + L3_UARTcom0_exp_protocol 解析应用协议 +----------------------------------------------------------------------------------------- +uartcom/urec2protocol: 接收到的数据放入到指向特定协议的缓存中，和协议的格式有关 一般分为 标头式或者标尾式 +公用的串口通讯定义 + struct _s_uart_rec_ 的公共协议包(关键的结构体)的声明------struct _s_uart_rec_ + void L1_uart_2buf(struct _s_uart_rec_ *p)串行数据保存到指向特定协议的缓冲中 +-------------------------------------------------------------------------------------------- +msp/uartx.c 底层代码 和cpu相关 缓存发送也放在里面 + L0_uart2_Init + uart2_IRQHandler + L0_Usend_uc------UserDef +----------------------------------------------------------------------------------------- +********************************************************************************/ + + +#ifndef _uart2_H +#define _uart2_H + +#include "../bsp/bsp_config.h" +#include "../tpc/ccmodbus.h" +#include "uart_x.h" + +#define uNum2 1 + +#define D_uart2_ES_INT(x) (x) ? (BITN_1(IE2,ES2)) : (BITN_0(IE2,ES2)) +#define L0_uart2_IntRI() (S2CON & S2RI)//BITN_G(SCON,U0RI) +#define L0_uart2_IntTI() (S2CON & S2TI)//BITN_G(SCON,U0TI) +#define L0_uart2_IntRIClear(); BITN_0(S2CON,S2RI) +#define L0_uart2_IntTIClear(); BITN_0(S2CON,S2TI) + +//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< + +void L0_uart2_buf_init(void); +void L0_uart2_sendArray(U8 * buf, U16 len); +void uart2_Handdle(void) ; +#define L0_uart2_uc(X) L0_uartN_uc(uNum2,X) +#define L0_uart2_us(X) L0_uartN_us(uNum2,X) +#define L0_uart2_ul(X) L0_uartN_ul(uNum2,X) +#define L0_uart2_0d0a() L0_uartN_0d0a(0) +#define L0_uart2_uchex(X) L0_uartN_uchex(uNum2,X) +#define L0_uart2_ushex(X) L0_uartN_ushex(uNum2,X) +#define L0_uart2_ulhex(X) L0_uartN_ulhex(uNum2,X) +#define L0_uart2_sendstr(buf) L0_uartN_sendstr(uNum2,buf) +extern TP_Handler_X s_uart2_rec; +extern TS_PH4_modbus s_uart2_ack; + +#endif //#ifndef _uart2_H + diff --git a/source/msp/UART3.c b/source/msp/UART3.c new file mode 100644 index 0000000..383bf45 --- /dev/null +++ b/source/msp/UART3.c @@ -0,0 +1,176 @@ +////////////////////////////////////////////////////////////////////////// +/// COPYRIGHT NOTICE +/// Copyright (c) 2015, 传控科技 +/// All rights reserved. +/// +/// @file main.c +/// @brief main app +/// +///（本文件实现的功能的详述） +/// +/// @version 1.1 CCsens technology +/// @author CC +/// @date 20150102 +/// +/// +/// 修订说明：最初版本 +/// Modified by: +/// Modified date: +/// Version: +/// Descriptions: +// 20160413 CC-ACC-VH02 +// 连接至 J22 RXD0 TXD0 +//P5_DIR &= ~BITN1; //p5.1输出TXD +//P5_DIR |= BITN0; //p5.0输入RXD +//P5_SEL0 &= ~(BITN0 +BITN1); //设置P5.0 P5.1为UART0 RXD TXD +//P5_SEL1 |= BITN0 +BITN1; + +/***************************************************************************** +update by cc @201700110 +针对多串口 和 单一串口 有区别 每个串口是独立的还是分开的有讲究 程序是复杂的还是软件应用简单是 +个需要平衡的事情. + +clib/clib.c: +公用的函数 和硬件无关 +放置串行模式(串口等其他通讯总线类的输出)输出的函数, +一些覆盖模式输出的(lcd等固屏输出的)的也可使用 + void Lc_print(void (*L0pf_send_uc)(char ww), char *dat,...) +----------------------------------------------------------------------------------------- +uartcom/Uprotocol2app + 协议到应用 + 为了适应不同的通讯协议需要不同的uart口来对应 和应用相关 + +typedef struct _ts_lcm_pro_; 应用协议包的定义? LCM的协议------------ + L3_UARTcom0_exp_protocol 解析应用协议 +----------------------------------------------------------------------------------------- +uartcom/urec2protocol: 接收到的数据放入到指向特定协议的缓存中，和协议的格式有关 一般分为 标头式或者标尾式 +公用的串口通讯定义 + struct _s_uart_rec_ 的公共协议包(关键的结构体)的声明------struct _s_uart_rec_ + void L1_uart_2buf(struct _s_uart_rec_ *p)串行数据保存到指向特定协议的缓冲中 +-------------------------------------------------------------------------------------------- +msp/uartx.c 底层代码 和cpu相关 缓存发送也放在里面 + L0_UART0_Init + UART0_IRQHandler + L0_Usend_uc------UserDef +----------------------------------------------------------------------------------------- +********************************************************************************/ +#include "uart3.h" +#include "../msp/time.h" +#include + +static volatile Ts_uart_send_buf idata ts_uart_send_shop; +struct _tp_handler_x s_uart3_rec; +TS_PH4_modbus s_uart3_ack; + +void L0_uart3_init(void) +{ +//#if(MainFre_11M == D_sys_MainFre) //115200bps@11.0592MHz +// S3CON = 0x10; //8位数据,可变波特率 +// S3CON |= 0x40; //串口3选择定时器3为波特率发生器 +// T4T3M |= 0x02; //定时器3时钟为Fosc,即1T +// T3L = 0xE8; //设定定时初值 +// T3H = 0xFF; //设定定时初值 +// T4T3M |= 0x08; //启动定时器3 + +//#elif (MainFre_22M == D_sys_MainFre) //115200bps@22.1184MHz +// S3CON = 0x10; //8位数据,可变波特率 +// S3CON |= 0x40; //串口3选择定时器3为波特率发生器 +// T4T3M |= 0x02; //定时器3时钟为Fosc,即1T +// T3L = 0xD0; //设定定时初值 +// T3H = 0xFF; //设定定时初值 +// T4T3M |= 0x08; //启动定时器3 +//#endif + + S3CON = 0x10; //8位数据,可变波特率 + S3CON &= 0xBF; //串口3选择定时器2为波特率发生器 + AUXR |= 0x04; //定时器时钟1T模式 + T2L = 0xD0; //设置定时初始值 + T2H = 0xFF; //设置定时初始值 + AUXR |= 0x10; //定时器2开始计时 +} + +void L0_uart3_buf_init(void) +{ + ts_uart[uNum3].p = &ts_uart_send_shop; + ts_uart[uNum3].p->now = 0; + ts_uart[uNum3].p->ok = D_ready; + ts_uart[uNum3].t = &s_uart3_rec; + ts_uart[uNum3].t->head = 0; + ts_uart[uNum3].t->ok = 0; + ts_uart[uNum3].tp_handler = L1_s2b_PH4; + ts_uart[uNum3].ack = (U8*)&s_uart3_ack; + L0_uart3_init(); + //D_uart3_ES_INT_OPEN(); //打开串口中断 + D_uart3_ES_INT(1); //打开串口中断 + +#if (D_UART3_485_TYPE != TYPE_485_NONE) + D_UART3_485_RX() //默认处于接收状态 +#endif +} + +void L0_uart3_sendArray(U8 * buf, U16 len) +{ +//#if (D_UART3_485_TYPE != TYPE_485_NONE) +// D_UART3_485_TX() //切换到输出状态 +//#endif + L0_uartN_sendArray(uNum3,buf,len); +} + +/************************************************* +UART 中断 +*************************************************/ +#define D_SERVE_UART3 interrupt 17 +void INTERRUPT_UART3(void) D_SERVE_UART3// using 3 +{ + NOP(); NOP(); NOP(); + if(L0_uart3_IntRI()) //如果是U0接收中断 + { + L0_uart3_IntRIClear(); //清除接收中断标志 + ts_uart[uNum3].t->reg = L0_uartN_get(uNum3); + ts_uart[uNum3].tp_handler(ts_uart[uNum3].t); + //L0_timer4_start(); + } + if(L0_uart3_IntTI()) + { + if(L0_uart3_IntTI()) //如果是U0发送中断 + { + L0_uart3_IntTIClear(); //清除发送中断标志 + if(ts_uart[uNum3].p->max != ts_uart[uNum3].p->now) + { + L0_uartN_set(uNum3,ts_uart[uNum3].p->p[ts_uart[uNum3].p->now]); + ts_uart[uNum3].p->now ++; + } + else + { + ts_uart[uNum3].p->ok = D_ready; + ts_uart[uNum3].p->max = 0; + ts_uart[uNum3].p->now = 0;//可以发送下一个数据 +#if (D_UART3_485_TYPE != TYPE_485_NONE) + D_UART3_485_RX() //切换到接收状态 +#endif + } + } + } + NOP(); NOP(); NOP(); +} + +void timer4_isrHanddle(void) D_SERVE_TIMER4 +{ + struct _tp_handler_x *p = &s_uart3_rec; + if((p->head == 1) && (p->num >= D_s_modbus_min)) + { + p->head = 0; + crc16(p->crc,p->buf,p->num - 2); //校验CRC + if(p->crc[0] == p->buf[p->num-2] && p->crc[1] == p->buf[p->num-1]) + { + if(p->ok == 0) + { + p->ok = 1; + } + } + //LED0 ^= 1; + } + L0_timer4_stop(); +} + + diff --git a/source/msp/UART3.h b/source/msp/UART3.h new file mode 100644 index 0000000..eb4bb28 --- /dev/null +++ b/source/msp/UART3.h @@ -0,0 +1,93 @@ +////////////////////////////////////////////////////////////////////////// +/// COPYRIGHT NOTICE +/// Copyright (c) 2015, 传控科技 +/// All rights reserved. +/// +/// @file main.c +/// @brief main app +/// +///（本文件实现的功能的详述） +/// +/// @version 1.1 CCsens technology +/// @author CC +/// @date 20150102 +/// +/// +/// 修订说明：最初版本 +/// Modified by: +/// Modified date: +/// Version: +/// Descriptions: +////////////////////////////////////////////////////////////////////////// +/***************************************************************************** +update by cc @201700110 +针对多串口 和 单一串口 有区别 每个串口是独立的还是分开的有讲究 程序是复杂的还是软件应用简单是 +个需要平衡的事情. + +clib/clib.c: +公用的函数 和硬件无关 +放置串行模式(串口等其他通讯总线类的输出)输出的函数, +一些覆盖模式输出的(lcd等固屏输出的)的也可使用 + void Lc_print(void (*L0pf_send_uc)(char ww), char *dat,...) +----------------------------------------------------------------------------------------- +uartcom/Uprotocol2app + 协议到应用 + 为了适应不同的通讯协议需要不同的uart口来对应 和应用相关 + +typedef struct _ts_lcm_pro_; 应用协议包的定义? LCM的协议------------ + L3_UARTcom0_exp_protocol 解析应用协议 +----------------------------------------------------------------------------------------- +uartcom/urec2protocol: 接收到的数据放入到指向特定协议的缓存中，和协议的格式有关 一般分为 标头式或者标尾式 +公用的串口通讯定义 + struct _s_uart_rec_ 的公共协议包(关键的结构体)的声明------struct _s_uart_rec_ + void L1_uart_2buf(struct _s_uart_rec_ *p)串行数据保存到指向特定协议的缓冲中 +-------------------------------------------------------------------------------------------- +msp/uartx.c 底层代码 和cpu相关 缓存发送也放在里面 + L0_uart3_Init + uart3_IRQHandler + L0_Usend_uc------UserDef +----------------------------------------------------------------------------------------- +********************************************************************************/ + + +#ifndef _uart3_H +#define _uart3_H + +#include "../bsp/bsp_config.h" +#include "../tpc/modbus.h" +#include "uart_x.h" + +#define uNum3 2 + +//#define S4SM0 BITN7 +#define D_uart3_ES_INT(x) (x) ? (BITN_1(IE2,ES3)) : (BITN_0(IE2,ES3)) +//#define D_uart3_ES_INT_CLOSE() BITN_0(IE2,ES3) +//#define D_uart3_ES_INT_OPEN() BITN_1(IE2,ES3) +#define L0_uart3_IntRI() (S3CON & S3RI)//BITN_G(SCON,U0RI) +#define L0_uart3_IntTI() (S3CON & S3TI)//BITN_G(SCON,U0TI) +#define L0_uart3_IntRIClear(); BITN_0(S3CON,S3RI) +#define L0_uart3_IntTIClear(); BITN_0(S3CON,S3TI) +#define L0_uart3_set(x) S3BUF = (x); +#define L0_uart3_get() (S3BUF) + + +//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< + +void L0_uart3_buf_init(void); +void L0_uart3_sendArray(U8 * buf, U16 len); + +#define L0_uart3_uc(X) L0_uartN_uc(uNum3,X) +#define L0_uart3_us(X) L0_uartN_us(uNum3,X) +#define L0_uart3_ul(X) L0_uartN_ul(uNum3,X) +#define L0_uart3_0d0a() L0_uartN_0d0a(uNum3) +#define L0_uart3_uchex(X) L0_uartN_uchex(uNum3,X) +#define L0_uart3_ushex(X) L0_uartN_ushex(uNum3,X) +#define L0_uart3_ulhex(X) L0_uartN_ulhex(uNum3,X) +#define L0_uart3_sendstr(buf) L0_uartN_sendstr(uNum3,buf) +#define L1_uart3_uchexArray(buf) L1_uartN_uchexArray(uNum3,buf) + +extern TP_Handler_X s_uart3_rec; +extern TS_PH4_modbus s_uart3_ack; + +#endif //#ifndef _uart3_H + diff --git a/source/msp/UART4.C b/source/msp/UART4.C new file mode 100644 index 0000000..9184f55 --- /dev/null +++ b/source/msp/UART4.C @@ -0,0 +1,169 @@ +////////////////////////////////////////////////////////////////////////// +/// COPYRIGHT NOTICE +/// Copyright (c) 2015, 传控科技 +/// All rights reserved. +/// +/// @file main.c +/// @brief main app +/// +///（本文件实现的功能的详述） +/// +/// @version 1.1 CCsens technology +/// @author CC +/// @date 20150102 +/// +/// +/// 修订说明：最初版本 +/// Modified by: +/// Modified date: +/// Version: +/// Descriptions: +// 20160413 CC-ACC-VH02 +// 连接至 J22 RXD0 TXD0 +//P5_DIR &= ~BITN1; //p5.1输出TXD +//P5_DIR |= BITN0; //p5.0输入RXD +//P5_SEL0 &= ~(BITN0 +BITN1); //设置P5.0 P5.1为uart4 RXD TXD +//P5_SEL1 |= BITN0 +BITN1; + +/***************************************************************************** +update by cc @201700110 +针对多串口 和 单一串口 有区别 每个串口是独立的还是分开的有讲究 程序是复杂的还是软件应用简单是 +个需要平衡的事情. + +clib/clib.c: +公用的函数 和硬件无关 +放置串行模式(串口等其他通讯总线类的输出)输出的函数, +一些覆盖模式输出的(lcd等固屏输出的)的也可使用 + void Lc_print(void (*L0pf_send_uc)(char ww), char *dat,...) +----------------------------------------------------------------------------------------- +uartcom/Uprotocol2app + 协议到应用 + 为了适应不同的通讯协议需要不同的uart口来对应 和应用相关 + +typedef struct _ts_lcm_pro_; 应用协议包的定义? LCM的协议------------ + L3_UARTcom0_exp_protocol 解析应用协议 +----------------------------------------------------------------------------------------- +uartcom/urec2protocol: 接收到的数据放入到指向特定协议的缓存中，和协议的格式有关 一般分为 标头式或者标尾式 +公用的串口通讯定义 + struct _s_uart_rec_ 的公共协议包(关键的结构体)的声明------struct _s_uart_rec_ + void L1_uart_2buf(struct _s_uart_rec_ *p)串行数据保存到指向特定协议的缓冲中 +-------------------------------------------------------------------------------------------- +msp/uartx.c 底层代码 和cpu相关 缓存发送也放在里面 + L0_uart4_Init + uart4_IRQHandler + L0_Usend_uc------UserDef +----------------------------------------------------------------------------------------- +********************************************************************************/ +#include "uart4.h" + +//#define _USE_485 + +static volatile Ts_uart_send_buf idata ts_uart_send_shop; +//TP_Handler_X s_uart4_at_rec; +//TP_Handler_X s_uart4_tcp_rec; +TP_Handler_X s_uart4_rec; +TS_PH3_ccmodbus s_uart4_ack; + +//#define FOSC 11059200L //系统频率 +//#define BAUD4 115200 //串口波特率 +void L0_uart4_init(void)//115200bps@11.0592MHz +{ + #if(MainFre_11M == D_sys_MainFre) +#if 0 + S4CON = 0x50; //8位可变波特率 + T4L = (65536 - (FOSC/4/BAUD4)); //设置波特率重装值 + T4H = (65536 - (FOSC/4/BAUD4))>>8; + T4T3M |= 0x20; //定时器4为1T模式 + T4T3M |= 0x80; //定时器4开始计时 +#else + S4CON = 0x10; //8位数据,可变波特率 + S4CON |= 0x40; //串口4选择定时器4为波特率发生器 + T4T3M |= 0x20; //定时器4时钟为Fosc,即1T + T4L = 0xE8; //设定定时初值 + T4H = 0xFF; //设定定时初值 + T4T3M |= 0x80; //启动定时器4 +#endif + + +#elif (MainFre_22M == D_sys_MainFre) //115200bps@22.1184MHz + S4CON = 0x10; //8位数据,可变波特率 + S4CON |= 0x40; //串口4选择定时器4为波特率发生器 + T4T3M |= 0x20; //定时器4时钟为Fosc,即1T + T4L = 0xD0; //设定定时初值 + T4H = 0xFF; //设定定时初值 + T4T3M |= 0x80; //启动定时器4 +#endif +} + +void L0_uart4_buf_init(void) +{ + ts_uart[uNum4].p = &ts_uart_send_shop; + ts_uart[uNum4].p->now = 0; + ts_uart[uNum4].p->ok = D_ready; + ts_uart[uNum4].t = &s_uart4_rec; + ts_uart[uNum4].t->head_0 = D_CMD_Filter1_ff; + ts_uart[uNum4].t->head_1 = D_CMD_Filter2_fe; + ts_uart[uNum4].t->head = 0; + ts_uart[uNum4].t->ok = 0; + ts_uart[uNum4].tp_handler = L1_s2b_PH3; + ts_uart[uNum4].ack = (U8*)&s_uart4_ack; + + //s_uart4_tcp_rec.head_0 = D_CMD_Filter1_ff; + //s_uart4_tcp_rec.head_1 = D_CMD_Filter2_fe; + //s_uart4_tcp_rec.head = 0; + //s_uart4_tcp_rec.ok = 0; + L0_uart4_init(); + D_uart4_ES_INT(1); //打开串口中断 + +#if (D_UART4_485_TYPE != TYPE_485_NONE) + D_UART4_485_RX() //默认处于接收状态 +#endif +} + +void L0_uart4_sendArray(U8 * buf, U16 len) +{ +#if (D_UART4_485_TYPE != TYPE_485_NONE) + D_UART4_485_TX() //切换到输出状态 +#endif + L0_uartN_sendArray(uNum4,buf,len); +} + +/************************************************* +UART 中断 +*************************************************/ + +#define D_SERVE_uart4 interrupt 18 +void INTERRUPT_uart4(void) D_SERVE_uart4// using 2 +{ +#if 1 + //NOP(); NOP(); NOP(); + if(L0_uart4_IntRI()) //如果是U0接收中断 + { + L0_uart4_IntRIClear(); //清除接收中断标志 + ts_uart[uNum4].t->reg = L0_uartN_get(uNum4); + ts_uart[uNum4].tp_handler(ts_uart[uNum4].t); + } + if(L0_uart4_IntTI()) //如果是U0发送中断 + { + L0_uart4_IntTIClear(); //清除发送中断标志 + if(ts_uart[uNum4].p->max != ts_uart[uNum4].p->now) + { + L0_uartN_set(uNum4,ts_uart[uNum4].p->p[ts_uart[uNum4].p->now]); + ts_uart[uNum4].p->now ++; + } + else + { + ts_uart[uNum4].p->ok = D_ready; + ts_uart[uNum4].p->max = 0; + ts_uart[uNum4].p->now = 0;//可以发送下一个数据 +#if (D_UART4_485_TYPE != TYPE_485_NONE) + D_UART4_485_RX() //切换到接收状态 +#endif + + } + } + //NOP(); NOP(); NOP(); +#endif +} + + diff --git a/source/msp/UART4.h b/source/msp/UART4.h new file mode 100644 index 0000000..b70da6c --- /dev/null +++ b/source/msp/UART4.h @@ -0,0 +1,88 @@ +////////////////////////////////////////////////////////////////////////// +/// COPYRIGHT NOTICE +/// Copyright (c) 2015, 传控科技 +/// All rights reserved. +/// +/// @file main.c +/// @brief main app +/// +///（本文件实现的功能的详述） +/// +/// @version 1.1 CCsens technology +/// @author CC +/// @date 20150102 +/// +/// +/// 修订说明：最初版本 +/// Modified by: +/// Modified date: +/// Version: +/// Descriptions: +////////////////////////////////////////////////////////////////////////// +/***************************************************************************** +update by cc @201700110 +针对多串口 和 单一串口 有区别 每个串口是独立的还是分开的有讲究 程序是复杂的还是软件应用简单是 +个需要平衡的事情. + +clib/clib.c: +公用的函数 和硬件无关 +放置串行模式(串口等其他通讯总线类的输出)输出的函数, +一些覆盖模式输出的(lcd等固屏输出的)的也可使用 + void Lc_print(void (*L0pf_send_uc)(char ww), char *dat,...) +----------------------------------------------------------------------------------------- +uartcom/Uprotocol2app + 协议到应用 + 为了适应不同的通讯协议需要不同的uart口来对应 和应用相关 + +typedef struct _ts_lcm_pro_; 应用协议包的定义? LCM的协议------------ + L3_UARTcom0_exp_protocol 解析应用协议 +----------------------------------------------------------------------------------------- +uartcom/urec2protocol: 接收到的数据放入到指向特定协议的缓存中，和协议的格式有关 一般分为 标头式或者标尾式 +公用的串口通讯定义 + struct _s_uart_rec_ 的公共协议包(关键的结构体)的声明------struct _s_uart_rec_ + void L1_uart_2buf(struct _s_uart_rec_ *p)串行数据保存到指向特定协议的缓冲中 +-------------------------------------------------------------------------------------------- +msp/uartx.c 底层代码 和cpu相关 缓存发送也放在里面 + L0_uart4_Init + uart4_IRQHandler + L0_Usend_uc------UserDef +----------------------------------------------------------------------------------------- +********************************************************************************/ + + +#ifndef _uart4_H +#define _uart4_H + +#include "../bsp/bsp_config.h" +#include "../tpc/tpc_ccmodbus.h" +#include "uartN.h" + +#define uNum4 3 + +#define D_uart4_ES_INT(x) (x) ? (BITN_1(IE2,ES4)) : (BITN_0(IE2,ES4)) +#define L0_uart4_IntRI() (S4CON & S4RI)//BITN_G(SCON,U0RI) +#define L0_uart4_IntTI() (S4CON & S4TI)//BITN_G(SCON,U0TI) +#define L0_uart4_IntRIClear(); BITN_0(S4CON,S4RI) +#define L0_uart4_IntTIClear(); BITN_0(S4CON,S4TI) + + +//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< + +void L0_uart4_buf_init(void); +void L0_uart4_sendArray(U8 * buf, U16 len); + +#define L0_uart4_uc(X) L0_uartN_uc(uNum4,X) +#define L0_uart4_us(X) L0_uartN_us(uNum4,X) +#define L0_uart4_ul(X) L0_uartN_ul(uNum4,X) +#define L0_uart4_0d0a() L0_uartN_0d0a(0) +#define L0_uart4_uchex(X) L0_uartN_uchex(uNum4,X) +#define L0_uart4_ushex(X) L0_uartN_ushex(uNum4,X) +#define L0_uart4_ulhex(X) L0_uartN_ulhex(uNum4,X) +#define L0_uart4_sendstr(buf) L0_uartN_sendstr(uNum4,buf) +#define L1_uart4_uchexArray(buf) L1_uartN_uchexArray(uNum4,buf) + +extern TP_Handler_X s_uart4_rec; +extern TS_PH3_ccmodbus s_uart4_ack; + +#endif //#ifndef _uart4_H + diff --git a/source/msp/eeprom.c b/source/msp/eeprom.c new file mode 100644 index 0000000..78ff57c --- /dev/null +++ b/source/msp/eeprom.c @@ -0,0 +1,222 @@ +//////////////////////////////////////////////////////////////////////////// +///@copyright Copyright (c) 2018, 传控科技 All rights reserved. +///------------------------------------------------------------------------- +/// @file msp_eeprom.c +/// @brief msp @ driver config +///------------------------------------------------------------------------- +/// @version 1.0 +/// @author CC +/// @date 20190106 +/// @note cc_AS_stc02 由stc-isp v6.0860 +////////////////////////////////////////////////////////////////////////////// +#include "eeprom.h" +#include "../bsp/bsp_config.h" + +struct eeprom_block_t eep_block; + +#if(TYPE_MCU == TYPE_MCU_STC_8A || TYPE_MCU == TYPE_MCU_STC_8F) +#define WT_30M 0x80 +#define WT_24M 0x81 +#define WT_20M 0x82 +#define WT_12M 0x83 +#define WT_6M 0x84 +#define WT_3M 0x85 +#define WT_2M 0x86 +#define WT_1M 0x87 + + +void L0_Iap_Idle() +{ + IAP_CONTR = 0; //关闭IAP功能 + IAP_CMD = 0; //清除命令寄存器 + IAP_TRIG = 0; //清除触发寄存器 + IAP_ADDRH = 0x80; //将地址设置到非IAP区域 + IAP_ADDRL = 0; +} + +char L0_Iap_Read(vU16 addr) +{ + char dat; + + IAP_CONTR = WT_12M; //使能IAP + IAP_CMD = 1; //设置IAP读命令 + IAP_ADDRL = addr; //设置IAP低地址 + IAP_ADDRH = addr >> 8; //设置IAP高地址 + IAP_TRIG = 0x5a; //写触发命令(0x5a) + IAP_TRIG = 0xa5; //写触发命令(0xa5) + _nop_(); + dat = IAP_DATA; //读IAP数据 + L0_Iap_Idle(); //关闭IAP功能 + + return dat; +} + +void L0_Iap_Program(vU16 addr, char dat) +{ + IAP_CONTR = WT_12M; //使能IAP + IAP_CMD = 2; //设置IAP写命令 + IAP_ADDRL = addr; //设置IAP低地址 + IAP_ADDRH = addr >> 8; //设置IAP高地址 + IAP_DATA = dat; //写IAP数据 + IAP_TRIG = 0x5a; //写触发命令(0x5a) + IAP_TRIG = 0xa5; //写触发命令(0xa5) + _nop_(); + L0_Iap_Idle(); //关闭IAP功能 +} + +///每个扇区512字节 +///指定地址可以为当前扇区内的任意地址，都会完整擦除当前扇区 +void L0_Iap_Erase(vU16 addr) +{ + IAP_CONTR = WT_12M; //使能IAP + IAP_CMD = 3; //设置IAP擦除命令 + IAP_ADDRL = addr; //设置IAP低地址 + IAP_ADDRH = addr >> 8; //设置IAP高地址 + IAP_TRIG = 0x5a; //写触发命令(0x5a) + IAP_TRIG = 0xa5; //写触发命令(0xa5) + _nop_(); // + L0_Iap_Idle(); //关闭IAP功能 +} + +#elif (TYPE_MCU == TYPE_MCU_STC_8G || TYPE_MCU == TYPE_MCU_STC_8H) +void L0_Iap_Idle() +{ + IAP_CONTR = 0; //关闭IAP功能 + IAP_CMD = 0; //清除命令寄存器 + IAP_TRIG = 0; //清除触发寄存器 + IAP_ADDRH = 0x80; //将地址设置到非IAP区域 + IAP_ADDRL = 0; +} + +char L0_Iap_Read(vU16 addr) +{ + char dat; + + IAP_CONTR = 0x80; //使能IAP + IAP_TPS = 12; + IAP_CMD = 1; //设置IAP读命令 + IAP_ADDRL = addr; //设置IAP低地址 + IAP_ADDRH = addr >> 8; //设置IAP高地址 + IAP_TRIG = 0x5a; //写触发命令(0x5a) + IAP_TRIG = 0xa5; //写触发命令(0xa5) + _nop_(); + dat = IAP_DATA; //读IAP数据 + L0_Iap_Idle(); //关闭IAP功能 + + return dat; +} + +void L0_Iap_Program(vU16 addr, char dat) +{ + IAP_CONTR = 0x80; //使能IAP + IAP_TPS = 12; //设置擦除等待参数 12MHz + IAP_CMD = 2; //设置IAP写命令 + IAP_ADDRL = addr; //设置IAP低地址 + IAP_ADDRH = addr >> 8; //设置IAP高地址 + IAP_DATA = dat; //写IAP数据 + IAP_TRIG = 0x5a; //写触发命令(0x5a) + IAP_TRIG = 0xa5; //写触发命令(0xa5) + _nop_(); + L0_Iap_Idle(); //关闭IAP功能 +} + +///每个扇区512字节 +///指定地址可以为当前扇区内的任意地址，都会完整擦除当前扇区 +void L0_Iap_Erase(vU16 addr) +{ + IAP_CONTR = 0x80; //使能IAP + IAP_TPS = 12; //设置擦除等待参数 12MHz + IAP_CMD = 3; //设置IAP擦除命令 + IAP_ADDRL = addr; //设置IAP低地址 + IAP_ADDRH = addr >> 8; //设置IAP高地址 + IAP_TRIG = 0x5a; //写触发命令(0x5a) + IAP_TRIG = 0xa5; //写触发命令(0xa5) + _nop_(); // + L0_Iap_Idle(); //关闭IAP功能 +} +#endif + + +void L0_Iap_Program_array(vU16 addr,U8 *buf,U8 len) +{ + U8 i = 0; + for(i=0;i D_EEP_SECTOR_BLOCK_BUF_SIZE) + { + return 1; + } + + Lc_memset((U8*)&eep_block,0,sizeof(eep_block)); + eep_block.filter[0] = D_EEP_BLOCK_FILTER0; + eep_block.filter[1] = D_EEP_BLOCK_FILTER1; + eep_block.len[0] = len >> 8 & 0xFF; + eep_block.len[1] = len >> 0 & 0xFF; + for(i=0;i0 +void L0_I2C_Start(void) +{ + L0_IIC_SIM_INIT(); + L0_I2C_SDA(1); + L0_I2C_SCL(1); + L0_I2C_SDA(0); + L0_I2C_SCL(0); +} +//************************************************ +//ֹͣλ IO_SDA = 0->1 +void L0_I2C_Stop(void) +{ + L0_I2C_SDA(0); + + L0_I2C_SCL(1); + + L0_I2C_SDA(1); + L0_IIC_SIM_INIT(); + L0_IIC_SIM_close(); +} +//************************************************ +//Ӧ(ack:IO_SDA = 0no_ack:IO_SDA = 0) +void L0_I2C_Ack(void) +{ //SDA Ϊ + L0_I2C_SCL(0); + L0_I2C_SDA(0); + L0_I2C_SCL(1); + L0_I2C_SCL(0); + L0_I2C_SDA(1); +} + +void L0_I2C_NoAck(void) +{ //SDA Ϊ + L0_I2C_SCL(0); + L0_I2C_SDA(1); + L0_I2C_SCL(1); + L0_I2C_SCL(0); + +} +/****** +I2C߱׼涨 ӦλΪ0ʾӦ ACK ΪA +Ϊ1ʾӦ NACK ΪNA +LSB֮ӦͷSDAߣSDA +ԵȴӦλ +ڽһֽڵݣ +߲ٽոʱӦӦ +ֽ֪ͨ˷Ӧ״̬ +Ӧֹ͡ +// SDAǷACK +bit L0_I2C_Test_Ack(void) +{ //SDA Ϊ + bit ACK_Flag = 0; + L0_I2C_SCL(0); + L0_I2C_SDA(1); + L0_I2C_SCL(1); + + + if(IO_SDA = 0) + ACK_Flag = 1; + else + ACK_Flag = 0; + L0_I2C_SCL(0); + return ACK_Flag; + // return 1;// debug +} +*******/ +//************************************************* +//ֽڷͳ +//c(Ҳǵַ)մӦ +//ǴӦλ +void L0_I2C_SendData(unsigned char c) +{ + unsigned char ack=8; + unsigned char BitCnt=8;//һֽ8λ + //SDA Ϊ + for(BitCnt = 0;BitCnt < 8;BitCnt ++) //Ҫ͵ݳΪ8λ + { + if((c << BitCnt ) & 0x80) + L0_I2C_SDA(1); //жϷλ + else + L0_I2C_SDA(0); + L0_I2C_SCL(1); //ʱΪߣ֪ͨʼλ + L0_I2C_SCL(0); + }//8clk + L0_I2C_SDA(1); //8λͷߣ׼Ӧλ + L0_I2C_SCL(1); + ///gRccUs05 += L0_I2C_SDA_ask(); + L0_I2C_SCL(0); + L0_I2C_delay(); +} +//************************************************** +//ֽڽճ +//ݣ˳Ӧ|Ӧ|i2c_ack_main(void)ʹ +//return: uchar1ֽ +unsigned char L0_I2C_ReceiveData(void) +{ + unsigned char BitCnt=8,IIC_RX_Data = 0; + L0_I2C_SDA(1); // SDA Ϊ + for(BitCnt = 0;BitCnt<8;BitCnt++) + { + L0_I2C_delay(1); + L0_I2C_SCL(0); //ʱΪͣ׼λ + L0_I2C_SCL(1); //ʱΪʹЧ + L0_I2C_delay(1); + IIC_RX_Data = IIC_RX_Data << 1; + if(1 == L0_I2C_SDA_ask()) + IIC_RX_Data = IIC_RX_Data + 1; //λ,յλretc + L0_I2C_delay(1); + }// 8clk up + L0_I2C_SCL(0); + return IIC_RX_Data; +} +/// ȡ n p +void L1_I2C_ReadNByte(unsigned char Sal, unsigned char *p,unsigned char n) +{ + unsigned char i; + L0_I2C_Start(); // I2C + L0_I2C_SendData((Sal)| 0x01); //ַ + for(i = 0;i0)///iicЧ ûн + { + L0_uart0_uc(gRccUs05);gRccUs05 = 0; + } + ***************/ +} + +//ȡregַn sla.(reg) sla.(reg+1)................ sla.(reg+n) +void L2_I2C_ReadReg(unsigned char sla,unsigned char reg, + unsigned char *r,unsigned char n) +{ +// U8 d[1]; +//S ADD W A REG A + L1_I2C_WriteReg(sla,reg); +//S ADD R A D1 A D2 A.....DX N P + L1_I2C_ReadNByte(sla,r,n); +} + +#if 0////ɾ +///S 80H A Register Address A S 81H A Data NA P +void L2_tws_ReadReg000(unsigned char sla,unsigned char reg, + unsigned char *v) +{ + unsigned char ack=8; + unsigned char BitCnt=8;//һֽ8λ + // U8 d[1]; + //S ADD W A REG A + //// L1_I2C_WriteReg(sla,reg); +//step 1---- + L0_I2C_Start(); //I2C +//step 2----L0_I2C_SendData(sla);//ַ + //SDA Ϊ + for(BitCnt = 0;BitCnt < 8;BitCnt ++) //Ҫ͵ݳΪ8λ + { + if((sla << BitCnt ) & 0x80) + L0_I2C_SDA(1); //жϷλ + else + L0_I2C_SDA(0); + L0_I2C_SCL(1); //ʱΪߣ֪ͨʼλ + L0_I2C_SCL(0); + }//8clk + L0_I2C_SDA(1); //8λͷߣ׼Ӧλ + L0_I2C_SCL(1); + L0_I2C_SCL(0); + +//step 3---L0_I2C_SendData(reg); + for(BitCnt = 0;BitCnt < 8;BitCnt ++) //Ҫ͵ݳΪ8λ + { + if((reg << BitCnt ) & 0x80) + L0_I2C_SDA(1); //жϷλ + else + L0_I2C_SDA(0); + L0_I2C_SCL(1); //ʱΪߣ֪ͨʼλ + L0_I2C_SCL(0); + }//8clk + L0_I2C_SDA(1); //8λͷߣ׼Ӧλ + L0_I2C_SCL(1); + L0_I2C_SCL(0); + +//step 4---- + L0_I2C_Start(); //I2C + +//step 5--- + //SDA Ϊ + sla|=0x01; + for(BitCnt = 0;BitCnt < 8;BitCnt ++) //Ҫ͵ݳΪ8λ + { + if((sla << BitCnt ) & 0x80) + L0_I2C_SDA(1); //жϷλ + else + L0_I2C_SDA(0); + L0_I2C_SCL(1); //ʱΪߣ֪ͨʼλ + L0_I2C_SCL(0); + }//8clk + L0_I2C_SDA(1); //8λͷߣ׼Ӧλ + L0_I2C_SCL(1); + L0_I2C_SCL(0); +//step 6---receive data + //SDA Ϊ +*v = L0_I2C_ReceiveData(); + L0_I2C_SCL(1); + L0_I2C_SCL(0);/// send NA +//step 7--- P + + L0_I2C_Stop(); + + + + +} + +///S 80H A Register Address A S 81H A Data NA P + + + +#endif + + + diff --git a/source/msp/iic_sim.h b/source/msp/iic_sim.h new file mode 100644 index 0000000..b6a89e8 --- /dev/null +++ b/source/msp/iic_sim.h @@ -0,0 +1,64 @@ +////////////////////////////////////////////////////////////////////////// +/// COPYRIGHT NOTICE +/// Copyright (c) 2018, ؿƼ +/// All rights reserved. +/// +/// @file iic_sim +/// @brief iic ģio 汾 cpu޹أΨһҪ޸ĵľͷеĹܽŶ +/// @info io ,طޱҪ޸ +///ļʵֵĹܵ +/// +/// @version 1.1 CCsens technology +/// @author CC +/// @date 20180102 + +// +////////////////////////////////////////////////////////////////////////// + +#ifndef _IIC_SIM_H_ +#define _IIC_SIM_H_ + +#include "../clib/type.h" +#include "../clib/clib.h" +#include "../ctask/tick.h" + + +///>>>˿λ壬޸!!!!!!>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> + +#include "../bsp/bsp_config.h" + + + +#if 0 +//// for stc 11.0M +#define delay10us() NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();///Lc_delay_us(1) //cpuʽӦĵ +#define L0_I2C_delay(x) NOP();NOP();///Lc_delay_us(x) +#else +///#define delay10us() NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();///Lc_delay_us(1) //cpuʽӦĵ +///#define L0_I2C_delay(x) NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();///Lc_delay_us(x) + +//#define delay10us() Lc_delay_us(3000) //cpuʽӦĵ +//#define L0_I2C_delay(x) Lc_delay_us(10000) +///#define delay10us() Lc_delay_us(80) //20us +///#define L0_I2C_delay(x) Lc_delay_us(300) //25us + +#define L0_slc_1_delay() Lc_delay_nop(4); +#define L0_slc_0_delay() Lc_delay_nop(1); // 4us + +#define L0_I2C_delay(x) ///Lc_delay_us(80) + +#endif + +//<<<<˿λ壬޸!!!!!!<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< + + +extern void L2_I2C_ReadReg(unsigned char sla,unsigned char reg,unsigned char *r,unsigned char n); +extern void L2_I2C_WriteCmd(unsigned char sla,unsigned char reg,unsigned char cmd); +extern void L0_I2C_INIT(unsigned char v); +////extern void L2_tws_ReadReg(unsigned char sla,unsigned char reg, +//// unsigned char *v); +#define L2_tws_ReadReg(x,y,z) L2_I2C_ReadReg((x),(y),(z),1) + + +#endif// #ifndef _IIC_H_ + diff --git a/source/msp/mcu support/.keep b/source/msp/mcu support/.keep new file mode 100644 index 0000000..e69de29 diff --git a/source/msp/time.c b/source/msp/time.c new file mode 100644 index 0000000..aa9b262 --- /dev/null +++ b/source/msp/time.c @@ -0,0 +1,160 @@ +#include "time.h" +#define D_TIMER_COUNT(t,clk,timeInUs) (U16)(65536 - 1.0 * (clk) / 1000 * (1.0 * timeInUs / 1000) / t) +//#define D_TIMER_COUNT(t,clk,timeInUs) (U16)(65536 - (clk) / 1000 * timeInUs / 1000 / t) + +/*************初始化定时器0由 stc-isp v6.86L定时器计算器生成******************/ +void L0_timer0_Init(void) +{ + U16 val = D_TIMER_COUNT(12,D_sys_MainFre,D_sys_Jiffies * 1000); + AUXR &= 0x7F; //定时器时钟12T模式 + TMOD &= 0xF0; //设置定时器模式 + //TL0 = 0x00; //设置定时初值 + //TH0 = 0x4C; //设置定时初值 + TL0 = val; //设置定时初值 + TH0 = val >> 8; //设置定时初值 + TF0 = 0; //清除TF0标志 + TR0 = 1; //定时器0开始计时 + ET0 = 1; //add by cc +} + + +//10---87 10s +/********************** Timer0中断函数************************/ +/// 和 L0_timer0_Init 关联,需要配置 bsp_config.h中的 D_sys_MainFre +/// 默认10ms 作为TTSS系统的定时引擎 +void timer0_isrHandle (void) D_SERVE_TIMER0 +{// + NOP(); NOP(); NOP(); + TF0 = 0; +#if 0 + /// 65535*65535 /3600/24/365=139nian/s=1.39nian/10ms + ///相当于1.39年后t_10ms 溢出，对于电池供电的系统而言 完全可以满足 + // 4,294,836,225 = 65535*65535 ;3600*24*60*60 = 31,536,000秒/年 + s_nos_tick.t_10ms ++;//D_led_D1_REV(); 20160522 验证 + +#else + + L1_tick_tick(); ///系统中的1sflag 和以10ms为颗粒的延时使用 为tdelay服务 + +#endif + /// BITN_1(DR_who_wakeup, DRB_who_wakeup_timer0); + NOP(); NOP(); NOP(); +} + + + +void L0_timer1_Init() //600微秒@11.0592MHz +{ +#if 0 + AUXR |= 0x40; //定时器时钟1T模式 + TMOD &= 0x0F; //设置定时器模式 + TL1 = 0x14; //设置定时初值 + TH1 = 0xE6; //设置定时初值 + TF1 = 0; //清除TF1标志 + TR1 = 1; //定时器1开始计时 + ET1 = 1; //add by cc + +#else + U16 val = D_TIMER_COUNT(1,D_sys_MainFre,600); + AUXR |= 0x40; //定时器时钟1T模式 + TMOD &= 0x0F; //设置定时器模式 + //TL1 = 0xCD; //设置定时初始值 + //TH1 = 0xD4; //设置定时初始值 + TL1 = val; //设置定时初值 + TH1 = val >>8; //设置定时初值 + TF1 = 0; //清除TF1标志 + TR1 = 1; //定时器1开始计时 + ET1 = 1; //add by cc +#endif +} + +//#define D_modbus_ot 6000 + +//#define D_modbus_ot 600 + +void L0_timer1_restart() //600微秒 +{ + U16 val = D_TIMER_COUNT(1,D_sys_MainFre,600); + TR1 = 0; //先关闭，否则会重复中断，起不到resetart效果 +#if 1 + AUXR |= 0x40; //定时器时钟1T模式 + TMOD &= 0x0F; //设置定时器模式 + //TL1 = 0x14; //设置定时初值 + //TH1 = 0xE6; //设置定时初值 + TL1 = val; //设置定时初值 + TH1 = val >>8; //设置定时初值 + TF1 = 0; //清除TF1标志 + TR1 = 1; //定时器1开始计时，每隔1ms加1 + ET1 = 1; //add by cc 打开定时器中断 + +#else + AUXR |= 0x40; //定时器时钟1T模式 + TMOD &= 0x0F; //设置定时器模式 + TL1 = 0xCD; //设置定时初始值 + TH1 = 0xD4; //设置定时初始值 + TF1 = 0; //清除TF1标志 + TR1 = 1; //定时器1开始计时 + ET1 = 1; //add by cc +#endif +// TR1 = 0; +// AUXR &= 0xBF; //定时器时钟12T模式 //5ms +// TMOD &= 0x0F; //设置定时器模式 +// TL1 = 0x00; //设置定时初始值 +// TH1 = 0xDC; //设置定时初始值 +// TF1 = 0; //清除TF1标志 +// TR1 = 1; //定时器1开始计时 +// ET1 = 1; //add by cc +} + +void L0_timer1_stop(void) +{ + TR1 = 0; + TF1 = 0; +} +void L0_timer3_restart() //600@22MHz +{ +// LED0 ^= 1; +// T4T3M = 0x00; +// T4T3M = 0xDD; //定时器时钟12T模式 +// T3L = 0x00; //设置定时初始值 +// T3H = 0x94; //设置定时初始值 +// AUXINTIF&=~T3IF; +// T4T3M =0x08; //定时器3开始计时 +// IE2=ET3; + T4T3M &= ~(0x08); //定时器3停止 + T4T3M &= 0xFD; //定时器时钟12T模式 + T3L = 0xAE; //设置定时初值 + T3H = 0xFB; //设置定时初值 + T4T3M |= 0x08; //定时器3开始开始 + + IE2 |= ET3; //开启定时器3中断 +} +void L0_timer3_stop(void) +{ + //LED0 ^= 1; +// T4T3M = 0xD1; +// AUXINTIF&=~T3IF; + T4T3M &= ~(0x08); +} +void L0_timer4_start(void) //600微 +{ +// U16 val = D_TIMER_COUNT(12,D_sys_MainFre,1); + T4T3M &= ~(0x80); //定时器4停止 + T4T3M &= 0xDF; //定时器时钟12T模式 + T4L = 0xAE; //设置定时初值 + T4H = 0xFB; //设置定时初值 +// T4L = val; //设置定时初值 +// T4H = val >> 8; //设置定时初值 + T4T3M |= 0x80; //定时器4开始计时 + IE2 |= ET4; //开启定时器4中断 +} + +void L0_timer4_stop(void) //1ms +{ + T4T3M &= ~(0x80); //定时器4停止 +} +/******************************END*********************************/ + + + + diff --git a/source/msp/time.h b/source/msp/time.h new file mode 100644 index 0000000..f4757fd --- /dev/null +++ b/source/msp/time.h @@ -0,0 +1,61 @@ +#ifndef INIT_TIMER0_H +#define INIT_TIMER0_H + +#include "../clib/type.h" + +#include "../bsp/bsp_config.h" +#include "../ctask/tick.h" +extern void L0_timer4_stop(void); +extern void L0_timer4_start(void); //600微秒@11.0592MHz +extern void L0_timer3_stop(void); +extern void L0_timer3_restart(void); //600微秒@11.0592MHz +extern void L0_timer3_Init(void); +extern void L0_timer1_stop(void); +extern void L0_timer1_start(); +extern void L0_timer1_restart(void); //600微秒@11.0592MHz +extern void L0_timer1_Init(void); +extern void L0_timer1_reset(void); +extern void L0_timer1_off(void); +extern void L0_timer1_on(void); +extern void L0_Timer1Init(void); +extern void L0_timer0_Init(void); +extern void L0_timer0_Init_32k(void) ; +#define L0_timer0_open(x) TR0 = x // + +// 他和t_10ms 关联,如果t_10ms递增为1时间隔为(D_TIMER0_10MS_COUNT*定时器间隔) +//#define D_TIMER0_10MS_COUNT 1 //定时器为 10ms一中断 + +#define D_TIMER0_10MS_COUNT 1 //定时器为 10ms一中断 + +/**************** + +#if(MainFre_5M == D_sys_MainFre) + +#define D_Cdelay_200us 20 +#define D_Cdelay_1us 1 ////while p21翻转时测定 500k 2us 一个指令 +#elif(MainFre_22M == D_sys_MainFre) + +#define L0_delay_1us() Lc_delay_nop(2) // 5个nop() 100ns 50个nop() 1us (20)=10us (2)1.5us +#define L0_delay_10us() Lc_delay_nop(20) // 5个nop() 100ns 50个nop() 1us (20)=10us (2)1.5us + +#define D_Cdelay_1ms 500 +#define D_Cdelay_15ms 1200 + + +#define D_Cdelay_200us 20 +#define D_Cdelay_1us 1 + +#elif(MainFre_11M == D_sys_MainFre) +等待 +#define L0_delay_1us() NOP();NOP(); // 11.05926M + + +#endif +**********/ + + + +#endif + + + diff --git a/source/msp/uart_x.c b/source/msp/uart_x.c new file mode 100644 index 0000000..bdda560 --- /dev/null +++ b/source/msp/uart_x.c @@ -0,0 +1,211 @@ +////////////////////////////////////////////////////////////////////////// +/// COPYRIGHT NOTICE +/// Copyright (c) 2015, 传控科技 +/// All rights reserved. +/// +/// @file main.c +/// @brief main app +/// +///（本文件实现的功能的详述） +/// +/// @version 1.1 CCsens technology +/// @author CC +/// @date 20150102 +/// +/// +/// 修订说明：最初版本 +/// Modified by: +/// Modified date: +/// Version: +/// Descriptions: +// 20160413 CC-ACC-VH02 +// 连接至 J22 RXD0 TXD0 +//P5_DIR &= ~BITN1; //p5.1输出TXD +//P5_DIR |= BITN0; //p5.0输入RXD +//P5_SEL0 &= ~(BITN0 +BITN1); //设置P5.0 P5.1为UART0 RXD TXD +//P5_SEL1 |= BITN0 +BITN1; + +/***************************************************************************** +update by cc @201700110 +针对多串口 和 单一串口 有区别 每个串口是独立的还是分开的有讲究 程序是复杂的还是软件应用简单是 +个需要平衡的事情. + +clib/clib.c: +公用的函数 和硬件无关 +放置串行模式(串口等其他通讯总线类的输出)输出的函数, +一些覆盖模式输出的(lcd等固屏输出的)的也可使用 + void Lc_print(void (*L0pf_send_uc)(char ww), char *dat,...) +----------------------------------------------------------------------------------------- +uartcom/Uprotocol2app + 协议到应用 + 为了适应不同的通讯协议需要不同的uart口来对应 和应用相关 + +typedef struct _ts_lcm_pro_; 应用协议包的定义? LCM的协议------------ + L3_UARTcom0_exp_protocol 解析应用协议 +----------------------------------------------------------------------------------------- +uartcom/urec2protocol: 接收到的数据放入到指向特定协议的缓存中，和协议的格式有关 一般分为 标头式或者标尾式 +公用的串口通讯定义 + struct _s_uart_rec_ 的公共协议包(关键的结构体)的声明------struct _s_uart_rec_ + void L1_uart_2buf(struct _s_uart_rec_ *p)串行数据保存到指向特定协议的缓冲中 +-------------------------------------------------------------------------------------------- +msp/uartx.c 底层代码 和cpu相关 缓存发送也放在里面 + L0_UART0_Init + UART0_IRQHandler + L0_Usend_uc------UserDef +----------------------------------------------------------------------------------------- +********************************************************************************/ +#include "uart_x.h" + +TS_uart_reg idata ts_uart[SERIAL_MAX_NUM] = {0}; + +void L0_uartN_set(U8 uartx,U8 x) +{ + switch(uartx) + { + case 0:SBUF = (x);break; + case 1:S2BUF = (x);break; + case 2:S3BUF = (x);break; + case 3:S4BUF = (x);break; + default:break; + } +} + +U8 L0_uartN_get(U8 uartx) +{ + U8 x = 0; + switch(uartx) + { + case 0:x = SBUF; break; + case 1:x = S2BUF;break; + case 2:x = S3BUF;break; + case 3:x = S4BUF;break; + default:break; + } + return x; +} + +void L0_waitFree_uartN(U8 uartx) +{ + ts_uart[uartx].p->over = 0; + while(ts_uart[uartx].p->ok != D_ready) + { + #if 0 //发送数据特别快时，某些情况下会导致数据发送出错 + if(ts_uart[uartx].p->over ++ > 600000) + { + break; + } + #endif + } +} + +void L0_uartN_sendArray(U8 uartx,void *buf,U16 len) +{ + L0_waitFree_uartN(uartx); + ts_uart[uartx].p->ok = D_clear; + ts_uart[uartx].p->over = 0; + ts_uart[uartx].p->max = len; + ts_uart[uartx].p->now = 1; + if(len <= D_UART_send_buf_max) + { + //将参数buf拷贝至内部buf + for(ts_uart[uartx].p->num = 0;ts_uart[uartx].p->num < len;ts_uart[uartx].p->num ++) + { + ts_uart[uartx].p->buf[ts_uart[uartx].p->num] = ((U8*)buf)[ts_uart[uartx].p->num]; + } + ts_uart[uartx].p->p = ts_uart[uartx].p->buf; + } + else + { + //不使用内部buf,如果再发送完毕之前,参数buf被回收,发送会出错 + ts_uart[uartx].p->p = (U8 *)buf; + } + L0_uartN_set(uartx,ts_uart[uartx].p->p[0]); +} + +void L0_uartN_uc(U8 uartx,U8 ww) +{ + L0_uartN_sendArray(uartx,&ww,1); +} + +void L0_uartN_us(U8 uartx,vU16 ww) +{ + U_U16 uStemp; + uStemp.word = ww; + ts_uart[uartx].p->buf3[0] = uStemp.BYTE2.h; + ts_uart[uartx].p->buf3[1] = uStemp.BYTE2.l; + L0_uartN_sendArray(uartx,ts_uart[uartx].p->buf3,2); +} + +void L0_uartN_ul(U8 uartx,vU32 ww) +{ + U_U32 uStemp; + L0_waitFree_uartN(uartx); + uStemp.dWord = ww; + ts_uart[uartx].p->buf3[0] = uStemp.BYTE4.byte0; + ts_uart[uartx].p->buf3[1] = uStemp.BYTE4.byte1; + ts_uart[uartx].p->buf3[2] = uStemp.BYTE4.byte2; + ts_uart[uartx].p->buf3[3] = uStemp.BYTE4.byte3; + L0_uartN_sendArray(uartx,ts_uart[uartx].p->buf3,4); +} + +void L0_uartN_0d0a(U8 uartx) +{ + L0_waitFree_uartN(uartx); + ts_uart[uartx].p->buf3[0] = 0x0d; + ts_uart[uartx].p->buf3[1] = 0x0a; + L0_uartN_sendArray(uartx,ts_uart[uartx].p->buf3,2); +} + +void L0_uartN_uchex(U8 uartx,U8 ww) +{ + L0_waitFree_uartN(uartx); + ts_uart[uartx].p->buf3[0] = cguHex2Char[D_uc_high(ww)][1]; + ts_uart[uartx].p->buf3[1] = cguHex2Char[D_uc_low (ww)][1]; + L0_uartN_sendArray(uartx,ts_uart[uartx].p->buf3,2); +} + +void L0_uartN_ushex(U8 uartx,vU16 ww) +{ + U_F16 k; + L0_waitFree_uartN(uartx); + k.us = ww; + ts_uart[uartx].p->buf3[0] = cguHex2Char[D_uc_high(k.BYTE2.H)][1]; + ts_uart[uartx].p->buf3[1] = cguHex2Char[D_uc_low (k.BYTE2.H)][1]; + ts_uart[uartx].p->buf3[2] = cguHex2Char[D_uc_high(k.BYTE2.L)][1]; + ts_uart[uartx].p->buf3[3] = cguHex2Char[D_uc_low (k.BYTE2.L)][1]; + L0_uartN_sendArray(uartx,ts_uart[uartx].p->buf3,4); +} + +void L0_uartN_ulhex(U8 uartx,U32 ww) +{ + U_U32 k; + L0_waitFree_uartN(uartx); + k.dWord = ww; + ts_uart[uartx].p->buf3[0] = cguHex2Char[D_uc_high(k.BYTE4.byte0)][1]; + ts_uart[uartx].p->buf3[1] = cguHex2Char[D_uc_low (k.BYTE4.byte0)][1]; + ts_uart[uartx].p->buf3[2] = cguHex2Char[D_uc_high(k.BYTE4.byte1)][1]; + ts_uart[uartx].p->buf3[3] = cguHex2Char[D_uc_low (k.BYTE4.byte1)][1]; + ts_uart[uartx].p->buf3[4] = cguHex2Char[D_uc_high(k.BYTE4.byte2)][1]; + ts_uart[uartx].p->buf3[5] = cguHex2Char[D_uc_low (k.BYTE4.byte2)][1]; + ts_uart[uartx].p->buf3[6] = cguHex2Char[D_uc_high(k.BYTE4.byte3)][1]; + ts_uart[uartx].p->buf3[7] = cguHex2Char[D_uc_low (k.BYTE4.byte3)][1]; + L0_uartN_sendArray(uartx,ts_uart[uartx].p->buf3,8); +} + +void L0_uartN_sendstr(U8 uartx,U8 *str) +{ + L0_uartN_sendArray(uartx,str,Lc_strlen(str)); +} + +void L0_uartN_uchexArray(U8 uartx,vU8 *buf,U16 n) +{ + int i; + for(i=0;i>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> +//L1_uart_2strbuf(&s_uart0_rec);s_uart0_rec.ok = 2 +/// 接收以od oa为结束的标准的assci码的协议 类似 send xx (回车换行)测试时注意以回车换行 +/// 为结束标志，也就是发送的数据后面 必须有回车换行 :0x0d 0x0a + + +//对于连续的多条协议，比如：abcdefg\r\n12345\r\n，如果前一条处理不及时，可能会被后一条覆盖 +void L1_s2b_0d0a(struct _tp_handler_x *p) //reentrant +{ + if(p->head == 0) + { + p->head = 1; + p->num = 0; + } + + if(p->num >= D_tp_handle_x_len) + { + p->num = 0; + } + p->cashe[1] = p->cashe[0]; + p->cashe[0] = p->reg;// + + p->buf[++p->num] = p->cashe[0]; + //p->buf[++p->num] = p->cashe[0]; + + if ((p->num > 2) && (p->cashe[0] == 0x0a) && (p->cashe[1] == 0x0d))// 0d0a + { + if(1 != p->ok) + { + p->buf[0] = p->num - 2; //去掉0d0a + if(p->sp2 != NULL) //备份缓冲区不为null + { + //byte_copy_uc(p->buf + 1,p->__buf,p->num-2); //经过调试,此处不要调用外部函数，入栈出栈会增加出错风险 + for(p->i=0;p->ibuf[0]+1;p->i++) + { + p->sp2[p->i] = p->buf[p->i]; + } + } + p->ok = 1;//收到 命令结束,必须有个地方清0，否则无法再次接受报文 + } + p->head = 0; + } +} + diff --git a/source/tpc/0d0a.h b/source/tpc/0d0a.h new file mode 100644 index 0000000..ddf5a39 --- /dev/null +++ b/source/tpc/0d0a.h @@ -0,0 +1,33 @@ +#ifndef TPC_0D0A_H +#define TPC_0D0A_H + +#include "tpc_x.h" + +///----------------------------------------------------------------------------------------- +//#define D_s_SSTR_0D0A_len 64 //str类的协议需要长度大一些，容易bug的地方，限制为接收64bytes的数据 +#if 0 +#define FLAG_NONE 0 +#define FLAG_DISCARD 1 +#define FLAG_CCID 2 +#define FLAG_CIP 3 +typedef struct _s_PC1_0D0A_ +{//8byte + vU8 reg; + // vU8 sub_num; //接收到的数目注意数据长度的范围 + vU8 head; //接收标志头标志 + + vU8 cashe[4]; + //vU8 filter1; + //vU8 filter2; + vU8 num; //接收到的数据的计数， 随着数据接收而变化注意数据长度的范围 + + vU8 ok; //接收协议ok标志 + vU8 max; //接收到的数目的最大值 + vU8 __buf[D_s_SSTR_0D0A_len+1];//buffer + vU8 buf[D_s_SSTR_0D0A_len+1];//array的第一位是 长度 //协议缓冲 + // U8 pro[16]; ///解析协议用 +}TS_Handle_0d0a; +#endif +extern void L1_s2b_0d0a(struct _tp_handler_x *p); //reentrant; + +#endif diff --git a/source/tpc/ccmodbus.c b/source/tpc/ccmodbus.c new file mode 100644 index 0000000..e3408a9 --- /dev/null +++ b/source/tpc/ccmodbus.c @@ -0,0 +1,182 @@ + +/***************************************************************************** +update by cc @201501101001 +针对多串口 和 单一串口 有区别 每个串口是独立的还是分开的有讲究 程序是复杂的还是软件应用简单是 +个需要平衡的事情. + +uartcom/uartlib.c: +公用的函数 和硬件无关 +放置串行模式(串口等其他通讯总线类的输出)输出的函数, +一些覆盖模式输出的(lcd等固屏输出的)的也可使用 + void Lc_print(void (*L0pf_send_uc)(char ww), char *dat,...) +----------------------------------------------------------------------------------------- +uartcom/uartcom0 + 和uart相关的通讯协议 com + n + 为了适应不同的通讯协议需要不同的uart口来对应 和应用相关 + +typedef struct _ts_lcm_pro_; 应用协议包的定义? LCM的协议------------ + L3_UARTcom0_exp_protocol 解析应用协议 +----------------------------------------------------------------------------------------- +uartcom/uprotocol: 主要是为 uartcom + n服务的 驱动层到应用层缓存的过度 +公用的串口通讯定义 + struct _s_protocol_ 的公共协议包(关键的结构体)的声明------struct _s_protocol_ + void L1_uart_2buf(struct _s_protocol_ *p)串行数据保存到缓冲中 +-------------------------------------------------------------------------------------------- +msp/uartx.c 底层代码 和cpu相关 + L0_UART0_Init + UART0_IRQHandler + L0_Usend_uc----------s_at0 +----------------------------------------------------------------------------------------- +********************************************************************************/ + +#include "ccmodbus.h" +#include "../clib/clib.h" +vU8 D_CMD_Filter1_ff; +vU8 D_CMD_Filter2_fe; +#if 0 +U8 L3_pack_ccmodbus_03(TS_PH3_ccmodbus *pmodbus ,U8 slaverId, U16 reg, U16 num) +{ + U8 bufsize = 4; + pmodbus->slaver = slaverId; + pmodbus->oper = MODBUS_OPER_READ; + pmodbus->buf[0] = reg >> 8 & 0xFF; + pmodbus->buf[1] = reg >> 0 & 0xFF; + pmodbus->buf[2] = num >> 8 * 0xFF; + pmodbus->buf[3] = num >> 0 & 0xFF; + crc16(pmodbus->crc,&pmodbus->slaver,2 + bufsize); + pmodbus->buf[bufsize] = pmodbus->crc[0]; + pmodbus->buf[bufsize + 1] = pmodbus->crc[1]; + + return bufsize + 2 + 2; +} + +U8 L3_pack_ccmodbus_06(TS_PH3_ccmodbus *pmodbus ,U8 slaverId, U16 reg, U8 *buf) +{ + U8 bufsize = 4; + pmodbus->slaver = slaverId; + pmodbus->oper = MODBUS_OPER_WRITE; + pmodbus->buf[0] = reg >> 8 & 0xFF; + pmodbus->buf[1] = reg >> 0 & 0xFF; + pmodbus->buf[2] = buf[0]; + pmodbus->buf[3] = buf[1]; + crc16(pmodbus->crc,&pmodbus->slaver,2 + bufsize); + pmodbus->buf[bufsize] = pmodbus->crc[0]; + pmodbus->buf[bufsize + 1] = pmodbus->crc[1]; + + return bufsize + 2 + 2; +} + +U8 L3_pack_ccmodbus_10(TS_PH3_ccmodbus *pmodbus ,U8 slaverId, U16 reg, U16 num, U8 bytes, U8 *buf) +{ + U8 bufsize = 5,i = 0; + pmodbus->slaver = slaverId; + pmodbus->oper = MODBUS_OPER_WRITE_M; + pmodbus->buf[0] = reg >> 8 & 0xFF; + pmodbus->buf[1] = reg >> 0 & 0xFF; + pmodbus->buf[2] = num >> 8 * 0xFF; + pmodbus->buf[3] = num >> 0 & 0xFF; + pmodbus->buf[4] = bytes; + + for(i=0;ibuf[5+i] = buf[i]; + } + crc16(pmodbus->crc,&pmodbus->slaver,2 + bufsize + bytes); + pmodbus->buf[bufsize + bytes] = pmodbus->crc[0]; + pmodbus->buf[bufsize + bytes + 1] = pmodbus->crc[1]; + + return bufsize + bytes + 2 + 2; +} +#endif + +U8 L3_pack_ccmodbus(TS_PH3_ccmodbus *pccmodbus, MD_SLAVER_INFO *slaver_info) +{ + pccmodbus->filter1 = D_CMD_Filter1_ff; + pccmodbus->filter2 = D_CMD_Filter2_fe; + pccmodbus->num = L3_pack_modbus((TS_PH4_modbus*)&pccmodbus->slaver, slaver_info); +#if 0 + switch(slaver_info->oper) + { + case MODBUS_OPER_READ: + pkglen = L3_pack_ccmodbus_03(pccmodbus,slaver_info->slaver,slaver_info->reg,slaver_info->regnum); + break; + case MODBUS_OPER_WRITE: + pkglen = L3_pack_ccmodbus_06(pccmodbus,slaver_info->slaver,slaver_info->reg,slaver_info->buf); + break; + case MODBUS_OPER_WRITE_M: + pkglen = L3_pack_ccmodbus_10(pccmodbus,slaver_info->slaver,slaver_info->reg,slaver_info->regnum,slaver_info->bytes,slaver_info->buf); + break; + default: + break; + } + pccmodbus->num = pkglen; +#endif + return pccmodbus->num + 3; +} + +U16 L3_ccmodbus_slaver_ack(TS_PH3_ccmodbus *pccmodbus,TS_PH3_ccmodbus *pModbusAck) +{ + U16 pkglen = L3_modbus_slaver_ack((TS_PH4_modbus*)&pccmodbus->slaver, (TS_PH4_modbus*)&pModbusAck->slaver); + pModbusAck->filter1 = D_CMD_Filter1_ff; + pModbusAck->filter2 = D_CMD_Filter2_fe; + pModbusAck->num = pkglen; + return pkglen + 3; +} + +void L3_ccmodbus_master_handler(TS_PH3_ccmodbus *pmodbus,MD_SLAVER_INFO *p_slaver_info) +{ + L3_modbus_master_handler((TS_PH4_modbus*)pmodbus->slaver,p_slaver_info); +} + +///FF FE 08 52 16 11 22 33 44 F5 9F 发送了一个modbus协议包(8个数据52 16 11 22 33 44 F5 9F ) +/// 0 1 2 3 4 5 6 7 8 9 10 +/// 协议表达的意思为地址为0x52的从机, 功能码16 数据为11 22 33 44,校验码 F5 9F +void L1_s2b_PH3(struct _tp_handler_x *p)// reentrant +{ + p->cashe[1] = p->cashe[0]; + p->cashe[0] = p->reg;// + + if (0 == p->head) + { + if ((p->cashe[1] == p->head_0)&&(p->cashe[0] == p->head_1)) + { + p->head = 1; + p->max = D_TPC_HANDLER_X_LEN ; + p->sp = p->buf; + p->num = 0; + p->sp[p->num++] = p->head_0; + p->sp[p->num++] = p->head_1; + } + } + else + { + p->sp[p->num++] = p->cashe[0]; + if(p->num == 3)//数量 第3个数据 + { + p->max = p->cashe[0] + 3; + if((p->max > D_TPC_HANDLER_X_LEN ) || (p->max < D_s_ccmodbus_min)) + { + p->head = 0; + return; //error 超过最大长度 + } + } + if(p->num >= p->max) + { + crc16(p->crc,p->buf + 3,p->num - 3 - 2); + if(p->crc[0] == p->buf[p->num-2] && p->crc[1] == p->buf[p->num-1]) + { + if (p->ok != 1) + { + p->ok = 1;//收到 命令结束,必须有个地方清0，否则无法再次接受报文 + } + } + p->head = 0; //放在if (p->ok != 1) 外 + } + } +} + + + +/****************************************************************************** +** End Of File +******************************************************************************/ diff --git a/source/tpc/ccmodbus.h b/source/tpc/ccmodbus.h new file mode 100644 index 0000000..234355f --- /dev/null +++ b/source/tpc/ccmodbus.h @@ -0,0 +1,98 @@ +////////////////////////////////////////////////////////////////////////// +/// COPYRIGHT NOTICE +/// Copyright (c) 2018, 传控科技 +/// All rights reserved. +/// +/// @file tpc_fsk.c +/// @brief transaction protocol control of fsk +/// +///（本文件实现的功能的详述） +/// +/// @version 1.1 CCsens technology +/// @author CC +/// @date 20150102 +/// +/// +/// @version 1.2 CCsens technology +/// @author CC +/// @date 20180308 +/// @info 整理 + +// +////////////////////////////////////////////////////////////////////////// + + +/***************************************************************************** +@version 1.2 +update by cc @201501101001 +针对多串口 和 单一串口 有区别 每个串口是独立的还是分开的有讲究 程序是复杂的还是软件应用简单是 +个需要平衡的事情. + +clib/uartlib.c: +公用的函数 和硬件无关 +接收各类协议的处理函数 +放置串行模式(串口等其他通讯总线类的输出)输出的函数, +一些覆盖模式输出的(lcd等固屏输出的)的也可使用 + void Lc_print(void (*L0pf_send_uc)(char ww), char *dat,...) +----------------------------------------------------------------------------------------- + + +----------------------------------------------------------------------------------------- + + +-------------------------------------------------------------------------------------------- +msp/uartx.c 底层代码 和cpu相关 + L0_UART0_Init + UART0_IRQHandler + L0_Usend_uc----------s_at0 +----------------------------------------------------------------------------------------- +********************************************************************************/ + + + +#ifndef __TPC_CCMODBUS_H_ +#define __TPC_CCMODBUS_H_ + +#include "tpc_x.h" +#include "modbus.h" +//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< +///协议类型: 十六进制协议3->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> +/// 发送的数据为有ff fe开头的十六进制的长协议，内包含标准的modbus协议 +///FF FE 08 52 16 11 22 33 44 F5 9F 发送了一个modbus协议包(8个数据52 16 11 22 33 44 F5 9F ) +/// 协议表达的意思为地址为0x52的从机, 功能码16 数据为11 22 33 44,校验码 F5 9F +/// 校验码的范围为 + +#define D_s_PH3_ccmodbus_max 128 +#define D_s_ccmodbus_min (D_s_modbus_min + 3) +extern vU8 D_CMD_Filter1_ff; +extern vU8 D_CMD_Filter2_fe; +typedef struct +{//8byte + vU8 filter1; + vU8 filter2; + vU8 num; //接收到的数据的计数， 随着数据接收而变化注意数据长度的范围 + vU8 slaver; //发送方的地址或命令 + vU8 oper; //命令 + vU8 buf[D_s_PH3_ccmodbus_max - 3];//D_s_PH3_ccmodbus_max - 3，长一点防止越界 + vU8 crc[2]; //crc16 +}TS_PH3_ccmodbus; + +#if 0 +typedef struct +{ + U16 slaver; + U16 oper; + U16 reg; + U16 regnum; + U16 bytes; + U8 *buf; + U16 mask; +}CCMD_SLAVER_INFO; +#endif + +extern U8 L3_pack_ccmodbus(TS_PH3_ccmodbus *pccmodbus, MD_SLAVER_INFO *slaver_info); +extern U16 L3_ccmodbus_slaver_ack(TS_PH3_ccmodbus *pccmodbus,TS_PH3_ccmodbus *pModbusAck); +extern void L3_ccmodbus_master_handler(TS_PH3_ccmodbus *pmodbus,MD_SLAVER_INFO *p_slaver_info); +extern void L1_s2b_PH3(struct _tp_handler_x *p);// reentrant; + +#endif /* end __TPC_CCMODBUS_H_ */ \ No newline at end of file diff --git a/source/tpc/debug.c b/source/tpc/debug.c new file mode 100644 index 0000000..59a0e4a --- /dev/null +++ b/source/tpc/debug.c @@ -0,0 +1,88 @@ + +/***************************************************************************** +update by cc @201501101001 +针对多串口 和 单一串口 有区别 每个串口是独立的还是分开的有讲究 程序是复杂的还是软件应用简单是 +个需要平衡的事情. + +uartcom/uartlib.c: +公用的函数 和硬件无关 +放置串行模式(串口等其他通讯总线类的输出)输出的函数, +一些覆盖模式输出的(lcd等固屏输出的)的也可使用 + void Lc_print(void (*L0pf_send_uc)(char ww), char *dat,...) +----------------------------------------------------------------------------------------- +uartcom/uartcom0 + 和uart相关的通讯协议 com + n + 为了适应不同的通讯协议需要不同的uart口来对应 和应用相关 + +typedef struct _ts_lcm_pro_; 应用协议包的定义? LCM的协议------------ + L3_UARTcom0_exp_protocol 解析应用协议 +----------------------------------------------------------------------------------------- +uartcom/uprotocol: 主要是为 uartcom + n服务的 驱动层到应用层缓存的过度 +公用的串口通讯定义 + struct _s_protocol_ 的公共协议包(关键的结构体)的声明------struct _s_protocol_ + void L1_uart_2buf(struct _s_protocol_ *p)串行数据保存到缓冲中 +-------------------------------------------------------------------------------------------- +msp/uartx.c 底层代码 和cpu相关 + L0_UART0_Init + UART0_IRQHandler + L0_Usend_uc----------s_at0 +----------------------------------------------------------------------------------------- +********************************************************************************/ + +#include "debug.h" +#include "../clib/clib.h" + +//NUM: 0 1 2 3 4 +// Fx R1 R2 R3 ocr +// F+从机 R1 R2 R3 校验 +//相关功能移动到tpc_fx.c +/// 实践中发现 如果收到多个以0d0a结束的短协议时,如果 +/// 协议之间间隔时间太短,ok处理不及时 会出现丢失协议的 +/// 的情况,所以 对于短暂的多个协议 应该有一定容量的缓冲 +/// 保留 ,同时 处理完协议后,应该清除接收缓冲,否则缓冲 +/// 会在自身满了后自动清除 +//_s_HRTU_P_rf_ +/// _s_HRTU_Pfx_ +/// fx 11 22 33 oc -- oc = 11+ 22+33 +//buf 0 1 2 3 [4] +//fd 01 02 03 06 fd为头 010203为数据 06为数据校验和(01+02+03) + +//对于连续的多条协议，如果前一条处理不及时，可能会被后一条覆盖 +void L1_s2b_PH1 (struct _tp_handler_x *p) //reentrant +{ + if (0 == p->head) + { + if (D_HETU_FX_fi == (p->reg & p->head_0)) + { + p->head = 1; + p->num = 1; + p->buf[0] = p->reg; + //p->ok = 1; + } + } + else + { + p->buf[p->num++] = p->reg; + if(p->num >= D_HETU_FX_buf_max) // [D_HETU_FX_buf_max == 5] + { + p->ocr = p->buf[1]; + p->ocr += p->buf[2]; + p->ocr += p->buf[3]; + if(p->ocr == p->buf[D_HETU_FX_buf_max-1]) + { + if (p->ok != 1) + { + p->ok = 1;//收到 命令结束,必须有个地方清0，否则无法再次接受报文 + } + } + p->head = 0; //放在if (p->ok != 1) 外 + } + } +} + + + +/****************************************************************************** +** End Of File +******************************************************************************/ + diff --git a/source/tpc/debug.h b/source/tpc/debug.h new file mode 100644 index 0000000..88d7231 --- /dev/null +++ b/source/tpc/debug.h @@ -0,0 +1,51 @@ +////////////////////////////////////////////////////////////////////////// +/// COPYRIGHT NOTICE +/// Copyright (c) 2018, 传控科技 +/// All rights reserved. +/// +/// @file tpc_fsk.c +/// @brief transaction protocol control of fsk +/// +///（本文件实现的功能的详述） +/// +/// @version 1.1 CCsens technology +/// @author CC +/// @date 20150102 +/// +/// +/// @version 1.2 CCsens technology +/// @author CC +/// @date 20180308 +/// @info 整理 + +// +////////////////////////////////////////////////////////////////////////// + + +#ifndef __TPC_DEBUG_H_ +#define __TPC_DEBUG_H_ + +#include "tpc_x.h" +//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< +//定长协议：长度固定为5个字节 +//eg: F1 01 02 03 06 +typedef struct +{//8byte + vU8 filter; + vU8 R1; + vU8 R2; + vU8 R3; + vU8 ocr; +}TS_P_debug; + +#define D_HETU_FX_buf_max 5 //定长协议 长度为5 + +extern void L1_s2b_PH1 (struct _tp_handler_x *p);// reentrant; + +#endif /* end __TPC_DEBUG_H_ */ +/***************************************************************************** +** End Of File +******************************************************************************/ + + + diff --git a/source/tpc/modbus.c b/source/tpc/modbus.c new file mode 100644 index 0000000..f858244 --- /dev/null +++ b/source/tpc/modbus.c @@ -0,0 +1,62 @@ + +/***************************************************************************** +update by cc @201501101001 +针对多串口 和 单一串口 有区别 每个串口是独立的还是分开的有讲究 程序是复杂的还是软件应用简单是 +个需要平衡的事情.d + +uartcom/uartlib.c: +公用的函数 和硬件无关 +放置串行模式(串口等其他通讯总线类的输出)输出的函数, +一些覆盖模式输出的(lcd等固屏输出的)的也可使用 + void Lc_print(void (*L0pf_send_uc)(char ww), char *dat,...) +----------------------------------------------------------------------------------------- +uartcom/uartcom0 + 和uart相关的通讯协议 com + n + 为了适应不同的通讯协议需要不同的uart口来对应 和应用相关 + +typedef struct _ts_lcm_pro_; 应用协议包的定义? LCM的协议------------ + L3_UARTcom0_exp_protocol 解析应用协议 +----------------------------------------------------------------------------------------- +uartcom/uprotocol: 主要是为 uartcom + n服务的 驱动层到应用层缓存的过度 +公用的串口通讯定义 + struct _s_protocol_ 的公共协议包(关键的结构体)的声明------struct _s_protocol_ + void L1_uart_2buf(struct _s_protocol_ *p)串行数据保存到缓冲中 +-------------------------------------------------------------------------------------------- +msp/uartx.c 底层代码 和cpu相关 + L0_UART0_Init + UART0_IRQHandler + L0_Usend_uc----------s_at0 +----------------------------------------------------------------------------------------- +********************************************************************************/ + +#include "modbus.h" +#include "../bsp/bsp_config.h" +#include "../ctask/tick.h" +#include "../clib/clib.h" + +//MODBUS协议解析函数 +//超出D_tp_handle_x_len，不继续保存数据 +void L1_s2b_PH4(struct _tp_handler_x *p) +{ + //p->modbusstmp = D_sys_now; + if(p->head == 0) + { + p->head = 1; + p->max = D_TPC_HANDLER_X_LEN; + p->sp = p->buf; + p->num = 0; + p->sp[p->num++] = p->reg; + } + else + { + if(p->num < p->max) + { + p->sp[p->num++] = p->reg; + } + } +} + +/****************************************************************************** +** End Of File +******************************************************************************/ + diff --git a/source/tpc/modbus.h b/source/tpc/modbus.h new file mode 100644 index 0000000..47222cf --- /dev/null +++ b/source/tpc/modbus.h @@ -0,0 +1,115 @@ +////////////////////////////////////////////////////////////////////////// +/// COPYRIGHT NOTICE +/// Copyright (c) 2018, 传控科技 +/// All rights reserved. +/// +/// @file tpc_fsk.c +/// @brief transaction protocol control of fsk +/// +///（本文件实现的功能的详述） +/// +/// @version 1.1 CCsens technology +/// @author CC +/// @date 20150102 +/// +/// +/// @version 1.2 CCsens technology +/// @author CC +/// @date 20180308 +/// @info 整理 + +// +////////////////////////////////////////////////////////////////////////// + + +#ifndef __TPC_MODBUS_H_ +#define __TPC_MODBUS_H_ + +#include "tpc_x.h" +//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< + +/** + * 用户协议 + */ +enum MODBUS_OPER +{ + MODBUS_OPER_READ = 0x03, + MODBUS_OPER_READCONFIG = 0x04, + MODBUS_OPER_WRITE = 0x06, + MODBUS_OPER_WRITE_M = 0x10, + MODBUS_OPER_ERR = 0x8F, +}; + +//协议类型: MODBUS RTU模式 +//#define D_s_PH4_modbus_max (128) +//#define D_s_PH4_modbus_max (64) +#define D_s_modbus_min 3 //modbus协议的最小长度 + + +typedef struct ts_ph4_modbus +{ + U8 slaver; //从机地址 + U8 oper; //功能码 + U8 buf[D_TPC_HANDLER_X_LEN + 8]; + U8 crc[2]; +}TS_PH4_modbus; + +typedef struct s_modbus_03_ack +{ + U8 bytes; + U8 buf[D_TPC_HANDLER_X_LEN-1]; +}Modbus03Ack; + +typedef struct s_modbus_06_ack +{ + U16 reg; + U16 val; +}Modbus06Ack; + +typedef struct s_modbus_10_ack +{ + U16 reg; + U16 num; +}Modbus10Ack; + +typedef struct +{ + U16 slaver; + U16 oper; + U16 reg; + U16 regnum; + U16 bytes; + U8 *buf; + U16 mask; +}MD_SLAVER_INFO; + +#if 0 +typedef struct +{ + U8 reg; + U8 slaver; //对于主设备，slaver代表当前轮询的包的id，主设备每次轮询时，总是应该将slaver设置为轮询到的从设备id；对于从设备，slaver总是等于slaverId + U8 max; //接收到的数目的最大值 + vU8 head; //接收标志头标志 + vU8 ok; //接收协议ok标志 + vU8 num; + vU8 *sp; + U8 buf[D_s_PH4_modbus_max + 8]; + vU8 crc[2]; + vU32 modbusstmp; +}TS_Handle_PH4; +#endif +extern U8 L3_pack_modbus(TS_PH4_modbus *pmodbus, MD_SLAVER_INFO *slaver_info); +//extern U8 L3_pack_modbusack(TS_PH4_modbus *pmodbus ,U8 slaver, U8 oper, U8 bufsize); +extern U16 L3_modbus_slaver_ack(TS_PH4_modbus *pmodbus,TS_PH4_modbus *pModbusAck); +extern void L3_modbus_master_handler(TS_PH4_modbus *pmodbus,MD_SLAVER_INFO *p_slaver_info); +extern void L1_s2b_PH4(struct _tp_handler_x *p); +extern void L1_modbus_split(struct _tp_handler_x *p); + + +#endif /* end __TPC_UART_H_ */ +/***************************************************************************** +** End Of File +******************************************************************************/ + + + diff --git a/source/tpc/tpc_x.h b/source/tpc/tpc_x.h new file mode 100644 index 0000000..9440fc6 --- /dev/null +++ b/source/tpc/tpc_x.h @@ -0,0 +1,25 @@ +#ifndef TPC_CONFIG_H +#define TPC_CONFIG_H + +#include "../bsp/bsp_config.h" +#include "../clib/type.h" + +typedef struct _tp_handler_x +{//8byte + vU8 reg; + vU8 head; //接收标志头标志 + vU8 cashe[2]; + vU8 head_0; + vU8 head_1; + vU8 num; //接收到的数据的计数， 随着数据接收而变化注意数据长度的范围 + vU8 ok; //接收协议ok标志 + vU8 yes; + vU8 max; //接收到的数目的最大值 + vU8 buf[D_TPC_HANDLER_X_LEN+16];////协议缓冲 + vU8 *sp; + vU8 *sp2; //备份值，如果协议需要备份，单独提供备份缓冲区 + vU8 ocr; + vU8 crc[2]; +}TP_Handler_X; + +#endif