commit adaa98cc5e03c9b07591ca61f76a6e071c8a2fed Author: zhangsan Date: Wed Aug 4 10:08:43 2021 +0800 v0.1 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..60abb09 --- /dev/null +++ b/keilp/cc_as_stc02_ps5ws.uvprojx @@ -0,0 +1,484 @@ + + + + 2.1 + +
### uVision Project, (C) Keil Software
+ + + + STC8F2K16S2 + 0x0 + MCS-51 + 0 + + + STC8F2K64S4 + STC + IRAM(0-0xFF) XRAM(0-0x07FF) IROM(0-0xFFF8) CLOCK(35000000) MODP2 + + "LIB\STARTUP.A51" ("Standard 8051 Startup Code") + + 63032 + STC8.H + + + + + + + + + + + 0 + 0 + d:\Keil\C51\BIN\ + + + STC\ + STC\ + + 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 + -pDP8051 + S8051.DLL + + TP51.DLL + -p51 + + + + 0 + 0 + 0 + 0 + 16 + + + + + 0 + 0 + 0 + 0 + 0 + -1 + + 0 + + "" () + + + + + 0 + + + + 2 + 0 + 2 + 0 + 0 + 0 + 0 + 0 + 0 + 1 + 1 + 1 + 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 + 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 + 0xfff9 + + + 0 + 0x0 + 0x100 + + + 0 + 0x0 + 0x800 + + + 0 + 0x0 + 0x0 + + + 0 + 0x0 + 0x0 + + + 0 + 0x0 + 0x0 + + + 0 + 0x0 + 0x0 + + + + + 0 + 0 + 0 + 0 + 1 + 3 + 2 + 2 + 0 + 1 + 0 + 0 + + + + + + + + + 0 + 1 + 0 + 0 + + + + + + + + + 0 + 0 + 1 + 0 + 2 + 1 + + REMOVEUNUSED + + + + + + + + + + + + + + + + + + + + + + + + + + + app + + + main.c + 1 + ..\source\app\main.c + + + common.c + 1 + ..\source\app\common.c + + + app_task_uart0.c + 1 + ..\source\app\app_task_uart0.c + + + app_task_adc.c + 1 + ..\source\app\app_task_adc.c + + + + + cpu + + + STARTUP.A51 + 2 + ..\source\cpu\STARTUP.A51 + + + + + msp + + + time.c + 1 + ..\source\msp\time.c + + + UART0.C + 1 + ..\source\msp\UART0.C + + + msp_eeprom.c + 1 + ..\source\msp\msp_eeprom.c + + + msp_id.c + 1 + ..\source\msp\msp_id.c + + + UARTN.C + 1 + ..\source\msp\UARTN.C + + + + + bsp + + + bsp_cs1232.c + 1 + ..\source\bsp\bsp_cs1232.c + + + bsp_485.c + 1 + ..\source\bsp\bsp_485.c + + + bsp_config.c + 1 + ..\source\bsp\bsp_config.c + + + + + ctask + + + task.c + 1 + ..\source\ctask\task.c + + + tick.c + 1 + ..\source\ctask\tick.c + + + + + tpc + + + tpc_modbus.c + 1 + ..\source\tpc\tpc_modbus.c + + + tpc_0d0a.c + 1 + ..\source\tpc\tpc_0d0a.c + + + tpc_ccmodbus.c + 1 + ..\source\tpc\tpc_ccmodbus.c + + + tpc_debug.c + 1 + ..\source\tpc\tpc_debug.c + + + + + clib + + + clib.c + 1 + ..\source\clib\clib.c + + + + + debug + + + cc_as_stc01_main.ini + 5 + ..\source\debug\cc_as_stc01_main.ini + + + + + + + + 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..f734da4 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..28241b7 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..e4c7691 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..86e6e41 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..204ad71 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..9a0d508 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..e4319c6 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..57d1b12 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..e6a6da5 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..4ab4c6a 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_algorithm.c b/source/app/app_algorithm.c new file mode 100644 index 0000000..8714b19 --- /dev/null +++ b/source/app/app_algorithm.c @@ -0,0 +1,1005 @@ +////////////////////////////////////////////////////////////////////////// +/// COPYRIGHT NOTICE +/// Copyright (c) 2015, ؿƼ +/// All rights reserved. +/// +/// @file app_ALGOration.c +/// @brief app_ALGOration app +/// +///ļʵֵĹܵ +/// +/// @version 1.1 CCsens technology +/// @author CC +/// @date 20190105 +/// +/// +/// ޶˵汾 +/// Modified by: +/// Modified date: +/// Version: +/// Descriptions: +/// 㷨 +////////////////////////////////////////////////////////////////////////// +///#include "app_calibration.h" + +#include "app_algorithm.h" +#include "app_flow.h" +#include "app_paraid.h" + +////#include "app_rfSend.h" + +#include "../clib/Clib.h" +#include "../clib/bit.h" +/// + +#ifdef D_buf_test +U8 test_buf[]; +U8 test_buf2[660]; +#endif + +#include "../bsp/bsp_power.h" + +#if 0 +s1 һҪȥ +s2 ͨ˲ƽƽ,ֵ +s3 ܵʽ㷨 +s4 й + low=0 low=0 + ```````\ /````````````\ /`````` + \ / \ / + \ low++ / \ low++ / + 0 zero....\.low_zero=low....../..................\.................../........ + \ / \ / + \ ___/ \ ___/ + \___ / \___ / + \ /high++ \ / + \___/ \___/ + high=0 + low + + /`````````\ + / \ +__________________/ \______________ + +#endif + + +//>>>>>>>>>>>>>>>>>>>>>0task +///L2_task_C2_init(); +#if 0 +1 ֵ +2 +3 㼰 ֵ +4 + +1 ֵ +2 ֵ +4 + +ֵ ֽ +0 ,0 +sum, 100 + +x*k = Sum +100k = Sum100 +k=Sum100/100; +x=Sum/k + Sum +x=------- + k + + Sum +x=------------ + Sum100/100 + + Sum*100 +x = ---------- + Sum100 + +U8 L2_task_ALGO_at(void) +{ + + + +} + +#endif + +vU16 L2_line_algo_media(U8 *buf,vU16 len); +TS_task_ALGO_ ts_task_ALGO; +void L2_task_ALGO_init(void) +{ +/// ts_task_ALGO.status = 0; + L1_task_init(&ts_task_ALGO.task); +/// ts_task_ALGO.p_buf2 = s_task_GC032A.buf; +/// ts_task_ALGO.t = 0; + L3_task_s_go(ts_task_ALGO,D_task_init); +} + +//>>>>>>>>>>>>>>>>>>>>>0task +///L2_task_ALGO_init(); + + +///L2_task_ALGO_handle(&ts_task_ALGO); + +/// Ҫвɼɵı־, ֵ˲,Ȼ(ƽ ֵ), +void L2_task_ALGO_handle(TS_task_ALGO_ *s) +{ + TTSS_Task_init(): + s->ok = D_clear; + s->cali_mode = D_clear; + L2_task_go(D_task_ALGO_wait); + TTSS_Task_step(D_task_ALGO_wait): + + TTSS_Task_step(D_task_ALGO_median): + /// s->usSum = L2_line_algo_media(s_task_GC032A.buf,D_pclk_per_hs_570); + L2_task_go(D_task_ALGO_updown); + TTSS_Task_step(D_task_ALGO_updown): + s->usPaperNum = 0xAAAA; + if(s->usSum >= D_paper_EE)///ͷŻǿ + { + + } + else if(s->usSum > D_paper_MAX)////ֽŴ + { + s->usPaperSection = D_cam_top; + } + else if(s->usSum > D_paper_150at_bottom)///bottom --top + {/// + s->usPaperSection = D_cam_150at; + } + else if(s->usSum > D_paper_00)//// 0---max ֽŷ仯 С + { + s->usPaperSection = D_cam_00; + //s->usSum + + } + else + { + s->usPaperSection = D_cam_erro; + } + /*** + if(s_task_GC032A.buf[4] < D_F_low) + { + TS_paer_value.r123.work_mode = D_ready; + }else + { + TS_paer_value.r123.work_mode = D_clear; + } + ************/ + + /// 0----0 + /// x -----usSum + ///150----usPaper150 + /// 3000 + + s->usPaperNum = s->usSum*15; + s->ustMP = s->usPaper150 / 10; + s->usPaperNum /= s->ustMP; + /// + + #define D_debug_add_send + #ifdef D_debug_add_send + PrintAlgo_D_send_us(s->usSum);PrintAlgo_L0_uart0_uc(0x09); + PrintAlgo_D_send_us(s->usPaper150);PrintAlgo_L0_uart0_uc(0x09); + PrintAlgo_D_send_us(s->usPaperNum); + //PrintCam_L0_uart0_uc(0x0d);/PrintCam_L0_uart0_uc(0x0a); + #endif + L2_task_go(D_task_ALGO_wait); + /// L2_task_go(D_task_ALGO_cali_mode); + + + /************** + TTSS_Task_step(D_task_ALGO_cali_mode) + if(D_ON == s->cali_mode) + {///PrintFlow_L0_uart0_uc(0x30+s->cali_delay); + L2_task_go(D_task_ALGO_cali_save); + }else + { + /// ts_task_FLOW.t_stamp_set = 5;// 20s * = + /// LD_gsensor_power(D_PowerMode_suspend); + if(D_cam_EE == s->usPaperSection) + {PrintAlgo_L0_uart0_uc('a'); + LD_gsensor_power(D_PowerMode_low); + L3_task_s_go(ts_task_FLOW,0); + + L2_task_go(D_task_ALGO_cali_wait); + }else + { + L2_task_go(D_task_ALGO_cali_end); + } + } + + + + + + + + TTSS_Task_step(D_task_ALGO_cali_save) + if(s->cali_delay ++ > 8) + {///PrintFlow_L0_uart0_uc('c'); + L2_task_go(D_task_ALGO_cali_end); + }else + {///ʱδ + L2_task_go(D_task_ALGO_sa); + if(D_cam_150at == s->usPaperSection) + { + //PrintFlow_L0_uart0_uc('a'); + if(s->cali_timer ++ > 2) + { + s->usPaper150 = s->usSum; /// + L1_Iap_Write_us(D_paraAdd0_paper150,s->usPaper150); + L1_Iap_Write_us(D_paraAdd1_paper150,s->usPaper150); + PrintAlgo_L0_uart0_uc('f');///PrintFlow_str("flash", 5); + TS_paer_value.r123.cali_timer ++; + L2_task_go(D_task_ALGO_cali_end); + } + } + } + TTSS_Task_step(D_task_ALGO_cali_wait) + /// ֻûжϵٴεûſԵؽcali ģʽ + Lc_delay_ms(1); + L0_mcu_WKTC(D_WKTC_500MS); //ʱ + L0_mcu_mode_powerdown();//״̬ + if(BITN_G(DR_who_wakeup, DRB_who_wakeup_action)) + { + BITN_0(DR_who_wakeup, DRB_who_wakeup_action); + PrintAlgo_L0_uart0_uc(s->cali_hit+0x30); + // PrintCam_L0_uart0_uc('#'); + if(s->cali_hit++ > 22) + {s->cali_hit = 0; + s->hit_ok = D_ready; + PrintAlgo_L0_uart0_uc('L'); + s->cali_mode = D_ON;s->cali_timer = s->cali_mode; + TS_paer_value.r123.cali_mode = 1; + L2_task_go(D_task_ALGO_sa); + } + }else + { + s->cali_hit = 0; + if(s->cali_over ++ > 25)///500ms*25 = 50s + { + s->cali_over = 0; + L2_task_go(D_task_ALGO_cali_end); + } + } + + TTSS_Task_step(D_task_ALGO_cali_end) + // PrintFlow_str("cali end", 9);// + // PrintAlgo_L0_uart0_uc('E'); + s->cali_mode = D_clear; + TS_paer_value.r123.cali_mode = s->cali_mode; + s->cali_delay = 0; +/// L3_task_s_go(ts_task_FLOW,D_task_init); +// + L2_task_go(D_task_ALGO_wait); + TTSS_Task_step(D_task_ALGO_sa) + L3_task_s_go(ts_task_FLOW,D_task_FLOW_wakeup); + L2_task_go(D_task_ALGO_wait); + + + *****************/ + TTSS_Task_end(); +} + +/**************************** + + +TTSS_Task_step(D_task_ALGO_updown) + L0_uart0_sendArray("paper =", 7); + D_send_ushex(s->usSum);L0_uart0_uc('-'); + #define D_paper_max 0x0b10 + ///0x0b1d 2845 + + + L2_task_go(D_task_ALGO_cal) +//L1_task_Tdelay(D_Tdelay_10ms); +TTSS_Task_step(D_task_ALGO_cal) + #ifdef D_debug_add_send + // L2_line_send();/// ݷȥʹ s_task_GC032A.buf + // D_send_us(DR_pclk_n); + // + #endif + s->usSum *= 10; // sumֵܳ + s->usPaper = s->usSum/s->usSum100; + s->ok = D_ready; + L2_task_go(D_task_ALGO_wait); + +#define D_F_low 30 +#define D_F_high 40 +#define D_F_diff 10 //D_F_high - D_F_low +cam һݵǰһ +16 +16 +16 +16 +17 +18 +19 +22 +25 +26 +26 +27 +29 +28 +28 +27 +27 +26 +26 +26 +25 +25 +/// ȥ +/// ______/\___________ +/// / \ +/// / ...............................\--high +/// / \ +/// / \ +/// / low \---low +///-16 17-- \ +/// +***************************/ +///#define D_F_low 23 +///#define D_F_high 30 +///#define D_F_diff 5 //D_F_high - D_F_low +///#define D_F_diff (D_F_high - D_F_low) + + +vU16 L2_line_algo_media(U8 *buf,vU16 len) +{ + vU16 i,usV = 0;//,usi = 0; + U8 cache[3]; + U8 f1; + for(i = 1;i < len;i ++) + { + + cache[2] = cache[1]; + cache[1] = cache[0]; + cache[0] = buf[i]; + f1 = Lc_U8_media3(cache[2],cache[1],cache[0]); + ///-------------------------------------------------- + if(f1 > D_F_low)//> + { + if(f1 > D_F_high)//>40 + { + f1 = D_F_diff;// 10 + }else + { + f1 -= D_F_low;// 40 30 + } + }else + {// <=low + f1 = 0; + } + ///-------------------------------------------------- + /// buf[i] = f1; + usV += f1;///ֵ 570*7 640*10 =6,400 65,535 + + } + return usV; +} + + + +#if 0 + + /// // s->usSum = L2_line_algo_media(test_buf,639); + if(ts_task_ALGO.usSum_temp > D_line_sum) + { + ////L3_task_s_go(ts_task_CALIB,D_task_CALIB_wait); + } + if(s->usSum_temp != s->usSum) + { + s->t++; + }else + { + s->t = 0; + } + if(s->t > 5) + { + L0_uart0_uc('X'); + }else + { + L0_uart0_uc('F'); + } + D_send_ushex(s->t);L0_uart0_uc(0x09); + + + TTSS_Task_step(D_task_ALGO_updown); + /// // s->usSum = L2_line_algo_media(test_buf,639); + if(ts_task_ALGO.usSum_temp > D_line_sum) + { + ////L3_task_s_go(ts_task_CALIB,D_task_CALIB_wait); + } + if(s->usSum_temp >= s->usSum) + { + s->t = s->usSum_temp - s->usSum; + }else + { + s->t = s->usSum - s->usSum_temp; + } + /// L0_uart0_uc(0x09); + L0_uart0_sendArray("paper =", 9); + D_send_ushex(s->usSum);L0_uart0_uc('-'); + D_send_ushex(s->usSum_temp);L0_uart0_uc('='); + s->usSum_temp = s->usSum; + #define D_paper_max 2000 + ///0x0b1d 2845 + + if(s->usSum > 0x0b10) + { + s->paperMode = D_max; + }else + { + s->paperMode = D_diff; + } + + if(s->t > D_paper_max) + { + + L0_uart0_uc('X'); + + }else + { + L0_uart0_uc('F'); + + + } + D_send_ushex(s->t);L0_uart0_uc(0x09); + L2_task_go(D_task_ALGO_cal); + //L1_task_Tdelay(D_Tdelay_10ms); + + L2_task_go(D_task_ALGO_updown); +TTSS_Task_step(D_task_ALGO_updown); + s->usLong = L2_line_algo_updown(s->p_buf2,639); + +vU16 L2_line_algo_updown(U8 *p_buf,U8 len) +{ + vU16 us_i = 0,up_point = 0,down_point = 0; + down_point = DR_pclk_n; + for(us_i = 1;us_i < len ;us_i ++) + { + if((p_buf[us_i - 1] == 0)&& + (p_buf[us_i] == 1))//// _/`` + { + if(p_buf[us_i + 1] == 0) + {//_/`\_ Ҫ + gRccUs03 ++; + }else + {// ___/````ؿʼߵƽ + up_point = us_i; + } + }else if((p_buf[us_i - 1] == 1)&& + (p_buf[us_i] == 0))//// ``\_ ½ + { + down_point = gRccUs03; + }else + { + + } + } + us_i = down_point - up_point; + return us_i; +} + +#endif + + +#if 0 ///def D_buf_test +U8 test_buf[] +={ +19 ,// 0 +19 ,// 1 +19 ,// 2 +20 ,// 3 +20 ,// 4 +20 ,// 5 +20 ,// 6 +20 ,// 7 +20 ,// 8 +20 ,// 9 +19 ,// 10 +119 ,// 11 +19 ,// 12 +19 ,// 13 +19 ,// 14 +19 ,// 15 +19 ,// 16 +20 ,// 17 +20 ,// 18 +20 ,// 19 +20 ,// 20 +20 ,// 21 +20 ,// 22 +20 ,// 23 +20 ,// 24 +20 ,// 25 +19 ,// 26 +19 ,// 27 +19 ,// 28 +119 ,// 29 +19 ,// 30 +19 ,// 31 +19 ,// 32 +19 ,// 33 +19 ,// 34 +19 ,// 35 +19 ,// 36 +19 ,// 37 +19 ,// 38 +19 ,// 39 +19 ,// 40 +20 ,// 41 +20 ,// 42 +19 ,// 43 +19 ,// 44 +19 ,// 45 +19 ,// 46 +20 ,// 47 +20 ,// 48 +20 ,// 49 +19 ,// 50 +19 ,// 51 +19 ,// 52 +19 ,// 53 +19 ,// 54 +20 ,// 55 +20 ,// 56 +20 ,// 57 +19 ,// 58 +19 ,// 59 +19 ,// 60 +20 ,// 61 +20 ,// 62 +20 ,// 63 +20 ,// 64 +20 ,// 65 +20 ,// 66 +20 ,// 67 +20 ,// 68 +20 ,// 69 +120 ,// 70 +19 ,// 71 +19 ,// 72 +19 ,// 73 +20 ,// 74 +20 ,// 75 +20 ,// 76 +20 ,// 77 +20 ,// 78 +20 ,// 79 +20 ,// 80 +20 ,// 81 +20 ,// 82 +20 ,// 83 +20 ,// 84 +20 ,// 85 +20 ,// 86 +20 ,// 87 +20 ,// 88 +20 ,// 89 +20 ,// 90 +20 ,// 91 +20 ,// 92 +121 ,// 93 +20 ,// 94 +20 ,// 95 +20 ,// 96 +20 ,// 97 +20 ,// 98 +21 ,// 99 +21 ,// 100 +21 ,// 101 +22 ,// 102 +24 ,// 103 +26 ,// 104 +28 ,// 105 +30 ,// 106 +32 ,// 107 +35 ,// 108 +38 ,// 109 +40 ,// 110 +42 ,// 111 +44 ,// 112 +146 ,// 113 +50 ,// 114 +51 ,// 115 +52 ,// 116 +52 ,// 117 +53 ,// 118 +53 ,// 119 +54 ,// 120 +54 ,// 121 +55 ,// 122 +55 ,// 123 +55 ,// 124 +55 ,// 125 +55 ,// 126 +56 ,// 127 +55 ,// 128 +55 ,// 129 +55 ,// 130 +56 ,// 131 +55 ,// 132 +155 ,// 133 +54 ,// 134 +53 ,// 135 +53 ,// 136 +52 ,// 137 +52 ,// 138 +52 ,// 139 +51 ,// 140 +49 ,// 141 +45 ,// 142 +43 ,// 143 +41 ,// 144 +39 ,// 145 +38 ,// 146 +36 ,// 147 +34 ,// 148 +31 ,// 149 +129 ,// 150 +28 ,// 151 +28 ,// 152 +27 ,// 153 +27 ,// 154 +27 ,// 155 +27 ,// 156 +27 ,// 157 +27 ,// 158 +26 ,// 159 +26 ,// 160 +26 ,// 161 +25 ,// 162 +25 ,// 163 +24 ,// 164 +25 ,// 165 +25 ,// 166 +25 ,// 167 +25 ,// 168 +25 ,// 169 +24 ,// 170 +24 ,// 171 +24 ,// 172 +23 ,// 173 +23 ,// 174 +22 ,// 175 +23 ,// 176 +22 ,// 177 +22 ,// 178 +22 ,// 179 +22 ,// 180 +22 ,// 181 +22 ,// 182 +22 ,// 183 +21 ,// 184 +21 ,// 185 +21 ,// 186 +21 ,// 187 +21 ,// 188 +22 ,// 189 +21 ,// 190 +21 ,// 191 +21 ,// 192 +21 ,// 193 +21 ,// 194 +21 ,// 195 +21 ,// 196 +21 ,// 197 +21 ,// 198 +121 ,// 199 +21 ,// 200 +21 ,// 201 +21 ,// 202 +21 ,// 203 +21 ,// 204 +21 ,// 205 +21 ,// 206 +21 ,// 207 +21 ,// 208 +21 ,// 209 +20 ,// 210 +20 ,// 211 +20 ,// 212 +20 ,// 213 +20 ,// 214 +20 ,// 215 +21 ,// 216 +21 ,// 217 +21 ,// 218 +20 ,// 219 +21 ,// 220 +21 ,// 221 +20 ,// 222 +120 ,// 223 +20 ,// 224 +20 ,// 225 +20 ,// 226 +20 ,// 227 +20 ,// 228 +20 ,// 229 +20 ,// 230 +20 ,// 231 +20 ,// 232 +19 ,// 233 +19 ,// 234 +19 ,// 235 +19 ,// 236 +20 ,// 237 +21 ,// 238 +21 ,// 239 +21 ,// 240 +20 ,// 241 +20 ,// 242 +20 ,// 243 +20 ,// 244 +20 ,// 245 +20 ,// 246 +20 ,// 247 +20 ,// 248 +20 ,// 249 +20 ,// 250 +21 ,// 251 +21 ,// 252 +21 ,// 253 +21 ,// 254 +21 ,// 255 +20 ,// 256 +20 ,// 257 +20 ,// 258 +20 ,// 259 +20 ,// 260 +20 ,// 261 +20 ,// 262 +20 ,// 263 +20 ,// 264 +20 ,// 265 +19 ,// 266 +19 ,// 267 +19 ,// 268 +19 ,// 269 +19 ,// 270 +19 ,// 271 +19 ,// 272 +19 ,// 273 +19 ,// 274 +19 ,// 275 +19 ,// 276 +19 ,// 277 +19 ,// 278 +19 ,// 279 +19 ,// 280 +19 ,// 281 +19 ,// 282 +20 ,// 283 +20 ,// 284 +20 ,// 285 +20 ,// 286 +119 ,// 287 +19 ,// 288 +19 ,// 289 +19 ,// 290 +19 ,// 291 +19 ,// 292 +19 ,// 293 +19 ,// 294 +19 ,// 295 +19 ,// 296 +19 ,// 297 +19 ,// 298 +19 ,// 299 +19 ,// 300 +19 ,// 301 +19 ,// 302 +19 ,// 303 +19 ,// 304 +19 ,// 305 +19 ,// 306 +19 ,// 307 +49 ,// 308 +19 ,// 309 +20 ,// 310 +19 ,// 311 +19 ,// 312 +19 ,// 313 +19 ,// 314 +19 ,// 315 +20 ,// 316 +19 ,// 317 +19 ,// 318 +19 ,// 319 +19 ,// 320 +19 ,// 321 +19 ,// 322 +19 ,// 323 +19 ,// 324 +19 ,// 325 +19 ,// 326 +19 ,// 327 +19 ,// 328 +19 ,// 329 +20 ,// 330 +20 ,// 331 +20 ,// 332 +19 ,// 333 +20 ,// 334 +20 ,// 335 +20 ,// 336 +20 ,// 337 +20 ,// 338 +19 ,// 339 +19 ,// 340 +19 ,// 341 +19 ,// 342 +19 ,// 343 +19 ,// 344 +19 ,// 345 +19 ,// 346 +19 ,// 347 +20 ,// 348 +20 ,// 349 +20 ,// 350 +20 ,// 351 +20 ,// 352 +20 ,// 353 +20 ,// 354 +20 ,// 355 +19 ,// 356 +19 ,// 357 +19 ,// 358 +19 ,// 359 +19 ,// 360 +19 ,// 361 +19 ,// 362 +19 ,// 363 +19 ,// 364 +19 ,// 365 +19 ,// 366 +19 ,// 367 +19 ,// 368 +19 ,// 369 +19 ,// 370 +19 ,// 371 +19 ,// 372 +19 ,// 373 +19 ,// 374 +19 ,// 375 +19 ,// 376 +19 ,// 377 +19 ,// 378 +19 ,// 379 +19 ,// 380 +19 ,// 381 +19 ,// 382 +19 ,// 383 +19 ,// 384 +19 ,// 385 +19 ,// 386 +19 ,// 387 +20 ,// 388 +20 ,// 389 +19 ,// 390 +19 ,// 391 +19 ,// 392 +19 ,// 393 +19 ,// 394 +19 ,// 395 +19 ,// 396 +19 ,// 397 +19 ,// 398 +19 ,// 399 +19 ,// 400 +19 ,// 401 +19 ,// 402 +19 ,// 403 +19 ,// 404 +19 ,// 405 +19 ,// 406 +19 ,// 407 +19 ,// 408 +19 ,// 409 +19 ,// 410 +20 ,// 411 +19 ,// 412 +19 ,// 413 +19 ,// 414 +19 ,// 415 +19 ,// 416 +19 ,// 417 +19 ,// 418 +19 ,// 419 +19 ,// 420 +19 ,// 421 +19 ,// 422 +19 ,// 423 +19 ,// 424 +19 ,// 425 +19 ,// 426 +19 ,// 427 +19 ,// 428 +19 ,// 429 +19 ,// 430 +19 ,// 431 +19 ,// 432 +19 ,// 433 +19 ,// 434 +19 ,// 435 +19 ,// 436 +20 ,// 437 +19 ,// 438 +19 ,// 439 +19 ,// 440 +19 ,// 441 +19 ,// 442 +19 ,// 443 +19 ,// 444 +19 ,// 445 +19 ,// 446 +19 ,// 447 +19 ,// 448 +19 ,// 449 +19 ,// 450 +19 ,// 451 +19 ,// 452 +19 ,// 453 +19 ,// 454 +19 ,// 455 +19 ,// 456 +19 ,// 457 +19 ,// 458 +19 ,// 459 +19 ,// 460 +19 ,// 461 +19 ,// 462 +19 ,// 463 +19 ,// 464 +19 ,// 465 +19 ,// 466 +19 ,// 467 +19 ,// 468 +19 ,// 469 +19 ,// 470 +19 ,// 471 +19 ,// 472 +19 ,// 473 +19 ,// 474 +19 ,// 475 +19 ,// 476 +19 ,// 477 +19 ,// 478 +19 ,// 479 +19 ,// 480 +19 ,// 481 +19 ,// 482 +19 ,// 483 +19 ,// 484 +19 ,// 485 +19 ,// 486 +19 ,// 487 +19 ,// 488 +19 ,// 489 +19 ,// 490 +19 ,// 491 +19 ,// 492 +19 ,// 493 +19 ,// 494 +19 ,// 495 +19 ,// 496 +19 ,// 497 +18 ,// 498 +18 ,// 499 +18 ,// 500 +19 ,// 501 +19 ,// 502 +19 ,// 503 +19 ,// 504 +19 ,// 505 +19 ,// 506 +19 ,// 507 +19 ,// 508 +19 // 509 +}; +#endif diff --git a/source/app/app_algorithm.h b/source/app/app_algorithm.h new file mode 100644 index 0000000..b855959 --- /dev/null +++ b/source/app/app_algorithm.h @@ -0,0 +1,168 @@ + +//////////////////////////////////////////////////////////////////////////// +///@copyright Copyright (c) 2018, ؿƼ All rights reserved. +///------------------------------------------------------------------------- +/// @file algorithm.h +/// @brief bsp @ driver config +///------------------------------------------------------------------------- +/// @version 1.0 +/// @author CC +/// @date 20180331 +/// @note cc_AS_stc02 +/// +/// +///algorithm///Ӣ [??lg?r?e?m] [??l???r?e?m] ///n.㷨;㷨; +/// +/// +/// +////////////////////////////////////////////////////////////////////////////// + + + + + + + + + + +#ifndef _APP_algorithm_H +#define _APP_algorithm_H + +#include "../clib/Type.h" +#include "../ctask/task.h" +#include "../msp/uart0.h" +#include "../clib/clib.h" +//#include "../debug/debug_drv.h"// +//#include "../msp/msp_plcd.h" + +//#include "../msp/SHC6601_rtc.h" +///#include "app_rf.h" +//#include "app_as.h" + +#include "../tpc/tpc_uart.h" + +//>>>>>>>>>>>>>>>>>>>>>0task + + +#define D_task_ALGO_median 0x51 +#define D_task_ALGO_wait 0x52 + +#define D_task_ALGO_cal 0x53 +#define D_task_ALGO_updown 0x54 +#define D_task_ALGO_section 0x57 + +#define D_task_ALGO_cali_mode 0x63 +#define D_task_ALGO_para 0x64 +#define D_task_ALGO_200in 0x66 + +#define D_task_ALGO_cali_end 0x69 + +#define D_task_ALGO_cali_wait 0x70 +#define D_task_ALGO_cali_save 0x73 + + +#define D_task_ALGO_sa 0x6b + +#define D_line_sum 1000 ///жķֵ + + + +typedef struct +{ + TS_task task; + vU16 usSum; + vU16 ustMP; + vU16 usPaper150; + vU16 usPaperNum; +// vU32 ul2; +// vU32 ul3; +// vU16 t; +/// vU16 usSum_temp; +// vU16 usSum100; +// vU16 usLong; /// +/// vU8 *p_buf2;// + vU8 usPaperSection; ///ֽŵĶ + vU8 cali_delay; + vU8 cali_timer; + vU8 cali_over; + vU8 cali_hit; + vU8 hit_ok:1; + vU8 ok:1; + vU8 cali_mode:1; //D_OK + vU8 ok2:1; + vU8 paperMode:3;// + +// vU8 buf3[520];// + +}TS_task_ALGO_; +extern TS_task_ALGO_ ts_task_ALGO; + +extern void L2_task_ALGO_handle(TS_task_ALGO_ *s); +extern void L2_task_ALGO_init(void); +extern void L2_task_ALGO_handle22(TS_task_ALGO_ *s); + +/*********************** +10 0.93 + +20 1.88mm --->0.094mm/paper +100 9.4 2.97mm-> 31.59574468 +150 14.1 15.9---> 169.1489362 2330 0x0924 +200 18.8 0 + + +****************/ + +#define D_paper_EE 0x0B10 ///0b1f + +#define D_paper_MAX 0x09AA ///2555 //170 + +#define D_paper_150LR 250 ///¸ֵ 150/15 =10ҳ +#define D_paper_150at 0x087f ///150У׼ 2330/150 = 15point/ֽ +#define D_paper_00 0x0015 +#define D_paper_150at_top (D_paper_150at + D_paper_150LR) +#define D_paper_150at_bottom (D_paper_150at - D_paper_150LR) + +#define D_cam_EE 0 +#define D_cam_top 1 +#define D_cam_150at 2 +#define D_cam_00 3 +#define D_cam_erro 4 +#define D_cam_noee 5 + +//<<<<<<<<<<<<<<<<<<<0task +#if 0 +#define PrintAlgo_L0_uart0_uchex(x) L0_uart0_uchex((x)) +#define PrintAlgo_L0_uart0_uc(x) L0_uart0_uc((x)) +#define PrintAlgo_D_send_us(x) D_send_ushex((x)) + +#define PrintAlgo_str(x,len) L0_uart0_sendArray((x),len) +#else + +#define PrintAlgo_L0_uart0_uchex(x) +#define PrintAlgo_L0_uart0_uc(x) +#define PrintAlgo_D_send_us(x) + +#define PrintAlgo_str(x,len) + +#endif +/************************************************************ +/// ȥ +/// ______/\___________ +/// / \ +/// / ...............................\--high +/// / \ +/// / \ +/// / low \---low +///-16 17-- \ +/// +*******************************************/ +#define D_F_low 23 +#define D_F_high 30 +#define D_F_diff 5 //D_F_high - D_F_low +///#define D_F_diff (D_F_high - D_F_low) + +#endif //_APP_algorithm_H ALGO + + + diff --git a/source/app/app_calibration.c b/source/app/app_calibration.c new file mode 100644 index 0000000..12ecec7 --- /dev/null +++ b/source/app/app_calibration.c @@ -0,0 +1,149 @@ +////////////////////////////////////////////////////////////////////////// +/// COPYRIGHT NOTICE +/// Copyright (c) 2015, ؿƼ +/// All rights reserved. +/// +/// @file app_calibration.c +/// @brief app_calibration app +/// +///ļʵֵĹܵ +/// +/// @version 1.1 CCsens technology +/// @author CC +/// @date 20170101 +/// +/// +/// ޶˵汾 +/// Modified by: +/// Modified date: +/// Version: +/// Descriptions: +/// Ӧ һϵʱ +////////////////////////////////////////////////////////////////////////// + +#include "app_calibration.h" +#include "../clib/Clib.h" +#include "../clib/bit.h" +#include "../bsp/bsp_cam.h" +/// + +#include "../bsp/bsp_power.h" + +TS_task_CALIB_ ts_task_CALIB; + +void L2_task_CALIB_init(void) +{ + ts_task_CALIB.status = 0; + L1_task_init(&ts_task_CALIB.task); + L3_task_s_go(ts_task_CALIB,D_task_init); +} + +//>>>>>>>>>>>>>>>>>>>>>0task +///L2_task_CALIB_init(); + +///L2_task_CALIB_handle(&ts_task_CALIB); +void L2_task_CALIB_handle(TS_task_CALIB_ *s) +{ + TTSS_Task_init(); + if(D_ready == ts_task_power.power2) + { + ts_task_power.power2 = D_clear; + L1_as_readXYZ(0); + L1_as_readXYZ(0); + L1_as_readXYZ(0); + L1_as_readXYZ(0); + L1_as_readXYZ(0); + L1_as_readXYZ(0); + L1_as_readXYZ(0); + L1_as_readXYZ(0); + L1_as_readXYZ(0); + + L1_as_readXYZ(0); + L1_as_readXYZ(0); + L1_as_readXYZ(0); + L1_as_readXYZ(0); + L1_as_readXYZ(0); + L1_as_readXYZ(0); + L1_as_readXYZ(0); + L1_as_readXYZ(0); + L1_as_readXYZ(0); + + + } + + +#if 0 + L0_uart0_uc('a'); + + ts_task_power.power2 = D_clear; + ts_task_CALIB.calib_time = D_clear; + L1_task_Tdelay(D_Tdelay_1s); + + + L2_task_go(D_task_CALIB_wait); + #endif + TTSS_Task_step(D_task_CALIB_rr); + + + TTSS_Task_step(D_task_CALIB_wait); + + if(D_ready == ts_task_power.power2) + { + ts_task_power.power2 = D_clear; + L0_uart0_uc('#'); + ts_task_CALIB.status ++; + if(ts_task_CALIB.status <= 8) + { + }else + { + L0_uart0_uc('!'); + ts_task_CALIB.status = 0; + ts_task_CALIB.calib_time = D_ready; + } + }else + { + ts_task_CALIB.status = 0; + ts_task_CALIB.calib_time = D_clear; + L0_uart0_uc('0'); + } + L2_task_go(D_task_CALIB_wait); + //L1_task_Tdelay(D_Tdelay_1s); + L1_task_Tdelay(D_Tdelay_500ms);////̶ļǷյУ׼û + TTSS_Task_step(D_task_CALIB_sleep); + + L2_task_go(D_task_CALIB_init_sensor); + L1_task_Tdelay(D_Tdelay_10ms); + TTSS_Task_end(); +} + +/********* +if(D_ready == ts_task_power.power2) +{ + ts_task_power.power2 = D_clear; + L0_uart0_uc('#'); + ts_task_CALIB.status ++; + if(ts_task_CALIB.status <= 4) + { + }else + { + L0_uart0_uc('!'); + // L1_task_Tdelay(D_Tdelay_1s); + // L2_task_go(D_task_CALIB_wait); + + } + /// L1_task_Tdelay(D_Tdelay_1s); + L2_task_go(D_task_CALIB_wait); +}else +{ + ts_task_CALIB.status = 0; + L0_uart0_uc('0'); + L1_task_Tdelay(D_Tdelay_2s); +} + + + + + +*********/ + + diff --git a/source/app/app_calibration.h b/source/app/app_calibration.h new file mode 100644 index 0000000..a7dae87 --- /dev/null +++ b/source/app/app_calibration.h @@ -0,0 +1,71 @@ +#ifndef _APP_calibration_H +#define _APP_calibration_H + +#include "../clib/Type.h" +#include "../ctask/task.h" +#include "../msp/uart0.h" +#include "../clib/clib.h" +//#include "../debug/debug_drv.h"// +//#include "../msp/msp_plcd.h" + +//#include "../msp/SHC6601_rtc.h" +///#include "app_rf.h" +//#include "app_as.h" +#include "../bsp/cw63xx.h" +#include "../bsp/bsp_msa300.h" +#include "../tpc/tpc_uart.h" +#include "../bsp/bsp_cam_isr.h" + +//>>>>>>>>>>>>>>>>>>>>>0task + +///#define D_task_CALIB_ask 0x56 +///#define D_task_CALIB_enter 0x57 +///#define D_task_CALIB_init 0x10 + +///#define D_task_OSD_init_key 0x11 +///#define D_task_CALIB_STEP 0x30 +///#define D_task_CALIB_heratbeat 0x70 + + +#define D_task_CALIB_send 0x40 +#define D_task_CALIB_send2 0x41 +#define D_task_CALIB_send3 0x42 + +#define D_task_CALIB_PreSend 0x43 +#define D_task_CALIB_PreSend2 0x44 + + + +#define D_task_CALIB_wait 0x51 +#define D_task_CALIB_rr 0x52 + +#define D_task_CALIB_sleep 0x53 +#define D_task_CALIB_init_sensor 0x54 +#define D_task_CALIB_wait_sensor 0x55 +#define D_task_CALIB_wakeup 0x56 +#define D_task_CALIB_wakeup2 0x57 +#define D_task_CALIB_overtime 0x58 +#define D_task_CALIB_wakeup3 0x59 + +typedef struct +{ + TS_task task; +// vU8 t_stamp;// +// vU8 first_run;// + unsigned char calib_time;// + unsigned char status;// +// unsigned char key;// +}TS_task_CALIB_; +extern TS_task_CALIB_ ts_task_CALIB; + +extern void L2_task_CALIB_handle(TS_task_CALIB_ *s); +extern void L2_task_CALIB_init(void); +extern void L2_task_CALIB_handle22(TS_task_CALIB_ *s); + + +//<<<<<<<<<<<<<<<<<<<0task + +#endif //_APP_calibration_H calib + + + diff --git a/source/app/app_flow.c b/source/app/app_flow.c new file mode 100644 index 0000000..0247590 --- /dev/null +++ b/source/app/app_flow.c @@ -0,0 +1,95 @@ +////////////////////////////////////////////////////////////////////////// +/// COPYRIGHT NOTICE +/// Copyright (c) 2015, ؿƼ +/// All rights reserved. +/// +/// @file app_flow.c +/// @brief app_flow app +/// +///ļʵֵĹܵ +/// +/// @version 1.1 CCsens technology +/// @author CC +/// @date 20170101 +/// +/// +/// ޶˵汾 +/// Modified by: +/// Modified date: +/// Version: +/// Descriptions: +/// Ӧ һϵʱ +////////////////////////////////////////////////////////////////////////// + +#include "app_flow.h" +#include "../clib/Clib.h" +#include "../clib/bit.h" +#include "app_algorithm.h" + + +TS_P_rf433 TS_paer_value= +{ + 0xaa,///vU8 ha; +// 0xaa,///vU8 hb; + 0xad, + 0x0123, +// 0x00,///U16 paperNum:12; //12bitֽ + ///U8 cameraIndex:2; //ͷ + ///U8 cameraWorking:1; //Ƿ + ///U8 reserved: 1; // + 0x56,///U8 cameraBoardPower; // + 0xcc//, 0xaa///vU8 hc; +}; + + +TS_task_FLOW_ ts_task_FLOW; +void L0_p_send(void) +{ + unsigned char *p; + + TS_paer_value.ha = 0xaa; +// TS_paer_value.hb = 0xaa; +/// TS_paer_value.hc = 0xaa; +/// TS_paer_value.r123.cameraBoardPower ++; + + TS_paer_value.filter1 = 0x0a; + +///TS_paer_value.r123.cameraBoardPower = s_task_GC032A.buf[2];; + TS_paer_value.r123.cameraIndex = D_cameralIndex; + TS_paer_value.r123.cameraWorking = 0; + TS_paer_value.r123.paperNum = ts_task_ALGO.usPaperNum; +//// L1_cw63xx_sta();///ֻеȳ Żᱻ +/// TS_paer_value.r123.LowPower = I2CTXD; +// TS_paer_value.r123.paperNum = 0x1234; + p = (unsigned char *)&TS_paer_value.r123; + TS_paer_value.ocr = *p; + p ++; + TS_paer_value.ocr += *p; + p ++; + TS_paer_value.ocr += *p; +// TS_paer_value.ocr = s_task_GC032A.buf[2]; +} + +void L2_task_FLOW_init(void) +{ + L1_task_init(&ts_task_FLOW.task); + L3_task_s_go(ts_task_FLOW,D_task_init); +} + +//>>>>>>>>>>>>>>>>>>>>>0task +#define D_FLOW_t_stamp 10 + +void L2_task_FLOW_handle33(TS_task_FLOW_ *s) +{ + TTSS_Task_init(): +/// PrintFlow_L0_uart0_uc('F'); + ts_task_ALGO.paperMode = D_max; + + L2_task_go(D_task_FLOW_wakeup); + + TTSS_Task_end(); +} + + + + diff --git a/source/app/app_flow.h b/source/app/app_flow.h new file mode 100644 index 0000000..52a504f --- /dev/null +++ b/source/app/app_flow.h @@ -0,0 +1,84 @@ +#ifndef _APP_FLOW_H +#define _APP_FLOW_H + + + +#include "../clib/Type.h" +#include "../ctask/task.h" +#include "../msp/uart0.h" +#include "../clib/clib.h" +//#include "../debug/debug_drv.h"// +//#include "../msp/msp_plcd.h" + +//#include "../msp/SHC6601_rtc.h" +///#include "app_rf.h" +//#include "app_as.h" +#include "../tpc/tpc_uart.h" + +//>>>>>>>>>>>>>>>>>>>>>0task + +///#define D_task_FLOW_ask 0x56 +///#define D_task_FLOW_enter 0x57 +///#define D_task_FLOW_init 0x10 + +///#define D_task_OSD_init_key 0x11 +///#define D_task_FLOW_STEP 0x30 +///#define D_task_FLOW_heratbeat 0x70 + +#define D_task_FLOW_wait_cam1 0x51 +#define D_task_FLOW_wait_cam 0x52 + +#define D_task_FLOW_lowPower 0x53 +#define D_task_FLOW_work 0x5b +#define D_task_FLOW_cali 0x5c + +#define D_task_FLOW_init_sensor 0x54 +#define D_task_FLOW_wait_sensor 0x55 +#define D_task_FLOW_wakeup 0x56 +#define D_task_FLOW_wakeup2 0x57 +#define D_task_FLOW_overtime 0x58 +#define D_task_FLOW_wakeup3 0x59 + +typedef struct +{ + TS_task task; + vU8 t_stamp; + vU16 t_stamp2; + vU16 wakeup_timer; + + vU8 long_hit; +// vU8 first_run;// +// unsigned char area;// +// unsigned char status;// +// unsigned char key;// +}TS_task_FLOW_; +extern TS_task_FLOW_ ts_task_FLOW; + +extern void L2_task_FLOW_handle(TS_task_FLOW_ *s); +extern void L2_task_FLOW_init(void); +extern void L2_task_FLOW_handle33(TS_task_FLOW_ *s); + + +extern TS_P_rf433 TS_paer_value; +#if 0 +#define PrintFlow_L0_uart0_uchex(x) L0_uart0_uchex((x)) +#define PrintFlow_L0_uart0_uc(x) L0_uart0_uc((x)) +#define PrintFlow_D_send_us(x) D_send_ushex((x)) + +#define PrintFlow_str(x,len) L0_uart0_sendArray((x),len) +#else + +#define PrintFlow_L0_uart0_uchex(x) +#define PrintFlow_L0_uart0_uc(x) +#define PrintFlow_D_send_us(x) + +#define PrintFlow_str(x,len) + +#endif + +//<<<<<<<<<<<<<<<<<<<0task + +#endif + + + diff --git a/source/app/app_paraid.c b/source/app/app_paraid.c new file mode 100644 index 0000000..bd61ebb --- /dev/null +++ b/source/app/app_paraid.c @@ -0,0 +1,124 @@ +////////////////////////////////////////////////////////////////////////// +/// COPYRIGHT NOTICE +/// Copyright (c) 2015, ؿƼ +/// All rights reserved. +/// +/// @file app_paraid.c +/// @brief parameter & id app +/// +///ļʵֵĹܵ +/// +/// @version 1.1 CCsens technology +/// @author CC +/// @date 20190107 +/// +/// +/// ޶˵汾 +/// Modified by: +/// Modified date: +/// Version: +/// Descriptions: +/// +////////////////////////////////////////////////////////////////////////// + +#include "app_algorithm.h" +#include "app_paraid.h" +#include "../clib/Clib.h" +#include "../clib/bit.h" +#include "../msp/msp_eeprom.h" +// + +/// + +#define D_paraid_debug_print +/// id +/// ֽŵò + +void L1_paraid_init(void) +{ + vU16 pa[2]; + +/// char *ID; +/// ID = (char idata *)0xf1;/// for (i=0; i<7; i++) { UartSend(ID[i]); } + ///UartSend(ID[i]); + +// L1_Iap_Read_us(D_paraAdd_paper150,&ts_task_ALGO.usPaper150); +// L1_Iap_Read_us(D_paraAdd_paper150,&ts_task_ALGO.usPaper150); +// L1_Iap_main(); + + + L1_Iap_Read_us(D_paraAdd0_paper150,&pa[0]); + L1_Iap_Read_us(D_paraAdd1_paper150,&pa[1]); + #ifdef D_paraid_debug_print + L0_uart0_us(pa[0]);L0_uart0_us(pa[1]); L0_uart0_uc(0xAA); + #endif + if(pa[1] == pa[0]) + { + if(0xffff != pa[1]) + { + if(pa[0] < D_paper_150at_top) + { + if(pa[0] > D_paper_150at_bottom) + { + goto GOTO_PARA_OK; + } + } + } + } + + + +/// GOTO_PARA_ERRO: + L1_Iap_Write_us(D_paraAdd0_paper150,D_paper_150at); + L1_Iap_Write_us(D_paraAdd1_paper150,D_paper_150at); + pa[0] = D_paper_150at; + + GOTO_PARA_OK: + ts_task_ALGO.usPaper150 = pa[0]; + #ifdef D_paraid_debug_print + L0_uart0_us(ts_task_ALGO.usPaper150);L0_uart0_uc(0xBB); + #endif + ///nothing + +} + + + + +void L1_Iap_Write_us(vU16 addr,vU16 val) +{ + EA = 0; + /********* + 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_(); // + _nop_(); + + + IAP_CMD = 2; //IAPд + IAP_DATA = dat; //дIAP + IAP_TRIG = 0x5a; //д(0x5a) + IAP_TRIG = 0xa5; //д(0xa5) + _nop_(); + L0_Iap_Idle(); //رIAP + ***************/ + L0_Iap_Erase(addr); + L0_Iap_Program(addr,val>>8); + L0_Iap_Program(addr+1,val&0x00ff); + EA = 1; +} + + +void L1_Iap_Read_us(vU16 addr,vU16 *val) +{ + EA = 0; + *val = L0_Iap_Read(addr); + *val <<= 8; + *val |= L0_Iap_Read(addr+1); + EA = 1; + +} diff --git a/source/app/app_paraid.h b/source/app/app_paraid.h new file mode 100644 index 0000000..f17c65b --- /dev/null +++ b/source/app/app_paraid.h @@ -0,0 +1,15 @@ +#ifndef _app_paraid_H +#define _app_paraid_H + +#include "../clib/clib.h" +extern void L1_Iap_Read_us(vU16 addr,vU16 *val); + +extern void L1_Iap_Write_us(vU16 addr,vU16 val); +#define D_paraAdd0_paper150 0x0000 +#define D_paraAdd1_paper150 0x0200 +extern void L1_paraid_init(void); + +#endif //_app_paraid_H calib + + + diff --git a/source/app/app_task_adc.c b/source/app/app_task_adc.c new file mode 100644 index 0000000..2b5f684 --- /dev/null +++ b/source/app/app_task_adc.c @@ -0,0 +1,351 @@ +#include "app_task_adc.h" +#include "../msp/UART0.h" + +//TS_ADC_CH_SWITCH ts_adc_ch_switch; +TS_ADC_CH_SAMPLE ts_adc_ch_sample[D_ch_max_num]; +TS_ADC_CH_BLUR ts_adc_ch_blur[D_ch_max_num]; +TS_ADC_ALL_BLUR ts_adc_all_blur; +TS_ADC_ALL_OUT ts_adc_all_out; +TS_ADC_SHOW ts_adc_show; + +void L3_task_adc_init(void) +{ + U8 i = 0; + for(i=0;ich_n)) + { + L2_task_go(D_task_ADC_CHx_WAIT_LOW_LEVEL); + } + else + { + s->adcval = s->pool; + L2_task_go(D_task_ADC_CHx_OUT); + } + + TTSS_Task_step(D_task_ADC_CHx_WAIT_LOW_LEVEL) + if(0 == L0_2dc_DOUT_AT(s->ch)) + { + L2_task_go(D_task_ADC_CHx_READ); + } + + TTSS_Task_step(D_task_ADC_CHx_READ) + s->adcval = L0_ADS1231_readCH(s->ch); + L2_task_go(D_task_ADC_CHx_OUT); + + TTSS_Task_step(D_task_ADC_CHx_OUT) + s->pool = s->adcval; + s->sum += s->adcval; + ++s->n; + if(s->n >= D_ADC_CH_SAMPLE_BUF_MAX) + { + s->n = 0; + s->sum = 0; + } + L2_task_go(D_task_ADC_CHx_SAMPLE); + + TTSS_Task_end(); +} + +//单路滤波任务 +#define D_task_ADC_CHx_BLUR_GET 0x51 +#define D_task_ADC_CHx_BLUR_AVG 0x52 +#define D_task_ADC_CHx_BLUR_SHIFT 0x53 +#define D_task_ADC_CHx_BLUR_COUNT 0x54 + +void L3_task_adc_ch_blur(TS_ADC_CH_BLUR *s) +{ + TTSS_Task_init() + L2_task_go(D_task_ADC_CHx_BLUR_GET); + + TTSS_Task_step(D_task_ADC_CHx_BLUR_GET) + if(ts_adc_ch_sample[s->ch_n].n >= R.p.cc_blur_ch_avg) + { + s->SA_sum = ts_adc_ch_sample[s->ch_n].sum; + s->SA_n = ts_adc_ch_sample[s->ch_n].n; + ts_adc_ch_sample[s->ch_n].sum = 0; + ts_adc_ch_sample[s->ch_n].n = 0; + L2_task_go(D_task_ADC_CHx_BLUR_AVG); + } + + TTSS_Task_step(D_task_ADC_CHx_BLUR_AVG) + s->SA_avg = s->SA_sum / s->SA_n; + L2_task_go(D_task_ADC_CHx_BLUR_SHIFT); + + TTSS_Task_step(D_task_ADC_CHx_BLUR_SHIFT) + s->SHA_sum -= s->SHA_avg; + s->SHA_sum += s->SA_avg; + s->SHA_avg = (S32)(s->SHA_sum >> R.p.cc_blur_ch_shift); + s->n++; + L2_task_go(D_task_ADC_CHx_BLUR_COUNT); + + TTSS_Task_step(D_task_ADC_CHx_BLUR_COUNT) + G.weight[s->ch_n] = D_COUNT_WEIGHT(s->SHA_avg); + L2_task_go(D_task_ADC_CHx_BLUR_GET); + + TTSS_Task_end(); +} + + +//单路滤波任务 +#define D_task_ADC_ALL_BLUR_GET 0x51 +#define D_task_ADC_ALL_BLUR_SHIFT0 0x52 +#define D_task_ADC_ALL_BLUR_SHIFT1 0x53 + +void L3_task_adc_all_blur(TS_ADC_ALL_BLUR *s) +{ + TTSS_Task_init() + L2_task_go(D_task_ADC_CHx_BLUR_GET); + + TTSS_Task_step(D_task_ADC_CHx_BLUR_GET) + //if(ts_adc_ch_blur[D_ch_max_num-1].n >= 1) + if(ts_adc_ch_blur[0].n >= 1) + { + ts_adc_ch_blur[0].n = 0; + ts_adc_ch_blur[1].n = 0; + ts_adc_ch_blur[2].n = 0; + ts_adc_ch_blur[3].n = 0; + s->sum = G.weight[0] + G.weight[1] + G.weight[2] + G.weight[3]; + L2_task_go(D_task_ADC_ALL_BLUR_SHIFT0); + } + + TTSS_Task_step(D_task_ADC_ALL_BLUR_SHIFT0) + s->SHA_sum_0 -= s->SHA_avg_0; + s->SHA_sum_0 += s->sum; + s->SHA_avg_0 = (S32)(s->SHA_sum_0 >> R.p.cc_blur_all_shift0); + s->SHA_pool_0[0] = s->SHA_pool_0[1]; + s->SHA_pool_0[1] = s->SHA_pool_0[2]; + s->SHA_pool_0[2] = s->SHA_avg_0; + L2_task_go(D_task_ADC_ALL_BLUR_SHIFT1); + + TTSS_Task_step(D_task_ADC_ALL_BLUR_SHIFT1) + s->SHA_sum_1 -= s->SHA_avg_1; + s->SHA_sum_1 += s->sum; + s->SHA_avg_1 = (S32)(s->SHA_sum_1 >> R.p.cc_blur_all_shift1); + //s->SHA_pool_1[0] = s->SHA_pool_1[1]; + //s->SHA_pool_1[1] = s->SHA_pool_1[2]; + //s->SHA_pool_1[2] = s->SHA_avg_1; + + s->n++; + L2_task_go(D_task_ADC_CHx_BLUR_GET); + + TTSS_Task_end(); +} + +#define D_task_ADC_ALL_OUT_GET 0x51 +#define D_task_ADC_ALL_OUT_DECIDE 0x52 +#define D_task_ADC_ALL_OUT_SHOW 0x53 +#define D_task_ADC_ALL_OUT_SHOW_1 0x54 +#define D_task_ADC_ALL_OUT_DEBUG 0x55 + +void L3_task_adc_all_out(TS_ADC_ALL_OUT *s) +{ + TTSS_Task_init() + //s->diff_threshold = (R.p.cc_blur_all_out_threshold); + //s->diff_threshold1 = (R.p.cc_blur_all_out_threshold1); + //s->diff_threshold2 = (R.p.cc_blur_all_out_threshold2); + //s->should_show_times_threshold = (R.p.cc_blur_all_out_should_show_times_threshold); + L2_task_go(D_task_ADC_ALL_OUT_GET); + + TTSS_Task_step(D_task_ADC_ALL_OUT_GET) + if(ts_adc_all_blur.n >= 1) + { + ts_adc_all_blur.n = 0; + Lc_buf_copy_uc((U8*)s->SHA_pool, (U8*)ts_adc_all_blur.SHA_pool_0, D_ADC_CH_BLUE_POOL_NUM * sizeof(S32)); + s->SHA_diff[0] = Lc_abs(s->SHA_pool[1] , s->SHA_pool[0]); + s->SHA_diff[1] = Lc_abs(s->SHA_pool[2] , s->SHA_pool[1]); + s->SHA_ddiff[0] = Lc_abs(s->SHA_diff[1] , s->SHA_diff[0]); + L2_task_go(D_task_ADC_ALL_OUT_DECIDE); + } + + TTSS_Task_step(D_task_ADC_ALL_OUT_DECIDE) + if((s->SHA_diff[1] >= R.p.cc_blur_all_out_d_threshold) || (s->SHA_diff[0] >= R.p.cc_blur_all_out_d_threshold) || (s->SHA_ddiff[0] >= R.p.cc_blur_all_out_dd_threshold)) + { + #if 1 + s->sum = s->SHA_pool[2] + s->SHA_pool[1] + s->SHA_pool[0]; + ts_adc_all_blur.SHA_sum_1 = s->sum; + ts_adc_all_blur.SHA_sum_1 <<= R.p.cc_blur_all_shift1; + ts_adc_all_blur.SHA_sum_1 /= 3; + ts_adc_all_blur.SHA_avg_1 = (S32)(ts_adc_all_blur.SHA_sum_1 >> R.p.cc_blur_all_shift1); + //s->val = ts_adc_all_blur.SHA_avg_0; + s->val = s->sum / 3; + //s->t = 0; + #else + ts_adc_all_blur.SHA_sum_1 = ts_adc_all_blur.SHA_avg_0 << R.p.cc_blur_all_shift1; + ts_adc_all_blur.SHA_avg_1 = ts_adc_all_blur.SHA_avg_0; + s->val = ts_adc_all_blur.SHA_avg_0; + //s->t = 0; + #endif + } + else + { + s->val = ts_adc_all_blur.SHA_avg_1; + //s->t = 1; + } + s->n++; + L2_task_go(D_task_ADC_ALL_OUT_GET); + TTSS_Task_end(); +} + +#define D_task_ADC_SHOW_GET 0x53 +#define D_task_ADC_SHOW_1 0x54 +#define D_task_ADC_SHOW_DEBUG 0x55 +void L3_task_adc_show(TS_ADC_SHOW *s) +{ + U8 i = 0,find = 0,j = 0; + TTSS_Task_init() + L2_task_go(D_task_ADC_SHOW_GET); + + TTSS_Task_step(D_task_ADC_SHOW_GET) + if(ts_adc_all_out.n >= 1) + { + ts_adc_all_out.n = 0; + s->val = ts_adc_all_out.val; + L2_task_go(D_task_ADC_SHOW_1); + } + + TTSS_Task_step(D_task_ADC_SHOW_1) + if((s->val - s->pool_val) * s->pool_gt < 0) + { + //符号改变，计数清0 + //L0_uart0_uc('-'); + L3_task_show_times_reset(); + } + s->pool_gt = (s->val >= s->pool_val) ? 1 : -1; + + s->diff_val = Lc_abs(s->val,s->pool_val); + for(i=0;idiff_val >= R.p.weight_show_limit[i].weight) + { + find = 1; + break; + } + } + if(find) + { + s->times[i]++; + for(j=0;jtimes[j] = 0; + } + } + } + else //小于显示分辨率(<0.02kg) + { + L3_task_show_times_reset(); + } + + for(i=0;itimes[i] >= R.p.weight_show_limit[i].times) + { + L3_task_show_times_reset(); + s->pool_val = s->val; + G._total_weight = s->pool_val; + R.total_weight = L3_count_std_weight(G._total_weight); + break; + } + } + + L2_task_go(D_task_ADC_SHOW_GET); + //L2_task_go(D_task_ADC_SHOW_DEBUG); +#if 0 + TTSS_Task_step(D_task_ADC_SHOW_DEBUG) + //L0_uart0_uc(s->t == 0 ? '0' : '1'); + s->u16_v = (vU16)(s->pool_val >> 16); + L0_uart0_ushex(s->u16_v); + s->u16_v = (vU16)(s->pool_val & 0x0000ffff); + L0_uart0_ushex(s->u16_v);//Lc_delay_us(500); + //L0_uart0_uc(0x0d); L0_uart0_uc(0x0a); + //L0_uart0_uc(' '); + //L0_uart0_uc(' '); + L2_task_go(D_task_ADC_SHOW_GET); +#endif + TTSS_Task_end(); +} + + +void L3_task_show_times_reset() +{ + U8 i = 0; + for(i=0;iok) + { + TS_PH4_modbus *ts_modbus = (TS_PH4_modbus *)ph4->buf; + 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); + + switch(ts_modbus->oper) + { + case 0x06: + case 0x10: + //重新计算重量 + R.total_weight = L3_count_std_weight(G._total_weight); + //持久化 + L3_eeprom_persist_param(); + break; + } + } + } + #endif +} + + diff --git a/source/app/app_task_uart0.h b/source/app/app_task_uart0.h new file mode 100644 index 0000000..347829a --- /dev/null +++ b/source/app/app_task_uart0.h @@ -0,0 +1,11 @@ +#ifndef APP_TASK_UART0_H +#define APP_TASK_UART0_H + +#include "common.h" +#include "../ctask/task.h" +#include "../tpc/tpc_modbus.h" + +//extern void L3_task_uart0_handler(TS_Handle_PH3 *ph3); +extern void L3_task_uart0_modbus_handler(TP_Handler_X *ph4); + +#endif diff --git a/source/app/common.c b/source/app/common.c new file mode 100644 index 0000000..3b5bf8d --- /dev/null +++ b/source/app/common.c @@ -0,0 +1,230 @@ +#include "common.h" +//#include "../tpc/tpc_uart.h" +#include "../bsp/bsp_cs1232.h" +#include "../msp/msp_eeprom.h" +#include "../msp/msp_id.h" + +struct global_param G; +struct ts_eeprom_param eep_param; +struct ts_eeprom_enc eep_enc; + +#define EEP_SECTOR_SIZE 0x200 +#define EEP_PARAM_ADDR (EEP_SECTOR_SIZE * 1) +#define EEP_ENC_ADDR (EEP_SECTOR_SIZE * 0) + +void L3_eeprom_read_param() +{ + U8 dlen = 0; + L0_Iap_Read_array(EEP_PARAM_ADDR, (U8*)&eep_param, 2 + EEPROM_PARAM_DATA_MAX + 2); + if(eep_param.filter == EEPROM_PARAM_FILTER) + { + dlen = eep_param.len - 2; + crc16(eep_param.crc,(U8*)&eep_param,2+dlen); + if(eep_param.crc[0] == eep_param.buf[dlen] && eep_param.crc[1] == eep_param.buf[dlen+1]) + { + L0_uart0_uc('#'); + //Lc_buf_copy_uc((U8*)&G.p,(U8*)eep_param.buf,dlen); + Lc_buf_copy_uc((U8*)&R.p,(U8*)eep_param.buf,sizeof(R.p));//防止dlen>sizeof(G.P)引起的内存错误 + } + } +} + +void L3_eeprom_persist_param() +{ + U8 dlen = sizeof(R.p); + eep_param.filter = EEPROM_PARAM_FILTER; + eep_param.len = dlen + 2; + Lc_buf_copy_uc((U8*)eep_param.buf,(U8*)&R.p,dlen); + crc16(eep_param.crc, &eep_param, 2+dlen); + eep_param.buf[dlen] = eep_param.crc[0]; + eep_param.buf[dlen+1] = eep_param.crc[1]; + + L0_Iap_Erase(EEP_PARAM_ADDR); + L0_Iap_Program_array(EEP_PARAM_ADDR, (U8*)&eep_param, 2 + dlen + 2); +} + +int L3_mcu_id_ok(void) +{ + U8 i = 0,crc[2]; + U32 enc_key; + //1.获取MCU_ID + L0_id_get_rom(G.e.mcu_id); + for(i=0;i= weight) + { + break; + } + } + if(isalver = G.p.slaver_id; + pmodbus->oper = oper; + Lc_buf_copy_uc(pmodbus->buf,buf,bufsize); + crc16(pmodbus->crc,&pmodbus->salver,2 + bufsize); + pmodbus->buf[bufsize] = pmodbus->crc[0]; + pmodbus->buf[bufsize + 1] = pmodbus->crc[1]; + + return bufsize + 2 + 2; +} + +TS_PH4_modbus modbusack; +Modbus03 modbus03; +Modbus03Ack modbus03Ack; +Modbus06 modbus06; +Modbus06Ack modbus06Ack; +Modbus10 modbus10; +Modbus10Ack modbus10Ack; + +int L3_ph4_common_handler(TS_PH4_modbus *pmodbus) +{ + U8 handlerStatus = TP_HANDLED, modbuslen = 0; + switch(pmodbus->oper) + { + case 0x03: + { + U16 i = 0,j = 0,regval = 0; + modbus03.reg = ((U16)pmodbus->buf[0]) << 8 | ((U16)pmodbus->buf[1]); + modbus03.num = ((U16)pmodbus->buf[2]) << 8 | ((U16)pmodbus->buf[3]); + if((modbus03.num < 5) && (modbus03.reg < sizeof(G)/2)) //每次最多读取4个寄存器 8个字节，以防止越界 + { + for(i=0; i> 8 & 0xFF; + modbus03Ack.buf[j++] = regval & 0xFF; + } + modbus03Ack.bytes = modbus03.num * 2; + modbuslen = L3_pack_PH4(&modbusack, 0x03, &modbus03Ack, modbus03Ack.bytes + 1); + L0_uart0_sendArray((U8*)&modbusack, modbuslen); + } + break; + } + case 0x06: + { + modbus06.reg = ((U16)pmodbus->buf[0]) << 8 | ((U16)pmodbus->buf[1]); + modbus06.val = ((U16)pmodbus->buf[2]) << 8 | ((U16)pmodbus->buf[3]); + if(modbus06.reg < sizeof(G)/2) + { + if(modbus06.reg == MEM_2_REG(&G.p.zero)) + { + G._total_zweight = G._total_weight; + G.total_zweight = G._total_zweight/10; + G.total_weight = 0; + } + else if(modbus06.reg == MEM_2_REG(&G.p.reset)) + { + L3_reg_reset(); + } + else + { + *(REG_2_MEM(modbus06.reg)) = modbus06.val; + } + modbus06Ack.reg = modbus06.reg; + modbus06Ack.val = *(REG_2_MEM(modbus06.reg)); + modbuslen = L3_pack_PH4(&modbusack, 0x06, &modbus06Ack, 4); + L0_uart0_sendArray((U8*)&modbusack, modbuslen); + } + + //重新计算重量 + G.total_weight = L3_count_std_weight(G._total_weight); + + //持久化 + if(modbus06.reg > MEM_2_REG(&G.reserved2) && modbus06.reg < MEM_2_REG(&G.reserved3)) + { + L3_eeprom_persist_param(); + } + break; + } + case 0x10: + { + U16 i = 0,j = 0,regval = 0; + modbus10.reg = ((U16)pmodbus->buf[0]) << 8 | ((U16)pmodbus->buf[1]); + modbus10.num = ((U16)pmodbus->buf[2]) << 8 | ((U16)pmodbus->buf[3]); + modbus10.count = pmodbus->buf[4]; + if((modbus10.num < 21) && (modbus10.reg < sizeof(G)/2)) //每次最多写入20个寄存器 40个字节，以防止越界 + { + for(i=0; ibuf[5+i*2]) << 8 | ((U16)pmodbus->buf[5+i*2+1]); + *(REG_2_MEM(modbus10.reg + i)) = regval; + } + modbus10Ack.reg = modbus10.reg; + modbus10Ack.num = modbus10.num; + modbuslen = L3_pack_PH4(&modbusack, 0x10, &modbus10Ack, 4); + L0_uart0_sendArray((U8*)&modbusack, modbuslen); + } + + //重新计算重量 + G.total_weight = L3_count_std_weight(G._total_weight); + + //持久化 + if(modbus10.reg > MEM_2_REG(&G.reserved2) && modbus10.reg < MEM_2_REG(&G.reserved3)) + { + L3_eeprom_persist_param(); + } + break; + } + default: + //L3_ph4_send_error_pkg(MODBUS_ERR_OPCODE); + break; + } + return handlerStatus; +} +#endif + diff --git a/source/app/common.h b/source/app/common.h new file mode 100644 index 0000000..fb88fb8 --- /dev/null +++ b/source/app/common.h @@ -0,0 +1,75 @@ +#ifndef APP_COMMON_H +#define APP_COMMON_H + +#include "../clib/type.h" + +#define APP_VERSION 0x10 + +#define D_MCU_BIGENDIAN 1 +// #define D_MCU_LITTLEENDIAN 1 + +#define D_COUNT_WEIGHT(adc) ((S32)((1000.0 * R.p.weight_max * (adc)) / (2 * 0x7FFFFF / 1000 * D_ADS1213_GAIN_VAL * R.p.lmd))) + +enum tp_handle +{ + TP_HANDLED, + TP_UNHANDLE +}; + +/** + * EEPROM 存储结构 + */ +#define EEPROM_PARAM_DATA_MAX 90 +#define EEPROM_PARAM_FILTER 0xAA + +typedef struct ts_eeprom_param +{ + U8 filter; + U8 len; + U8 buf[EEPROM_PARAM_DATA_MAX]; + U8 crc[2]; +}EEPROM_PARAM; + +#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; + +#define baud_rade L3_baud_rate_change(G.p.baud_rate) + +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; + +#define D_ch_max_num 4 +typedef struct global_param +{ + //EncryptInfo + McuEncryptInfo e; + + //Global Variables + S32 weight[D_ch_max_num]; //4路重量 + S32 _total_weight; //实际重量*1000 + S32 _total_zweight; //实际皮重*1000 +}GlobalParam; + +extern struct global_param G; +extern struct ts_eeprom_param eep_param; +extern struct ts_eeprom_enc eep_enc; + +extern void L3_param_init(void); +extern int L3_mcu_id_ok(); +extern S32 L3_count_std_weight(S32 weight); +extern void L3_eeprom_persist_param(void); + +#endif + diff --git a/source/app/main.c b/source/app/main.c new file mode 100644 index 0000000..1ead5a2 --- /dev/null +++ b/source/app/main.c @@ -0,0 +1,183 @@ +////////////////////////////////////////////////////////////////////////// +/// COPYRIGHT NOTICE +/// Copyright (c) 2015, 传控科技 +/// All rights reserved. +/// +/// @file main.c +/// @brief main app +/// +///（本文件实现的功能的详述） +/// +/// @version 1.1 CCsens technology +/// @author CC +/// @date 20150102 +/// @note +/// +/// @version 1.2 CCsens technology +/// @author CC +/// @date 20180903 +/// @note cc_gsm_PD03SM_vh03_m10_debug01 +//20160413 CC-ACC-VH02 +//20170111 CC-ls_02 +// +//20170608 cc_as_stc01_main +// +//20180903 cc_gsm_PD03SM_vh03_m10_debug01 +// +// +/// @version 1.3 CCsens technology +/// @author CC +/// @date 20180903 +/// @note add calibrationg function +/// @version 1.4 CCsens technology +/// @author CC +/// @date 20190101 +/// @note add calibrationg function + +////////////////////////////////////////////////////////////////////////// + + +/// 下面是一个含有两个参数的函数的注释说明（简述） +/// +/// 这里写该函数的详述信息 +/// @param a 被测试的变量（param描述参数） +/// @param s 指向描述测试信息的字符串 +/// @return 测试结果（return描述返回值） +/// @see Test() （本函数参考其它的相关的函数，这里作一个链接） +/// @note (note描述需要注意的问题) +/************************************************ +stc5ac32s +程序结构 + + +有动静 + 并且采集的值小于c200 设置采集间隔缩短 + 采集值 在 c200>>>>>>>>>>>>>>>>>>>>_s_task_GC032A_>>>>>>>>>>>>>>>>>>>>>> + + + + +struct _s_task_GC032A_ s_task_GC032A; + +void L2_task_GC032A_init(void) +{ + L0_cam_isr_init(); + + L1_task_init(&s_task_GC032A.task); + ///L3_task_s_go(s_task_GC032A,D_task_init); + s_task_GC032A.next_line = D_clear; + s_task_GC032A.run = D_run; + s_task_GC032A.line_get = D_clear; + s_task_GC032A.cal_ok = D_clear; + s_task_GC032A.frames = 0; + s_task_GC032A.vs_ok = D_clear; + s_task_GC032A.line_en = D_ON; + s_task_GC032A.cal_en = D_OFF; +/// D_HSYNCS_open();//BITN_1(INT_CLKO, INT_EX2);//ʹINT2ж +} + +#if 10 + +///// get +void L2_task_GC032A_handle(struct _s_task_GC032A_ *s) +{ + + TTSS_Task_init(); + //PWDNͣ0 -- 1 -- ߣ + L0_GC032A_standby(); + L0_uart0_uc('2'); + L2_task_go(D_task_GC032A_init_DVDD); + TTSS_Task_step(D_task_GC032A_init_DVDD); + L0_GC032A_work(); + //IOVDDϵ磬ʱ50usϣ + D_cam_DVDD_on(); + // L0_uart0_uc('3'); + L2_task_go(D_task_GC032A_init_AVDD); + //L1_task_Tdelay(D_Tdelay_10ms); + TTSS_Task_step(D_task_GC032A_init_AVDD); + //AVDD28ϵ磬ʱ0us + D_cam_AVDD_on(); + L0_uart0_uc('4'); + L2_task_go(D_task_GC032A_init_pwdn); + TTSS_Task_step(D_task_GC032A_init_pwdn); + //ṩ032AϵͳƵ + /// L0_MCLKO_init(D_ON); + //L0_uart0_uc('n'); + //PWDNߣʱ + L0_GC032A_standby();DL0_WDT();// + L2_task_go(D_task_GC032A_init_pwdn_wait); + L1_task_Tdelay(D_Tdelay_10ms); + TTSS_Task_step(D_task_GC032A_init_pwdn_wait); + L0_GC032A_work(); + GC032a_L0_uart0_uc('5');/// Lc_delay_ms(20); + gRccUs03 = 0; + // L0_GC032A_write(GC6133_init_reg_tbl[gRccUs03][0],GC6133_init_reg_tbl[gRccUs03][1]);/// + L2_task_go(D_task_GC032A_write_reg); + //L2_task_go(0); + L1_task_Tdelay(D_Tdelay_10ms); + TTSS_Task_step(D_task_GC032A_write_reg); + //ͷ Լ2sʱ + if(0 != GC6133_init_reg_tbl[gRccUs03][0]) + { + //GC032a_L0_uart0_uc('k'); + L0_GC032A_write(GC6133_init_reg_tbl[gRccUs03][0],GC6133_init_reg_tbl[gRccUs03][1]);/// + gRccUs03 ++; + }else + { + L2_task_go(D_task_GC032A_div); + ///L1_task_Tdelay(D_Tdelay_500ms); + L1_task_Tdelay(D_Tdelay_1s);///Ҫ ʱܹؼaaaaaa + } + TTSS_Task_step(D_task_GC032A_div); + //L0_GC032A_write(0xfc,0x02); //λ?? + L0_GC032A_write(0xf8,0x03);/// ָƵ + L0_GC032A_write(0xfa,D_0xfa);DL0_WDT();// + GC032a_L0_uart0_uc('6'); + L2_task_go(D_task_GC032A_start_time); +///------------------------------------------------------cam init over +///------------------------------------------------------cam init over +///------------------------------------------------------cam init over + +////ȴ Ź + TTSS_Task_step(D_task_GC032A_start_time); + D_cam_led_on();D_VSYNCS_open(); + L1_GC032A_sleep(D_wakeup); + GC032a_L0_uart0_uc('7'); +/// s->one_line_ok = D_clear;D_ledb_OFF(); + L2_task_go(D_task_GC032A_led); + TTSS_Task_step(D_task_GC032A_led); + ///vs /```24.8ms````\__________________________..1.16s...____________________________/````````\___________ + ///cam_led ```````````\_________________________________________________________/`````````````````\____ + if(D_ready == s->vs_ok)///Ϊ˹ص + { + s_task_GC032A.vs_ok = D_clear; + D_cam_led_off(); GC032a_L0_uart0_uc('D'); + L2_task_go(D_task_GC032A_wait); + } + TTSS_Task_step(D_task_GC032A_wait);////>>>>>>>>>>>>>>>>>>>>>>>--- + ///Ҫ + + if(D_ready == s->line_get) + {DL0_WDT();// + s->line_get = D_clear; + /// 1.standby + /// D_cam_led_off(); + if(D_ON == s->line_en) + { + GC032a_L0_uart0_uc(0xfe); + GC032a_L0_uart0_uc(0xfd); + D_send_us(DR_pclk_n); + //D_send_us(s->lines); + L2_task_go(D_task_GC032A_send_line); + }else + { + L2_task_go(D_task_GC032A_cal); + } + + L1_task_Tdelay(D_Tdelay_10ms); + } + TTSS_Task_step(D_task_GC032A_send_line); + if(D_uart0_free()) + { + L0_uart0_sendArraylong(s->buf,0,199); + L2_task_go(D_task_GC032A_send2); + } + TTSS_Task_step(D_task_GC032A_send2); + if(D_uart0_free()) + { + L0_uart0_sendArraylong(s->buf,200,399); + L2_task_go(D_task_GC032A_send3); + } + TTSS_Task_step(D_task_GC032A_send3); + if(D_uart0_free()) + { + L0_uart0_sendArraylong(s->buf,400,599); + L2_task_go(D_task_GC032A_send4); + } + TTSS_Task_step(D_task_GC032A_send4); + if(D_uart0_free()) + { + L0_uart0_sendArraylong(s->buf,600,639); + L2_task_go(D_task_GC032A_send5); + } + TTSS_Task_step(D_task_GC032A_send5); + if(D_uart0_free()) + { + // 'fe','fd','fd','fc' + // GC032a_L0_uart0_uc(0xfd); + // GC032a_L0_uart0_uc(0xfc); + L2_task_go(D_task_GC032A_line1); + //L2_task_go(D_task_GC032A_sleep); + } + + TTSS_Task_step(D_task_GC032A_line1) + for(gRccUs03 = 1;gRccUs03 < 568;gRccUs03 ++) + { + if((s->buf[gRccUs03 - 1] == 0)&& + (s->buf[gRccUs03] == 1))//// _/`` + { + if(s->buf[gRccUs03 + 1] == 0) + {//_/`\_ Ҫ + + }else + {// ___/````ؿʼߵƽ + s->up_point = gRccUs03; + } + }else if((s->buf[gRccUs03 - 1] == 1)&& + (s->buf[gRccUs03] == 0))//// ``\_ ½ + { + s->down_point = gRccUs03; + + }else + { + + } + } + L2_task_go(D_task_GC032A_line2); + + TTSS_Task_step(D_task_GC032A_line2) + + D_send_us(s->up_point); + D_send_us(s->down_point); + D_send_us(s->down_point - s->up_point); + // DR_pdata_n =0; + // 'fe','fd','fd','fc' + GC032a_L0_uart0_uc(0xfd); + GC032a_L0_uart0_uc(0xfc); + if(D_ON == s->cal_en) + { + L2_task_go(D_task_GC032A_cal); + }else + { + L2_task_go(D_task_GC032A_sleep); + } + TTSS_Task_step(D_task_GC032A_cal) + + + GC032a_L0_uart0_uc('8');//2.1ms + L2_task_go(D_task_GC032A_sleep); + + + TTSS_Task_step(D_task_GC032A_sample); + ///20181007Գ ֶεled ͨvs ض Ƿֲõ + ///ʱled + D_cam_led_on();GC032a_L0_uart0_uc('`'); + L2_task_go(D_task_GC032A_sleep); + // L1_task_Tdelay(D_Tdelay_500ms+6); + TTSS_Task_step(D_task_GC032A_sleep); + /// յⲿrun ˯״̬ ͹Ĵ + ////CAL 10MS 433 10MS ܹ20ms / 1160ms/vs ȡ10ms + /////1160-10 - 20 = 1130ms + /// GC032a_L0_uart0_uc(0x88); + if(D_run == s->run) + { + GC032a_L0_uart0_uc('9');//2.1ms + L2_task_go(D_task_GC032A_led); + L1_task_Tdelay(D_Tdelay_10ms); + }else + { + D_cam_led_off(); + L1_GC032A_sleep(D_sleep); + L2_task_go(0); + } +///<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< + TTSS_Task_end(); +} + +#else + +///// get +void L2_task_GC032A_handle(struct _s_task_GC032A_ *s) +{ + + TTSS_Task_init(); + //PWDNͣ0 -- 1 -- ߣ + L0_GC032A_standby(); + L0_uart0_uc('2'); + L2_task_go(D_task_GC032A_init_DVDD); + TTSS_Task_step(D_task_GC032A_init_DVDD); + L0_GC032A_work(); + //IOVDDϵ磬ʱ50usϣ + D_cam_DVDD_on(); + // L0_uart0_uc('3'); + L2_task_go(D_task_GC032A_init_AVDD); + //L1_task_Tdelay(D_Tdelay_10ms); + TTSS_Task_step(D_task_GC032A_init_AVDD); + //AVDD28ϵ磬ʱ0us + D_cam_AVDD_on(); + L0_uart0_uc('4'); + L2_task_go(D_task_GC032A_init_pwdn); + TTSS_Task_step(D_task_GC032A_init_pwdn); + //ṩ032AϵͳƵ + /// L0_MCLKO_init(D_ON); + //L0_uart0_uc('n'); + //PWDNߣʱ + L0_GC032A_standby();DL0_WDT();// + L2_task_go(D_task_GC032A_init_pwdn_wait); + L1_task_Tdelay(D_Tdelay_10ms); + TTSS_Task_step(D_task_GC032A_init_pwdn_wait); + L0_GC032A_work(); + GC032a_L0_uart0_uc('5');/// Lc_delay_ms(20); + gRccUs03 = 0; + // L0_GC032A_write(GC6133_init_reg_tbl[gRccUs03][0],GC6133_init_reg_tbl[gRccUs03][1]);/// + L2_task_go(D_task_GC032A_write_reg); + //L2_task_go(0); + L1_task_Tdelay(D_Tdelay_10ms); + TTSS_Task_step(D_task_GC032A_write_reg); + //ͷ Լ2sʱ + if(0 != GC6133_init_reg_tbl[gRccUs03][0]) + { + //GC032a_L0_uart0_uc('k'); + L0_GC032A_write(GC6133_init_reg_tbl[gRccUs03][0],GC6133_init_reg_tbl[gRccUs03][1]);/// + gRccUs03 ++; + }else + { + L2_task_go(D_task_GC032A_div); + ///L1_task_Tdelay(D_Tdelay_500ms); + L1_task_Tdelay(D_Tdelay_1s);///Ҫ ʱܹؼaaaaaa + } + TTSS_Task_step(D_task_GC032A_div); + //L0_GC032A_write(0xfc,0x02); //λ?? + L0_GC032A_write(0xf8,0x03);/// ָƵ + L0_GC032A_write(0xfa,D_0xfa);DL0_WDT();// + GC032a_L0_uart0_uc('6'); + L2_task_go(D_task_GC032A_start_time); +///------------------------------------------------------cam init over +///------------------------------------------------------cam init over +///------------------------------------------------------cam init over + +////ȴ Ź + TTSS_Task_step(D_task_GC032A_start_time); + D_cam_led_on();D_VSYNCS_open(); + L1_GC032A_sleep(D_wakeup); + GC032a_L0_uart0_uc('7'); +/// s->one_line_ok = D_clear;D_ledb_OFF(); + L2_task_go(D_task_GC032A_led); + TTSS_Task_step(D_task_GC032A_led); + ///vs /```24.8ms````\__________________________..1.16s...____________________________/````````\___________ + ///cam_led ```````````\_________________________________________________________/`````````````````\____ + if(D_ready == s->vs_ok)///Ϊ˹ص + { + s_task_GC032A.vs_ok = D_clear; + D_cam_led_off(); GC032a_L0_uart0_uc('_'); + L2_task_go(D_task_GC032A_wait); + } + TTSS_Task_step(D_task_GC032A_wait);////>>>>>>>>>>>>>>>>>>>>>>>--- + ///Ҫ + if(1 == s->line_get) + {DL0_WDT();// + s->line_get = 0; + L2_task_go(D_task_GC032A_cal);//// м + } + TTSS_Task_step(D_task_GC032A_cal); + ///һ line + ///D_txd4_wakeup(); + ///GC032a_L0_uart0_uc(0xd); GC032a_L0_uart0_uc(0xa);// + s->buf[D_pclk_per_hs + 1] =s->buf[30]; + ///GC032a_L0_uart0_uchex(s->buf[D_pclk_per_hs + 1]); + gRccUs04 = 0; + for(gRccUs03 = 0;gRccUs03 < D_pclk_per_hs_2;gRccUs03 ++) + { //s->buf[gRccUs03] = 0x10; + //debug ʾǰյ + //L0_uart0_uc(s->buf[gRccUs03]); + if(s->buf[gRccUs03] >= 0x10) + { + s->buf[gRccUs03] -= 0x10; + } + s->buf[gRccUs03] >>= 1; + gRccUs04 += s->buf[gRccUs03]; + } + gRccUs04 >>= 2;//gRccUs04 >>= 4; + TS_paer_value.r123.paperNum = gRccUs04; + ///GC032a_L0_uart0_uchex((unsigned char)(gRccUs04>>8)); + s_task_GC032A.cal_ok = D_ready; + + L2_task_go(D_task_GC032A_sample);/// ʱʼ + L1_task_Tdelay(D_Tdelay_300ms); //700=1a 600=1e 500 21 400 25 300 26 + + TTSS_Task_step(D_task_GC032A_sample); + ///20181007Գ ֶεled ͨvs ض Ƿֲõ + ///ʱled + D_cam_led_on();GC032a_L0_uart0_uc('`'); + L2_task_go(D_task_GC032A_sleep); + // L1_task_Tdelay(D_Tdelay_500ms+6); + TTSS_Task_step(D_task_GC032A_sleep); + /// յⲿrun ˯״̬ ͹Ĵ + ////CAL 10MS 433 10MS ܹ20ms / 1160ms/vs ȡ10ms + /////1160-10 - 20 = 1130ms + /// GC032a_L0_uart0_uc(0x88); + if(D_run == s->run) + { + GC032a_L0_uart0_uc('r');//2.1ms + L2_task_go(D_task_GC032A_led); + }else + { + D_cam_led_off(); + L1_GC032A_sleep(D_sleep); + L2_task_go(0); + } +///<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< + TTSS_Task_end(); +} + + + + +#endif + +void L1_GC032A_sleep(unsigned char onf) +{///FE 15 Fd 33 44//standby +///FE 05 Fd 33 44//wakeup + if(D_sleep == onf) + { + GC032a_L0_uart0_uc('L'); + /// standby: + L0_GC032A_write(0xfc,0x03); L0_GC032A_write(0xf7,0x00); L0_GC032A_write(0xf9,0xcf); L0_GC032A_write(0xf3,0x00); + Lc_delay_nop(30); + Lc_delay_nop(30); + /// D_cam_AVDD_off(); + // D_cam_led_off(); + }else + { + GC032a_L0_uart0_uc('X'); + /// ˳standby: + L0_GC032A_write(0xfc,0x02); L0_GC032A_write(0xf7,0x01); L0_GC032A_write(0xf9,0xce); L0_GC032A_write(0xf3,0xff); + /// D_cam_led_on(); + } +} + +#if 10 +void L3_GC032A_fun(U8 *pPara) +{ + + +} +#else + +//// fe 01 reg data 0cx +/// Ac 01 02 03 ocr ---bsp_debug.c +/// p.cmd p.R2 p.R3 p.ocr +///Ac 00 03 01 00/// ACC_X[13:6] + +void L3_GC032A_fun(U8 *pPara) +{ + U8 i,val[2]; +// unsigned short j; + TS_P_debug *p = pPara; + switch(p->cmd) + { + + case 0x01: + ///AE 01 FE 33 44 // L0_GC032A_read(0xFE,&i,1); ȡǰҳ + ///AE 01 F0 33 44 // L0_GC032A_read(0xF0,&i,1); ȡid i= 0x23 + L0_GC032A_read(p->R2,&i,1); + L0_uart0_uc(i); + break; + //޸ͷò + case 0x02: + /// fe 02 r2 r3 xx üĴ(r2) = r3 + /// sysreg FE 02 FE 01 44 //õǰҳ01 + L0_GC032A_write(p->R2,p->R3); + L0_uart0_uc(p->R2); + L0_uart0_uc(p->R3); + break; + //ͷգ + case 0x03:/// sysreg FE 03 03 04 05 //ǷһlineݣݷΪһ֡=640Line = 640line*480pclk + ///AE 03 01 33 44 //s_task_GC032A.line_onf = 01 + ///AE 03 00 33 44 //s_task_GC032A.line_onf = 00 + s_task_GC032A.line_onf = p->R2; + L0_uart0_uc(0x30|s_task_GC032A.line_onf); + break; + case 0x05: + ///AE 05 01 33 44 // standby + ///AE 05 00 33 44 //˳ standby + L1_GC032A_sleep(p->R2); + L0_uart0_uc(0x30|s_task_GC032A.line_onf); + break; + case 6:///AE 06 22 33 44 + D_cam_led_off(); + break; + case 7:///AE 07 22 33 44 + D_cam_led_on(); + + break; + /******************* + case 0x00: + L0_GC032A_read(p->R2,val,p->R3); + L0_uart0_uc(p->cmd); + L0_uart0_uc(p->R2); + L0_uart0_uc(p->R3); + L0_uart0_uc('G'); + for(i = 0;i < p->R3;i++) + { + L0_uart0_uc(val[i]); + } + break; + //ȡͷò + case 0x35: + L0_GC032A_standby();// led 17.1-16.9ma standby 6.2ma + L0_uart0_uc(0x31); + break; + case 0x36: + /// ˳standby: + L0_GC032A_work(); + L0_uart0_uc(0x30); + break; + + + ****************************/ + + default: + break; + }; +} + +#endif + + + +#if 0 +FE 02 88 15 10 13 11 15 11 16 12 14 11 15 12 16 12 16 14 17 13 17 13 16 13 16 12 16 13 16 12 18 +14 15 12 15 13 15 12 16 14 15 13 15 12 15 13 16 14 18 14 17 13 16 10 16 15 1A 15 22 2D 3A 3F 47 +41 53 5E 63 65 69 6C 6F 71 7A 72 73 75 7A 7B 7E 7D 82 85 8B 8F 90 8F 93 96 9A 9D 9A 97 98 96 99 +9A 9B 9A 9C 9E 9F 9F 9D 9A 9A 99 9C 9B 9B 9A 9A 9B 9C 9D 9F 9F A0 A1 A2 A3 A2 A2 A3 A1 A3 A4 A4 +A4 A4 A3 A3 A2 A2 A3 A5 A6 A7 A8 A7 A6 A6 A5 A6 A6 A8 AA AA AA AA AA AB AB AB AC AC AB AC AC AD +AF AE AD AD AC AC AB AC AC AD AD AE AE AE AF AD AE AE AD AE AE AE AE AE AF AF AF AF AF AF B0 B1 +B1 B1 B2 B1 B1 B1 B1 B1 B1 B2 B2 B2 B3 B2 B2 B2 B3 B3 B3 B4 B4 B4 B4 B4 B4 B4 B4 B4 B4 B4 B4 B5 +B4 B5 B6 B5 B5 B4 B4 B4 B3 B4 B5 B5 B5 B5 B5 B5 B5 B5 B5 B5 B5 B5 B6 B6 B5 B6 B6 B6 B6 B6 B6 B6 +B6 B6 B6 B6 B6 B6 B6 B6 B7 B6 B6 B7 B6 B7 B7 B7 B7 B7 B7 B7 B7 B7 B7 B7 B7 B7 B7 B7 B7 B7 B7 B7 +B8 B7 B7 B8 B8 B7 B8 B8 B7 B8 B9 B8 B8 B8 B7 B7 B7 B7 B7 B7 B7 B7 B7 B7 B7 B7 B7 B8 B7 B7 B8 B8 +B8 B8 B8 B8 B8 B8 B7 B7 B7 B7 B8 B8 B9 B8 B9 B8 B8 B8 B8 B7 B7 B7 B7 B7 B8 B8 B8 B8 B8 B8 B8 B8 +B9 B8 B8 B8 B8 B9 BA B8 B8 B8 B7 B8 B8 B8 B8 B8 B8 B8 B9 B8 B7 B7 B7 B7 B7 B7 B6 B6 B7 B7 B7 B7 +B7 B7 B7 B8 B8 B8 B8 B8 B8 B8 B8 B8 B9 B9 B9 B8 B9 B8 B8 B9 BA B9 B8 B8 B8 B8 B9 B8 B9 B8 B8 B8 +B8 B8 B9 B9 B8 B9 B9 B9 B9 B8 B8 B8 B8 B8 B8 B8 B8 B8 B8 B8 B8 B9 B9 B8 B9 B9 B9 B9 B9 B9 BA B9 +B9 B9 B9 B9 B8 B9 B9 B9 B9 B9 B9 B9 B8 B9 B9 B9 B9 B9 B9 B9 B9 B9 BB B9 B9 B9 B9 B9 B9 B9 BA BA +BB B9 B8 B8 B8 B8 B8 B9 B9 BA BA B9 BA B9 B9 B9 B9 B9 B8 B8 B8 B8 B9 B9 B9 B9 BA BA BB B9 B9 B9 +B9 B9 B9 B9 B9 B9 B9 B9 B9 B9 B9 B9 BA B9 B9 B9 B9 BA BA BB BB BA BB BA B9 B9 B9 B9 B9 B9 B9 BA +BB BA BA BA BA B9 B8 B8 B8 B8 B8 B9 B9 BA BB BB BB BA BA B9 B9 B9 B9 B9 BA fd fc + + + +#endif + + + + + + + + + + + + + + diff --git a/source/bsp/backu/bsp_cam - 副本.c b/source/bsp/backu/bsp_cam - 副本.c new file mode 100644 index 0000000..e9c132c --- /dev/null +++ b/source/bsp/backu/bsp_cam - 副本.c @@ -0,0 +1,574 @@ +//////////////////////////////////////////////////////////////////////////// +///@copyright Copyright (c) 2018, ؿƼ All rights reserved. +///------------------------------------------------------------------------- +/// @file bsp_gc6133.c.c +/// @brief bsp @ driver config +///------------------------------------------------------------------------- +/// @version 1.0 +/// @author CC +/// @date 20180331 +/// @note cc_AS_stc02 +////////////////////////////////////////////////////////////////////////////// + +#include "Bsp_debug.h" +#include "bsp_func.h" +#include "bsp_power.h" +#include "bsp_cam_isr.h" +#include "bsp_cam.h" +#include "../msp/uart0.h" +#include "cw63xx.h" +#include "../clib/Clib.h" +#include "../clib/bit.h" +#include "../msp/time.h" + +TS_P_rf433 TS_paer_value= +{ + 0xaa,///vU8 ha; +// 0xaa,///vU8 hb; + 0xad, + 0x0123, +// 0x00,///U16 paperNum:12; //12bitֽ + ///U8 cameraIndex:2; //ͷ + ///U8 cameraWorking:1; //Ƿ + ///U8 reserved: 1; // + 0x56,///U8 cameraBoardPower; // + 0xcc//, 0xaa///vU8 hc; + +}; + +void GC032A_port_init(void) +{ + ///00 ׼˫ 20mA 270-150uS + ///01 20mA + ///10 + ///11 © open-Drain ڲϿ ©ģʽȿԶⲿ״̬ҲԶߵ͵ƽ + + //p3.6 --HSYNC +// BITN_0(P3M1,BITN6);BITN_0(P3M0,BITN6); + ///P3.7 -- VSYNC +// BITN_0(P3M1,BITN7);BITN_0(P3M0,BITN7); + L0_GC032A_standby(); + D_cam_AVDD_on(); + +} +////>>>>>>>>>>>>>>>>>>>>>_s_task_GC032A_>>>>>>>>>>>>>>>>>>>>>> + + + + +struct _s_task_GC032A_ s_task_GC032A; + +void L2_task_GC032A_init(void) +{ + L0_cam_isr_init(); + + L1_task_init(&s_task_GC032A.task); + ///L3_task_s_go(s_task_GC032A,D_task_init); + s_task_GC032A.next_line = D_clear; + s_task_GC032A.run = D_run; + s_task_GC032A.line_get = D_clear; + s_task_GC032A.cal_ok = D_clear; + s_task_GC032A.frames = 0; + s_task_GC032A.vs_ok = D_clear; + s_task_GC032A.line_en = D_ON; + s_task_GC032A.cal_en = D_OFF; +/// D_HSYNCS_open();//BITN_1(INT_CLKO, INT_EX2);//ʹINT2ж +} + +#if 10 + +///// get +void L2_task_GC032A_handle(struct _s_task_GC032A_ *s) +{ + + TTSS_Task_init(); + //PWDNͣ0 -- 1 -- ߣ + L0_GC032A_standby(); + L0_uart0_uc('2'); + L2_task_go(D_task_GC032A_init_DVDD); + TTSS_Task_step(D_task_GC032A_init_DVDD); + L0_GC032A_work(); + //IOVDDϵ磬ʱ50usϣ + D_cam_DVDD_on(); + // L0_uart0_uc('3'); + L2_task_go(D_task_GC032A_init_AVDD); + //L1_task_Tdelay(D_Tdelay_10ms); + TTSS_Task_step(D_task_GC032A_init_AVDD); + //AVDD28ϵ磬ʱ0us + D_cam_AVDD_on(); + L0_uart0_uc('4'); + L2_task_go(D_task_GC032A_init_pwdn); + TTSS_Task_step(D_task_GC032A_init_pwdn); + //ṩ032AϵͳƵ + /// L0_MCLKO_init(D_ON); + //L0_uart0_uc('n'); + //PWDNߣʱ + L0_GC032A_standby();DL0_WDT();// + L2_task_go(D_task_GC032A_init_pwdn_wait); + L1_task_Tdelay(D_Tdelay_10ms); + TTSS_Task_step(D_task_GC032A_init_pwdn_wait); + L0_GC032A_work(); + GC032a_L0_uart0_uc('5');/// Lc_delay_ms(20); + gRccUs03 = 0; + // L0_GC032A_write(GC6133_init_reg_tbl[gRccUs03][0],GC6133_init_reg_tbl[gRccUs03][1]);/// + L2_task_go(D_task_GC032A_write_reg); + //L2_task_go(0); + L1_task_Tdelay(D_Tdelay_10ms); + TTSS_Task_step(D_task_GC032A_write_reg); + //ͷ Լ2sʱ + if(0 != GC6133_init_reg_tbl[gRccUs03][0]) + { + //GC032a_L0_uart0_uc('k'); + L0_GC032A_write(GC6133_init_reg_tbl[gRccUs03][0],GC6133_init_reg_tbl[gRccUs03][1]);/// + gRccUs03 ++; + }else + { + L2_task_go(D_task_GC032A_div); + ///L1_task_Tdelay(D_Tdelay_500ms); + L1_task_Tdelay(D_Tdelay_1s);///Ҫ ʱܹؼaaaaaa + } + TTSS_Task_step(D_task_GC032A_div); + //L0_GC032A_write(0xfc,0x02); //λ?? + L0_GC032A_write(0xf8,0x03);/// ָƵ + L0_GC032A_write(0xfa,D_0xfa);DL0_WDT();// + GC032a_L0_uart0_uc('6'); + L2_task_go(D_task_GC032A_start_time); +///------------------------------------------------------cam init over +///------------------------------------------------------cam init over +///------------------------------------------------------cam init over + +////ȴ Ź + TTSS_Task_step(D_task_GC032A_start_time); + D_cam_led_on();D_VSYNCS_open(); + L1_GC032A_sleep(D_wakeup); + GC032a_L0_uart0_uc('7'); +/// s->one_line_ok = D_clear;D_ledb_OFF(); + L2_task_go(D_task_GC032A_led); + TTSS_Task_step(D_task_GC032A_led); + ///vs /```24.8ms````\__________________________..1.16s...____________________________/````````\___________ + ///cam_led ```````````\_________________________________________________________/`````````````````\____ + if(D_ready == s->vs_ok)///Ϊ˹ص + { + s_task_GC032A.vs_ok = D_clear; + D_cam_led_off(); GC032a_L0_uart0_uc('D'); + L2_task_go(D_task_GC032A_wait); + } + TTSS_Task_step(D_task_GC032A_wait);////>>>>>>>>>>>>>>>>>>>>>>>--- + ///Ҫ + + if(D_ready == s->line_get) + {DL0_WDT();// + s->line_get = D_clear; + /// 1.standby + /// D_cam_led_off(); + if(D_ON == s->line_en) + { + GC032a_L0_uart0_uc(0xfe); + GC032a_L0_uart0_uc(0xfd); + D_send_us(DR_pclk_n); + //D_send_us(s->lines); + L2_task_go(D_task_GC032A_send_line); + }else + { + L2_task_go(D_task_GC032A_cal); + } + + L1_task_Tdelay(D_Tdelay_10ms); + } + TTSS_Task_step(D_task_GC032A_send_line); + if(D_uart0_free()) + { + L0_uart0_sendArraylong(s->buf,0,199); + L2_task_go(D_task_GC032A_send2); + } + TTSS_Task_step(D_task_GC032A_send2); + if(D_uart0_free()) + { + L0_uart0_sendArraylong(s->buf,200,399); + L2_task_go(D_task_GC032A_send3); + } + TTSS_Task_step(D_task_GC032A_send3); + if(D_uart0_free()) + { + L0_uart0_sendArraylong(s->buf,400,509); + L2_task_go(D_task_GC032A_send5); + } + TTSS_Task_step(D_task_GC032A_send4); + if(D_uart0_free()) + { + L0_uart0_sendArraylong(s->buf,600,639); + L2_task_go(D_task_GC032A_send5); + } + TTSS_Task_step(D_task_GC032A_send5); + if(D_uart0_free()) + { + // 'fe','fd','fd','fc' + // GC032a_L0_uart0_uc(0xfd); + // GC032a_L0_uart0_uc(0xfc); + L2_task_go(D_task_GC032A_line1); + //L2_task_go(D_task_GC032A_sleep); + } + + TTSS_Task_step(D_task_GC032A_line1) + for(gRccUs03 = 1;gRccUs03 < 568;gRccUs03 ++) + { + if((s->buf[gRccUs03 - 1] == 0)&& + (s->buf[gRccUs03] == 1))//// _/`` + { + if(s->buf[gRccUs03 + 1] == 0) + {//_/`\_ Ҫ + + }else + {// ___/````ؿʼߵƽ + s->up_point = gRccUs03; + } + }else if((s->buf[gRccUs03 - 1] == 1)&& + (s->buf[gRccUs03] == 0))//// ``\_ ½ + { + s->down_point = gRccUs03; + + }else + { + + } + } + L2_task_go(D_task_GC032A_line2); + + TTSS_Task_step(D_task_GC032A_line2) + + D_send_us(s->up_point); + D_send_us(s->down_point); + D_send_us(s->down_point - s->up_point); + // DR_pdata_n =0; + // 'fe','fd','fd','fc' + GC032a_L0_uart0_uc(0xfd); + GC032a_L0_uart0_uc(0xfc); + if(D_ON == s->cal_en) + { + L2_task_go(D_task_GC032A_cal); + }else + { + L2_task_go(D_task_GC032A_sleep); + } + TTSS_Task_step(D_task_GC032A_cal) + + + GC032a_L0_uart0_uc('8');//2.1ms + L2_task_go(D_task_GC032A_sleep); + + + TTSS_Task_step(D_task_GC032A_sample); + ///20181007Գ ֶεled ͨvs ض Ƿֲõ + ///ʱled + D_cam_led_on();GC032a_L0_uart0_uc('`'); + L2_task_go(D_task_GC032A_sleep); + // L1_task_Tdelay(D_Tdelay_500ms+6); + TTSS_Task_step(D_task_GC032A_sleep); + /// յⲿrun ˯״̬ ͹Ĵ + ////CAL 10MS 433 10MS ܹ20ms / 1160ms/vs ȡ10ms + /////1160-10 - 20 = 1130ms + /// GC032a_L0_uart0_uc(0x88); + if(D_run == s->run) + { + GC032a_L0_uart0_uc('9');//2.1ms + L2_task_go(D_task_GC032A_led); + L1_task_Tdelay(D_Tdelay_10ms); + }else + { + D_cam_led_off(); + L1_GC032A_sleep(D_sleep); + L2_task_go(0); + } +///<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< + TTSS_Task_end(); +} + +#else + +///// get +void L2_task_GC032A_handle(struct _s_task_GC032A_ *s) +{ + + TTSS_Task_init(); + //PWDNͣ0 -- 1 -- ߣ + L0_GC032A_standby(); + L0_uart0_uc('2'); + L2_task_go(D_task_GC032A_init_DVDD); + TTSS_Task_step(D_task_GC032A_init_DVDD); + L0_GC032A_work(); + //IOVDDϵ磬ʱ50usϣ + D_cam_DVDD_on(); + // L0_uart0_uc('3'); + L2_task_go(D_task_GC032A_init_AVDD); + //L1_task_Tdelay(D_Tdelay_10ms); + TTSS_Task_step(D_task_GC032A_init_AVDD); + //AVDD28ϵ磬ʱ0us + D_cam_AVDD_on(); + L0_uart0_uc('4'); + L2_task_go(D_task_GC032A_init_pwdn); + TTSS_Task_step(D_task_GC032A_init_pwdn); + //ṩ032AϵͳƵ + /// L0_MCLKO_init(D_ON); + //L0_uart0_uc('n'); + //PWDNߣʱ + L0_GC032A_standby();DL0_WDT();// + L2_task_go(D_task_GC032A_init_pwdn_wait); + L1_task_Tdelay(D_Tdelay_10ms); + TTSS_Task_step(D_task_GC032A_init_pwdn_wait); + L0_GC032A_work(); + GC032a_L0_uart0_uc('5');/// Lc_delay_ms(20); + gRccUs03 = 0; + // L0_GC032A_write(GC6133_init_reg_tbl[gRccUs03][0],GC6133_init_reg_tbl[gRccUs03][1]);/// + L2_task_go(D_task_GC032A_write_reg); + //L2_task_go(0); + L1_task_Tdelay(D_Tdelay_10ms); + TTSS_Task_step(D_task_GC032A_write_reg); + //ͷ Լ2sʱ + if(0 != GC6133_init_reg_tbl[gRccUs03][0]) + { + //GC032a_L0_uart0_uc('k'); + L0_GC032A_write(GC6133_init_reg_tbl[gRccUs03][0],GC6133_init_reg_tbl[gRccUs03][1]);/// + gRccUs03 ++; + }else + { + L2_task_go(D_task_GC032A_div); + ///L1_task_Tdelay(D_Tdelay_500ms); + L1_task_Tdelay(D_Tdelay_1s);///Ҫ ʱܹؼaaaaaa + } + TTSS_Task_step(D_task_GC032A_div); + //L0_GC032A_write(0xfc,0x02); //λ?? + L0_GC032A_write(0xf8,0x03);/// ָƵ + L0_GC032A_write(0xfa,D_0xfa);DL0_WDT();// + GC032a_L0_uart0_uc('6'); + L2_task_go(D_task_GC032A_start_time); +///------------------------------------------------------cam init over +///------------------------------------------------------cam init over +///------------------------------------------------------cam init over + +////ȴ Ź + TTSS_Task_step(D_task_GC032A_start_time); + D_cam_led_on();D_VSYNCS_open(); + L1_GC032A_sleep(D_wakeup); + GC032a_L0_uart0_uc('7'); +/// s->one_line_ok = D_clear;D_ledb_OFF(); + L2_task_go(D_task_GC032A_led); + TTSS_Task_step(D_task_GC032A_led); + ///vs /```24.8ms````\__________________________..1.16s...____________________________/````````\___________ + ///cam_led ```````````\_________________________________________________________/`````````````````\____ + if(D_ready == s->vs_ok)///Ϊ˹ص + { + s_task_GC032A.vs_ok = D_clear; + D_cam_led_off(); GC032a_L0_uart0_uc('_'); + L2_task_go(D_task_GC032A_wait); + } + TTSS_Task_step(D_task_GC032A_wait);////>>>>>>>>>>>>>>>>>>>>>>>--- + ///Ҫ + if(1 == s->line_get) + {DL0_WDT();// + s->line_get = 0; + L2_task_go(D_task_GC032A_cal);//// м + } + TTSS_Task_step(D_task_GC032A_cal); + ///һ line + ///D_txd4_wakeup(); + ///GC032a_L0_uart0_uc(0xd); GC032a_L0_uart0_uc(0xa);// + s->buf[D_pclk_per_hs + 1] =s->buf[30]; + ///GC032a_L0_uart0_uchex(s->buf[D_pclk_per_hs + 1]); + gRccUs04 = 0; + for(gRccUs03 = 0;gRccUs03 < D_pclk_per_hs_2;gRccUs03 ++) + { //s->buf[gRccUs03] = 0x10; + //debug ʾǰյ + //L0_uart0_uc(s->buf[gRccUs03]); + if(s->buf[gRccUs03] >= 0x10) + { + s->buf[gRccUs03] -= 0x10; + } + s->buf[gRccUs03] >>= 1; + gRccUs04 += s->buf[gRccUs03]; + } + gRccUs04 >>= 2;//gRccUs04 >>= 4; + TS_paer_value.r123.paperNum = gRccUs04; + ///GC032a_L0_uart0_uchex((unsigned char)(gRccUs04>>8)); + s_task_GC032A.cal_ok = D_ready; + + L2_task_go(D_task_GC032A_sample);/// ʱʼ + L1_task_Tdelay(D_Tdelay_300ms); //700=1a 600=1e 500 21 400 25 300 26 + + TTSS_Task_step(D_task_GC032A_sample); + ///20181007Գ ֶεled ͨvs ض Ƿֲõ + ///ʱled + D_cam_led_on();GC032a_L0_uart0_uc('`'); + L2_task_go(D_task_GC032A_sleep); + // L1_task_Tdelay(D_Tdelay_500ms+6); + TTSS_Task_step(D_task_GC032A_sleep); + /// յⲿrun ˯״̬ ͹Ĵ + ////CAL 10MS 433 10MS ܹ20ms / 1160ms/vs ȡ10ms + /////1160-10 - 20 = 1130ms + /// GC032a_L0_uart0_uc(0x88); + if(D_run == s->run) + { + GC032a_L0_uart0_uc('r');//2.1ms + L2_task_go(D_task_GC032A_led); + }else + { + D_cam_led_off(); + L1_GC032A_sleep(D_sleep); + L2_task_go(0); + } +///<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< + TTSS_Task_end(); +} + + + + +#endif + +void L1_GC032A_sleep(unsigned char onf) +{///FE 15 Fd 33 44//standby +///FE 05 Fd 33 44//wakeup + if(D_sleep == onf) + { + GC032a_L0_uart0_uc('L'); + /// standby: + L0_GC032A_write(0xfc,0x03); L0_GC032A_write(0xf7,0x00); L0_GC032A_write(0xf9,0xcf); L0_GC032A_write(0xf3,0x00); + Lc_delay_nop(30); + Lc_delay_nop(30); + /// D_cam_AVDD_off(); + // D_cam_led_off(); + }else + { + GC032a_L0_uart0_uc('X'); + /// ˳standby: + L0_GC032A_write(0xfc,0x02); L0_GC032A_write(0xf7,0x01); L0_GC032A_write(0xf9,0xce); L0_GC032A_write(0xf3,0xff); + /// D_cam_led_on(); + } +} + +#if 10 +void L3_GC032A_fun(U8 *pPara) +{ + + +} +#else + +//// fe 01 reg data 0cx +/// Ac 01 02 03 ocr ---bsp_debug.c +/// p.cmd p.R2 p.R3 p.ocr +///Ac 00 03 01 00/// ACC_X[13:6] + +void L3_GC032A_fun(U8 *pPara) +{ + U8 i,val[2]; +// unsigned short j; + TS_P_debug *p = pPara; + switch(p->cmd) + { + + case 0x01: + ///AE 01 FE 33 44 // L0_GC032A_read(0xFE,&i,1); ȡǰҳ + ///AE 01 F0 33 44 // L0_GC032A_read(0xF0,&i,1); ȡid i= 0x23 + L0_GC032A_read(p->R2,&i,1); + L0_uart0_uc(i); + break; + //޸ͷò + case 0x02: + /// fe 02 r2 r3 xx üĴ(r2) = r3 + /// sysreg FE 02 FE 01 44 //õǰҳ01 + L0_GC032A_write(p->R2,p->R3); + L0_uart0_uc(p->R2); + L0_uart0_uc(p->R3); + break; + //ͷգ + case 0x03:/// sysreg FE 03 03 04 05 //ǷһlineݣݷΪһ֡=640Line = 640line*480pclk + ///AE 03 01 33 44 //s_task_GC032A.line_onf = 01 + ///AE 03 00 33 44 //s_task_GC032A.line_onf = 00 + s_task_GC032A.line_onf = p->R2; + L0_uart0_uc(0x30|s_task_GC032A.line_onf); + break; + case 0x05: + ///AE 05 01 33 44 // standby + ///AE 05 00 33 44 //˳ standby + L1_GC032A_sleep(p->R2); + L0_uart0_uc(0x30|s_task_GC032A.line_onf); + break; + case 6:///AE 06 22 33 44 + D_cam_led_off(); + break; + case 7:///AE 07 22 33 44 + D_cam_led_on(); + + break; + /******************* + case 0x00: + L0_GC032A_read(p->R2,val,p->R3); + L0_uart0_uc(p->cmd); + L0_uart0_uc(p->R2); + L0_uart0_uc(p->R3); + L0_uart0_uc('G'); + for(i = 0;i < p->R3;i++) + { + L0_uart0_uc(val[i]); + } + break; + //ȡͷò + case 0x35: + L0_GC032A_standby();// led 17.1-16.9ma standby 6.2ma + L0_uart0_uc(0x31); + break; + case 0x36: + /// ˳standby: + L0_GC032A_work(); + L0_uart0_uc(0x30); + break; + + + ****************************/ + + default: + break; + }; +} + +#endif + + + +#if 0 +FE 02 88 15 10 13 11 15 11 16 12 14 11 15 12 16 12 16 14 17 13 17 13 16 13 16 12 16 13 16 12 18 +14 15 12 15 13 15 12 16 14 15 13 15 12 15 13 16 14 18 14 17 13 16 10 16 15 1A 15 22 2D 3A 3F 47 +41 53 5E 63 65 69 6C 6F 71 7A 72 73 75 7A 7B 7E 7D 82 85 8B 8F 90 8F 93 96 9A 9D 9A 97 98 96 99 +9A 9B 9A 9C 9E 9F 9F 9D 9A 9A 99 9C 9B 9B 9A 9A 9B 9C 9D 9F 9F A0 A1 A2 A3 A2 A2 A3 A1 A3 A4 A4 +A4 A4 A3 A3 A2 A2 A3 A5 A6 A7 A8 A7 A6 A6 A5 A6 A6 A8 AA AA AA AA AA AB AB AB AC AC AB AC AC AD +AF AE AD AD AC AC AB AC AC AD AD AE AE AE AF AD AE AE AD AE AE AE AE AE AF AF AF AF AF AF B0 B1 +B1 B1 B2 B1 B1 B1 B1 B1 B1 B2 B2 B2 B3 B2 B2 B2 B3 B3 B3 B4 B4 B4 B4 B4 B4 B4 B4 B4 B4 B4 B4 B5 +B4 B5 B6 B5 B5 B4 B4 B4 B3 B4 B5 B5 B5 B5 B5 B5 B5 B5 B5 B5 B5 B5 B6 B6 B5 B6 B6 B6 B6 B6 B6 B6 +B6 B6 B6 B6 B6 B6 B6 B6 B7 B6 B6 B7 B6 B7 B7 B7 B7 B7 B7 B7 B7 B7 B7 B7 B7 B7 B7 B7 B7 B7 B7 B7 +B8 B7 B7 B8 B8 B7 B8 B8 B7 B8 B9 B8 B8 B8 B7 B7 B7 B7 B7 B7 B7 B7 B7 B7 B7 B7 B7 B8 B7 B7 B8 B8 +B8 B8 B8 B8 B8 B8 B7 B7 B7 B7 B8 B8 B9 B8 B9 B8 B8 B8 B8 B7 B7 B7 B7 B7 B8 B8 B8 B8 B8 B8 B8 B8 +B9 B8 B8 B8 B8 B9 BA B8 B8 B8 B7 B8 B8 B8 B8 B8 B8 B8 B9 B8 B7 B7 B7 B7 B7 B7 B6 B6 B7 B7 B7 B7 +B7 B7 B7 B8 B8 B8 B8 B8 B8 B8 B8 B8 B9 B9 B9 B8 B9 B8 B8 B9 BA B9 B8 B8 B8 B8 B9 B8 B9 B8 B8 B8 +B8 B8 B9 B9 B8 B9 B9 B9 B9 B8 B8 B8 B8 B8 B8 B8 B8 B8 B8 B8 B8 B9 B9 B8 B9 B9 B9 B9 B9 B9 BA B9 +B9 B9 B9 B9 B8 B9 B9 B9 B9 B9 B9 B9 B8 B9 B9 B9 B9 B9 B9 B9 B9 B9 BB B9 B9 B9 B9 B9 B9 B9 BA BA +BB B9 B8 B8 B8 B8 B8 B9 B9 BA BA B9 BA B9 B9 B9 B9 B9 B8 B8 B8 B8 B9 B9 B9 B9 BA BA BB B9 B9 B9 +B9 B9 B9 B9 B9 B9 B9 B9 B9 B9 B9 B9 BA B9 B9 B9 B9 BA BA BB BB BA BB BA B9 B9 B9 B9 B9 B9 B9 BA +BB BA BA BA BA B9 B8 B8 B8 B8 B8 B9 B9 BA BB BB BB BA BA B9 B9 B9 B9 B9 BA fd fc + + + +#endif + + + + + + + + + + + + + + diff --git a/source/bsp/backu/bsp_cam.c b/source/bsp/backu/bsp_cam.c new file mode 100644 index 0000000..00e44f6 --- /dev/null +++ b/source/bsp/backu/bsp_cam.c @@ -0,0 +1,706 @@ +//////////////////////////////////////////////////////////////////////////// +///@copyright Copyright (c) 2018, ؿƼ All rights reserved. +///------------------------------------------------------------------------- +/// @file bsp_gc6133.c.c +/// @brief bsp @ driver config +///------------------------------------------------------------------------- +/// @version 1.0 +/// @author CC +/// @date 20180331 +/// @note cc_AS_stc02 +////////////////////////////////////////////////////////////////////////////// + +#include "Bsp_debug.h" +#include "bsp_func.h" +#include "bsp_power.h" +#include "bsp_cam_isr.h" +#include "bsp_cam.h" +#include "../msp/uart0.h" +#include "cw63xx.h" +#include "../clib/Clib.h" +#include "../clib/bit.h" +#include "../msp/time.h" + +/// һȵڶӳ20ms ͬ,һ10.5ms ڶûз,ɸ + +#define D_p_send_delay(); L1_task_Cdelay(D_Cdelay_15ms*(1+D_cameralIndex)); + +////>>>>>>>>>>>>>>>>>>>>>_s_task_GC032A_>>>>>>>>>>>>>>>>>>>>>> + + +void L0_p_send(void); +extern TS_P_rf433 TS_paer_value; + + +struct _s_task_GC032A_ s_task_GC032A; + +void L2_task_GC032A_init(void) +{ + L0_cam_isr_init(); + + L1_task_init(&s_task_GC032A.task); + + s_task_GC032A.next_line = D_clear; + s_task_GC032A.line_ok = D_run; + s_task_GC032A.line_get = D_clear; + s_task_GC032A.cal_ok = D_clear; + s_task_GC032A.vs_ok = D_clear; +} + +//// ɼеij 20190217 +//// step01 ϵʱʼ +///step02 üĴ +///step03 жϽɼģʽ +///step04 ׽һ֡ ʼÿһ ͬʱԹرledԼ +/// step05 Ҫ ɼҪһ +/// step06------>״̬ +/// |----->ɼһ + + +#if(MODE_CAM_LINE == MODE_CAM) + + +#if 0 + +/// ɼʱһʱ led Ϊ´εcamṩԴ +/// ȴrunź رչ, fixme: +void L2_task_GC032A_handle(struct _s_task_GC032A_ *s) +{ + TTSS_Task_init() + //#define D_pclk_per_hs 6 +// PrintCam_L0_uart0_uc('$'); + L2_task_go(D_task_GC032A_init_standby); + TTSS_Task_step(D_task_GC032A_init_standby) + L0_GC032A_standby(); + D_cam_led_on(); + //PWDNͣ0 -- 1 -- ߣ + // PrintCam_L0_uart0_uc('2'); + L2_task_go(D_task_GC032A_init_DVDD); + TTSS_step01(D_task_GC032A_init_DVDD); + L0_GC032A_work(); + //IOVDDϵ磬ʱ50usϣ + L2_task_go(D_task_GC032A_init_AVDD); + TTSS_Task_step(D_task_GC032A_init_AVDD); + //AVDD28ϵ磬ʱ0us + D_cam_AVDD_on(); + L2_task_go(D_task_GC032A_init_pwdn); + TTSS_Task_step(D_task_GC032A_init_pwdn); + //ṩ032AϵͳƵ + L0_MCLKO_init(D_ON); + L2_task_GC032A_init(); + //PWDNߣʱ + L0_GC032A_standby(); + DL0_WDT();// + L2_task_go(D_task_GC032A_init_pwdn_wait); + L1_task_Cdelay(D_Cdelay_15ms); + TTSS_Task_step(D_task_GC032A_init_pwdn_wait); + L0_GC032A_work(); + gRccUs03 = 0; + L2_task_go(D_task_GC032A_write_reg); + L1_task_Cdelay(D_Cdelay_15ms); + TTSS_Task_step(D_task_GC032A_write_reg); + //ͷ Լ2sʱ + if(0 != GC6133_init_reg_tbl[gRccUs03][0]) + { + //GC032a_L0_uart0_uc('k'); + L0_GC032A_write(GC6133_init_reg_tbl[gRccUs03][0],GC6133_init_reg_tbl[gRccUs03][1]);/// + gRccUs03 ++; + }else + { + L2_task_go(D_task_GC032A_div); + L1_task_Tdelay(D_Tdelay_1s);///Ҫ ʱܹؼaaaaaa + } + TTSS_Task_step(D_task_GC032A_div); + //L0_GC032A_write(0xfc,0x02); //λ?? + L0_GC032A_write(0xf8,0x03);/// ָƵ + L0_GC032A_write(0xfa,D_0xfa);DL0_WDT(); + L2_task_go(D_task_GC032A_wakup_sample); +///------------------------------------------------------cam init over +///------------------------------------------------------cam init over +///------------------------------------------------------cam init over + +////ȴ Ź + TTSS_step03(D_task_GC032A_wakup_sample) + L1_GC032A_sleep(D_wakeup); + GC032a_L0_uart0_uc('w'); + ///D_ledb_OFF(); + L2_task_go((D_task_GC032A_wakup_sample2)); + L1_task_Tdelay(D_Tdelay_1s5); + TTSS_step04(D_task_GC032A_wakup_sample2); + D_VSYNCS_open();////̨жϿʼ + L2_task_go(D_task_GC032A_one_frame); +////////////////////////////////////////////////////////////////////////////// + TTSS_step04(D_task_GC032A_one_frame); + ////һ֡ݵĿʼ((ں̨ж)) + ///vs /```24.8ms````\__________________________..1.16s...____________________________/````````\___________ + ///cam_led ```````````\_________________________________________________________/`````````````````\____ + if(D_ready == s->vs_ok)///Ϊ˹ص + { + /// PrintCam_L0_uart0_uc('V'); + s_task_GC032A.vs_ok = D_clear; + D_cam_led_off(); + L2_task_go(D_task_GC032A_wait); + //L1_task_Tdelay(D_Tdelay_50ms); ////ȡgetline camҪƵʱ + } + TTSS_step05(D_task_GC032A_wait);////>>>>>>>>>>>>>>>>>>>>>>>--- + ///ҪLine(ں̨ж) + if(D_clear != s->line_get) + {DL0_WDT(); ////memo20190217 : 1.15s + //PrintCam_L0_uart0_uc(s->line_get);// L2_line_send(); + s->buf2_ok = D_ready;///buf2_ok׼ÿɹ㷨ѯ + L2_task_go(D_task_GC032A_sleep); + /// L1_task_Tdelay(D_Tdelay_10ms); + } + TTSS_Task_step(D_task_GC032A_sleep) + /// + L1_GC032A_sleep(D_sleep); + L0_GC032A_standby(); + L0_MCLKO_init(D_OFF); + D_cam_led_off(); + L2_task_go(D_task_FLOW_PreSend); + + ////>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> + TTSS_Task_step(D_task_FLOW_PreSend); + D_txd4_wakeup();/// 1ms433 sleepԷ + /// TS_paer_value.r123.cameraBoardPower = s->t_stamp+0x30; + L0_p_send(); + //D_txd4_low(); + L2_task_go(D_task_FLOW_send); + // L1_task_Tdelay(D_Tdelay_10ms); + ///L1_task_Cdelay(60);//2ms---mcu+433޷ + TTSS_Task_step(D_task_FLOW_send); + //D_txd4_wakeup(); + L0_uart0_sendArray((unsigned char *)&TS_paer_value,6); + L2_task_go(D_task_FLOW_send2); + TTSS_Task_step(D_task_FLOW_send2); + if(D_uart0_free()) + { + L2_task_go(D_task_FLOW_send3);/// + D_p_send_delay(); + + } + TTSS_Task_step(D_task_FLOW_send3); + L0_uart0_sendArray((unsigned char *)&TS_paer_value,6); + L2_task_go(D_task_FLOW_send4); + TTSS_Task_step(D_task_FLOW_send4); + if(D_uart0_free()) + { + L2_task_go(D_task_FLOW_send5); + } + TTSS_Task_step(D_task_FLOW_send5); + D_txd4_low();///ƺʱ15ms + D_cam_AVDD_off();///עӰ췢 + L2_task_go(0); + +///<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< + TTSS_Task_end(); +} +#endif + +#elif(MODE_CAM_FRAME == MODE_CAM) + +#elif(MODE_CAM_TEST == MODE_CAM) + +#define PrintCam_L0_uart0_uc(x) L0_uart0_uc(x) +#define PrintCam_D_send_us(x) L0_uart0_us(x) + +///#define L0_uart0_sendArraylong(a,start,end) L0_uart0_sendArray(a(start)) + +/// ɼʱһʱ led Ϊ´εcamṩԴ +/// ȴrunź رչ, fixme: +void L2_task_GC032A_handleTest(struct _s_task_GC032A_ *s) +{ + TTSS_Task_init() + //#define D_pclk_per_hs 6 +// PrintCam_L0_uart0_uc('$'); + L2_task_go(D_task_GC032A_init_standby); + TTSS_Task_step(D_task_GC032A_init_standby) + L0_GC032A_standby(); + D_cam_led_on(); + //PWDNͣ0 -- 1 -- ߣ + // PrintCam_L0_uart0_uc('2'); + L2_task_go(D_task_GC032A_init_DVDD); + TTSS_step01(D_task_GC032A_init_DVDD); + L0_GC032A_work(); + //IOVDDϵ磬ʱ50usϣ + L2_task_go(D_task_GC032A_init_AVDD); + TTSS_Task_step(D_task_GC032A_init_AVDD); + //AVDD28ϵ磬ʱ0us + D_cam_AVDD_on(); + L2_task_go(D_task_GC032A_init_pwdn); + TTSS_Task_step(D_task_GC032A_init_pwdn); + //ṩ032AϵͳƵ + L0_MCLKO_init(D_ON); + L2_task_GC032A_init(); + //PWDNߣʱ + L0_GC032A_standby(); + DL0_WDT();// + L2_task_go(D_task_GC032A_init_pwdn_wait); + L1_task_Cdelay(D_Cdelay_15ms); + TTSS_Task_step(D_task_GC032A_init_pwdn_wait); + L0_GC032A_work(); + gRccUs03 = 0; + L2_task_go(D_task_GC032A_write_reg); + L1_task_Cdelay(D_Cdelay_15ms); + TTSS_Task_step(D_task_GC032A_write_reg); + //ͷ Լ2sʱ + if(0 != GC6133_init_reg_tbl[gRccUs03][0]) + { + L0_GC032A_write(GC6133_init_reg_tbl[gRccUs03][0],GC6133_init_reg_tbl[gRccUs03][1]);/// + gRccUs03 ++; + }else + { + L2_task_go(D_task_GC032A_div); + L1_task_Tdelay(D_Tdelay_1s);///Ҫ ʱܹؼaaaaaa + } + TTSS_Task_step(D_task_GC032A_div); + //L0_GC032A_write(0xfc,0x02); //λ?? + L0_GC032A_write(0xf8,0x03);/// ָƵ + L0_GC032A_write(0xfa,D_0xfa);DL0_WDT(); + L2_task_go(D_task_GC032A_wakup_sample); +///------------------------------------------------------cam init over +///------------------------------------------------------cam init over +///------------------------------------------------------cam init over + +////ȴ Ź + TTSS_step03(D_task_GC032A_wakup_sample) + L1_GC032A_sleep(D_wakeup); + ///D_ledb_OFF(); + L2_task_go((D_task_GC032A_wakup_sample2)); + L1_task_Tdelay(D_Tdelay_1s5); + TTSS_step04(D_task_GC032A_wakup_sample2); + D_VSYNCS_open();////̨жϿʼ + PrintCam_L0_uart0_uc('w'); + L2_task_go(D_task_GC032A_one_frame); +////////////////////////////////////////////////////////////////////////////// + TTSS_step04(D_task_GC032A_one_frame); + + + PrintCam_L0_uart0_uc('.'); + + ////һ֡ݵĿʼ((ں̨ж)) + ///vs /```24.8ms````\__________________________..1.16s...____________________________/````````\___________ + ///cam_led ```````````\_________________________________________________________/`````````````````\____ + if(D_ready == s->vs_ok)///Ϊ˹ص + { + s->vs_ok = D_clear; + PrintCam_L0_uart0_uc('V'); +/// D_cam_led_off(); + D_HSYNCS_open(); + L2_task_go(D_task_GC032A_send2); + //L1_task_Tdelay(D_Tdelay_50ms); ////ȡgetline camҪƵʱ + } + + TTSS_Task_step(D_task_GC032A_send2)///----------------------ʼһһеķ + + if(1 == s_task_GC032A.line_ok) + { + s_task_GC032A.line_ok = 0; + /// + PrintCam_L0_uart0_uc(0xfe); + PrintCam_L0_uart0_uc(0xfd); + ///PrintCam_D_send_us(DR_pclk_n); + PrintCam_D_send_us(DR_line_n); + L0_uart0_sendArray(&s_task_GC032A.buf[0],200); + + L2_task_go(D_task_GC032A_06); + /// L1_task_Tdelay(D_Tdelay_50ms); + }else { } + TTSS_step06(D_task_GC032A_06); + /********************************************************* + TTS_for_add(s_task_GC032A.lines,0,627)///[0]--[199]199 + + /// s_task_GC032A.buf[s_task_GC032A.lines] = s_task_GC032A.lines; + s_task_GC032A.buf[s_task_GC032A.lines] = 0; + TTS_for_add_end() + + **************************************************/ + if(D_uart0_send_over()) + { + L0_uart0_sendArray(&s_task_GC032A.buf[200],200); + L2_task_go(D_task_GC032A_07); + } + TTSS_step06(D_task_GC032A_07); + if(D_uart0_send_over()) + { + L0_uart0_sendArray(&s_task_GC032A.buf[400],200); + L2_task_go(D_task_GC032A_08); + } + TTSS_step06(D_task_GC032A_08); + if(D_uart0_send_over()) + { + L0_uart0_sendArray(&s_task_GC032A.buf[600],D_pclk_per_hs-600);/// 628point + + // 'fe','fd','fd','fc' 46 44 20 46 43 0d 0a + PrintCam_L0_uart0_uc(0xfd); + PrintCam_L0_uart0_uc(0xfc); + s_task_GC032A.next_line = 1; + L2_task_go(D_task_GC032A_send2); + L1_task_Tdelay(D_Tdelay_10ms); + } +///<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< + TTSS_Task_end(); +} +#endif + +void L1_GC032A_sleep(unsigned char onf) +{///FE 15 Fd 33 44//standby +///FE 05 Fd 33 44//wakeup + if(D_sleep == onf) + { + // GC032a_L0_uart0_uc('L'); + /// standby: + L0_GC032A_write(0xfc,0x03); L0_GC032A_write(0xf7,0x00); L0_GC032A_write(0xf9,0xcf); L0_GC032A_write(0xf3,0x00); + Lc_delay_nop(30); + Lc_delay_nop(30); + }else + { + // GC032a_L0_uart0_uc('X'); + /// ˳standby: + L0_GC032A_write(0xfc,0x02); L0_GC032A_write(0xf7,0x01); L0_GC032A_write(0xf9,0xce); L0_GC032A_write(0xf3,0xff); + } +} + +void L2_line_send(void) +{ +#if 0 + PrintCam_L0_uart0_uc(0x0d); + PrintCam_L0_uart0_uc(0x0a); +// PrintCam_L0_uart0_uc(0xfe); +// PrintCam_L0_uart0_uc(0xfd); +PrintCam_D_send_us(DR_pclk_n); +/// PrintCam_D_send_us(s_task_GC032A.usSum); + PrintCam_L0_uart0_uc(0x09); +// PrintCam_D_send_us(0x1234); PrintCam_D_send_us(0x5678); PrintCam_D_send_us(0xabcd); + +// PrintCam_L0_uart0_uc(0x0d); +// PrintCam_L0_uart0_uc(0x0a); + PrintCam_L0_uart0_sendArray(&(s_task_GC032A.buf[50]),40); + + PrintCam_L0_uart0_uc(0x09); + PrintCam_L0_uart0_sendArray(&(s_task_GC032A.buf[50]),40); + PrintCam_L0_uart0_uc(0x09); + PrintCam_L0_uart0_sendArray(&s_task_GC032A.buf[D_pclk_per_hs_570-21],20); + + ///Lc_hex2ascii(&(s_task_GC032A.buf[0]),10,ts_uart_send_shop.buf); +// Lc_hex2ascii(&s_task_GC032A.buf[D_pclk_per_hs_570-10],2,ts_uart_send_shop.buf2); +// L0_uart0_sendArray(ts_uart_send_shop.buf2,2*3); +///#ifdef D_debug_add_send + +// PrintCam_L0_uart0_uc('P'); + + ///L0_uart0_sendArraylong(s_task_GC032A.buf,D_pclk_per_hs_570-10,D_pclk_per_hs_570); + // 'fe','fd','fd','fc' +// PrintCam_L0_uart0_uc(0xfd); +// PrintCam_L0_uart0_uc(0xfc); + PrintCam_L0_uart0_uc(0x0d); + PrintCam_L0_uart0_uc(0x0a); +///#else + /***** + ?? + 10 10 10 10 10 10 10 10 10 10 + 10 10 10 10 11 11 11 11 11 11 + 11 11 11 11 11 11 11 11 11 11 + 11 11 + 10 10 10 10 10 10 10 10 10 10 + 10 10 10 10 10 10 10 10 10 10 + CRpaper =04F8-g-offdiff :. + + ******/ + ///vU16 i; for(i = 0;i <= D_pclk_per_hs_570; i ++) {s_task_GC032A.buf[i]=i; } + PrintCam_L0_uart0_uc(0xfe); + PrintCam_L0_uart0_uc(0xfd); + PrintCam_D_send_us(DR_pclk_n); + L0_uart0_sendArray(s_task_GC032A.buf,200); + L0_uart0_sendArray(&s_task_GC032A.buf[200],200); + L0_uart0_sendArray(&s_task_GC032A.buf[400],(D_pclk_per_hs_570-400)); + +// PrintCam_D_send_us(ts_task_ALGO.usSum_temp); +//// PrintCam_D_send_us(s_task_GC032A.down_point); +// PrintCam_D_send_us(s_task_GC032A.down_point - s_task_GC032A.up_point); + // DR_pdata_n =0; +// PrintCam_D_send_us(0x1234); + // 'fe','fd','fd','fc' +// PrintCam_L0_uart0_uc(0xfd); +// PrintCam_L0_uart0_uc(0xfc); + #endif +/* */ +} + + +#if 0 + +void GC032A_port_init(void) +{ + ///00 ׼˫ 20mA 270-150uS + ///01 20mA + ///10 + ///11 © open-Drain ڲϿ ©ģʽȿԶⲿ״̬ҲԶߵ͵ƽ + + //p3.6 --HSYNC +// BITN_0(P3M1,BITN6);BITN_0(P3M0,BITN6); + ///P3.7 -- VSYNC +// BITN_0(P3M1,BITN7);BITN_0(P3M0,BITN7); + L0_GC032A_standby(); + D_cam_AVDD_on(); + +} + + + + + + + +//// AX CMD R2 R3 R4 +/// Ae 01 01 03 04 +void L3_GC032A_fun(U8 *pPara) +{ + *pPara = 0; +} + /******** +void L3_GC032A_fun(U8 *pPara) +{ + U8 i,val[2]; + // unsigned short j; + TS_P_debug *p = pPara; + switch(p->cmd) + { + + case 3: //Ae 03 03 04 00 + //xx 03 R2 R3 xx + + PrintCam_L0_uart0_uc(0x0d); + PrintCam_L0_uart0_uc(0x0a); + PrintCam_L0_uart0_uc('l'); + Lc_delay_ms(12); + s_task_GC032A.vline_get = p->R2 << 8; + s_task_GC032A.vline_get |= p->R3; + L0_uart0_uchex(p->R2); + Lc_delay_ms(12); + L0_uart0_uchex(p->R3); + Lc_delay_ms(1200); + PrintCam_L0_uart0_uc(0x0d); + PrintCam_L0_uart0_uc(0x0a); + PrintCam_L0_uart0_uc(0x0d); + PrintCam_L0_uart0_uc(0x0a); + PrintCam_L0_uart0_uc(0x0d); + PrintCam_L0_uart0_uc(0x0a); + + break; + + default: + break; + }; + + +} +********/ +///#else + +//// fe 01 reg data 0cx +/// Ac 01 02 03 ocr ---bsp_debug.c +/// U8 i,val[2]; +// unsigned short j; + TS_P_debug *p = pPara; + switch(p->cmd) + { + + case 0x01: p.cmd p.R2 p.R3 p.ocr +///Ac 00 03 01 00/// ACC_X[13:6] + +void L3_GC032A_fun(U8 *pPara) +{ + U8 i,val[2]; +// unsigned short j; + TS_P_debug *p = pPara; + switch(p->cmd) + { + + case 0x01: + ///AE 01 FE 33 44 // L0_GC032A_read(0xFE,&i,1); ȡǰҳ + ///AE 01 F0 33 44 // L0_GC032A_read(0xF0,&i,1); ȡid i= 0x23 + L0_GC032A_read(p->R2,&i,1); + PrintCam_L0_uart0_uc(i); + break; + //޸ͷò + case 0x02: + /// fe 02 r2 r3 xx üĴ(r2) = r3 + /// sysreg FE 02 FE 01 44 //õǰҳ01 + L0_GC032A_write(p->R2,p->R3); + PrintCam_L0_uart0_uc(p->R2); + PrintCam_L0_uart0_uc(p->R3); + break; + //ͷգ + case 0x03:/// sysreg FE 03 03 04 05 //ǷһlineݣݷΪһ֡=640Line = 640line*480pclk + ///AE 03 01 33 44 //s_task_GC032A.line_onf = 01 + ///AE 03 00 33 44 //s_task_GC032A.line_onf = 00 + s_task_GC032A.line_onf = p->R2; + PrintCam_L0_uart0_uc(0x30|s_task_GC032A.line_onf); + break; + case 0x05: + ///AE 05 01 33 44 // standby + ///AE 05 00 33 44 //˳ standby + L1_GC032A_sleep(p->R2); + PrintCam_L0_uart0_uc(0x30|s_task_GC032A.line_onf); + break; + case 6:///AE 06 22 33 44 + D_cam_led_off(); + break; + case 7:///AE 07 22 33 44 + D_cam_led_on(); + + break; + /******************* + case 0x00: + L0_GC032A_read(p->R2,val,p->R3); + PrintCam_L0_uart0_uc(p->cmd); + PrintCam_L0_uart0_uc(p->R2); + PrintCam_L0_uart0_uc(p->R3); + PrintCam_L0_uart0_uc('G'); + for(i = 0;i < p->R3;i++) + { + PrintCam_L0_uart0_uc(val[i]); + } + break; + //ȡͷò + case 0x35: + L0_GC032A_standby();// led 17.1-16.9ma standby 6.2ma + PrintCam_L0_uart0_uc(0x31); + break; + case 0x36: + /// ˳standby: + L0_GC032A_work(); + PrintCam_L0_uart0_uc(0x30); + break; + + + ****************************/ + + default: + break; + }; +} + +#endif + + + +#if 0 +254 253 + +FE FD 02 7F ///639 +1A 1B 1B 1B 1B 1B 1A 1C 1B 1B 1B 1A 1A 19 19 1A 19 1A 19 1A 19 1A 19 19 18 19 19 18 18 18 18 18 18 18 18 18 18 18 18 18 18 18 18 17 16 17 16 18 18 18 18 18 18 18 18 18 18 18 18 17 17 17 17 18 18 17 17 17 17 17 16 17 17 17 17 18 18 18 18 18 18 18 18 18 18 18 18 18 18 18 18 18 17 17 17 17 17 17 17 17 17 17 18 18 18 18 18 19 19 19 19 19 19 18 18 19 19 19 18 18 18 1A 19 19 19 19 19 1A 1A 1A 1A 1A 1A 19 19 18 19 19 19 1A 1A 1A 1B 1B 1B 1C 1C 1C 1C 1C 1C 1C 1D 1D 1D 1C 1C 1C 1C 1D 1E 1C 1C 1C 1D 1C 1C 1C 1C 1C 1C 1C 1D 1D 1D 1D 1C 1B 1A 1B 1A 1B 1D 1D 1D 1D 1D 1C 1C 1C 1C 1C 1C 1C 1C 1C 1C 1C 1B 1B 1B 1B 1B 1B 1C 1C 1C 1C 1B 1B 1C 1C 1C 1E 1C 1C 1C 1C 1C 1C 1C 1C 1C 1C 1C 1C 1B 1C 1B 1C 1C 1D 1D 1C 1C 1C 1C 1C 1C 1C 1C 1C 1C 1C 1C 1D 1D 1D 1C 1C 1C 1C 1C 1D 1D 1E 1D 1E 1F 1F 1E 1E 1E 1E 1E 1E 1E 1E 1D 1D 1C 1C 1C 1C 1C 1C 1C 1C 1C 1D 1D 1D 1D 1C 1D 1D 1D 1D 1D 1E 1E 1E 1E 1E 1E 1E 1E 1E 1E 1E 1E 1D 1C 1C 1C 1C 1C 1C 1C 1B 1C 1C 1C 1C 1C 1C 1C 1C 1C 1C 1B 1C 1C 1C 1C 1C 1C 1D 1C 1C 1C 1C 1D 1F 1F 1D 1C 1C 1B 1C 1C 1C 1C 1C 1C 1B 1B 1B 1B 1B 1B 1B 1C 1C 1C 1C 1C 1D 1C 1C 1C 1D 1D 1D 1D 1E 1D 1C 1C 1C 1C 1C 1C 1C 1C 1D 1D 1E 1E 1E 1D 1D 1D 1D 1C 1D 1C 1C 1C 1C 1D 1D 1D 1D 1C 1C 1C 1C 1C 1C 1B 1B 1C 1C 1C 1C 1B 1B 1B 1B 1D 1B 1C 1B 1B 1B 1C 1D 1C 1B 19 1A 19 1B 1C 1A 1A 1A 1A 1A 1A 1B 1B 1B 1A 1B 19 1B 1A 1A 1A 1A 1A 19 18 19 19 1A 1A 1A 1A 1A 19 19 18 18 18 18 18 1A 18 18 18 18 18 18 18 18 19 1A 19 19 19 19 19 19 19 1A 1A 1A 1A 19 19 18 18 18 18 18 18 19 18 18 18 19 18 18 18 18 18 1A 18 18 18 18 18 18 18 18 17 17 17 18 18 18 18 17 17 17 17 17 16 17 17 18 18 19 19 19 19 19 19 18 18 18 18 18 18 17 17 18 18 17 17 17 17 17 17 19 17 17 17 17 17 17 17 17 17 17 17 17 18 17 17 17 17 17 17 17 17 16 16 17 17 17 17 17 16 16 17 17 17 17 16 16 16 16 16 16 16 17 16 16 16 16 16 16 16 16 16 16 18 19 16 16 16 16 15 16 17 17 16 15 15 16 16 16 15 14 14 15 17 15 15 15 15 16 16 16 16 16 15 16 16 16 15 15 15 15 15 +FD FC +253 252 + +254 253 /639./ 253 252 + + +#endif + + + + + +#if 0/// memo +//memo20190217 : 1.15s + /********* + [15:37:04.337]աv 4.337 + [15:37:05.487]աv 5.487 1.15 + [15:37:06.637]աv 6.637 1.15 + [15:37:07.787]աk 7.787 1.15 + [15:37:08.947]աv 8.947 1.16 + [15:37:10.097]աv 10.097 1.15 + [15:37:11.247]աv 11.247 1.15 + [15:37:12.397]աv 12.397 1.15 + [15:37:13.547]աk 13.547 1.15 + 48 31 61 77 77 77 77 2E 56 77 77 77 33 76 01 D3 56 2E 77 77 77 00 + + ***/ + +void GC032A_port_init(void) +{ + ///00 ׼˫ 20mA 270-150uS + ///01 20mA + ///10 + ///11 © open-Drain ڲϿ ©ģʽȿԶⲿ״̬ҲԶߵ͵ƽ + //p3.6 --HSYNC +// BITN_0(P3M1,BITN6);BITN_0(P3M0,BITN6); + ///P3.7 -- VSYNC +// BITN_0(P3M1,BITN7);BITN_0(P3M0,BITN7); +// L0_GC032A_standby(); +// D_cam_AVDD_on(); +} + +void L2_line_send(void) +{ +// /// vU16 usi; + PrintCam_D_send_us(0x1234); + PrintCam_D_send_us(0x5678); + PrintCam_D_send_us(0xabcd); +#if 0 + + PrintCam_L0_uart0_uc(0x0d); + PrintCam_L0_uart0_uc(0x0a); +// PrintCam_L0_uart0_uc(0xfe); +// PrintCam_L0_uart0_uc(0xfd); + PrintCam_D_send_us(DR_pclk_n); + PrintCam_D_send_us(0x1234); + PrintCam_D_send_us(0x5678); + PrintCam_D_send_us(0xabcd); + + PrintCam_L0_uart0_uc(0x0d); + PrintCam_L0_uart0_uc(0x0a); + + PrintCam_L0_uart0_sendArray(&(s_task_GC032A.buf[0]),2); + + PrintCam_L0_uart0_uc(0x09); +/// PrintCam_L0_uart0_sendArray(&s_task_GC032A.buf[D_pclk_per_hs_570-10],9); + ///Lc_hex2ascii(&(s_task_GC032A.buf[0]),10,ts_uart_send_shop.buf); + Lc_hex2ascii(&s_task_GC032A.buf[D_pclk_per_hs_570-10],2,ts_uart_send_shop.buf2); + L0_uart0_sendArray(ts_uart_send_shop.buf2,2*3); +///#ifdef D_debug_add_send + + PrintCam_L0_uart0_uc('P'); + + ///L0_uart0_sendArraylong(s_task_GC032A.buf,D_pclk_per_hs_570-10,D_pclk_per_hs_570); + // 'fe','fd','fd','fc' +// PrintCam_L0_uart0_uc(0xfd); +// PrintCam_L0_uart0_uc(0xfc); +// PrintCam_L0_uart0_uc(0x0d); +// PrintCam_L0_uart0_uc(0x0a); +///#else + + [18:41:16.591]?????02 FE FD 02 42 12 12 12 12 12 12 12 12 12 12 12 11 11 11 11 11 11 11 11 11 11 11 11 11 12 12 12 12 12 12 12 12 12 12 12 11 11 11 11 11 11 11 12 12 12 13 13 14 15 16 16 17 18 18 17 17 16 16 17 19 1C 1F 25 28 2A 2C 2D 2E 2F 30 31 31 32 32 32 32 31 31 32 32 32 32 33 33 33 33 33 33 33 33 33 33 33 33 33 32 32 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 34 33 34 34 34 34 34 34 34 34 34 34 34 35 35 34 35 35 35 35 35 35 36 35 35 36 36 11 11 11 FD FC + + + + PrintCam_L0_uart0_uc(0xfe); + PrintCam_L0_uart0_uc(0xfd); + PrintCam_D_send_us(DR_pclk_n); + L0_uart0_sendArraylong(s_task_GC032A.buf,0,199); + L0_uart0_sendArraylong(s_task_GC032A.buf,200,399); + if(D_pclk_per_hs < 600) + { + L0_uart0_sendArraylong(s_task_GC032A.buf,400,599); + }else + { + L0_uart0_sendArraylong(s_task_GC032A.buf,400,599); + L0_uart0_sendArraylong(s_task_GC032A.buf,600,(D_pclk_per_hs-1)); + } +// PrintCam_D_send_us(ts_task_ALGO.usSum_temp); +//// PrintCam_D_send_us(s_task_GC032A.down_point); +// PrintCam_D_send_us(s_task_GC032A.down_point - s_task_GC032A.up_point); + // DR_pdata_n =0; +// PrintCam_D_send_us(0x1234); + // 'fe','fd','fd','fc' + PrintCam_L0_uart0_uc(0xfd); + PrintCam_L0_uart0_uc(0xfc); + #endif +/* */ +} + +#endif + + diff --git a/source/bsp/backu/bsp_cam.h b/source/bsp/backu/bsp_cam.h new file mode 100644 index 0000000..bc1f645 --- /dev/null +++ b/source/bsp/backu/bsp_cam.h @@ -0,0 +1,189 @@ +//////////////////////////////////////////////////////////////////////////// +///@copyright Copyright (c) 2018, ؿƼ All rights reserved. +///------------------------------------------------------------------------- +/// @file bsp_gc6133.c.h +/// @brief bsp @ driver config +///------------------------------------------------------------------------- +/// @version 1.0 +/// @author CC +/// @date 20180331 +/// @note cc_AS_stc02 + +////////////////////////////////////////////////////////////////////////////// + +#ifndef _bsp_cam_H +#define _bsp_cam_H + +#include "../bsp/bsp_config.h" + +#include "../tpc/tpc_uart.h" + +#include "../msp/uart0.h" + +#include "bsp_gc032a.h" + +//>>>>>>>>>>>>>>>>>>>>>0gc63xxtask + +//#define D_i2c_addr_gc61xx 0x80 //page8/30 @pdf +#define D_i2c_addr_gc032A 0x42 //page15/31 @pdf +///// 400KHz Tlow > 1.3us +#define L0_GC032A_write(R,D) L2_I2C_WriteCmd(D_i2c_addr_gc032A,(R),(D)) +#define L0_GC032A_read(R,D,N) L2_I2C_ReadReg(D_i2c_addr_gc032A,(R),(D),(N)) +#define L0_GC032A_reg(R,D) L2_tws_ReadReg(D_i2c_addr_gc032A,(R),(D)) + + /// p55 pwdn + /// p54 inclk + /// p3.7 vsync + /// p3.6 hsync +#if 0 +#define L0_GC032A_work() D_P55_OFF(); +#define L0_GC032A_standby() + +#else +#define L0_GC032A_work() D_P55_OFF();D_stdIO_P1_ALL();\ + D_stdIO_P5(BITN4);\ + D_stdIO_P5(BITN5);\ + D_stdIO_P3(BITN7);\ + D_stdIO_P3(BITN6); +#define L0_GC032A_standby() D_HighR_P1_ALL();\ + D_HighI_P5(BITN4);\ + D_HighI_P5(BITN5);\ + D_HighI_P3(BITN7);\ + D_HighI_P3(BITN6);D_P55_ON(); +///pwdn 100uAD_P55_OFF();// + + +#endif + + + +#define GC6123_SERIAL_write_cmos_sensor L0_GC032A_write + +///#define D_pclk_per_hs 628 +///#define D_pclk_per_hs 688 +#define D_pclk_per_hs 639 ///027F + +#define D_pclk_per_hs_570 570 + +//#define D_pclk_per_hs 580 + +#define D_pclk_per_hs_2 D_pclk_per_hs +///#define D_pclk_per_hs_2 (110) + +//#define D_pclk_per_hs 6 + +struct _s_task_GC032A_ +{ + TS_task task; +/// vU32 t_stamp; + unsigned short lines; ///ǰв + unsigned short frames; ///ǰв + + unsigned char next_line:1; ///һвʼ + unsigned char cal_ok:1; ///ǰв// + unsigned char lamp:1; ///ǰƵı־ + unsigned char line_get:1; ///ǰҪв Լ + unsigned char line_ok:1; /// Ŀ + unsigned char vs_ok:1; /// ʼһ֡IJ յvsź + unsigned char line_onf:2; /// D_line_onf_get=0Ҫ͵һline\\ D_line_onf_all=1 line + + +// volatile unsigned short usHs_count; +// volatile unsigned short usPclk; + unsigned char buf2_ok; + +/// volatile unsigned short usN; +////// unsigned short usMax; + unsigned char buf[D_pclk_per_hs +2]; +}; +#define D_line_onf_all 1 +#define D_line_onf_get 0 + + +extern struct _s_task_GC032A_ s_task_GC032A; + + +void L2_task_GC032A_init(void); + +#define D_task_GC032A_init_standby 0x36 + +#define D_task_GC032A_init_DVDD 0x30 +#define D_task_GC032A_init_AVDD 0x31 +#define D_task_GC032A_init_pwdn 0x32 +#define D_task_GC032A_init_pwdn_wait 0x33 + + +#define D_task_FLOW_PreSend 0xa3 +#define D_task_FLOW_PreSend2 0xa4 + + + + +#define D_task_FLOW_send 0x90 +#define D_task_FLOW_send2 0x91 +#define D_task_FLOW_send3 0x92 +#define D_task_FLOW_send4 0x93 +#define D_task_FLOW_send5 0x94 + + + +#define D_task_GC032A_write_reg 0x40 +#define D_task_GC032A_wakup_sample 0x41 +#define D_task_GC032A_start_time2 0x43 + +#define D_task_GC032A_wakup_sample2 0x44 + + +#define D_task_GC032A_wait 0x51 +#define D_task_GC032A_one_frame 0x52 +#define D_task_GC032A_write_reg2 0x53 +#define D_task_GC032A_div 0x54 +#define D_task_GC032A_dat 0x55 + + +#define D_task_GC032A_led 0x56 + + + +#define D_task_GC032A_send_line 0x61 +#define D_task_GC032A_send2 0x62 +#define D_task_GC032A_send3 0x63 +#define D_task_GC032A_send4 0x64 + +////#define D_task_GC032A_over 0x63 +#define D_task_GC032A_cal 0x65 +///#define D_task_GC032A_send_over 0x64 + +#define D_task_GC032A_sleep 0x67 +#define D_task_GC032A_06 0x68 +#define D_task_GC032A_07 0x69 +#define D_task_GC032A_08 0x6a +#define D_task_GC032A_09 0x6b + +#define D_task_GC032A_sample 0x68 + +#define D_task_GC032A_end 0x69 + +#define D_task_GC032A_next_line 0x70 + + +extern void L2_task_GC032A_handle(struct _s_task_GC032A_ *s); +extern void L2_task_GC032A_handleTest(struct _s_task_GC032A_ *s); + + +//////////////////////////////////////////////////////////////////// + + +extern void GC032A_port_init(void); +extern void L3_GC032A_fun(U8 *pPara); + +extern void L1_GC032A_sleep(unsigned char onf); + +#define D_cam_led_on(); L1_cw63_reg_set(D_power_VCC2,D_CW63XX_ON|D_CW63XX_3V2);//P34 = 1;/////s_task_GC032A.lamp = D_ON; +#define D_cam_led_off(); L1_cw63_reg_set(D_power_VCC2,D_CW63XX_OFF|D_CW63XX_3V2);///P34 = 0;/////s_task_GC032A.lamp = D_OFF; + + + + +#endif // #ifndef _bsp_gc6133_H + diff --git a/source/bsp/backu/bsp_cam_isr.c b/source/bsp/backu/bsp_cam_isr.c new file mode 100644 index 0000000..f3a7f8f --- /dev/null +++ b/source/bsp/backu/bsp_cam_isr.c @@ -0,0 +1,218 @@ +//////////////////////////////////////////////////////////////////////////// +///@copyright Copyright (c) 2018, ؿƼ All rights reserved. +///------------------------------------------------------------------------- +/// @file bsp_gc6133.c.c +/// @brief bsp @ driver config +///------------------------------------------------------------------------- +/// @version 1.0 +/// @author CC +/// @date 20180331 +/// @note cc_AS_stc02 +///------------------------------------------------------------------------- +/// @version 1.2 +/// @author CC +/// @date 20180703 +/// @note cc_AS_stc02 +////////////////////////////////////////////////////////////////////////////// + +//#include "Bsp_debug.h" +#include "bsp_func.h" +#include "bsp_cam_isr.h" +#include "bsp_cam.h" +#include "../msp/uart0.h" +#include "cw63xx.h" +#include "../clib/Clib.h" +#include "../clib/bit.h" +#include "../msp/time.h" +#define D_pclk_div_hs 1 ///D_pclk_per_hs*D_pclk_div_hs < 680 + +///vs p3.7 int3 +///hs p3.6 int2 +///pclk p3.2 int0 +/// row lineȷԱʾһ һе˼.columnıʾһġ + +#define D_line_get 10 +#define D_row_get2 4 +#ifdef doc_98989 +vs /```24.8ms````\_______________________________..1.16s..._____________________________________________/```````````\__________ +hs /\/\_2.14MS_/\____/\____/\____ ...... __/\____/\____/\__480__/\____/\____/\____/\/\ + +hs /``\________________________hs______________________/``\ +pclk |||||||||||||||||||||||||||||||||||||||||||||||640 + + +Line0 L1 L2 L1 L1 L1 L1 L1 L1 L480 +---------------------------------------------------------------------- + 1 1 1 1 1 1 1 1 1 --- --- 1 + 2 2 2 2 2 2 2 2 2 --- --- 2 + 3 3 3 3 3 3 3 3 3 --- --- 3 + 4 4 4 4 4 4 4 4 4 --- --- 4 + 5 5 5 5 5 5 5 5 5 --- --- 5 + 6 6 6 6 6 6 6 6 6 --- --- 6 + 7 7 7 7 7 7 7 7 7 --- --- 7 + 8 8 8 8 8 8 8 8 8 --- --- 8 + 9 9 9 9 9 9 9 9 9 --- --- 9 + 10 10 10 10 10 10 10 10 10 --- --- 10 + 11 11 11 11 11 11 11 11 11 --- --- 11 + 12 12 12 12 12 12 12 12 12 --- --- 12 + 13 13 13 13 13 13 13 13 13 --- --- 13 + 14 14 14 14 14 14 14 14 14 --- --- 14 + . . . . . . . . . --- --- . + . . . . . . . . . --- --- . + . . . . . . . . . --- --- . + . . . . . . . . . --- --- . + 640 640 640 640 640 640 640 640 640 --- --- 640 + +#endif ///doc_98989 + + +void L0_cam_isr_init(void) +{ + IT0 = 1;///int0 ½ش = 0 ؾɴ +/// IT0 = 0;////int0 ½ش = 0 ؾɴ +/// L0_INT0_OPEN(); + D_HSYNCS_close(); + D_VSYNCS_open(); + D_PCLK_close(); + +} + +#if(MODE_CAM_LINE == MODE_CAM) + + +#if 0 +////////// +/////һ֡ݵĿʼ +void L0_VSYNCS_Isr (void) interrupt D_ISR_int3////½ +{////ҵһ֡ݵĿͷһ + L0_INT3_CLEAR(); + ///s_task_GC032A.usHs_count = 0; + DR_line_n = 0; +/// s_task_GC032A.next_line = D_ready;///һ ȷ֡ͷǵһУ/// +/// s_task_GC032A.one_line_ok = D_clear; + s_task_GC032A.line_get = D_clear; + s_task_GC032A.vs_ok = D_ready; + //s_task_GC032A.frames ++; + //if(s_task_GC032A.frames > 10) + {/// ʱ + ///s_task_GC032A.frames = 0; + } + D_ledb_OFF(); +/// D_leda_ON(); + D_HSYNCS_open(); +} + +/////һline rowݵĿʼ +void L0_HSYNCS_Isr(void) interrupt D_ISR_int2/// using 1 /½ +{///hs Ч + L0_INT2_CLEAR(); + //// hsźŵļvsЧʱ㣬usHs_count=D_row_getʹ + //// ǰһ֡ĵD_row_gethsҲһеĵڼ + ///if(D_ready == s_task_GC032A.next_line) + {///D_P33_REV(); + //D_leda_OFF(); + /// s_task_GC032A.next_line = D_clear;///ΪһݵʱԶԶСڷ͵ʱ + ///Ϊ߿ɿ + ///˺ɡgc032a + s_task_GC032A.lines = DR_line_n;////浱ǰкŵ,Ϊкű仯ٶȳ + ////͵ٶ,"gc032A"ʹõʱDR_line_n Ѿ仯 + ///0 24 58 94 129 165 200 236 271 307 342 378 + D_PCLK_open(); + //D_P35_REV() ; + DR_pclk_n = 0; + if(DR_line_n >= D_line_get) + { + s_task_GC032A.line_get = D_ready; + D_HSYNCS_close();D_PCLK_close(); + } + } + DR_line_n ++;///ǰ +} + +////s_task_GC032A.buf ŵһе +//// pclk int0 ÿIJ +void L0_PCLK_Isr(void) interrupt D_ISR_int0 /// using 10/// +{///PCLK +// D_P34_REV(); + DR_Dat = P1; + s_task_GC032A.buf[DR_pclk_n] = DR_Dat; // s_task_GC032A.buf[DR_pclk_n] = 0xaa;//P1&0xf0; //s_task_GC032A.buf[s_task_GC032A.usN] = s_task_GC032A.usN; + DR_pclk_n++;// D_P34_REV(); + if(DR_pclk_n > D_pclk_per_hs)////һеЧݽ D_pclk_per_hs̶ + { + D_PCLK_close(); + + //D_ledb_REV() ; + DR_pclk_n = D_pclk_per_hs; ///fixme + DR_pclk_n = 0; +/// s_task_GC032A.one_line_ok = D_ready;////gc032a񡱴Ϣ Կʼ߷ + D_ledb_ON(); + } +} +#endif + +#elif(MODE_CAM_FRAME == MODE_CAM) + +#elif(MODE_CAM_TEST == MODE_CAM) +///// +void L0_VSYNCS_Isr (void) interrupt D_ISR_int3////½ +{////ҵһ֡ݵĿͷһ + ///s_task_GC032A.usHs_count = 0; + DR_line_n = 0; + s_task_GC032A.next_line = 1;///һ ȷ֡ͷǵһУ/// + s_task_GC032A.vs_ok = D_ready; +} + +/////һline rowݵĿʼ +void L0_HSYNCS_Isr(void) interrupt D_ISR_int2/// using 1 /½ +{///hs Ч + //// hsźŵļvsЧʱ㣬usHs_count=D_row_getʹ + //// ǰһ֡ĵD_row_gethsҲһеĵڼ + if(s_task_GC032A.next_line) + {///D_P33_REV(); + s_task_GC032A.next_line = 0;///ΪһݵʱԶԶСڷ͵ʱ + ///Ϊ߿ɿ + ///˺ɡgc032a + s_task_GC032A.lines = DR_line_n;////浱ǰкŵ,Ϊкű仯ٶȳ + ////͵ٶ,"gc032A"ʹõʱDR_line_n Ѿ仯 + ///0 24 58 94 129 165 200 236 271 307 342 378 + + /***** + if(D_line_get == DR_line_n) + { + s_task_GC032A.line_get = 1; + } + ******/ + D_PCLK_open();///¼һ + DR_pclk_n = 0; + } + DR_line_n ++;///ǰ +} + +////s_task_GC032A.buf ŵһе +//// pclk int0 ÿIJ +void L0_PCLK_Isr(void) interrupt D_ISR_int0 //// using 10/// +{///PCLK +// D_P34_REV(); +//// DR_Dat = P1; s_task_GC032A.buf[DR_pclk_n] = DR_Dat; + s_task_GC032A.buf[DR_pclk_n] = P1; + + + ////s_task_GC032A.buf[DR_pclk_n] = 0xcc; + ///s_task_GC032A.buf[DR_pclk_n] = DR_pclk_n; + DR_pclk_n++;// D_P34_REV(); + if(DR_pclk_n > D_pclk_per_hs) ////һеЧݽ D_pclk_per_hs̶ + { + D_PCLK_close(); + DR_pclk_n = D_pclk_per_hs; ///fixme + + s_task_GC032A.line_ok = 1; ////gc032a񡱴Ϣ Կʼ߷ + } +} + + +////յ next_line ¼ǰڼlines pclkɼݵbufУȻline_ok +///// send buf, set next_line after send buf over + +#endif + + diff --git a/source/bsp/backu/bsp_cam_isr.h b/source/bsp/backu/bsp_cam_isr.h new file mode 100644 index 0000000..bac07b9 --- /dev/null +++ b/source/bsp/backu/bsp_cam_isr.h @@ -0,0 +1,62 @@ +//////////////////////////////////////////////////////////////////////////// +///@copyright Copyright (c) 2018, ؿƼ All rights reserved. +///------------------------------------------------------------------------- +/// @file bsp_gc6133.c.h +/// @brief bsp @ driver config +///------------------------------------------------------------------------- +/// @version 1.0 +/// @author CC +/// @date 20180331 +/// @note cc_AS_stc02 + +////////////////////////////////////////////////////////////////////////////// + +#ifndef _bsp_cam_isr_H +#define _bsp_cam_isr_H + +#include "../bsp/bsp_config.h" + +#include "../tpc/tpc_uart.h" + +#include "../msp/uart0.h" + +#include "bsp_gc032a.h" + +#define D_VSYNCS_open(); L0_INT3_OPEN(); +#define D_VSYNCS_close(); L0_INT3_CLOSE(); + +#define D_HSYNCS_open(); L0_INT2_OPEN(); +#define D_HSYNCS_close(); L0_INT2_CLOSE(); + +#define D_PCLK_open(); L0_INT0_OPEN(); +#define D_PCLK_close(); L0_INT0_CLOSE(); + + +#define DR_pclk_n gRccUs05 + +#define DR_line_n gRccUs01 +#define DR_line_n_H gRccUs01_H +#define DR_line_n_L gRccUs01_L + + +///// #define DR_Hs_count gRccUs02//s_task_GC032A.usPclk +///#define DR_Dat CCAP1L +#define DR_Dat SPDAT + +//>>>>>>>>>>>>>>>>>>>>>0gc63xxtask + +//#define D_row_max 640 + +//////////////////////////////////////////////////////////////////// + + +extern void L0_cam_isr_init(void) ; + + + + + + + +#endif // #ifndef _bsp_cam_isr_H + diff --git a/source/bsp/backu/bsp_func.c b/source/bsp/backu/bsp_func.c new file mode 100644 index 0000000..bcc170f --- /dev/null +++ b/source/bsp/backu/bsp_func.c @@ -0,0 +1,53 @@ +//////////////////////////////////////////////////////////////////////////// +///@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 + + + +////////////////////////////////////////////////////////////////////////////// + +#include "bsp_func.h" +#include "../msp/uart0.h" +//#include "../tpc/tpc_modbus.h" + +///struct _s_sysclk s_sysclk; + + +////MCLK0 ҪʱرԽԼ +void L0_MCLKO_init(U8 onf) +{ + BITN_1(P_SW2,EAXFR); + CKSEL &= B0000_0011; + if (D_ON == onf) + { + ///----------------------------------------------------- + // p107@stc8.pdf + ///step 1 :system out clock + //BITS_CLR(CKSEL,BITC_4,BIT4); /// REG BITxʼ Nλ + ///λãһҪʹãá + BITS_SET(CKSEL,D_CLKODIV_DIV8);/// sytem out clock 300k + ///step 2 :IO + BITN_0(CKSEL,MCLKO_S);/// P5.4 SELECTED + BITN_0(P5M1,BITN4);BITN_1(P5M0,BITN4);/// 01 + } + else + { + BITS_CLR(CKSEL,BITC_4,BIT4); + BITN_1(P5M1,BITN4);BITN_0(P5M0,BITN4);/// 00 ׼˫01 10 11 © + //// 32k L1_task_Tdelay(D_Tdelay_ms); ˴Լ8s + ///fixme + /// BITN_1(P5M1,BITN4);BITN_0(P5M0,BITN4);/// 00 ׼˫01 10 11 © + ///? ʹ10 11.130 ʹ01 Ϊ10.65 + //P54 = 1; Ȼȸʡ =1=0ʡ 10uA + } + BITN_0(P_SW2,EAXFR); +} + + diff --git a/source/bsp/backu/bsp_func.h b/source/bsp/backu/bsp_func.h new file mode 100644 index 0000000..194f7f0 --- /dev/null +++ b/source/bsp/backu/bsp_func.h @@ -0,0 +1,52 @@ +//////////////////////////////////////////////////////////////////////////// +///@copyright Copyright (c) 2018, ؿƼ All rights reserved. +///------------------------------------------------------------------------- +/// @file bsp_func.c +/// @brief bsp_func +///------------------------------------------------------------------------- +/// @version 1.0 +/// @author CC +/// @date 20170122 +/// @note cc_AS_stc01 +////////////////////////////////////////////////////////////////////////////// + +#ifndef _bsp_func_H +#define _bsp_func_H + +#include "../bsp/bsp_config.h" +#include "../clib/bit.h" +struct _s_sysclk +{ + U32 m; + U32 clk; + U32 out; +}; + +extern struct _s_sysclk s_sysclk; + +#define P3130 0 +//#define P1617 0 +#define P3736 1 + +extern void L0_MCLKO_init(U8 onf); + + +#define D_CLKODIV_NONE 0 + +#define D_CLKODIV_DIV1 B0001_0000 +#define D_CLKODIV_DIV2 B0010_0000 +#define D_CLKODIV_DIV4 B0100_0000 +#define D_CLKODIV_DIV8 B0110_0000 +#define D_CLKODIV_DIV16 B1000_0000 +#define D_CLKODIV_DIV32 B1010_0000 +#define D_CLKODIV_DIV64 B1100_0000 +#define D_CLKODIV_DIV128 B1110_0000 + +#define D_CLKODIV_MCLKO_S BITN3 + +#define D_CLKODIV_MCKSEL_IN24M B0000_0000 +#define D_CLKODIV_MCKSEL_EXTERN B0000_0001 +#define D_CLKODIV_MCKSEL_IN32K B0000_0011 + +#endif // #ifndef _bsp_func_H + diff --git a/source/bsp/backu/bsp_gc032a.c b/source/bsp/backu/bsp_gc032a.c new file mode 100644 index 0000000..6650b50 --- /dev/null +++ b/source/bsp/backu/bsp_gc032a.c @@ -0,0 +1,773 @@ +#include "bsp_gc032a.h" +#if 0 +const U8 GC6133_init_reg_sys[][2]= { + + /*System*/ + {0xf3,0xff}, + {0xf5,0x06}, + {0xf7,0x01}, + {0xf9,0xce}, + {0xfa,0x00}, +//1002 {0xf8,0x03},//////Ƶ {0xf8,0x03}, +{0xf8,0x0f},//////Ƶ {0xf8,0x03}, + // {0xfa,D_0xfa}, // cc add + /// {0xfd,D_0xfa}, // cc add + /// {0xfa,D_0xfa}, // cc add + /// {0xfd,D_0xfa}, // cc add +///20181002ʱʹýϸƵ ָƵ + {0xfc,0x02}, + {0x00,0x00} +/// ///20181003 +// +}; + + +const U8 GC6133_init_reg_tbl[][2]= { + {0xfe,0x02},//page 2 + {0x81,0x03}, + + {0xfe,0x00}, + {0x77,0x64}, + {0x78,0x40}, + {0x79,0x60}, + /*ANALOG & CISCTL*/ + {0xfe,0x00},//page 0 + {0x03,0x01}, + {0x04,0xce}, + {0x05,0x01}, + {0x06,0xad}, + {0x07,0x00}, + {0x08,0x10}, + {0x0a,0x00}, + {0x0c,0x00}, + {0x0d,0x01}, + {0x0e,0xe8}, + {0x0f,0x02}, + {0x10,0x88}, + {0x17,0x54}, + {0x19,0x08}, + {0x1a,0x0a}, + {0x1f,0x40}, + {0x20,0x30}, + {0x2e,0x80}, + {0x2f,0x2b}, + {0x30,0x1a}, + {0xfe,0x02}, + {0x03,0x02}, + {0x05,0xd7}, + {0x06,0x60}, + {0x08,0x80}, + {0x12,0x89}, + + /* BLK*/ + {0xfe,0x00},//page 1 + {0x18,0x02}, + {0xfe,0x02},//page 2 + {0x40,0x22}, + {0x45,0x00}, + {0x46,0x00}, + {0x49,0x20}, + {0x4b,0x3c}, + {0x50,0x20}, + {0x42,0x10}, + + /*ISP*/ + {0xfe,0x01},//page 1 + {0x0a,0xc5}, + {0x45,0x00}, + {0xfe,0x00},//page 0 + {0x40,0xff}, + {0x41,0x25}, + {0x42,0xcd},///cc201805 close AWB{0x42,0xcf}, +/// {0x44,0x83},///P0:0x44 Output_format [7] YUV420_row_switch 5h03: Y Cr Y Cb + {0x44,B1001_0000},///P0:0x44 Output_format [7] YUV420_row_switch 5h10: only Y + + {0x43,0x12},////{0x43,D_P00x43},// ///EABLE CrCb fixed en 02 +/** P0:0x43 special_effect 7 0x00 RW [7] NA + [6] subsample2 + [5] subsample4 + [4] GAMMA_en + [3:2] only_edge_map + [1] CrCb_ fixed_en + [0] inverse color*/ + {0xda,0x00}, + {0xdb,0x00}, + /////{0x46,0x22}, +////------------------------------------- +{0x46,B0010_1000},// hs high pclk polarity {0x46,0x22}, +/* P0:0x46 sync_mode 8 0x0f RW +[7] data delay half +[6] hsync delay half +[5] odd_even_col_switch +[4] odd_even_row_switch + +[3] opclk gated in HB +[2] opclk polarity +[1] hsync polarity +[0] vsync polarity*/ +// {0x4c,D_P00x4c},//lsc test image +// {0x4D,0xfc},//lsc test image + +// {0x4a,0x86},//////div_gate+clk_en 82 +/**P0:0x4a Clock_gating_e +n +8 0x82 RW [7] ISP quiet mode +[6] close AAA pclk +[5]vb change +[4]vb chang flop +--------------------- +[3]hb change +[2] DIV_gatedclk_en +[1] exception +[0] AEC_delay_mode*/ + +////------------------------------------- + {0x49,0x03}, + {0x52,0x02}, + {0x54,0x00}, + {0xfe,0x02}, + {0x22,0xf6}, + + /*Shading*/ + {0xfe,0x01},//page 1 + {0xc1,0x38}, + {0xc2,0x4c}, + {0xc3,0x00}, + {0xc4,0x32}, + {0xc5,0x24}, + {0xc6,0x16}, + {0xc7,0x08}, + {0xc8,0x08}, + {0xc9,0x00}, + {0xca,0x20}, + {0xdc,0x8a}, + {0xdd,0xa0}, + {0xde,0xa6}, + {0xdf,0x75}, + + /*AWB*//*20170110*/ + {0xfe, 0x01},//page 1 + {0x7c, 0x09}, + {0x65, 0x06}, + {0x7c, 0x08}, + {0x56, 0xf4}, + {0x66, 0x0f}, + {0x67, 0x84}, + {0x6b, 0x80}, + {0x6d, 0x12}, + {0x6e, 0xb0}, + {0xfe, 0x01}, + {0x90, 0x00}, + {0x91, 0x00}, + {0x92, 0xf4}, + {0x93, 0xd5}, + {0x95, 0x0f}, + {0x96, 0xf4}, + {0x97, 0x2d}, + {0x98, 0x0f}, + {0x9a, 0x2d}, + {0x9b, 0x0f}, + {0x9c, 0x59}, + {0x9d, 0x2d}, + {0x9f, 0x67}, + {0xa0, 0x59}, + {0xa1, 0x00}, + {0xa2, 0x00}, + {0x86, 0x00}, + {0x87, 0x00}, + {0x88, 0x00}, + {0x89, 0x00}, + {0xa4, 0x00}, + {0xa5, 0x00}, + {0xa6, 0xd4}, + {0xa7, 0x9f}, + {0xa9, 0xd4}, + {0xaa, 0x9f}, + {0xab, 0xac}, + {0xac, 0x9f}, + {0xae, 0xd4}, + {0xaf, 0xac}, + {0xb0, 0xd4}, + {0xb1, 0xa3}, + {0xb3, 0xd4}, + {0xb4, 0xac}, + {0xb5, 0x00}, + {0xb6, 0x00}, + {0x8b, 0x00}, + {0x8c, 0x00}, + {0x8d, 0x00}, + {0x8e, 0x00}, + {0x94, 0x50}, + {0x99, 0xa6}, + {0x9e, 0xaa}, + {0xa3, 0x0a}, + {0x8a, 0x00}, + {0xa8, 0x50}, + {0xad, 0x55}, + {0xb2, 0x55}, + {0xb7, 0x05}, + {0x8f, 0x00}, + {0xb8, 0xb3}, + {0xb9, 0xb6}, + + + /*CC*/ + {0xfe,0x01},//page 0 + {0xd0,0x40}, + {0xd1,0xf8}, + {0xd2,0x00}, + {0xd3,0xfa}, + {0xd4,0x45}, + {0xd5,0x02}, + + {0xd6,0x30}, + {0xd7,0xfa}, + {0xd8,0x08}, + {0xd9,0x08}, + {0xda,0x58}, + {0xdb,0x02}, + {0xfe,0x00}, + + /*Gamma*/ + {0xfe,0x00},//page 0 + {0xba,0x00}, + {0xbb,0x04}, + {0xbc,0x0a}, + {0xbd,0x0e}, + {0xbe,0x22}, + {0xbf,0x30}, + {0xc0,0x3d}, + {0xc1,0x4a}, + {0xc2,0x5d}, + {0xc3,0x6b}, + {0xc4,0x7a}, + {0xc5,0x85}, + {0xc6,0x90}, + {0xc7,0xa5}, + {0xc8,0xb5}, + {0xc9,0xc2}, + {0xca,0xcc}, + {0xcb,0xd5}, + {0xcc,0xde}, + {0xcd,0xea}, + {0xce,0xf5}, + {0xcf,0xff}, + + /*Auto Gamma*/ + {0xfe,0x00}, + {0x5a,0x08}, + {0x5b,0x0f}, + {0x5c,0x15}, + {0x5d,0x1c}, + {0x5e,0x28}, + {0x5f,0x36}, + {0x60,0x45}, + {0x61,0x51}, + {0x62,0x6a}, + {0x63,0x7d}, + {0x64,0x8d}, + {0x65,0x98}, + {0x66,0xa2}, + {0x67,0xb5}, + {0x68,0xc3}, + {0x69,0xcd}, + {0x6a,0xd4}, + {0x6b,0xdc}, + {0x6c,0xe3}, + {0x6d,0xf0}, + {0x6e,0xf9}, + {0x6f,0xff}, + + /*Gain*/ + {0xfe,0x00}, + {0x70,0x50}, + + /*AEC*/ + {0xfe,0x00},//page 0 + {0x4f,0x00},///cc201805 close ACE /// {0x4f,0x01}, + {0xfe,0x01},//page 1 + {0x0d,0x00},//08 add 20170110 + {0x12,0xa0}, + {0x13,0x3a}, + {0x44,0x04}, + {0x1f,0x30}, + {0x20,0x40}, + {0x26,0x9a}, + {0x3e,0x20}, + {0x3f,0x2d}, + {0x40,0x40}, + {0x41,0x5b}, + {0x42,0x82}, + {0x43,0xb7}, + {0x04,0x0a}, + {0x02,0x79}, + {0x03,0xc0}, + + /*measure window*/ + {0xfe,0x01},//page 1 + {0xcc,0x08}, + {0xcd,0x08}, + {0xce,0xa4}, + {0xcf,0xec}, + + /*DNDD*/ + {0xfe,0x00}, + {0x81,0xb8}, + {0x82,0x12}, + {0x83,0x0a}, + {0x84,0x01}, + {0x86,0x50}, + {0x87,0x18}, + {0x88,0x10}, + {0x89,0x70}, + {0x8a,0x20}, + {0x8b,0x10}, + {0x8c,0x08}, + {0x8d,0x0a}, + + /*Intpee*/ + {0xfe,0x00}, + {0x8f,0xaa}, + {0x90,0x9c}, + {0x91,0x52}, + {0x92,0x03}, + {0x93,0x03}, + {0x94,0x08}, + {0x95,0x44}, + {0x97,0x00}, + {0x98,0x00}, + + /*ASDE*/ + {0xfe,0x00}, + {0xa1,0x30}, + {0xa2,0x41}, + {0xa4,0x30}, + {0xa5,0x20}, + {0xaa,0x30}, + {0xac,0x32}, + + /*YCP*/ + {0xfe,0x00}, + {0xd1,0x3c}, + {0xd2,0x3c}, + {0xd3,0x38}, + {0xd6,0xf4}, + {0xd7,0x1d}, + {0xdd,0x73}, + {0xde,0x84}, + + /*Banding*/ + {0xfe,0x00}, + {0x05,0x01}, + {0x06,0xad}, + {0x07,0x00}, + {0x08,0x10}, + + {0xfe,0x01}, + {0x25,0x00}, + {0x26,0x9a}, + + {0x27,0x01}, + {0x28,0xce}, + {0x29,0x03}, + {0x2a,0x02}, + {0x2b,0x04}, + {0x2c,0x36}, + {0x2d,0x07}, + {0x2e,0xd2}, + {0x2f,0x0b}, + {0x30,0x6e}, + {0x31,0x0e}, + {0x32,0x70}, + {0x33,0x12}, + {0x34,0x0c}, + {0x3c,0x30}, + {0xfe,0x00}, + {0x00,0x00} + +}; +#else + +const U8 code GC6133_init_reg_tbl[][2]= { + + /*System*/ + {0xf3,0xff}, + {0xf5,0x06}, + {0xf7,0x01}, + {0xf9,0xce}, + {0xfa,0x00}, +//1002 {0xf8,0x03},//////Ƶ {0xf8,0x03}, +{0xf8,0x0f},//////Ƶ {0xf8,0x03}, + // {0xfa,D_0xfa}, // cc add + /// {0xfd,D_0xfa}, // cc add + /// {0xfa,D_0xfa}, // cc add + /// {0xfd,D_0xfa}, // cc add +///20181002ʱʹýϸƵ ָƵ + {0xfc,0x02}, + + {0xfe,0x02},//page 2 + {0x81,0x03}, + + {0xfe,0x00}, + {0x77,0x64}, + {0x78,0x40}, + {0x79,0x60}, + /*ANALOG & CISCTL*/ + {0xfe,0x00},//page 0 + {0x03,0x01}, + {0x04,0xce}, + {0x05,0x01}, + {0x06,0xad}, + {0x07,0x00}, + {0x08,0x10}, + {0x0a,0x00}, + {0x0c,0x00}, + {0x0d,0x01}, + {0x0e,0xe8}, + {0x0f,0x02}, + {0x10,0x88}, + {0x17,0x54}, + {0x19,0x08}, + {0x1a,0x0a}, + {0x1f,0x40}, + {0x20,0x30}, + {0x2e,0x80}, + {0x2f,0x2b}, + {0x30,0x1a}, + {0xfe,0x02}, + {0x03,0x02}, + {0x05,0xd7}, + {0x06,0x60}, + {0x08,0x80}, + {0x12,0x89}, + + /* BLK*/ + {0xfe,0x00},//page 1 + {0x18,0x02}, + {0xfe,0x02},//page 2 + {0x40,0x22}, + {0x45,0x00}, + {0x46,0x00}, + {0x49,0x20}, + {0x4b,0x3c}, + {0x50,0x20}, + {0x42,0x10}, + + /*ISP*/ + {0xfe,0x01},//page 1 + {0x0a,0xc5}, + {0x45,0x00}, + {0xfe,0x00},//page 0 + {0x40,0xff}, + {0x41,0x25}, + {0x42,0xcd},///cc201805 close AWB{0x42,0xcf}, +/// {0x44,0x83},///P0:0x44 Output_format [7] YUV420_row_switch 5h03: Y Cr Y Cb + {0x44,B1001_0000},///P0:0x44 Output_format [7] YUV420_row_switch 5h10: only Y + + {0x43,0x12},////{0x43,D_P00x43},// ///EABLE CrCb fixed en 02 +/** P0:0x43 special_effect 7 0x00 RW [7] NA + [6] subsample2 + [5] subsample4 + [4] GAMMA_en + [3:2] only_edge_map + [1] CrCb_ fixed_en + [0] inverse color*/ + {0xda,0x00}, + {0xdb,0x00}, + /////{0x46,0x22}, +////------------------------------------- +{0x46,B0010_1000},// hs high pclk polarity {0x46,0x22}, +/* P0:0x46 sync_mode 8 0x0f RW +[7] data delay half +[6] hsync delay half +[5] odd_even_col_switch +[4] odd_even_row_switch + +[3] opclk gated in HB +[2] opclk polarity +[1] hsync polarity +[0] vsync polarity*/ +// {0x4c,D_P00x4c},//lsc test image +// {0x4D,0xfc},//lsc test image + +// {0x4a,0x86},//////div_gate+clk_en 82 +/**P0:0x4a Clock_gating_e +n +8 0x82 RW [7] ISP quiet mode +[6] close AAA pclk +[5]vb change +[4]vb chang flop +--------------------- +[3]hb change +[2] DIV_gatedclk_en +[1] exception +[0] AEC_delay_mode*/ + +////------------------------------------- + {0x49,0x03}, + {0x52,0x02}, + {0x54,0x00}, + {0xfe,0x02}, + {0x22,0xf6}, + + /*Shading*/ + {0xfe,0x01},//page 1 + {0xc1,0x38}, + {0xc2,0x4c}, + {0xc3,0x00}, + {0xc4,0x32}, + {0xc5,0x24}, + {0xc6,0x16}, + {0xc7,0x08}, + {0xc8,0x08}, + {0xc9,0x00}, + {0xca,0x20}, + {0xdc,0x8a}, + {0xdd,0xa0}, + {0xde,0xa6}, + {0xdf,0x75}, + + /*AWB*//*20170110*/ + {0xfe, 0x01},//page 1 + {0x7c, 0x09}, + {0x65, 0x06}, + {0x7c, 0x08}, + {0x56, 0xf4}, + {0x66, 0x0f}, + {0x67, 0x84}, + {0x6b, 0x80}, + {0x6d, 0x12}, + {0x6e, 0xb0}, + {0xfe, 0x01}, + {0x90, 0x00}, + {0x91, 0x00}, + {0x92, 0xf4}, + {0x93, 0xd5}, + {0x95, 0x0f}, + {0x96, 0xf4}, + {0x97, 0x2d}, + {0x98, 0x0f}, + {0x9a, 0x2d}, + {0x9b, 0x0f}, + {0x9c, 0x59}, + {0x9d, 0x2d}, + {0x9f, 0x67}, + {0xa0, 0x59}, + {0xa1, 0x00}, + {0xa2, 0x00}, + {0x86, 0x00}, + {0x87, 0x00}, + {0x88, 0x00}, + {0x89, 0x00}, + {0xa4, 0x00}, + {0xa5, 0x00}, + {0xa6, 0xd4}, + {0xa7, 0x9f}, + {0xa9, 0xd4}, + {0xaa, 0x9f}, + {0xab, 0xac}, + {0xac, 0x9f}, + {0xae, 0xd4}, + {0xaf, 0xac}, + {0xb0, 0xd4}, + {0xb1, 0xa3}, + {0xb3, 0xd4}, + {0xb4, 0xac}, + {0xb5, 0x00}, + {0xb6, 0x00}, + {0x8b, 0x00}, + {0x8c, 0x00}, + {0x8d, 0x00}, + {0x8e, 0x00}, + {0x94, 0x50}, + {0x99, 0xa6}, + {0x9e, 0xaa}, + {0xa3, 0x0a}, + {0x8a, 0x00}, + {0xa8, 0x50}, + {0xad, 0x55}, + {0xb2, 0x55}, + {0xb7, 0x05}, + {0x8f, 0x00}, + {0xb8, 0xb3}, + {0xb9, 0xb6}, + + + /*CC*/ + {0xfe,0x01},//page 0 + {0xd0,0x40}, + {0xd1,0xf8}, + {0xd2,0x00}, + {0xd3,0xfa}, + {0xd4,0x45}, + {0xd5,0x02}, + + {0xd6,0x30}, + {0xd7,0xfa}, + {0xd8,0x08}, + {0xd9,0x08}, + {0xda,0x58}, + {0xdb,0x02}, + {0xfe,0x00}, + + /*Gamma*/ + {0xfe,0x00},//page 0 + {0xba,0x00}, + {0xbb,0x04}, + {0xbc,0x0a}, + {0xbd,0x0e}, + {0xbe,0x22}, + {0xbf,0x30}, + {0xc0,0x3d}, + {0xc1,0x4a}, + {0xc2,0x5d}, + {0xc3,0x6b}, + {0xc4,0x7a}, + {0xc5,0x85}, + {0xc6,0x90}, + {0xc7,0xa5}, + {0xc8,0xb5}, + {0xc9,0xc2}, + {0xca,0xcc}, + {0xcb,0xd5}, + {0xcc,0xde}, + {0xcd,0xea}, + {0xce,0xf5}, + {0xcf,0xff}, + + /*Auto Gamma*/ + {0xfe,0x00}, + {0x5a,0x08}, + {0x5b,0x0f}, + {0x5c,0x15}, + {0x5d,0x1c}, + {0x5e,0x28}, + {0x5f,0x36}, + {0x60,0x45}, + {0x61,0x51}, + {0x62,0x6a}, + {0x63,0x7d}, + {0x64,0x8d}, + {0x65,0x98}, + {0x66,0xa2}, + {0x67,0xb5}, + {0x68,0xc3}, + {0x69,0xcd}, + {0x6a,0xd4}, + {0x6b,0xdc}, + {0x6c,0xe3}, + {0x6d,0xf0}, + {0x6e,0xf9}, + {0x6f,0xff}, + + /*Gain*/ + {0xfe,0x00}, + {0x70,0x50}, + + /*AEC*/ + {0xfe,0x00},//page 0 + {0x4f,0x00},///cc201805 close ACE /// {0x4f,0x01}, + {0xfe,0x01},//page 1 + {0x0d,0x00},//08 add 20170110 + {0x12,0xa0}, + {0x13,0x3a}, + {0x44,0x04}, + {0x1f,0x30}, + {0x20,0x40}, + {0x26,0x9a}, + {0x3e,0x20}, + {0x3f,0x2d}, + {0x40,0x40}, + {0x41,0x5b}, + {0x42,0x82}, + {0x43,0xb7}, + {0x04,0x0a}, + {0x02,0x79}, + {0x03,0xc0}, + + /*measure window*/ + {0xfe,0x01},//page 1 + {0xcc,0x08}, + {0xcd,0x08}, + {0xce,0xa4}, + {0xcf,0xec}, + + /*DNDD*/ + {0xfe,0x00}, + {0x81,0xb8}, + {0x82,0x12}, + {0x83,0x0a}, + {0x84,0x01}, + {0x86,0x50}, + {0x87,0x18}, + {0x88,0x10}, + {0x89,0x70}, + {0x8a,0x20}, + {0x8b,0x10}, + {0x8c,0x08}, + {0x8d,0x0a}, + + /*Intpee*/ + {0xfe,0x00}, + {0x8f,0xaa}, + {0x90,0x9c}, + {0x91,0x52}, + {0x92,0x03}, + {0x93,0x03}, + {0x94,0x08}, + {0x95,0x44}, + {0x97,0x00}, + {0x98,0x00}, + + /*ASDE*/ + {0xfe,0x00}, + {0xa1,0x30}, + {0xa2,0x41}, + {0xa4,0x30}, + {0xa5,0x20}, + {0xaa,0x30}, + {0xac,0x32}, + + /*YCP*/ + {0xfe,0x00}, + {0xd1,0x3c}, + {0xd2,0x3c}, + {0xd3,0x38}, + {0xd6,0xf4}, + {0xd7,0x1d}, + {0xdd,0x73}, + {0xde,0x84}, + + /*Banding*/ + {0xfe,0x00}, + {0x05,0x01}, + {0x06,0xad}, + {0x07,0x00}, + {0x08,0x10}, + + {0xfe,0x01}, + {0x25,0x00}, + {0x26,0x9a}, + + {0x27,0x01}, + {0x28,0xce}, + {0x29,0x03}, + {0x2a,0x02}, + {0x2b,0x04}, + {0x2c,0x36}, + {0x2d,0x07}, + {0x2e,0xd2}, + {0x2f,0x0b}, + {0x30,0x6e}, + {0x31,0x0e}, + {0x32,0x70}, + {0x33,0x12}, + {0x34,0x0c}, + {0x3c,0x30}, + {0xfe,0x00}, + {0x00,0x00} + +}; + + +#endif diff --git a/source/bsp/backu/bsp_gc032a.h b/source/bsp/backu/bsp_gc032a.h new file mode 100644 index 0000000..7be8e1a --- /dev/null +++ b/source/bsp/backu/bsp_gc032a.h @@ -0,0 +1,19 @@ + +#ifndef _gc_032a_H_ +#define _gc_032a_H_ + +#include "../bsp/bsp_config.h" + +#include "../clib/type.h" +#include "../clib/clib.h" +#include "../ctask/tick.h" + +//#define GC6133_reg_tbl_len 291 GC6133_reg_tbl_len+1 + +#define GC6133_reg_tbl_len (292) + + +extern U8 code GC6133_init_reg_tbl[][2]; + + +#endif///_gc_032a_H_ diff --git a/source/bsp/backu/bsp_msa300.c b/source/bsp/backu/bsp_msa300.c new file mode 100644 index 0000000..3e152fe --- /dev/null +++ b/source/bsp/backu/bsp_msa300.c @@ -0,0 +1,261 @@ +//////////////////////////////////////////////////////////////////////////// +///@copyright Copyright (c) 2017, ؿƼ All rights reserved. +///------------------------------------------------------------------------- +/// @file msa300.c +/// @brief msa300 driver app +///------------------------------------------------------------------------- +/// @version 1.0 +/// @author CC +/// @date 20170122 +/// @note cc_AS_stc01 +////////////////////////////////////////////////////////////////////////////// + +/******************************************************************************/ +/***************************** Include Files **********************************/ +/******************************************************************************/ +#include "bsp_msa300.h" +#include "../msp/uart0.h" +struct _s_gsens_ s_as;//[D_as_ch_mun]; + + +// data*3.91mg/LSB 1g = 90 1/2g = 45 1/3g = 30 333mg/3.91mg = 85d=0x55 +/// б30Ⱦ +//#define D_actionTH_init 0x02 +#define D_actionTH_init 0x0f +//#define D_actionTH_init 0x25 /// z25ٽֵ +////#define D_actionTH_init 0x0c +////#define D_actionTH_init 0x04 +/// жϳʱΪ4s 4sжϽ ½ +// #define D_latch_time_init D_latch_4s +#define D_latch_time_init D_latch_50ms + + + + +#if 0 +void L1_as_power_mode(unsigned char dev,unsigned char ps) +{ + // s_as[0].reg_power + s_as[0].reg_power &= 0x3f; + s_as[0].reg_power |= ps; + L2_I2C_WriteCmd(dev,MSA_REG_POWERMODE_BW,s_as[0].reg_power); // normal ģʽ +} + + +/// D_sensor_active_close();DL_ms300_int_close(); + +/// L1_as_WorkStatus(D_wakeup); + +///extern void L1_as_WorkStatus(unsigned char d); +void L1_as_WorkStatus(unsigned char d) +{ + if(D_wakeup == d) + { +/// L1_ms300_reg_set(MSA_REG_INTERRUPT_MAPPING3,D_INT2_S_TAP|D_INT2_ACTIVE); + D_sensor_active_open();BITN_0(DR_who_wakeup, DRB_who_wakeup_action); + }else + { +/// L1_ms300_reg_set(MSA_REG_INTERRUPT_MAPPING3,0); + D_sensor_active_close(); + } +} +void L1_as_action(void) +{ + L2_I2C_ReadReg(D_i2c_addr_Gsensor,MSA_REG_Tape_Active_Status,&s_as[0].reg_temp,1); /// read only + ///L0_uart0_uc('.'); + s_as[0].reg_temp &= B0111_0111;/// ȥλ + if(s_as[0].reg_action == s_as[0].reg_temp) + { + }else + { + + s_as[0].action_ok = 1; + s_as[0].reg_action = s_as[0].reg_temp; + } +/// L0_uart0_uchex(s_as[0].reg_temp) +} +#endif + +/// msa300 ʼ ǰʹiicijʼ +/// ʹж EA +void L1_msa300_init(void) +{ + /// +///step 1: ȡpower reg + LD_gsensor_power(D_PowerMode_normal ); + /// ϵstandby ģʽ Ҫ 00:normal mode, 01:low power mode, 10/11 suspend mode + +///step 2: ÷ֱʺͼٶȷΧ +/// L1_ms300_reg_set(MSA_REG_G_RANGE,((D_MSA_14BIT)|(D_MSA_2G))); // 8b8t 2g + L1_ms300_reg_set(MSA_REG_G_RANGE,((D_MSA_8BIT)|(D_MSA_2G))); // 8b8t 2g +// L1_ms300_reg_set(NSA_REG_ODR_AXIS_DISABLE, +// D_ODR_31Hz25); + +///step 3: Ƶʺʹbandwidth Ƶʵһ +/// ODR BW +/// 15.63Hz (0100) 7.81Hz +/// CLOSE Yر y Ϊģŵ + L1_ms300_reg_set(MSA_REG_ODR_AXIS_DISABLE,D_AXIS_DIS_Y|D_ODR_15P63Hz); +// L1_ms300_reg_set(MSA_REG_ODR_AXIS_DISABLE,D_ODR_31Hz25); +////-------------------------------------------------------------------------- + //CC-MD-VH06 + /// for pcb (INT1 PIN5 ) --- SENSINT2---(P3.0 INT1) + /// (INT2 PIN6 ) --- SENSINT3---(P3.1/INT0) + +///step 4: active ж ʹXZ + L1_ms300_reg_set(MSA_REG_INTERRUPT_SETTINGS1, + ACTIVE_INT_EN_Y|ACTIVE_INT_EN_X); /// fixme:ҪACTIVE_INT_EN_Y + L1_ms300_reg_set(D_Active_TH,D_actionTH_init); + +///step 5: + /// ACTIVE жϺ single tapжӳ䵽 int2ϣҲint2ƽ仯֪ͨmcu + /// ps3.sch msa300.int1==sensint2 msa300.int2==sensint3 ---rxd +/// L1_ms300_reg_set(MSA_REG_INTERRUPT_MAPPING1,INT1_ACTIVE|INT1_S_TAP_INT); +// L1_ms300_reg_set(MSA_REG_INTERRUPT_MAPPING3,D_INT2_ACTIVE); + L1_ms300_reg_set(MSA_REG_INTERRUPT_MAPPING3,D_INT2_S_TAP|D_INT2_ACTIVE); + +/// INT2_OD 0: push-pull +/// INT2_LVL 0: low, 1:high +/// L1_ms300_reg_set(MSA_REG_INT_PIN_CONFIG,D_INT2_OD|D_INT2_LVL_low); + L1_ms300_reg_set(MSA_REG_INT_PIN_CONFIG,D_INT2_pull|D_INT2_LVL_low); + ///L1_ms300_reg_set(MSA_REG_INT_PIN_CONFIG,0|D_INT2_LVL_high); + +////-------------------------------------------------------------------------- +///step 6 : 1sʱ \_____1s______/```` + L1_ms300_reg_set(MSA_REG_INT_LATCH,D_latch_time_init); + ///L1_i2c_Configure(0);DL_ms300_int_open + ///();D_sensor_active_open(); +/// L1_as_WorkStatus(D_wakeup); + +// LD_gsensor_power(D_PowerMode_normal ); + LD_gsensor_power(D_PowerMode_low ); +} +#if 0///nouse + +///0x02 ACC_X[5:0] 0x00 +//0x03 ACC_X[13:6] 0x00 +//0x04 ACC_Y[5:0] 0x00 +//0x05 ACC_Y[13:6] 0x00 +//0x06 ACC_Z[5:0] 0x00 +//0x07 ACC_Z[13:6] 0x00 +/// 0 1 2 3 4 5 +// x5:0 x13:6 y5:0 y13:6 z5:0 z13:6 +void L1_as_readXYZ(unsigned char CH) +{ + +/********************************************** +///read data +//S ADD W A REG A +//S ADD R A D1 A D2 A.....DX N P + L2_I2C_ReadReg(D_i2c_addr_AS1,0x02,(unsigned char *)s_as[CH].d,6); + +////d 0 1 2 3 4 5 +//// 02 03 04 05 06 07 +//// XL XH YL YH ZL ZH +/// +L0_uart0_uc(0x09); +// L0_uart0_uchex(s_as[0].d[0]); L0_uart0_uc(0x09); + L0_uart0_uchex(s_as[0].d[1]); L0_uart0_uc(0x09); +// L0_uart0_uchex(s_as[0].d[2]); L0_uart0_uc(0x09); + L0_uart0_uchex(s_as[0].d[3]); L0_uart0_uc(0x09); +// L0_uart0_uchex(s_as[0].d[4]); L0_uart0_uc(0x09); + L0_uart0_uchex(s_as[0].d[5]); +/// L0_uart0_sendArray((unsigned char *)&s_as[CH],6); +L0_uart0_uc(0x0d); +L0_uart0_uc(0x0a); + + + +Lc_delay_ms(10); + *****************************************/ + +} + +#endif //////nouse +/***************** + +L2_I2C_ReadReg(D_i2c_addr_HP303B,0x0d,d,1); + L0_MUART_uc(d[0]); +L2_I2C_ReadReg(D_i2c_addr_AS1,0x05,d,1);// 11 =0f + L0_MUART_uc(d[0]); +L2_I2C_ReadReg(D_i2c_addr_AS2,0x05,d,1);//10 =0f + L0_MUART_uc(d[0]); + + L1_as1_readXYZ(); + s_p_rf.ucR1 = (U8)(s_as1.x>>8); + s_p_rf.ucR2 = (U8)(s_as1.y>>8); + s_p_rf.ucR3 = (U8)(s_as1.z>>8); +p = (U8*)&s_p_rf; + + L0_MUART_uc(s_p_rf.ucR1); + L0_MUART_uc(s_p_rf.ucR2); + L0_MUART_uc(s_p_rf.ucR3); + L0_MUART_uc(0xc7); + *********************/ +#if 0 + +void L3_msa300_fun(U8 *pPara) +{ + U8 val = 0; + TS_P_debug *p = pPara; + /// Ac 01 02 03 ocr ---bsp_debug.c + /// p.cmd p.R2 p.R3 p.ocr + ///Ac 00 03 01 00/// ACC_X[13:6] + switch(p->cmd) + { + case 0: + /// fc 00 02 01 xx ȡreg02 еһ + ///0x02 ACC_X[5:0] 0x00 + //0x03 ACC_X[13:6] 0x00 + //0x04 ACC_Y[5:0] 0x00 + //0x05 ACC_Y[13:6] 0x00 + //0x06 ACC_Z[5:0] 0x00 + //0x07 ACC_Z[13:6] 0x00 + //// Ac 00 03 01 00/// ACC_X[13:6] + //// Ac 00 05 01 00/// ACC_Y[13:6] + //// Ac 00 07 01 00/// ACC_Z[13:6] + L2_I2C_ReadReg(D_i2c_addr_AS1,p->R2 ,&val,p->R3); + ///L0_uart0_uc(p->R2); + ///L0_uart0_uc(p->R3); + L0_uart0_uc(val); + break; + case 2: + ///Ac 02 22 01 00/// (05)=01 + L0_uart0_uc('W'); + ///L2_I2C_WriteCmd(D_i2c_addr_AS1,p->R2,p->R3); + //L0_uart0_uc(pPara[2]); + // L0_uart0_uc(p->R2); + // L0_uart0_uc(p->R3); + break; + case 3: + ///Ac 03 22 01 00/// (05)=01 + L1_as_action(); + if(1 == s_as[0].action_ok) + { + s_as[0].action_ok = 0; + L0_uart0_uc(s_as[0].reg_action); + } + /********************* + L2_I2C_ReadReg(D_i2c_addr_Gsensor,MSA_REG_Tape_Active_Status,&s_as[0].reg_temp,1); /// read only + ///L0_uart0_uc('.'); + s_as[0].reg_temp &= B0111_0111; + if(s_as[0].reg_power == s_as[0].reg_temp) + { + + }else + { + L0_uart0_uc(s_as[0].reg_temp); + s_as[0].reg_power = s_as[0].reg_temp; + }*************************/ + break; + default: + break; + }; +} +///#else +void L3_msa300_fun(U8 *pPara) +{ +} +#endif + + diff --git a/source/bsp/backu/bsp_msa300.h b/source/bsp/backu/bsp_msa300.h new file mode 100644 index 0000000..4069586 --- /dev/null +++ b/source/bsp/backu/bsp_msa300.h @@ -0,0 +1,473 @@ +//////////////////////////////////////////////////////////////////////////// +///@copyright Copyright (c) 2017, ؿƼ All rights reserved. +///------------------------------------------------------------------------- +/// @file msa300.c +/// @brief msa300 driver app +///------------------------------------------------------------------------- +/// @version 1.0 +/// @author CC +/// @date 20170122 +/// @note cc_AS_stc01 +////////////////////////////////////////////////////////////////////////////// + + + +#ifndef _MSA300_H +#define _MSA300_H + + +#include "../clib/bit.h" + +#include "../msp/iic_sim.h" + + + + +/*********************************************************************** + + U51(SDO=1) int2 P33 ----------------U10(SDO=0) int2 P32----------------MCU----USB + 0x4c 0x4e + AS1 AS2 + +**************************************************************************/ + + +#define D_i2c_addr_AS1 0x4c // u51 +//#define D_i2c_addr_AS2 0x4e +/* Register define for NSA asic */ +#define MSA_REG_SPI_I2C 0x00 +#define MSA_REG_WHO_AM_I 0x01 +#define MSA_REG_ACC_X_LSB 0x02 +#define MSA_REG_ACC_X_MSB 0x03 +#define MSA_REG_ACC_Y_LSB 0x04 +#define MSA_REG_ACC_Y_MSB 0x05 +#define MSA_REG_ACC_Z_LSB 0x06 +#define MSA_REG_ACC_Z_MSB 0x07 + + +#define MSA_REG_Tape_Active_Status 0x0B + +#define MSA_REG_G_RANGE 0x0f +#define MSA_REG_ODR_AXIS_DISABLE 0x10 +#define MSA_REG_POWERMODE_BW 0x11 +#define MSA_REG_SWAP_POLARITY 0x12 +#define MSA_REG_FIFO_CTRL 0x14 +#define MSA_REG_INTERRUPT_SETTINGS1 0x16 +#define MSA_REG_INTERRUPT_SETTINGS2 0x17 +#define MSA_REG_INTERRUPT_MAPPING1 0x19 +#define MSA_REG_INTERRUPT_MAPPING2 0x1a +#define MSA_REG_INTERRUPT_MAPPING3 0x1b +#define MSA_REG_INT_PIN_CONFIG 0x20 +#define MSA_REG_INT_LATCH 0x21 +#define MSA_REG_ACTIVE_DURATION 0x27 +#define MSA_REG_ACTIVE_THRESHOLD 0x28 +#define MSA_REG_TAP_DURATION 0x2A +#define MSA_REG_TAP_THRESHOLD 0x2B +#define MSA_REG_CUSTOM_OFFSET_X 0x38 +#define MSA_REG_CUSTOM_OFFSET_Y 0x39 +#define MSA_REG_CUSTOM_OFFSET_Z 0x3a +#define MSA_REG_ENGINEERING_MODE 0x7f +#define MSA_REG_SENSITIVITY_TRIM_X 0x80 +#define MSA_REG_SENSITIVITY_TRIM_Y 0x81 +#define MSA_REG_SENSITIVITY_TRIM_Z 0x82 +#define MSA_REG_COARSE_OFFSET_TRIM_X 0x83 +#define MSA_REG_COARSE_OFFSET_TRIM_Y 0x84 +#define MSA_REG_COARSE_OFFSET_TRIM_Z 0x85 +#define MSA_REG_FINE_OFFSET_TRIM_X 0x86 +#define MSA_REG_FINE_OFFSET_TRIM_Y 0x87 +#define MSA_REG_FINE_OFFSET_TRIM_Z 0x88 +#define MSA_REG_SENS_COMP 0x8c +#define MSA_REG_MEMS_OPTION 0x8f +#define MSA_REG_CHIP_INFO 0xc0 +#define MSA_REG_CHIP_INFO_SECOND 0xc1 +#define MSA_REG_SENS_COARSE_TRIM 0xd1 + +/************* + +------------------------------------------------------------------- +Reg 0x0F(Resolution/Range)Read/Write +Bit7 Bit6 Bit5 Bit4 |Bit3 Bit2 |Bit1 Bit0 | Default + |RESOLUTION[1:0] | FS[1:0] | 0X00 + + +RESOLUTION[1:0]: resolution of x/y/z axes, +00:14bit, 01:12bit, 10:10bit, 11:8bit + + +FS[1:0]: acceleration range of x/y/z axes, +00:+/-2g, 01:+/-4g, 10:+/-8g, 11:+/-16g + + +*********/ +#define D_MSA_8BIT B0000_1100 +#define D_MSA_12BIT B0000_0100 +#define D_MSA_10BIT B0000_1000 +#define D_MSA_14BIT B0000_0000 + +#define D_MSA_16G B0000_0011 +#define D_MSA_8G B0000_0001 +#define D_MSA_4G B0000_0010 +#define D_MSA_2G B0000_0000 +/********** +ODR Output data rate 1 1000 Hz + +Reg0x10(ODR) Read/Write Default 0X0F +Bit7 Bit6 Bit5 +X_AXIS_DIS Y_AXIS_DIS Z_AXIS_DIS +Bit4 +Bit3 Bit2 Bit1 Bit0 +ODR[3:0] + +X_AXIS_DIS: 0:enable, 1:disable Y_AXIS_DIS: 0:enable, 1:disable Z_AXIS_DIS: 0:enable, 1:disable +ODR[3:0]: +0000:1Hz (not available in normal mode) +0001:1.95Hz (not available in normal mode) +0010:3.9Hz 0011:7.81Hz +0100:15.63Hz 0101: 31.25Hz 0110: 62.5Hz 0111: 125Hz 1000: 250Hz +1001: 500Hz (not available in low power mode) +1010-1111: (not available in low power mode) + + +Table 5: bandwidth under different ODR and BW settings in normal mode +ODR BW +1000Hz (1010-1111) 500Hz +500Hz (1001) 250Hz +250Hz (1000) 125Hz +125Hz (0111) 62.5Hz +62.5Hz (0110) 31.25Hz +31.25Hz (0101) 15.63Hz +15.63Hz (0100) 7.81Hz +7.81Hz (0011) 3.9Hz +3.9Hz (0010) 1.95Hz +MSA300 supports four different acceleration measurement ranges, it is selected +ODR BW +15.63Hz (0100) 7.81Hz + +*********/ +/// fixme: ʵ͹鲻һ +#define D_AXIS_DIS_Y B1000_0000 +#define D_AXIS_DIS_X B0100_0000 +#define D_AXIS_DIS_Z B0010_0000 + +#define D_ODR_31Hz25 0x05 +#define D_ODR_250Hz 0x08 +#define D_ODR_125Hz 0x0f +#define D_ODR_15P63Hz B0000_0100 + + + +/********** +Reg0x11(Power Mode/Bandwidth) Read/Write +------------------------------------------------------------------ +Bit7 Bit6 |Bit5 Bit4 Bit3 Bit2 Bit1 |Bit0 Default 0X9E +---------------------------------------------------------------------- +PWR_MODE | LOW_POWER_BW[3:0] | +-------------------------------------------------------------------- +PWR_MODE: 00:normal mode, 01:low power mode, 10/11 suspend mode +LOW_POWER_BW[3:0]: +0000-0010:1.95Hz +0011:3.9Hz, +0100:7.81Hz +0101:15.63Hz, +0110: 31.25Hz, +0111: 62.5Hz, +1000: 125Hz, +1001: 250Hz, +1010-1111:500Hz +***********/ +//#define D_PowerMode_normal 0x00 +//#define D_PowerMode_low 0x40 +//#define D_PowerMode_suspend 0x80 +#define D_lowPower_BW (0x0F<<1) + +#define D_PowerMode_normal 0x1e +#define D_PowerMode_suspend 0x9e + +#define D_gs_LPBW1H9 (0<<1) +#define D_gs_LPBW3H9 (3<<1) +#define D_gs_LPBW7H8 (4<<1) +#define D_gs_LPBW15H (5<<1) +#define D_gs_LPBW31H (6<<1) +#define D_gs_LPBW62H (7<<1) +#define D_gs_LPBW125H (8<<1) +#define D_gs_LPBW250H (9<<1) +#define D_gs_LPBW500H (10<<1) + + +///#define D_PowerMode_low 0x5e + +#define D_PowerMode_low (0x50|D_gs_LPBW1H9) +//#define D_PowerMode_low 0x5e///(0x40|D_gs_LPBW62H) + +#define LD_gsensor_power(Pmode) L2_I2C_WriteCmd(D_i2c_addr_Gsensor,MSA_REG_POWERMODE_BW,Pmode);s_as.power=Pmode + + +/********** + + +/************************************** +Reg 0x1B (Int_Map_2) Read/Write +Bit7 Bit6 Bit5 Bit4 Bit3 Bit2 Bit1 Bit0 Default + +Bit6 INT2_ORIENT +Bit5 INT2_S_TAP +Bit4 INT2_D_TAP +Bit2 INT2_ACTIVE +Bit1 RESERVED +Bit0 INT2_FREEFALL +0X00 +INT2_ORIENT: map orientation interrupt to INT2, 0:disable, 1:enable INT2_S_TAP: map single tap interrupt to INT2, 0:disable, 1:enable INT2_D_TAP: map double tap interrupt to INT2, 0:disable, 1:enable INT2_ACTIVE: map active interrupt to INT2, 0:disable, 1:enable INT2_FREEFALL: map freefall interrupt to INT2, 0:disable, 1:enable +***************************************/ +#define D_INT2_ORIENT BITN6 +#define D_INT2_S_TAP BITN5 +#define D_INT2_D_TAP BITN4 +#define D_INT2_ACTIVE BITN2 +#define D_INT2_FREEFALL BITN1 +/********************************************** + +Reg 0x20 (Int_Map_2) Read/Write +Bit7 Bit6 Bit5 Bit4 Bit3 Bit2 Bit1 Bit0 Default 0X00 +Bit3 INT2_OD +Bit2 NT2_LVL +Bit1 IINT1_OD +Bit0 INT1_LVL +INT2_OD: select output for INT2, 0: push-pull, 1:OD +INT2_LVL: select active level for INT2, 0: low, 1:high +INT1_OD: select output for INT1, 0: push-pull, 1:OD +INT1_LVL: select active level for INT1, 0: low, 1:high +***************************************/ +#define D_INT2_pull 0 +#define D_INT2_OD BITN3 +#define D_INT2_LVL_high BITN2 +#define D_INT2_LVL_low 0 + + +#define D_INT1_pull 0 +#define D_INT1_OD BITN1 +#define D_INT1_LVL_high BITN0 +#define D_INT1_LVL_low 0 + + + +/************************************************************* + + U51(SDO=1) int2 P33 ----------------U10(SDO=0) int2 P32----------------MCU----USB + 0x4c 0x4e + AS1 AS2 + +-------------------------------------------------------------------- +Reg 0x16(Int_Set_0) Read/Write +Bit7 Bit6 Bit5 Bit4 Bit3 Bit2 Bit1 Bit0 Default 0X00 +------------------------------------------------------------------- +Ӧ λʶ +Tap +˫͵ +ʹܵ s_tap_en ʹ˫d_tap_en +ж״̬: s_tap_int , d_tap_int +ͨٶбǷ񳬹趨ֵжǷе¼ + +Bit6 ORIENT_INT_EN +Bit5 S_TAP_INT_EN +Bit4 D_TAP_INT_EN +Bit2 ACTIVE_INT_EN_Z +Bit1 ACTIVE_INT_EN_Y +Bit0 ACTIVE_INT_EN_X + +------------------------------------------------------------------- +ORIENT_INT_EN: orient interrupt, 0:disable, 1:enable +S_TAP_INT_EN: single tap interrupt, 0:disable, 1:enable +D_TAP_INT_EN: double tap interrupt, 0:disable, 1:enable +ACTIVE_INT_EN_Z: active interrupt for the z axis, 0:disable, 1:enable +ACTIVE_INT_EN_Y: active interrupt for the y axis, 0:disable, 1:enable +ACTIVE_INT_EN_X: active interrupt for the x axis, 0:disable, 1:enable + + +reg 0x16ӦReg 0x19 +------------------------------------------------------------------- +Reg 0x19(Int_Map_0) Read/Write +Bit7 Bit6 Bit5 Bit4 Bit3 Bit2 Bit1 Bit0 Default +------------------------------------------------------------------- + INT1_ORIENT + INT1_S_TAP + INT1_D_TAP + INT1_ACTIVE + INT1_FREEFALL + 0X00 +------------------------------------------------------------------- +INT1_ORIENT: map orientation interrupt to INT1, 0:disable, 1:enable +INT1_S_TAP: map single tap interrupt to INT1, 0:disable, 1:enable +INT1_D_TAP: map double tap interrupt to INT1, 0:disable, 1:enable +INT1_ACTIVE: map active interrupt to INT1, 0:disable, 1:enable +INT1_FREEFALL: map freefall interrupt to INT1, 0:disable, 1:enable + + +------------------------------------------------------------------- +Reg 0x27 (Active_Dur) Read/Write +Bit7 Bit6 Bit5 Bit4 Bit3 Bit2 Bit1 Bit0 Default + ACTIVE_DUR[1:0] 0X00 +ACTIVE_DUR[1:0]: active duration time is (ACTIVE_DUR[1:0]+1)ms +------------------------------------------------------------------- +Reg 0x28(Active_Th) Read/Write + +Bit7 Bit6 Bit5 Bit4 Bit3 Bit2 Bit1 Bit0 Default +ACTIVE_TH[7:0] 0X14 +ACTIVE_TH[7:0]: threshold of active interrupt +3.91mg/LSB(2g range) +7.81mg/LSB(4g range) +15.625mg/LSB(8g range) +31.25mg/LSB(16g range) + + + +**************************************************************************/ + +#define ACTIVE_INT_EN_Z BITN2 +#define ACTIVE_INT_EN_Y BITN1 +#define ACTIVE_INT_EN_X BITN0 + + +/*************************************** +0x21 RESET_INT LATCH_INT[3:0] 0x00 + latch_int Interrupt mode + 0000 non-latched + 0001 temporary latched 250ms + 0010 temporary latched 500ms + 0011 temporary latched 1s + 0100 temporary latched 2s + 0101 temporary latched 4s + 0110 temporary latched 8s + 0111 Latched + 1000 non-latched + 1001 temporary latched 1ms + 1010 temporary latched 1ms + 1011 temporary latched 2ms + 1100 temporary latched 25ms + 1101 temporary latched 50ms + 1110 temporary latched 100ms + 1111 Latched + + _______/``latch period````\_______ +****************************************/ +#define D_no_latched 0x01 +#define D_latch_250ms 0x01 +#define D_latch_500ms 0x02 +#define D_latch_1s 0x03 +#define D_latch_2s 0x04 +#define D_latch_4s 0x05 +#define D_latch_8s 0x06 +#define D_latched 0x07 +#define D_no_latched2 0x08 +#define D_latch_1ms 0x09 +#define D_latch_1ms2 0x0a +#define D_latch_2ms 0x0B +#define D_latch_25ms 0x0C +#define D_latch_50ms 0x0D +#define D_latch_100ms 0x0E +#define D_latched2 0x0f + +/**************************************************** +Reg 0x09(Motion_Interrupt) :Read only +Bit7 Bit6 Bit5 Bit4 Bit3 Bit2 Bit1 Bit0 Default 0X00 +Bit6 ORIENT_INT +Bit5 S_TAP_INT +Bit4 D_TAP_INT +Bit2 ACTIVE_INT +Bit0 FREEFALL_INT +ʱͣĶô Ҫλж +ͼǺڰ +Ķ Ҫر +ҲдĶʱҪ5s֮ٹ Ϣ5 Ѻĵ +С + +ORIENT_INT: orientation interrupt status,0:inactive,1:active +S_TAP_INT: single tap interrupt status,0:inactive,1:active +D_TAP_INT: double tap interrupt status,0:inactive,1:active +ACTIVE_INT: active interrupt status,0:inactive,1:active +FREEFALL_INT: freefall interrupt status,0:inactive,1:active +------------------------------------------------------------------- +Reg 0x0B(Tape_Active_Status) :Read only +Bit7 Bit6 Bit5 Bit4 Bit3 Bit2 Bit1 Bit0 Default +TAP_SIGN + TAP_FIRST_X + TAP_FIRST_Y + TAP_FIRST_Z + ACTIVE_SIGN + ACTIVE_FIRST_X + ACTIVE_FIRST_Y + ACTIVE_FIRST_Z + 0X00 +------------------------------------------------------------------- +TAP_SIGN: sign of tap triggering signal, 0:positive,1:negative +TAP_FIRST_X: tap interrupt triggered by x axis, 1:positive,0:negative +TAP_FIRST_Y: tap interrupt triggered by y axis, 1:positive,0:negative +TAP_FIRST_Z: tap interrupt triggered by z axis, 1:positive,0:negative +ACTIVE_SIGN: sign of active interrupt, 0:positive,1:negative +ACTIVE_FIRST_X: active interrupt triggered by x axis, 1:positive,0:negative +ACTIVE_FIRST_Y: active interrupt triggered by y axis, 1:positive,0:negative +ACTIVE_FIRST_Z: active interrupt triggered by z axis, 1:positive,0:negative + + +***************************************************/ + +#define INT1_S_TAP_INT BITN5 ///ж +#define INT1_D_TAP_INT BITN4 ///˫ж +#define INT1_ACTIVE BITN2 /// ж + +#define D_Active_TH 0x28 +#define D_Active_Dur 0x27 + + +#define D_i2c_addr_AS1 0x4c // u51 +#define D_i2c_addr_AS2 0x4e + + +#define D_i2c_addr_Gsensor 0x4c // u51 + + +#define D_i2c_addr_AS1 0x4c // u51 +#define D_i2c_addr_AS2 0x4e + +/******************************************************************************/ +/***************************** Include Files **********************************/ +/******************************************************************************/ + +// 400Khz 1/400 ms 2.5us + +//Symbol Parameter Condition Min Max Unit +//fscl Clock frequency 400 kHz +#define D_as_ch_mun 1 +struct _s_gsens_ +{//8byte + U8 d[6]; +// U8 reg_action; + U8 power; +// U8 reg_temp; +// U8 action_ok; + + // U16 x; + // U16 y; + // U16 z; + +}; +extern struct _s_gsens_ s_as; +extern void L1_as_readXYZ(unsigned char CH); +extern void L1_msa300_init(void); +extern void L3_msa300_fun(U8 *pPara); +extern void L1_as_action(void); + +extern void L1_as_WorkStatus(unsigned char d); +///L1_msa300_power(D_sleep); +extern void L1_msa300_power(U8 mode); + +#define L1_ms300_reg_set(x,y) L2_I2C_WriteCmd(D_i2c_addr_Gsensor, (x),(y) ) +#define L1_ms300_reg_get(x,y) L2_I2C_ReadReg(D_i2c_addr_Gsensor,(x),1) +#define DL_ms300_int_open(); L1_ms300_reg_set(MSA_REG_INTERRUPT_MAPPING3,D_INT2_S_TAP|D_INT2_ACTIVE); +#define DL_ms300_int_close(); L1_ms300_reg_set(MSA_REG_INTERRUPT_MAPPING3,0); + + + + +#endif // #ifndef _MSA300_H + + + diff --git a/source/bsp/backu/cw63xx.c b/source/bsp/backu/cw63xx.c new file mode 100644 index 0000000..c171c3e --- /dev/null +++ b/source/bsp/backu/cw63xx.c @@ -0,0 +1,191 @@ +//////////////////////////////////////////////////////////////////////////// +///@copyright Copyright (c) 2017, ؿƼ All rights reserved. +///------------------------------------------------------------------------- +/// @file cw63xx.c +/// @brief cw630x driver app +///------------------------------------------------------------------------- +/// @version 1.0 +/// @author CC +/// @date 20170122 +/// @note cc_AS_stc01 + +/// @version 1.1 +/// @author CC +/// @date 20170619 +/// @note for + + +////////////////////////////////////////////////////////////////////////////// + +#include "cw63xx.h" +//#include "../debug/debug_drv.h" +#include "../msp/iic_sim.h" +#include "../msp/uart0.h" +//#include "msa300.h" + +///------------------------------------------------------------------------- +/// @breif L1_cw63xx_init +/// @param a s_task_PWON +/// @param s "L1_cw63xx_init" +/// @return none +/// @see Test() οصĺһӣ +/// @note (noteҪע) +///------------------------------------------------------------------------- +#define D_lowPower_warnning 0x02 +#define D_lowPower_BAT_FULL 0x08 + + + + +/***************************** + +if(BITN_G(I2CTXD,BITN1)) + +CHG_IN DCIN 5V Դ룬⵽粢жϣĴ 0x03[5] 0 1 +BAT_FULLس磬Ϊ 0򴥷жϣĴ 0x03[4] 0 1 +BAT_OT¶ȹߣĬֵ 60ң򴥷жϲֹͣ磬Ĵ 0x03[3] 0 1 +BAT_UT¶ȹͣĬֵ 0ң򴥷жϲֹͣ磬Ĵ 0x03[2] 0 1 +LOW_BATصѹڸ澯ֵʱĬΪ 3.4V򴥷жϣĴ 0x03[1] 0 1 +BUTTON£ᴥһжϣĴ 0x03[0] 0 1 + +ʵУȥغ BAT_FULLжϡ + +***************************/ +void L1_cw63xx_sta(void) +{ + U8 d; + L2_I2C_ReadReg(D_i2c_addr_cw63xx,D_CW63X_REG_Interrupt,&d,1); + if(BITN_G(d, BITN1))///յ͵ѹ + { + I2CTXD = 1; + } + + if(BITN_G(d, BITN4))///ֻгŵѹ־ + { + I2CTXD = 0; + } + L2_I2C_WriteCmd(D_i2c_addr_cw63xx,D_CW63X_REG_Interrupt,0); +} +#if 0 +void L1_cw63xx_init(void) +{ + U8 val = 0; + // LDO1 LDO2 LDO3 LDO4 + #if 0 + L2_I2C_WriteCmd(D_i2c_addr_cw63xx,D_CW63X_REG_LDO1,D_CW63XX_ON|D_CW63XX_3V2); // normal ģʽ + Lc_delay_ms(100);// 2000--7s + L2_I2C_WriteCmd(D_i2c_addr_cw63xx,D_CW63X_REG_LDO2,D_CW63XX_ON|D_CW63XX_3V2); // LDO1 Ϊ1.8v + Lc_delay_ms(100); + L2_I2C_WriteCmd(D_i2c_addr_cw63xx,D_CW63X_REG_LDO3,D_CW63XX_ON|D_CW63XX_3V2); // normal ģʽ + Lc_delay_ms(100);// 2000--7s + L2_I2C_WriteCmd(D_i2c_addr_cw63xx,D_CW63X_REG_LDO4,D_CW63XX_ON|D_CW63XX_3V2); // LDO1 Ϊ1.8v +//#else + L2_I2C_WriteCmd(D_i2c_addr_cw63xx,D_power_VCC,D_CW63XX_ON|D_CW63XX_2V5); // mcu gsensor + Lc_delay_ms(10);// 2000--7s + L2_I2C_WriteCmd(D_i2c_addr_cw63xx,D_power_VCC1,D_CW63XX_ON|D_CW63XX_3V); // uart4 sed ch430 mcu_program + Lc_delay_ms(10); + L2_I2C_WriteCmd(D_i2c_addr_cw63xx,D_power_VCC2,D_CW63XX_ON|D_CW63XX_2V5); //uart 4 receive + Lc_delay_ms(10);// 2000--7s + L2_I2C_WriteCmd(D_i2c_addr_cw63xx,D_power_VCC3,D_CW63XX_ON|D_CW63XX_2V5); // AS cpu 2.5v + + //L2_I2C_WriteCmd(D_i2c_addr_cw63xx,D_power_VCC2,D_CW63XX_ON|D_CW63XX_1V8); // AS cpu 2.5v + //Lc_delay_ms(600); + L2_I2C_WriteCmd(D_i2c_addr_cw63xx,D_power_VCC3,D_CW63XX_ON|D_CW63XX_2V8); // AS cpu 2.5v + Lc_delay_ms(10); + + #endif + + L2_I2C_WriteCmd(D_i2c_addr_cw63xx,D_CW63X_REG_Charge,0x3F);///150mA CHARGE + ///L2_I2C_ReadReg(D_i2c_addr_cw63xx,D_CW63X_REG_Charge,&val,1); +// L0_uart0_uchex(val); +// Lc_delay_ms(10); + //// Lc_delay_ms(10); + //// L2_I2C_ReadReg(D_i2c_addr_cw63xx,D_CW63X_REG_Charge,&val,1); + //// L0_uart0_uc(val); + //// Lc_delay_ms(10); + /****************** + while(9) + { + L2_I2C_WriteCmd(D_i2c_addr_cw63xx,D_power_VCC2,D_CW63XX_ON|D_CW63XX_2V8); L0_uart0_uc('e'); + Lc_delay_ms(30); + L2_I2C_WriteCmd(D_i2c_addr_cw63xx,D_power_VCC2,D_CW63XX_OFF|D_CW63XX_2V8); + Lc_delay_ms(30); + + } +*****************/ + +///-------------------------------------------------------------------- +// L2_I2C_ReadReg(D_i2c_addr_cw63xx,D_CW63X_REG_LDO1,s_as1.d,4);// press +// L0_uart0_uchex(s_as1.d[0]); L0_uart0_uchex(s_as1.d[1]); L0_uart0_uchex(s_as1.d[2]); L0_uart0_uchex(s_as1.d[3]); + +} + +void L3_cw63xx_fun(U8 *pPara) +{ +*pPara=0; +} + +///#else + +//// FX CMD R2 R3 4 +void L3_cw63xx_fun(U8 *pPara) +{ + U8 val = 0; + TS_P_debug *p = pPara; + switch(p->cmd) + { + /********** + case 0: + L1_cw63xx_init(); + L0_uart0_uc('C'); + L0_uart0_uc(p->R1); + L0_uart0_uc(p->R2); + L0_uart0_uc(p->R3); + break; + ***********/ + case 1: //// + //// AX CMDR2 R3 R4 + /// AD 01 01 03 04 ȡreg 01ֵ + //void L2_I2C_ReadReg(unsigned char sla,unsigned char reg, + // unsigned char *r,unsigned char n) + L2_I2C_ReadReg(D_i2c_addr_cw63xx,p->R2,&val,1); + L0_uart0_uc(val); + break; + + + case 2: //FD 02 03 04 00 + ///aD 02 0A 38 00 //vcc1 off + ///aD 02 0A B8 00 //vcc1 ON + ///FD 02 0B 04 00 B0011_1000 + ///FD 02 0C 04 00 + ///FD 02 01 3a 00 100mA + + L0_uart0_uc('W'); + L2_I2C_WriteCmd(D_i2c_addr_cw63xx,p->R2,p->R3); + //L0_uart0_uc(pPara[2]); + + L0_uart0_uc(p->R2); + L0_uart0_uc(p->R3); + break; + + + default: + break; + }; +} + +L2_I2C_ReadReg(D_i2c_addr_cw63xx,0,s_as.d,4); +L0_uart0_sendArray(s_as.d,4); +L2_I2C_WriteCmd(D_i2c_addr_cw63xx,0x03,0);////жϺҪдж +CHG_IN DCIN 5V Դ룬⵽粢жϣĴ 0x03[5] 0 1 +BAT_FULLس磬Ϊ 0򴥷жϣĴ 0x03[4] 0 1 +BAT_OT¶ȹߣĬֵ 60ң򴥷жϲֹͣ磬Ĵ 0x03[3] 0 1 +BAT_UT¶ȹͣĬֵ 0ң򴥷жϲֹͣ磬Ĵ 0x03[2] 0 1 +LOW_BATصѹڸ澯ֵʱĬΪ 3.4V򴥷жϣĴ 0x03[1] 0 1 +BUTTON£ᴥһжϣĴ 0x03[0] 0 1 + +ʵУȥغ BAT_FULLжϡ + +#endif + + diff --git a/source/bsp/backu/cw63xx.h b/source/bsp/backu/cw63xx.h new file mode 100644 index 0000000..5b741bb --- /dev/null +++ b/source/bsp/backu/cw63xx.h @@ -0,0 +1,123 @@ +//////////////////////////////////////////////////////////////////////////// +///@copyright Copyright (c) 2017, ؿƼ All rights reserved. +///------------------------------------------------------------------------- +/// @file msa300.c +/// @brief msa300 driver app +///------------------------------------------------------------------------- +/// @version 1.0 +/// @author CC +/// @date 20170122 +/// @note cc_AS_stc01 +////////////////////////////////////////////////////////////////////////////// + +#ifndef _cw63xx_H +#define _cw63xx_H + +#define D_i2c_addr_cw63xx 0x12 + + +#include "../msp/iic_sim.h" +//#include "../bsp/type_hs.h" +///-------------------------------------------------------------------- +#define D_CW63X_REG_system 0X00 +#define D_CW63X_REG_Charge 0X01 +#define D_CW63X_EN_NTC BITN7 ///Enable NTC check +#define D_CW63X_EN_CHG BITN6 /// Enable charging +#define D_CW63X_EN_TIMER BITN5 // Enalble charging timer + +// in power-off state,the IC will turn off LDO1,2,3,B ut hte LDORTC/LDO4 will remain on +#define D_CW63X_power_off 0x0a +//L1_cw63xx_set(D_CW63X_REG_Safety,D_CW63X_EN_NTC|D_CW63X_EN_CHG|D_CW63X_EN_TIMER|D_CW63X_power_off); +//L1_cw63xx_set(D_CW63X_REG_Safety,D_CW63X_EN_NTC|D_CW63X_EN_CHG|D_CW63X_EN_TIMER); + +///-------------------------------------------------------------------- + +#define D_CW63X_REG_Safety 0X02 +#define D_CW63X_LowBateryThreshold 0 +#define L0_set_LBT(x) ((x) - 28) +// L0_set_LBT(28) +/// L1_cw63xx_set(D_CW63X_REG_Safety,L0_set_LBT(28));/// 2.8v +/// fixme ʵֵԴIJ +///-------------------------------------------------------------------- +#define D_CW63X_REG_Interrupt 0X03 +#define D_CW63X_REG_Interrupt_type 0X04 +#define D_CW63X_INT_CHG_OUT BITN7 ///Charging unplugged +#define D_CW63X_INT_TIMER_EXPIRE BITN6 ///Charging timer expire +#define D_CW63X_INT_CHG_INT BITN5 ///Charger detected +#define D_CW63X_INT_BAT_FULL BITN4 ///Battery full + +#define D_CW63X_INT_BAT_OT BITN3 ///Battery over temperature +#define D_CW63X_INT_BAT_UT BITN2 ///Battery under temperature +#define D_CW63X_INT_LOW_BAT BITN1 ///Battery low voltage +#define D_CW63X_INT_BUTTON BITN0 ///button detected + +///-------------------------------------------------------------------- + +#define D_CW63X_REG_LDO1 0X0A +#define D_CW63X_REG_LDO2 0X0B +#define D_CW63X_REG_LDO3 0X0C +#define D_CW63X_REG_LDO4 0X0D + + +//// reg[]543] reg[210] +//// 54 3 +//// || |210 +#define D_CW63XX_V800 B0000_0000 +#define D_CW63XX_V975 B0000_0111 +#define D_CW63XX_1V4 B0001_0100 + + +#define D_CW63XX_1V8 B0001_1100 +#define D_CW63XX_2V1 B0011_0001 +#define D_CW63XX_2V5 B0011_0101 +#define D_CW63XX_2V8 B0011_1000 +#define D_CW63XX_3V B0011_1010 +#define D_CW63XX_3V2 B0011_1100 + +#define D_CW63XX_ON B1000_0000 +#define D_CW63XX_OFF B0000_0000 + + +////extern void L1_cw63xx_init(void); +extern void L3_cw63xx_fun(U8 *pPara); +extern void L1_cw63xx_sta(void); + +///debug ʹU8 +////ine L3_cw63xx_fun(x); + + +///--------------------------------- + + + + + +#define D_power_VCC1 D_CW63X_REG_LDO1 +#define D_power_VCC2 D_CW63X_REG_LDO2 +#define D_power_VCC3 D_CW63X_REG_LDO3 +#define D_power_VCC D_CW63X_REG_LDO4 +/* +#define D_power_rf_Rxd D_power_VCC2 /// rfģ +#define D_power_rf_Txd D_power_VCC1 /// rf ģ + +#define D_power_AS D_power_VCC3 /// ASģ + +#define L2_power_AS_OFF(); L2_I2C_WriteCmd(D_i2c_addr_cw63xx,D_power_AS,D_CW63XX_OFF|D_CW63XX_3V); +#define L2_power_AS_ON(); L2_I2C_WriteCmd(D_i2c_addr_cw63xx,D_power_AS,D_CW63XX_ON|D_CW63XX_3V); +#define L2_power_rf_Rxd_OFF(); L2_I2C_WriteCmd(D_i2c_addr_cw63xx,D_power_rf_Rxd,D_CW63XX_OFF|D_CW63XX_3V); +#define L2_power_rf_Rxd_ON(); L2_I2C_WriteCmd(D_i2c_addr_cw63xx,D_power_rf_Rxd,D_CW63XX_ON|D_CW63XX_3V); + +//#define L2_power_rf_Txd_OFF(); //L2_I2C_WriteCmd(D_i2c_addr_cw63xx,D_power_rf_Txd,D_CW63XX_OFF|D_CW63XX_3V); +//#define L2_power_rf_Txd_ON(); //L2_I2C_WriteCmd(D_i2c_addr_cw63xx,D_power_rf_Txd,D_CW63XX_ON|D_CW63XX_3V); + +/// fixme for the +#define L2_power_rf_Txd_OFF(); //L2_I2C_WriteCmd(D_i2c_addr_cw63xx,D_power_rf_Rxd,D_CW63XX_OFF|D_CW63XX_3V); +#define L2_power_rf_Txd_ON(); //L2_I2C_WriteCmd(D_i2c_addr_cw63xx,D_power_rf_Rxd,D_CW63XX_ON|D_CW63XX_3V); +*/ + +#define L1_cw63xx_init() L2_I2C_WriteCmd(D_i2c_addr_cw63xx,D_CW63X_REG_Charge,0x3F);\ + L2_I2C_WriteCmd(D_i2c_addr_cw63xx,D_CW63X_REG_Safety,0x05);///n3.3v baongjin + + +#endif // #ifndef _cw63xx_H + diff --git a/source/bsp/board support/msa300.c b/source/bsp/board support/msa300.c new file mode 100644 index 0000000..85331b9 --- /dev/null +++ b/source/bsp/board support/msa300.c @@ -0,0 +1,75 @@ +//////////////////////////////////////////////////////////////////////////// +///@copyright Copyright (c) 2017, ؿƼ All rights reserved. +///------------------------------------------------------------------------- +/// @file msa300.c +/// @brief msa300 driver app +///------------------------------------------------------------------------- +/// @version 1.0 +/// @author CC +/// @date 20170122 +/// @note cc_AS_stc01 +////////////////////////////////////////////////////////////////////////////// + + + +/******************************************************************************/ +/***************************** Include Files **********************************/ +/******************************************************************************/ +#include "msa300.h" +struct _s_gsens_ s_as1,s_as2; +void L1_msa300_init(void) +{ + /// ϵstandby ģʽ Ҫ + L2_I2C_WriteCmd(D_i2c_addr_AS1,0x11,0x1e); // normal ģʽ + L2_I2C_WriteCmd(D_i2c_addr_AS2,0x11,0x1e); // normal ģʽ + +} + +void L1_as1_readXYZ(void) +{ +///read data +//S ADD W A REG A +//S ADD R A D1 A D2 A.....DX N P + L2_I2C_ReadReg(D_i2c_addr_AS1,0x02,(unsigned char *)&s_as1,6); +// L2_I2C_ReadReg(D_i2c_addr_AS2,0,(unsigned char *)&s_as2,3); +} + +void L1_as2_readXYZ(void) +{ +///read data +//S ADD W A REG A +//S ADD R A D1 A D2 A.....DX N P + L2_I2C_ReadReg(D_i2c_addr_AS2,0x02,(unsigned char *)&s_as2,6); +} + + + + + + +#if 0 + +L2_I2C_ReadReg(D_i2c_addr_HP303B,0x0d,d,1); + L0_MUART_uc(d[0]); +L2_I2C_ReadReg(D_i2c_addr_AS1,0x05,d,1);// 11 =0f + L0_MUART_uc(d[0]); +L2_I2C_ReadReg(D_i2c_addr_AS2,0x05,d,1);//10 =0f + L0_MUART_uc(d[0]); + + + L1_as1_readXYZ(); + s_p_rf.ucR1 = (U8)(s_as1.x>>8); + s_p_rf.ucR2 = (U8)(s_as1.y>>8); + s_p_rf.ucR3 = (U8)(s_as1.z>>8); +p = (U8*)&s_p_rf; + + L0_MUART_uc(s_p_rf.ucR1); + L0_MUART_uc(s_p_rf.ucR2); + L0_MUART_uc(s_p_rf.ucR3); + L0_MUART_uc(0xc7); + + +#endif + + + diff --git a/source/bsp/board support/msa300.h b/source/bsp/board support/msa300.h new file mode 100644 index 0000000..34b0714 --- /dev/null +++ b/source/bsp/board support/msa300.h @@ -0,0 +1,63 @@ +//////////////////////////////////////////////////////////////////////////// +///@copyright Copyright (c) 2017, ؿƼ All rights reserved. +///------------------------------------------------------------------------- +/// @file msa300.c +/// @brief msa300 driver app +///------------------------------------------------------------------------- +/// @version 1.0 +/// @author CC +/// @date 20170122 +/// @note cc_AS_stc01 +////////////////////////////////////////////////////////////////////////////// + + + +#ifndef _MSA300_H +#define _MSA300_H + + +#include "../msp/iic_sim.h" + + + + +/*********************************************************************** + + U51(SDO=1) int2 P33 ----------------U10(SDO=0) int2 P32----------------MCU----USB + 0x4c 0x4e + AS1 AS2 + +**************************************************************************/ + + +#define D_i2c_addr_AS1 0x4c // u51 +#define D_i2c_addr_AS2 0x4e + +/******************************************************************************/ +/***************************** Include Files **********************************/ +/******************************************************************************/ + +// 400Khz 1/400 ms 2.5us + +//Symbol Parameter Condition Min Max Unit +//fscl Clock frequency 400 kHz + +struct _s_gsens_ +{//8byte + + U8 d[6]; + // U16 x; + // U16 y; + // U16 z; + +}; +extern struct _s_gsens_ s_as1,s_as2; + +extern void L1_as1_readXYZ(void); +extern void L1_as2_readXYZ(void); +extern void L1_msa300_init(void); + +#endif // #ifndef _MSA300_H + + + diff --git a/source/bsp/bsp_485.c b/source/bsp/bsp_485.c new file mode 100644 index 0000000..b2efe0e --- /dev/null +++ b/source/bsp/bsp_485.c @@ -0,0 +1,8 @@ +#include "bsp_485.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/bsp_485.h b/source/bsp/bsp_485.h new file mode 100644 index 0000000..e3629e4 --- /dev/null +++ b/source/bsp/bsp_485.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/bsp_config.c b/source/bsp/bsp_config.c new file mode 100644 index 0000000..9145292 --- /dev/null +++ b/source/bsp/bsp_config.c @@ -0,0 +1,119 @@ +#include "bsp_config.h" +#include "../tpc/tpc_modbus.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; + +GlobalRegister R; + +void L0_reg_reset() +{ + U8 i = 0; + //R.p.reset = 0; + 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.zero = 0; + R.p.weight_max = 500; //500kg + R.p.lmd = 2; //2mv/v + + R.p.cc_blur_ch_avg = 6; + R.p.cc_blur_ch_shift = 2; + R.p.cc_blur_all_shift0 = 2; + R.p.cc_blur_all_shift1 = 4; + R.p.cc_blur_all_out_d_threshold = 200; //0.2kg + R.p.cc_blur_all_out_dd_threshold = 200; //0.2kg + + for(i=0;i +#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_STC_8A 51 +#define TYPE_MCU_STC_8F 52 +#define TYPE_MCU_STC_8G 53 +#define TYPE_MCU_SHC6601 66 +#define TYPE_MCU_LPC17xx 3217 +#define TYPE_MCU_STM32 3232 + +#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 1 +#define TYPE_JIFFIES_10MS 2 +#define TYPE_JIFFIES_25MS 3 +//<<<<<<<<<<<<<<<<<<<<<<<<<<<.SysTimer TYPE end + +//>>>>>>>>>>>>>>>>>>>>>>.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 + +//>>>>>>>>>>>>>>>>>>>>>>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 + +//>>>>>>>>>>>>>>>>>>>>>>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 +//<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> +#define TYPE_UASER_BOARD TYPE_BOARD_WEIGH_0B + +//STEP 2 TYPE_UASER_BOARD CONFIG >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> +#if(TYPE_UASER_BOARD == TYPE_BOARD_WEIGH_0B) + #include + #include + #include + #include "../cpu/stc_stc8f.h" + #include "../cpu/stc_macro.h" + + //基本配置(工作频率、时钟、看门狗、字节序) + #define TYPE_MCU TYPE_MCU_STC_8F + #define TYPE_IDE TYPE_IDE_KEIL + #define D_CPUfamily_type D_CPUfamily_8bits + #define D_sys_MainFre MainFre_11M + #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_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_uart3_BRT BRT_115200 + #define D_uart4_BRT BRT_115200 + + //485配置 + #define D_UART0_485_TYPE TYPE_485_SLAVER //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 LED0 P10 //D4 + #define LED1 P35 //D4 + + //EEP存储地址定义 + #define D_EEP_SECTOR_SIZE 0x200 + #define D_EEP_PARAM_ADDR (D_EEP_SECTOR_SIZE * 0) //eeprom参数区扇区地址 + + #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) + +#elif(TYPE_UASER_BOARD == TYPE_BOARD_433_0A) + xxx +#endif + + +//STEP 3 Register CONFIG >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> + + +#if 0 +序号 量程 系数 +1 100kg 100% +2 200kg 100% +3 300kg 100% +4 400kg 100% +5 500kg 100% +6 600kg 100% +7 700kg 100% +8 800kg 100% +9 900kg 100% +10 1000kg 100% +#endif + +#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_weight_show_limit_num 5 +#define D_weight_std_num 10 +typedef struct global_register +{ + //RO Register + S16 reserved1; + S32 total_weight; //净重（显示重量）*100 + S32 total_zweight; //皮重*100 + //RW Register + S16 reserved2; + struct { //需要持久化的参数，不能超过72字节，否则会导致eeprom溢出 + U16 reset; //reset标志，写入任何值，所有参数恢复初始值 + U16 adc_ch_status; + S16 slaver_id; + S16 zero; //清0标志，写入任何值清0（去皮） + S16 weight_max; //量程 + S16 lmd; //2mv/v + S16 cc_blur_ch_avg; //均值滤波点数 + S16 cc_blur_ch_shift; //移位滤波点数 + S16 cc_blur_all_shift0; //和值移位滤波点数1 + S16 cc_blur_all_shift1; //和值移位滤波点数2 + S16 cc_blur_all_out_d_threshold; //移位阈值1 + S16 cc_blur_all_out_dd_threshold;//移位阈值2 + struct{ + S16 weight; + S16 times; + } weight_show_limit[D_weight_show_limit_num]; + struct { + S16 weight_range; //量程 x 100 + S16 ratio; //重量计算系数，默认100，保留两位小数，相当于x1 + } weight_std[D_weight_std_num]; + U16 baud_rate; //波特率 + U16 stop_bits; //停止位 + }p; + S16 reserved3; +}GlobalRegister; + +//寄存器内存基地址 +#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)) + +extern GlobalRegister R; + +//Step4: IRQ Config +#if (TYPE_MCU == TYPE_MCU_STC_8A || TYPE_MCU == TYPE_MCU_STC_8F) +#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 + +//======================================================== 以下为协议配置 ==================================================== +#define D_CMD_Filter1_ff 0xFF +#define D_CMD_Filter2_fe 0xFE +#define D_HETU_FX_fi 0xF0 +#define D_HETU_FX_MASK 0x0F +#define D_tp_handle_x_len 64 + +extern void L0_board_config(void); +extern void L0_reg_init(void); + +#endif//_BSP_CONFIG_H +/*********************************end file*********************************************/ + + + + diff --git a/source/bsp/bsp_cs1232.c b/source/bsp/bsp_cs1232.c new file mode 100644 index 0000000..45ffb11 --- /dev/null +++ b/source/bsp/bsp_cs1232.c @@ -0,0 +1,231 @@ +//////////////////////////////////////////////////////////////////////////// +///@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 "bsp_cs1232.h" +TSS_FLOW_ tss_ads; + +//#define D_ADC_GATHER_Way1 1 + +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_INIT(void) +{ + D_ADS1213_INIT(); + + L0_ADS1213_CH(D_ADCCH_1); + Lc_delay_ms(100);///57ms 建立时间 + + //L0_ADS1213_CH(D_ADCCH_3); + //Lc_delay_ms(100);///57ms 建立时间 +} + +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(); + } +} + +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; +} + + +vtype i; vU32 rdata = 0; + +vS32 L0_ADS1231_readCH(vtype ch) +{ + 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(0 == L0_2dc_DOUT_AT(ch)) + { + if(e ++ > 100000) + { + return 0; + } + } + e = 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; + } + } + if(rdata & 0x800000) //???λ?1??<0?? + { + rdata |= 0xFF000000; + } + return rdata; +} + + +void L1_ADS1213_main(void) +{ + U8 ch = D_ADCCH_4; + 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/bsp_cs1232.h b/source/bsp/bsp_cs1232.h new file mode 100644 index 0000000..b39f16d --- /dev/null +++ b/source/bsp/bsp_cs1232.h @@ -0,0 +1,229 @@ +//////////////////////////////////////////////////////////////////////////// +///@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_T 0 + +#define D_ADCCH_1 1 +#define D_ADCCH_2 2 +#define D_ADCCH_3 3 +#define D_ADCCH_4 4 + +#define D_ADCCH_Toff 5 + + ///数字部分需要有四个数据转换周期满足模拟输入信号的建立和滤波器的建立时间要求。芯 + ///片从外部差分输入信号切换到温度传感器、从温度传感器切换到外部差分输入信号，或通 + ///道间切换，到新的正确的数据到来都需要四个数据转换周期。整个建立过程如下图所示： + ///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.2 TEMP 1 +P1.3 SCLK3 2 +P1.4 DOUT1 3 +P1.5 SCLK1 4 +P1.6 DOUT2 5 +P1.7 SCLK2 6 +P5.4 PDWN 7 +P5.5 CS_A0 9 +P1.1 DOUT3 20 +P1.0 LED1 19 +P3.7 GAIN1 18 +P3.6 GAIN0 17 +P3.5 LED2 16 +P3.4 DOUT4 15 +P3.3 SCLK4 14 +P3.2 485_RE 13 +P3.1 TXD0 12 +P3.0 RXD0 11 +*****************/ + + +#define D_ADC_DOUT1_INIT() ///D_P16_INIT() +#define D_ADC_SCLK1_INIT() ///D_P17_INIT() +#define D_ADC_CS_A0_INIT() ///D_P55_INIT() +#define D_ADC_DOUT1_AT() D_P14_AT() +#define D_ADC_DOUT1_ON() D_P14_ON() +#define D_ADC_SCLK1_ON() D_P15_ON();D_adc_delay2(); +#define D_ADC_CS_A0_ON() D_P55_ON() +#define D_ADC_DOUT1_OFF() D_P14_OFF() +#define D_ADC_SCLK1_OFF() D_P15_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_P16_ON() +#define D_ADC_DOUT2_AT() D_P16_AT() +#define D_ADC_SCLK2_ON() D_P17_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_P16_OFF() +#define D_ADC_SCLK2_OFF() D_P17_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_P11_AT() +#define D_ADC_DOUT3_ON() D_P11_ON() +#define D_ADC_SCLK3_ON() D_P13_ON();D_adc_delay2(); +#define D_ADC_DOUT3_OFF() D_P11_OFF() +#define D_ADC_SCLK3_OFF() D_P13_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_P34_AT() +#define D_ADC_DOUT4_ON() D_P34_ON() +#define D_ADC_SCLK4_ON() D_P33_ON();D_adc_delay2(); +#define D_ADC_DOUT4_OFF() D_P34_OFF() +#define D_ADC_SCLK4_OFF() D_P33_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_P54_OFF() +#define D_ADC_PDWN_ON() D_P54_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_P36_OFF() +#define D_ADC_GAIN1_ON() D_P37_ON() +#define D_ADC_GAIN0_ON() D_P36_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/bsp_debug.c b/source/bsp/bsp_debug.c new file mode 100644 index 0000000..a7b6838 --- /dev/null +++ b/source/bsp/bsp_debug.c @@ -0,0 +1,14 @@ +//////////////////////////////////////////////////////////////////////////// +///@copyright Copyright (c) 2018, ؿƼ All rights reserved. +///------------------------------------------------------------------------- +/// @file bsp_debug.c +/// @brief bsp @ driver config +///------------------------------------------------------------------------- +/// @version 1.0 +/// @author CC +/// @date 20180331 +/// @note cc_AS_stc02 +////////////////////////////////////////////////////////////////////////////// + +//#include "bsp_debug.h" + diff --git a/source/bsp/bsp_debug.h b/source/bsp/bsp_debug.h new file mode 100644 index 0000000..6940097 --- /dev/null +++ b/source/bsp/bsp_debug.h @@ -0,0 +1,36 @@ +//////////////////////////////////////////////////////////////////////////// +///@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 _bsp_debug_H +#define _bsp_debug_H + +#include "../bsp/bsp_config.h" + +#include "../tpc/tpc_uart.h" + +#include "../msp/uart0.h" + +#define TS_debug_MAX 6 +typedef struct +{ + vU8 add; + void (*p2fun)(U8 *pPara); +}TS_debug_; + +extern void L3_debug_exp_protocol(TS_Handle_PH1 *p); +//extern void L3_UARTcom0_exp_protocol(void); +extern TS_debug_ volatile ts_debug[TS_debug_MAX]; + + +#endif // #ifndef _bsp_drv_H + diff --git a/source/bsp/bsp_power.c b/source/bsp/bsp_power.c new file mode 100644 index 0000000..ea64ceb --- /dev/null +++ b/source/bsp/bsp_power.c @@ -0,0 +1,128 @@ +//////////////////////////////////////////////////////////////////////////// +///@copyright Copyright (c) 2017, 传控科技 All rights reserved. +///------------------------------------------------------------------------- +/// @file APP_POWER.c +/// @brief APP_POWER driver app 电源管理 + +///------------------------------------------------------------------------- +/// @version 1.0 +/// @author CC +/// @date 20170122 +/// @note cc_AS_stc01 +////////////////////////////////////////////////////////////////////////////// + + + +/******************************************************************************/ +/***************************** Include Files **********************************/ +/******************************************************************************/ +//#include "app_Gsensor.h" + +#include "bsp_power.h" + +ts_task_power_ ts_task_power; + +void L1_app_POWER_init(void) +{ + DL0_WDT_init(); + //L0_INT4_OPEN(); +} + +/// INT1 和INT0可以可以终止掉电状态 这样唤醒后执行进入掉电模式语句的吓一条 +/// p32 + +//// SENSINT2 ccSensor_CG_V02_m08_debug p3.3 int 1 pin14 +//// gsensor 的中断给出来 cpu被唤醒 开始工作 +//// int4 只有下降沿中断 +void L0_sensor_active(void) interrupt D_sensor_active_isrNo +{ + NOP(); NOP(); NOP(); + //L0_INT4_CLEAR(); + BITN_1(DR_who_wakeup, DRB_who_wakeup_action); + NOP(); NOP(); NOP(); + +} + +#if 0 + + while (1) + { + /// P31 = 0; + /// NOP(); NOP(); NOP(); NOP(); NOP();///22m 5个 100ns 一个20ns + D_cam_led_on();///400us + // L0_delay_1us(); + Lc_delay_ms(gRccUs01);///300--200ms + D_cam_led_off(); + P31 = 1; + /// NOP(); NOP(); NOP(); NOP(); NOP(); + //L0_delay_1us(); + Lc_delay_ms(900);//100--70ms + } + + void L1_app_POWER_handle(void) + { + //// fixme: 需要调试 + /********************** + if(1 == s_mu_b.power) + { + s_mu_b.power = 0; + if(INT1)///___/``` + {// 催眠cpu + L0_uart0_uc('`'); + //给主循环传递标志 + s_mu_b.work = 0; + }else + {// 唤醒cpu/// ```\____ + L0_uart0_uc('L'); + s_mu_b.work = 1; + } + + } + if(P30)///___/``` + {// + + // L0_uart0_uc('`'); + }else + {// 唤醒cpu/// ```\____ + L0_uart0_uc('L'); + s_mu_b.work = 1; + } + + + + ************************/ + + + + if(1 == ts_task_power.power) + { + ts_task_power.power = 0; + ///L0_uart0_uc('L'); + + } + } + + if(0 == s_mu_b.work) + {/// step 1: 关闭一些耗电的东西 + /// fixme: vcc1 因为下载的原因需要 改进 + + /// vcc1 ch340e Uart4.txd +// L2_power_AS_OFF(); +/// L0_mcu_mode_powerdown(); + /// L2_power_AS_ON(); + + //// step : 打开电源 + } + + + + +void Int0_Routine(void) interrupt D_ISR_int1 +{ + s_mu_b.power = 1; +} + +#endif + + + diff --git a/source/bsp/bsp_power.h b/source/bsp/bsp_power.h new file mode 100644 index 0000000..4da7121 --- /dev/null +++ b/source/bsp/bsp_power.h @@ -0,0 +1,132 @@ +//////////////////////////////////////////////////////////////////////////// +///@copyright Copyright (c) 2017, 传控科技 All rights reserved. +///------------------------------------------------------------------------- +/// @file BSP_POWER.c +/// @brief BSP_POWER driver app 电源管理 +///------------------------------------------------------------------------- +/// @version 1.0 +/// @author CC +/// @date 20170122 +/// @note cc_AS_stc01 +///////////////////////////////////////////////////////////////////////////////// @version 1.0 +/// @author CC +/// @date 20180921 +/// @note +////////////////////////////////////////////////////////////////////////////// + +#ifndef _BSP_POWER_H +#define _BSP_POWER_H + +#include "../bsp/bsp_config.h" + + +#define L1_cw63_reg_set(x,y) L2_I2C_WriteCmd(D_i2c_addr_cw63xx, (x),(y) ) +#define L1_cw63_reg_get(x,y) L2_I2C_ReadReg(D_i2c_addr_cw63xx,(x),1) + + +///#define D_cam_led_on(); L1_cw63_reg_set(D_power_VCC2,D_CW63XX_ON|D_CW63XX_2V8); +///#define D_cam_led_off(); L1_cw63_reg_set(D_power_VCC2,D_CW63XX_OFF|D_CW63XX_2V8); + + +///#define D_cam_led_off(); D_cam_led_on();/// + + +#define D_cam_DVDD_on(); L1_cw63_reg_set(D_power_VCC,D_CW63XX_ON|D_CW63XX_2V5); +#define D_cam_DVDD_off(); L1_cw63_reg_set(D_power_VCC,D_CW63XX_OFF|D_CW63XX_2V5); + +#define D_cam_AVDD_on(); L1_cw63_reg_set(D_power_VCC1,D_CW63XX_ON|D_CW63XX_2V8);////D_cam_AVDD_off(); +#define D_cam_AVDD_off(); L1_cw63_reg_set(D_power_VCC1,D_CW63XX_OFF|D_CW63XX_2V8);/// +/// + + +/******************************************************************************/ +/***************************** Include Files **********************************/ +/******************************************************************************/ + +////#include "../bsp/msa300.h" + +#include "../msp/uart0.h" + +#define L0_mcu_mode_powerdown() PCON |= 0x02;_nop_();_nop_();_nop_();_nop_(); +/// PCON |= 0x02; //将STOP(PCON.1)置1,MCU将进入掉电模式 +// //此时CPU无时钟,不执行指令,且所欲外设停止工作 +// //外部中断信号和外部复位信号可以终止掉电模式 +// + +#define L0_mcu_mode_powerIDL() PCON = 0x01;_nop_();_nop_();_nop_();_nop_(); +/// PCON |= 0x02; //将STOP(PCON.0)置1,MCU将进入 模式 +// //此时CPU 停止工作 +// //外部中断信号和外部复位信号可以终止 +// +///1000,000/32,000 x 16x(1+n) = +#define D_WKTC_16S 0X7FFF +#define D_WKTC_15S 29999 +#define D_WKTC_10S 19999 +#define D_WKTC_5S 9999 +#define D_WKTC_3S 5999 +#define D_WKTC_2S 3999 +#define D_WKTC_1S 1999 +#define D_WKTC_500MS 999 +#define D_WKTC_50mS 99 + +#define L0_mcu_WKTC(X) WKTC = 0x8000|(X) + +///#define L0_mcu_WKTC(X) WKTCH = B1111_1111;WKTCL = 0XFF + + + +#define D_sensor_active_isrNo D_ISR_int4 + + +typedef struct +{ + U8 TI:1; + U8 RI:1; + U8 Tx_en:1; + U8 Rx_en:1; //波特率的位数 eive bit number (8 data bits + 1 stop bit) + U8 work:1; + U8 show_mod:1; // =0 普通模式 //s_mu_b.show_mod + U8 power:1; // =0 普通模式 //s_mu_b.power + U8 power2:1; // =0 普通模式 //s_mu_b.show_mod +// U8 power; // =0 普通模式 //s_mu_b.show_mod + +}ts_task_power_; +extern ts_task_power_ ts_task_power; + + +extern void L1_app_POWER_init(void); +extern void L1_app_POWER_handle(void); + + // WDT_CONTR = 0x23; //11m使能看门狗,溢出时间约为0.5s + /// WDT_CONTR = 0x24; //11m使能看门狗,溢出时间约为1s + // WDT_CONTR = 0x27; //11m使能看门狗,溢出时间约为8s + // P32 = 0; //测试端口 +/// ///22m 2.5s +#ifdef D_use_WDT + +#define DL0_WDT_init() WDT_CONTR =BITN5|D_WDT_2520ms +#define DL0_WDT() WDT_CONTR |= 0x10 //清看门狗,否则系统复位 +#else + +#define DL0_WDT_init() +#define DL0_WDT() + +#endif +///注意和烧写界面的硬件看门狗启动 +#define D_WDT_315ms B0010_0011 +#define D_WDT_629ms B0010_0100 +#define D_WDT_1260ms B0010_0101 +#define D_WDT_2520ms B0010_0110 +#define D_WDT_5030ms B0010_0111 + +///11m +#define D_WDT_524ms B0010_0011 +#define D_WDT_1050ms B0010_0100 +#define D_WDT_2100ms B0010_0101 +#define D_WDT_4200ms B0010_0110 +#define D_WDT_8390ms B0010_0111 + + +#endif // #ifndef _BSP_POWER_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..c8250bf --- /dev/null +++ b/source/clib/clib.c @@ -0,0 +1,1715 @@ +/***************************************************************************** + * 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" + +#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]; + } +} + + +///// 0 1 (1-0)+1 +//// 把buf中的数据从[usStart]到[usEnd] 共 usEnd-usStart+1 的数据转换成ascii +/// 0x11 0x22 ---> 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..df4e003 --- /dev/null +++ b/source/clib/clib.h @@ -0,0 +1,114 @@ +/***************************************************************************** + * 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 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 int libc_strlen(char *str); + +#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..a07b789 --- /dev/null +++ b/source/clib/type.h @@ -0,0 +1,317 @@ +////////////////////////////////////////////////////////////////////////// +/// 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 + +#ifndef MIN +#define MIN(a,b) (((a) < (b)) ? (a) : (b)) +#endif + +#ifndef MAX +#define MAX(a, b) (((a) > (b)) ? (a) : (b)) +#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..a84d004 --- /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 2048 +; +; 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/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..ee75f39 --- /dev/null +++ b/source/ctask/task.h @@ -0,0 +1,159 @@ +/******************************** +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_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..3644450 --- /dev/null +++ b/source/ctask/tick.c @@ -0,0 +1,48 @@ +/***************************************************************************** + * 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; +} + + +//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++; + 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..29c91ac --- /dev/null +++ b/source/ctask/tick.h @@ -0,0 +1,88 @@ +/***************************************************************************** + * 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 系统定时器整秒时刻标志,需要软件清除 +}; +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 50 +#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/debug/cc_as_stc01_main.ini b/source/debug/cc_as_stc01_main.ini new file mode 100644 index 0000000..7636777 --- /dev/null +++ b/source/debug/cc_as_stc01_main.ini @@ -0,0 +1,7 @@ +//MODE COM4 9600,0,8,1 +//ASSIGN COM4 < SIN > SOUT +// please "dir vtreg" and show the +MODE COM2 115200,0,8,1 +ASSIGN COM2 < S0IN > S0OUT +//MODE COM1 9600,0,8,1 +//ASSIGN COM1 < S0IN > S0OUT diff --git a/source/debug/cc_ls_03_debug.ini b/source/debug/cc_ls_03_debug.ini new file mode 100644 index 0000000..87a0def --- /dev/null +++ b/source/debug/cc_ls_03_debug.ini @@ -0,0 +1,6 @@ +//MODE COM4 9600,0,8,1 +//ASSIGN COM4 < SIN > SOUT +MODE COM6 9600,0,8,1 +ASSIGN COM6 < S0IN > S0OUT +//MODE COM1 9600,0,8,1 +//ASSIGN COM1 < S0IN > S0OUT diff --git a/source/debug/debug.ini b/source/debug/debug.ini new file mode 100644 index 0000000..203177f --- /dev/null +++ b/source/debug/debug.ini @@ -0,0 +1,123 @@ +MODE COM1 9600,0,8,1 +//assign com1 SOUT +ASSIGN COM1 < SIN > SOUT +//ASSIGN WIN SOUT +KILL FUNC * +KILL BUTTON * + + +//swatch(0.5) +DEFINE BUTTON "adc", "adc()" +signal void adc (void) { +// while (1) { /* repeat forever */ + P14= 0; /* set PORTA bit 0 */ + printf("adc is on\n"); + twatch(500); + //} /* repeat */ +} + +DEFINE BUTTON "k1 ", "k1()" +signal void k1 (void) { +P2.0= 0; + //P20= 0; + printf("K1 down\n"); + swatch(0.17); + P2.0= 1; + //P20= 1; + swatch(0.17); + printf("K1 up\n"); +} + + +DEFINE BUTTON "k2 ", "k2()" +signal void k2 (void) { + P2.1= 0; + //P21= 0; + printf("K2 down\n"); + swatch(0.17); + P2.1= 1; + //P21= 1; + swatch(0.17); + printf("K2 up\n"); +} + + +DEFINE BUTTON "k3 ", "k3()" +signal void k3 (void) { + P2.2= 0; + //P22= 0; + printf("K3 down\n"); + swatch(0.07); + P2.2= 1; + //P22= 1; + swatch(0.07); + printf("K3 up\n"); +} + + + + +DEFINE BUTTON "kx4 enter/", "kx4()" +signal void kx4 (void) { + + P13= 0; /* set PORTA bit 0 */ + printf("Kx4 down\n"); + swatch(0.07); + + P13= 1; + swatch(0.07); + printf("Kx4 up\n"); +} + +DEFINE BUTTON "<-- kx1_left ", "kx1_left()" +signal void kx1_left (void) { + + P12= 0; /* set PORTA bit 0 */ + + printf("kx1_left down\n"); + swatch(0.07); + P11= 0; + swatch(0.07); + + P12= 1; + swatch(0.07); + P11= 1; + swatch(0.07); + printf("kx1_left up\n"); + +} + +DEFINE BUTTON "kx1_right--> ", "kx1_right()" +signal void kx1_right (void) { + + P11= 0; /* set PORTA bit 0 */ + + printf("kx1_right down\n"); + swatch(0.07); + P12= 0; + swatch(0.07); + + P11= 1; + swatch(0.07); + P12= 1; + swatch(0.07); + printf("kx1_right up\n"); + +} +DEFINE BUTTON "My Registers", "MyRegs()" + +FUNC void MyRegs (void) { + printf ("---------- MyRegs() ----------\n"); + printf (" R4 R8 R9 R10 R11 R12\n"); + printf (" %04X %04X %04X %04X %04X %04X\n", + R0, R1, R2, R3, R4, R5); + printf ("------------------------------\n"); +} + + + +//bs write P3,1,"check_moto()"//дp2Ķִ signal +//signal void check_moto (void) + + + diff --git a/source/debug/testiic.uvla b/source/debug/testiic.uvla new file mode 100644 index 0000000..95fb5b0 Binary files /dev/null and b/source/debug/testiic.uvla differ diff --git a/source/msp/UART0.C b/source/msp/UART0.C new file mode 100644 index 0000000..ed7c42e --- /dev/null +++ b/source/msp/UART0.C @@ -0,0 +1,217 @@ +////////////////////////////////////////////////////////////////////////// +/// 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) +{ +#if(MainFre_22M == D_sys_MainFre) //115200bps@22.1184MHz + SCON = 0x50; //8位数据,可变波特率 + AUXR |= 0x40; //定时器1时钟为Fosc,即1T + AUXR &= 0xFE; //串口1选择定时器1为波特率发生器 + TMOD &= 0x0F; //设定定时器1为16位自动重装方式 + TL1 = 0xD0; //设定定时初值 + TH1 = 0xFF; //设定定时初值 + ET1 = 0; //禁止定时器1中断 + TR1 = 1; //启动定时器1 + +#elif(MainFre_11M == D_sys_MainFre) //115200bps@22.1184MHz + +#if(BRT_115200 == D_uart0_BRT && SBIT_1 == D_uart0_SBIT) //115200bps@11.0592MHz + SCON = 0x50; //8位数据,可变波特率 + AUXR |= 0x01; //串口1选择定时器2为波特率发生器 + AUXR &= 0xFB; //定时器2时钟为Fosc/12,即12T + T2L = 0xFE; //设定定时初值 + T2H = 0xFF; //设定定时初值 + AUXR |= 0x10; //启动定时器2 + +#elif(BRT_19200 == D_uart0_BRT && SBIT_1 == D_uart0_SBIT) //19200@11.0592MHz + xxxx + SCON = 0x50; //8位数据,可变波特率 + AUXR |= 0x01; //串口1选择定时器2为波特率发生器 + AUXR |= 0x04; //定时器2时钟为Fosc,即1T + T2L = 0x70; //设定定时初值 + T2H = 0xFF; //设定定时初值 + AUXR |= 0x10; //启动定时器2 +#elif(BRT_19200 == D_uart0_BRT && SBIT_2 == D_uart0_SBIT) //19200@11.0592MHz + xxx + //使用第9位数据模拟1个停止位,可变波特率;SM2=0, TB8=1(第9bit总为1模拟1个停止位) + SCON = 0xD8; + AUXR |= 0x01; //串口1选择定时器2为波特率发生器 + AUXR |= 0x04; //定时器2时钟为Fosc,即1T + T2L = 0x70; //设定定时初值 + T2H = 0xFF; //设定定时初值 + AUXR |= 0x10; //启动定时器2 +#elif (BRT_9600 == D_uart0_BRT) //9600bps@11.0592MHz + xxx + SCON = 0x50; //8位数据,可变波特率 + AUXR |= 0x01; //串口1选择定时器2为波特率发生器 + AUXR &= 0xFB; //定时器2时钟为Fosc/12,即12T + T2L = 0xE8; //设定定时初值 + T2H = 0xFF; //设定定时初值 + AUXR |= 0x10; //启动定时器2 +#endif +#endif//D_sys_MainFre) +} + +void L0_uart0_buf_init(void) +{ + ts_uart[uNum0].p = &ts_uart_send_shop; + 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 = D_CMD_Filter1_ff; + //ts_uart[uNum0].t->head_1 = D_CMD_Filter1_fe; + ts_uart[uNum0].t->head = 0; + ts_uart[uNum0].t->ok = 0; + ts_uart[uNum0].tp_handler = L1_s2b_PH4; + 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接收中断 + { + L0_uart0_IntRIClear(); //清除接收中断标志 + L0_timer1_start(0); + ts_uart[uNum0].t->reg = L0_uartN_get(uNum0); + ts_uart[uNum0].tp_handler(ts_uart[uNum0].t); + } + if(L0_uart0_IntTI()) //如果是U0发送中断 + { + 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(); +} + +#if 0 +void timer1_isrHanddle (void) D_SERVE_TIMER1 +{// + TF1 = 0; + //s_nos_tick.uart0_free = 1; + //if(s_uart0_rec.head == 1) //收到一条协议 + if(s_uart0_rec.head == 1) //收到一条协议 + { + s_uart0_rec.head = 0; + P10 ^= 1; + if(s_uart0_rec.ok == 0) + { + s_uart0_rec.ok = 1; + //Lc_buf_copy_uc(); + } + } +} +#else +void timer1_isrHanddle(void) D_SERVE_TIMER1 +{ + struct _tp_handler_x *p = &s_uart0_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_timer1_stop(); +} +#endif + + + diff --git a/source/msp/UART0.h b/source/msp/UART0.h new file mode 100644 index 0000000..91224b6 --- /dev/null +++ b/source/msp/UART0.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_UART0_Init + UART0_IRQHandler + L0_Usend_uc------UserDef +----------------------------------------------------------------------------------------- +********************************************************************************/ + + +#ifndef _uart0_H +#define _uart0_H +#include "../bsp/bsp_config.h" +#include "../tpc/tpc_modbus.h" +#include "uartN.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..3884af7 --- /dev/null +++ b/source/msp/UART2.c @@ -0,0 +1,156 @@ +////////////////////////////////////////////////////////////////////////// +/// 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/common.h" + +//#define _USE_485 + +static volatile Ts_uart_send_buf idata ts_uart_send_shop; +TP_Handler_X s_uart2_rec; +TS_PH3_ccmodbus 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 = 0xD0; //设定定时初值 + T2H = 0xFF; //设定定时初值 + AUXR |= 0x10; //启动定时器2 +#endif +} + +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 = D_CMD_Filter1_ff; + ts_uart[uNum2].t->head_1 = D_CMD_Filter2_fe; + ts_uart[uNum2].t->head = 0; + ts_uart[uNum2].t->ok = 0; + ts_uart[uNum2].tp_handler = L1_s2b_PH3; + 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接收中断 + { + L0_uart2_IntRIClear(); //清除接收中断标志 + ts_uart[uNum2].t->reg = L0_uartN_get(uNum2); + ts_uart[uNum2].tp_handler(ts_uart[uNum2].t); + } + 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..8d2835b --- /dev/null +++ b/source/msp/UART2.h @@ -0,0 +1,86 @@ +////////////////////////////////////////////////////////////////////////// +/// 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/tpc_ccmodbus.h" +#include "uartN.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); + +#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_PH3_ccmodbus 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..5c59ccb --- /dev/null +++ b/source/msp/UART3.c @@ -0,0 +1,170 @@ +////////////////////////////////////////////////////////////////////////// +/// 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 "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 + +} + +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(0); + } + 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_irq(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..a4e2ea8 --- /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/tpc_modbus.h" +#include "uartN.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/UARTN.C b/source/msp/UARTN.C new file mode 100644 index 0000000..6f84292 --- /dev/null +++ b/source/msp/UARTN.C @@ -0,0 +1,209 @@ +////////////////////////////////////////////////////////////////////////// +/// 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 "uartN.h" + +TS_uart_reg idata ts_uart[SERIAL_MAX_NUM] = {0}; + +void L0_uartN_set(U8 uartx,U8 x) reentrant +{ + 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) +{ + if(len > 0) + { + 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_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; + 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) +{ + 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) +{ + 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; + 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; + 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,libc_strlen(str)); +} + +void L0_uartN_uchexArray(U8 uartx,vU8 *buf,U16 n) +{ + int i; + for(i=0;i>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> +////fixme:和cpu的程序容量息息相关 +#define D_send_buf_max 16 /// 9600bps = 10000bps = 1000 Bps = 1Byte/ms + /// 19200bps = 20000bps = 2000Bps = 2Byte/ms = 1Byte/0.5ms + /// 128Bytes = 128*0.5ms = 64ms +#define D_send_buf2_max 8 //此处改动会影响L0_uartN_ulhex函数 + +typedef struct _ts_uart0_send_buf_ +{//8byte + vU8 num; //接收到的数目注意数据长度的范围 + vU8 *p; + vU16 now; /// 当前buf所在的位置 0------(max-1) + vU16 max; /// 当前buf的最大值,也就是需要发送的长度 + vU32 over; /// 结束等待标志，over累加到某个值时，结束等待 + vU8 ok; /// 发送完成标志 + vU8 buf[D_send_buf_max + 1]; +/// U8 buf2[D_send_buf2_max]; + vU8 buf3[D_send_buf2_max]; +//// U8 buf4[D_send_buf_max]; + /// U8 buf[D_send_buf_max + 1];//buffer 的第一位是 长度 +}Ts_uart_send_buf; + +typedef struct _TS_uart_reg +{ + Ts_uart_send_buf idata *p; + //eUSCI_UART_Config *c; + //int sta; + //U8 heartbeat; + TP_Handler_X *t; + void (*tp_handler)(TP_Handler_X *); //reentrant; + U8 *ack; //ack +}TS_uart_reg; + +//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< +#define SERIAL_MAX_NUM 1 +extern TS_uart_reg idata ts_uart[SERIAL_MAX_NUM]; + +extern void L0_uartN_init(U8 uartx); +extern void L0_uartN_set(U8 uartx,U8 x) reentrant; +extern U8 L0_uartN_get(U8 uartx); +extern void L0_uartN_sendArray(U8 uartx,void *buf,U16 len); +extern void L0_uartN_uc(U8 uartx,U8 ww); +extern void L0_uartN_us(U8 uartx,vU16 ww); +extern void L0_uartN_ul(U8 uartx,vU32 ww); +extern void L0_uartN_0d0a(U8 uartx); +extern void L0_uartN_uchex(U8 uartx, U8 ww); +extern void L0_uartN_ushex(U8 uartx, U16 ww); +extern void L0_uartN_ulhex(U8 uartx, U32 ww); +extern void L0_uartN_sendstr(U8 uartx,U8 *buf); +extern void L1_uartN_uchexArray(U8 uartx,vU8 *buf,U16 n); + + +#endif //#ifndef _uartN_H + diff --git a/source/msp/iic_sim.c b/source/msp/iic_sim.c new file mode 100644 index 0000000..203b9cf --- /dev/null +++ b/source/msp/iic_sim.c @@ -0,0 +1,355 @@ +////////////////////////////////////////////////////////////////////////// +/// COPYRIGHT NOTICE +/// Copyright (c) 2018, ؿƼ +/// All rights reserved. +/// +/// @file iic_sim +/// @brief iic ģio 汾 cpu޹أΨһҪ޸ĵľͷеĹܽŶ +/// @info ޱҪ޸ +///ļʵֵĹܵ +/// +/// @version 1.1 CCsens technology +/// @author CC +/// @date 20180102 + +// +////////////////////////////////////////////////////////////////////////// + +#include "iic_sim.h" + +/*------------------------------------------------ + ˿ڶ +I2CߴݹУÿһֽڣ +ҪһӦ״̬λݵ +ͨӦλ֪Ӧλʱ +Ӧλ״̬ѭ˭ +˭ԭ򣬼ɽӦλ +Ӧʱڼ뽫SDA +ͣʹʱĸߵƽڼ䱣ȶĵ͵ƽͼ9 +Ȼ뿼ǽͱʱ +ϸı6 ӻʱ +ӦλɴӻӴӻʱӦλ + +I2C߱׼涨 ӦλΪ0ʾӦ ACK +ΪA Ϊ1ʾӦ NACK +ΪNALSB֮ӦͷSDAߣSDA +ԵȴӦλ +ڽһֽڵݣ +߲ٽոʱӦӦ +ֽ֪ͨ˷Ӧ״̬ +Ӧֹ͡ + +------------------------------------------------*/ +///<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< + + + +void L0_I2C_SCL(unsigned char v) +{ + if(v) + { + L0_SCL_ON(); + L0_slc_1_delay(); + } + else + { + L0_SCL_OFF(); + L0_slc_0_delay(); + } +} +void L0_I2C_SDA(unsigned char v) +{ + if(v) + { + L0_SDA_ON(); + L0_slc_1_delay(); + } + else + { + L0_SDA_OFF(); + L0_slc_0_delay(); + } +} +void L0_I2C_INIT(unsigned char v) +{ + if (v) + { + L0_IIC_SIM_INIT(); + L0_I2C_SDA(1); + L0_I2C_SCL(1); + }else + { + + + } +} + +unsigned char L0_I2C_SDA_ask(void) +{ + + return L0_SDA_AT(); + +} + +///<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< + + + +/**************** + +void L0_I2C_Reset(void) +{ + L0_I2C_SCL(1); L0_I2C_SDA(1); //ȷͷ +} + + +********************/ + +//********************************************** +//ʼλ IO_SDA=1->0 +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/msp_eeprom.c b/source/msp/msp_eeprom.c new file mode 100644 index 0000000..51ace62 --- /dev/null +++ b/source/msp/msp_eeprom.c @@ -0,0 +1,151 @@ +//////////////////////////////////////////////////////////////////////////// +///@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 "msp_eeprom.h" + + +#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 + + +U_F16 uf_ee_add; + + +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功能 +} + +void L0_Iap_Program_array(vU16 addr,U8 *buf,U8 len) +{ + U8 i = 0; + for(i=0;i>8 & 0xFF); + L0_uart0_uchex(i>>0 & 0xFF); + } + } +#endif + Lc_delay_ms(100); + L0_uart0_uc('%'); + + while(1); +} +#endif + diff --git a/source/msp/msp_eeprom.h b/source/msp/msp_eeprom.h new file mode 100644 index 0000000..681fbaa --- /dev/null +++ b/source/msp/msp_eeprom.h @@ -0,0 +1,43 @@ +////////////////////////////////////////////////////////////////////////// +/// COPYRIGHT NOTICE +/// Copyright (c) 2018, 传控科技 +/// All rights reserved. +/// +/// @file msp_eeprom +/// @brief msp_eeprom +/// @info +///（本文件实现的功能的详述） +/// +/// @version 1.1 CCsens technology +/// @author CC +/// @date 20190106 + +// +////////////////////////////////////////////////////////////////////////// + +#ifndef _msp_eeprom_H_ +#define _msp_eeprom_H_ + +#include "../clib/type.h" +#include "../clib/clib.h" +#include "../ctask/tick.h" + + +///>>>端口位定义，可修改!!!!!!>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> + +#include "../bsp/bsp_config.h" +#include "uart0.h" + +extern void L3_eeprom_fun(U8 *pPara); + +///每个扇区512字节 +extern void L0_Iap_Erase(vU16 addr); +extern void L0_Iap_Program(vU16 addr, char dat); +extern char L0_Iap_Read(vU16 addr); +extern void L0_Iap_Program_array(vU16 addr,U8 *buf,U8 len); +extern void L0_Iap_Read_array(vU16 addr,U8 *buf,U8 len); +extern void L1_Iap_main(void); + +#endif// #ifndef _msp_eeprom_H_ + + diff --git a/source/msp/msp_id.c b/source/msp/msp_id.c new file mode 100644 index 0000000..c2c345b --- /dev/null +++ b/source/msp/msp_id.c @@ -0,0 +1,52 @@ +//////////////////////////////////////////////////////////////////////////// +///@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 "msp_id.h" + +#define MSP_ID_LEN 7 + +void L0_id_get(U8 *id) +{ + U8 i = 0; + char *ID = (char idata *)0xf1; + for(i=0;i>>端口位定义，可修改!!!!!!>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> + +#include "../bsp/bsp_config.h" + + +#include "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/msp/time.c b/source/msp/time.c new file mode 100644 index 0000000..7131189 --- /dev/null +++ b/source/msp/time.c @@ -0,0 +1,205 @@ +#include "Time.h" + +/*************初始化定时器0由 stc-isp v6.86L定时器计算器生成******************/ +#if(MainFre_5M == D_sys_MainFre) +#elif(MainFre_27M == D_sys_MainFre) +#elif(MainFre_22M == D_sys_MainFre) +void L0_timer0_Init(void) //25毫秒@22.1184MHz +{ + AUXR &= 0x7F; //定时器时钟12T模式 + TMOD &= 0xF0; //设置定时器模式 + TL0 = 0x00; //设置定时初值 + TH0 = 0x4C; //设置定时初值 + TF0 = 0; //清除TF0标志 + TR0 = 1; //定时器0开始计时 + ET0 = 1; //add by cc +} + + +/******************************************** +void L0_timer0_Init(void) //10毫秒@22.1184MHz +{ + AUXR &= 0x7F; //定时器时钟12T模式 + TMOD &= 0xF0; //设置定时器模式 + TL0 = 0x00; //设置定时初值 + TH0 = 0xB8; //设置定时初值 + TF0 = 0; //清除TF0标志 + TR0 = 1; //定时器0开始计时 + ET0 = 1; //add by cc +} + +void L0_timer0_Init_32k(void) //4fen@32kHz +{ + AUXR &= 0x7F; //定时器时钟12T模式 + TMOD &= 0xF0; //设置定时器模式 + #if 0 + TL0 = 0x00; //设置定时初值 + TH0 = 0xB8; //设置定时初值/// 4m20s 71 + #else + TL0 = 0x00; //设置定时初值 + TH0 = 0xcc; //设置定时初值// ff 4s + + + #endif + TF0 = 0; //清除TF0标志 + TR0 = 1; //定时器0开始计时 + ET0 = 1; //add by cc + BITN_0(DR_who_wakeup, DRB_who_wakeup_timer0); /// 标志中断类型: 定时器 +} +****************************************************/ + +#else ///MainFre_11M +void L0_timer0_Init(void) //10毫秒@11.0592MHz +{ + AUXR &= 0x7F; //定时器时钟12T模式 + TMOD &= 0xF0; //设置定时器模式 + TL0 = 0x00; //设置定时初值 + TH0 = 0xDC; //设置定时初值 + TF0 = 0; //清除TF0标志 + TR0 = 1; //定时器0开始计时 + ET0 = 1; //add by cc +} + +/******************************************** +void L0_timer0_Init(void) //25毫秒@11.0592MHz +{ + AUXR &= 0x7F; //定时器时钟12T模式 + TMOD &= 0xF0; //设置定时器模式 + TL0 = 0x00; //设置定时初值 + TH0 = 0xA6; //设置定时初值 + TF0 = 0; //清除TF0标志 + TR0 = 1; //定时器0开始计时 + ET0 = 1; //add by cc +} +****************************************************/ +#endif//D_sys_MainFre) + +//10---87 10s +/********************** Timer0中断函数************************/ +/// 和 L0_timer0_Init 关联,需要配置 bsp_config.h中的 D_sys_MainFre +/// 默认10ms 作为TTSS系统的定时引擎 +void timer0_isrHanddle (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(); +} + + + + + + + + + +#if(MainFre_5M == D_sys_MainFre) +#elif(MainFre_27M == D_sys_MainFre) +#elif(MainFre_22M == D_sys_MainFre) +/****************************** +void L0_Timer1_Init(void) //35毫秒@22.1184MHz +{///自动重载 + AUXR &= 0xFB; //定时器时钟12T模式 + T2L = 0x00; //设置定时初值 + T2H = 0x04; //设置定时初值 + AUXR |= 0x10; //定时器2开始计时 + + BITN_1(IE2, ET2);// IE2 = ET2; //使能定时器中断 +} +**********************************/ +#else ///MainFre_11M + +void L0_timer1_Init_7ms(void) //7毫秒@11.0592MHz +{ + AUXR &= 0xBF; //定时器时钟12T模式 + TMOD &= 0x0F; //设置定时器模式 + TL1 = 0xCD; //设置定时初值 + TH1 = 0xE6; //设置定时初值 + TF1 = 0; //清除TF1标志 + TR1 = 1; //定时器1开始计时 + ET1 = 1; //add by cc +} + +void L0_timer1_Init_5ms(void) //5毫秒@11.0592MHz +{//0x7F示波器测试大约40ms，led闪烁 肉眼可见 + AUXR &= 0xBF; //定时器时钟12T模式 + TMOD &= 0x0F; //设置定时器模式 + TL1 = 0x00; //设置定时初值 + TH1 = 0xEE; //设置定时初值 + TF1 = 0; //清除TF1标志 + TR1 = 1; //定时器1开始计时 + ET1 = 1; //add by cc +} + +void L0_timer1_Init_1ms(void) //1毫秒@11.0592MHz +{ + AUXR |= 0x40; //定时器时钟1T模式 + TMOD &= 0x0F; //设置定时器模式 + TL1 = 0xCD; //设置定时初值 + TH1 = 0xD4; //设置定时初值 + TF1 = 0; //清除TF1标志 + TR1 = 1; //定时器1开始计时 + ET1 = 1; //add by cc +} + +void L0_timer1_Init(void) //600微秒@11.0592MHz +{ + AUXR |= 0x40; //定时器时钟1T模式 + TMOD &= 0x0F; //设置定时器模式 + TL1 = 0x14; //设置定时初值 + TH1 = 0xE6; //设置定时初值 + TF1 = 0; //清除TF1标志 + TR1 = 1; //定时器1开始计时 + ET1 = 1; //add by cc +} + + +//0x7F示波器测试大约40ms，led闪烁 肉眼可见 +void L0_timer1_reset(void) +{ + TR1 = 0; + TL1 = 0x14; //设置定时初值 + TH1 = 0xE6; //设置定时初值 + TR1 = 1; + TF1 = 0; +} + +#endif//D_sys_MainFre) + + + +void L0_timer1_start(U16 v) //600微秒@11.0592MHz +{ + AUXR |= 0x40; //定时器时钟1T模式 + TMOD &= 0x0F; //设置定时器模式 + TL1 = 0x14; //设置定时初值 + TH1 = 0xE6; //设置定时初值 + TF1 = 0; //清除TF1标志 + TR1 = 1; //定时器1开始计时 + ET1 = 1; //add by cc +} + +void L0_timer1_stop(void) +{ + TR1 = 0; + TF1 = 0; +} + + +/******************************END*********************************/ + + + + diff --git a/source/msp/time.h b/source/msp/time.h new file mode 100644 index 0000000..f923c0b --- /dev/null +++ b/source/msp/time.h @@ -0,0 +1,56 @@ +#ifndef INIT_TIMER0_H +#define INIT_TIMER0_H + +#include "../clib/type.h" + +#include "../bsp/bsp_config.h" +#include "../ctask/tick.h" + +extern void L0_timer1_stop(void); +extern void L0_timer1_start(U16 v); +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/tpc/tpc_0d0a.c b/source/tpc/tpc_0d0a.c new file mode 100644 index 0000000..e713210 --- /dev/null +++ b/source/tpc/tpc_0d0a.c @@ -0,0 +1,47 @@ +#include "tpc_0d0a.h" +#include "../clib/clib.h" + +//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> +//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/tpc_0d0a.h b/source/tpc/tpc_0d0a.h new file mode 100644 index 0000000..ddf5a39 --- /dev/null +++ b/source/tpc/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/tpc_ccmodbus.c b/source/tpc/tpc_ccmodbus.c new file mode 100644 index 0000000..1ef753f --- /dev/null +++ b/source/tpc/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 "tpc_ccmodbus.h" +#include "../clib/clib.h" + +#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) +{ + U8 pkglen = 0; + 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_tp_handle_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_tp_handle_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/tpc_ccmodbus.h b/source/tpc/tpc_ccmodbus.h new file mode 100644 index 0000000..80f9eff --- /dev/null +++ b/source/tpc/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 "tpc_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) + +typedef struct +{//8byte + vU8 filter1; + vU8 filter2; + vU8 num; //接收到的数据的计数， 随着数据接收而变化注意数据长度的范围 + vU8 slaver; //发送方的地址或命令 + vU8 oper; //命令 + vU8 buf[D_tp_handle_x_len + 8];//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_ */ + diff --git a/source/tpc/tpc_debug.c b/source/tpc/tpc_debug.c new file mode 100644 index 0000000..639cc5f --- /dev/null +++ b/source/tpc/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 "tpc_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/tpc_debug.h b/source/tpc/tpc_debug.h new file mode 100644 index 0000000..88d7231 --- /dev/null +++ b/source/tpc/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/tpc_modbus.c b/source/tpc/tpc_modbus.c new file mode 100644 index 0000000..abacdd4 --- /dev/null +++ b/source/tpc/tpc_modbus.c @@ -0,0 +1,254 @@ + +/***************************************************************************** +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 "tpc_modbus.h" +#include "../bsp/bsp_config.h" +#include "../ctask/tick.h" +#include "../clib/clib.h" + +U8 L3_pack_modbus_03(TS_PH4_modbus *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_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; + } + 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; + } + 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; + } +} + +//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_tp_handle_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; + } + } +} + +#if 0 +//MODBUS协议分割函数，该函数应该被timer0中断调用 +//本函数负责检查modbus crc，不负责校验业务ID +//校验业务ID，在具体的业务处理函数中实现 +void L1_modbus_split(struct _tp_handler_x *p) +{ + if((p->head == 1) && (p->num >= D_s_modbus_min)) + { + crc16_irq(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; + } + } + p->head = 0; + } +} +#endif + +/****************************************************************************** +** End Of File +******************************************************************************/ + diff --git a/source/tpc/tpc_modbus.h b/source/tpc/tpc_modbus.h new file mode 100644 index 0000000..80e0890 --- /dev/null +++ b/source/tpc/tpc_modbus.h @@ -0,0 +1,114 @@ +////////////////////////////////////////////////////////////////////////// +/// 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 4 //modbus协议的最小长度 + +typedef struct ts_ph4_modbus +{ + U8 slaver; //从机地址 + U8 oper; //功能码 + U8 buf[D_tp_handle_x_len + 8]; + U8 crc[2]; +}TS_PH4_modbus; + +typedef struct s_modbus_03_ack +{ + U8 bytes; + U8 buf[D_tp_handle_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..b54545d --- /dev/null +++ b/source/tpc/tpc_x.h @@ -0,0 +1,32 @@ +#ifndef TPC_X_H +#define TPC_X_H + +#include "../bsp/bsp_config.h" +#if 0 +#include "tpc_debug.h" +#include "tpc_ccmodbus.h" +#include "tpc_modbus.h" +#include "tpc_0d0a.h" +#endif + +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 max; //接收到的数目的最大值 + //vU8 __buf[D_tp_handle_x_len+1];//buffer + vU8 buf[D_tp_handle_x_len+16];//array的第一位是 长度 //协议缓冲 + vU8 *sp; + vU8 *sp2; //备份值，如果协议需要备份，单独提供备份缓冲区 + vU8 ocr; + vU8 crc[2]; + vU32 modbusstmp; + U8 i; +}TP_Handler_X; + +#endif