commit c3d5a5bd74e4f497fd53ff8a24a4624dc946e95f Author: zhangsan Date: Thu Oct 7 15:30:13 2021 +0800 20210705 开封发货 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..646f75d --- /dev/null +++ b/keilp/cc_as_stc02_ps5ws.uvprojx @@ -0,0 +1,469 @@ + + + + 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 + + + iic_sim.c + 1 + ..\source\msp\iic_sim.c + + + msp_eeprom.c + 1 + ..\source\msp\msp_eeprom.c + + + msp_id.c + 1 + ..\source\msp\msp_id.c + + + + + bsp + + + bsp_power.c + 1 + ..\source\bsp\bsp_power.c + + + bsp_cs1232.c + 1 + ..\source\bsp\bsp_cs1232.c + + + bsp_485.c + 1 + ..\source\bsp\bsp_485.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 + + + + + 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..754f6e3 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..c8b4f42 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..9911101 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..c159f36 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..50d7c65 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..b50bf1b 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..593a129 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..704a36f 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..4b902b2 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..218c725 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/33.txt b/source/33.txt new file mode 100644 index 0000000..ad7917e --- /dev/null +++ b/source/33.txt @@ -0,0 +1,141 @@ +#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 +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_task_init, Highlight +typedef, Control +typeid, Keyword +typename, Keyword +UINT, Keyword +union, Control +unsigned, Keyword +using, Keyword +value, Keyword +virtual, Keyword +VOID, Keyword +void, Keyword +volatile, Keyword +wchar_t, Keyword +while, Control +WORD, Keyword +[, Delimiter +{, Delimiter +], Delimiter +}, Delimiter 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..ca31cd5 --- /dev/null +++ b/source/app/app_task_adc.c @@ -0,0 +1,352 @@ +#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 >= G.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 >> G.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 >> G.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 >> G.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 = (G.p.cc_blur_all_out_threshold); + //s->diff_threshold1 = (G.p.cc_blur_all_out_threshold1); + //s->diff_threshold2 = (G.p.cc_blur_all_out_threshold2); + //s->should_show_times_threshold = (G.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] >= G.p.cc_blur_all_out_d_threshold) || (s->SHA_diff[0] >= G.p.cc_blur_all_out_d_threshold) || (s->SHA_ddiff[0] >= G.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 <<= G.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 >> G.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 << G.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 >= G.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] >= G.p.weight_show_limit[i].times) + { + L3_task_show_times_reset(); + s->pool_val = s->val; + G._total_weight = s->pool_val; + G.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); + + 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,16); + s->u16_v = (vU16)(s->pool_val & 0x0000ffff); + L0_uart0_ushex(s->u16_v,16);//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); + + TTSS_Task_end(); +} + + +void L3_task_show_times_reset() +{ + U8 i = 0; + for(i=0;i 5ms + if(ph4->ok) + { + ph4->ok = 0; + crc16(ph4->crc,ph4->buf,ph4->num - 2); + if(ph4->crc[0] == ph4->buf[ph4->num-2] && ph4->crc[1] == ph4->buf[ph4->num-1]) + { + L3_ph4_common_handler((TS_PH4_modbus*)(ph4->buf)); + } + else + { + L3_ph4_send_error_pkg(MODBUS_ERR_CRC); + } + } +} + + diff --git a/source/app/app_task_uart0.h b/source/app/app_task_uart0.h new file mode 100644 index 0000000..550bb31 --- /dev/null +++ b/source/app/app_task_uart0.h @@ -0,0 +1,12 @@ +#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(TS_Handle_PH4 *ph4); + + +#endif diff --git a/source/app/app_ws.c b/source/app/app_ws.c new file mode 100644 index 0000000..b1dad17 --- /dev/null +++ b/source/app/app_ws.c @@ -0,0 +1,131 @@ +////////////////////////////////////////////////////////////////////////// +/// COPYRIGHT NOTICE +/// Copyright (c) 2020, ؿƼ +/// 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_ws.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; + L0_nos_tick1s_start(s_nos_tick.n_stamp3); + L0_nos_tick1s_interval(s_nos_tick.n_stamp3) + + L2_task_go(D_task_FLOW_wakeup); + + TTSS_Task_step(D_task_WS_ch): + + + + + + TTSS_Task_step(D_task_WS_T):////һʱ ʼɼ¶ в + if(s_nos_tick.flag_1s2) + { + s_nos_tick.flag_1s2 = 0; + if(L0_nos_tick1s_interval(s_nos_tick.n_stamp3) > 60) + { + L0_nos_tick1s_start(s_nos_tick.n_stamp3); + + L0_ADS1213_CH(D_ADCCH_Toff); + L0_ADS1213_CH(D_ADCCH_1); + + L2_task_go(D_task_WS_T2); + + + }else + { + + L2_task_go(D_task_WS_ch); + } + + }else + { + L2_task_go(D_task_WS_ch); + + } + + TTSS_Task_step(D_task_WS_T2): +// L0_ADS1213_read(); + + + TTSS_Task_end(); +} + + + + diff --git a/source/app/app_ws.h b/source/app/app_ws.h new file mode 100644 index 0000000..a449daa --- /dev/null +++ b/source/app/app_ws.h @@ -0,0 +1,72 @@ +#ifndef _APP_WS_H +#define _APP_WS_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 "../tpc/tpc_uart.h" +#include "../clib/bit.h" +#include "app_algorithm.h" + +//>>>>>>>>>>>>>>>>>>>>>0task + +///#define D_task_WS_ask 0x56 +///#define D_task_WS_enter 0x57 +///#define D_task_WS_init 0x10 + +///#define D_task_OSD_init_key 0x11 +///#define D_task_WS_STEP 0x30 +///#define D_task_WS_heratbeat 0x70 + +#define D_task_WS_wait_cam1 0x51 +#define D_task_WS_T 0x52 +#define D_task_WS_T2 0x62 + +#define D_task_WS_lowPower 0x53 +#define D_task_WS_work 0x5b +#define D_task_WS_cali 0x5c + +#define D_task_WS_ch 0x54 +#define D_task_WS_cal 0x55 + + + + +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_WS_; +extern TS_task_WS_ ts_task_WS; + +extern void L2_task_WS_handle(TS_task_WS_ *s); +extern void L2_task_WS_init(void); +extern void L2_task_WS_handle33(TS_task_WS_ *s); + + +extern TS_P_rf433 TS_paer_value; + + +//<<<<<<<<<<<<<<<<<<<0task + +#endif + + + diff --git a/source/app/common.c b/source/app/common.c new file mode 100644 index 0000000..67fc94f --- /dev/null +++ b/source/app/common.c @@ -0,0 +1,287 @@ +#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*)&G.p,(U8*)eep_param.buf,sizeof(G.p));//防止dlen>sizeof(G.P)引起的内存错误 + } + } +} + +void L3_eeprom_persist_param() +{ + U8 dlen = sizeof(G.p); + eep_param.filter = EEPROM_PARAM_FILTER; + eep_param.len = dlen + 2; + Lc_buf_copy_uc((U8*)eep_param.buf,(U8*)&G.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; +} + +int L3_ph4_send_error_pkg(U8 errcode) +{ + TS_PH4_modbus modbusack; + U8 modbuslen = 0; + ModbusErrAck modbusErrAck; + modbusErrAck.errcode = errcode; + + modbuslen = L3_pack_PH4(&modbusack, MODBUS_OPER_ERR, &modbusErrAck, sizeof(modbusErrAck)); + L0_uart0_sendArray((U8*)&modbusack, modbuslen); + return 0; +} + + +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; +} + diff --git a/source/app/common.h b/source/app/common.h new file mode 100644 index 0000000..6eb44e8 --- /dev/null +++ b/source/app/common.h @@ -0,0 +1,238 @@ +#ifndef APP_COMMON_H +#define APP_COMMON_H + +#include "../clib/type.h" + +#define APP_VERSION 0x10 +#define P485_SLAVER_ID 0x01 + +#define D_MCU_BIGENDIAN 1 +// #define D_MCU_LITTLEENDIAN 1 + +#define D_COUNT_WEIGHT(adc) ((S32)((1000.0 * G.p.weight_max * (adc)) / (2 * 0x7FFFFF / 1000 * D_ADS1213_GAIN_VAL * G.p.lmd))) + +enum tp_handle +{ + TP_HANDLED, + TP_UNHANDLE +}; + +/** + * EEPROM 存储结构 + */ +#define EEPROM_PARAM_DATA_MAX 86 +#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; + + +/** + * 用户协议 + */ +enum PROTOCOL_OPER +{ + OPER_RESERVED = 0x00, + OPER_READ = 0x01, + OPER_WRITE = 0x02, + OPER_ACK = 0x03, + OPER_REPORT = 0x04, +}; + +enum MODBUS_OPER +{ + MODBUS_OPER_READ = 0x03, + MODBUS_OPER_WRITE = 0x06, + MODBUS_OPER_ERR = 0x8F, +}; + +enum MODBUS_ERR_CODE +{ + MODBUS_ERR_LEN = 0x01, + MODBUS_ERR_CRC = 0x02, + MODBUS_ERR_OPCODE = 0x03, +}; + +//协议类型: MODBUS RTU模式 +//#define D_s_PH4_modbus_max (16) +#define D_s_PH4_modbus_max (64) + +typedef struct ts_ph4_modbus +{ + U8 salver; //从机地址 + U8 oper; //功能码 + U8 buf[D_s_PH4_modbus_max]; + U8 crc[2]; + U8 num; +}TS_PH4_modbus; + +typedef struct s_modbus_03 +{ + U16 reg; + U16 num; +}Modbus03; + +typedef struct s_modbus_03_ack +{ + U8 bytes; + U8 buf[D_s_PH4_modbus_max-1]; +}Modbus03Ack; + +typedef struct s_modbus_06 +{ + U16 reg; + U16 val; +}Modbus06; + +typedef struct s_modbus_06_ack +{ + U16 reg; + U16 val; +}Modbus06Ack; + +typedef struct s_modbus_10 +{ + U16 reg; + U16 num; + U8 count; +}Modbus10; + +typedef struct s_modbus_10_ack +{ + U16 reg; + U16 num; +}Modbus10Ack; + + +typedef struct s_modbus_err_ack +{ + U8 errcode; +}ModbusErrAck; + + + + + +/** + * Register Map + */ + +#define D_ch_max_num 4 +#define D_weight_std_num 10 + +#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 +typedef struct weight_stdization +{ + S16 weight_range; //量程 x 100 + S16 ratio; //重量计算系数，默认100，保留两位小数，相当于x1 +}WeightStdization; + +#define D_weight_show_limit_num 5 +typedef struct weight_show_limit +{ + S16 weight; + S16 times; +}WeightShowLimit; + +//需要持久化的参数，不能超过72字节，否则会导致eeprom溢出 +typedef struct global_param_changable +{ + 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 + WeightShowLimit weight_show_limit[D_weight_show_limit_num]; + WeightStdization weight_std[D_weight_std_num]; +}GlobalNeedPersistParam; + +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; + +typedef struct global_param +{ + //RO Register + S16 reserved1; + S32 total_weight; //净重（显示重量）*100 + S32 total_zweight; //皮重*100 + + //RW Register + S16 reserved2; + GlobalNeedPersistParam p; + S16 reserved3; + + //EncryptInfo + McuEncryptInfo e; + + //Global Variables + S32 weight[D_ch_max_num]; //4路重量 + S32 _total_weight; //实际重量*1000 + S32 _total_zweight; //实际皮重*1000 +}GlobalParam; + +#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 REG_MEM_BASE ((U16*)(&G)) //寄存器基础地址（本文件外部不应该使用该宏定义） +//变量地址转寄存器 +#define MEM_2_REG(mem) (((U16*)(mem) - REG_MEM_BASE) + 1) +//寄存器转变量地址 +#define REG_2_MEM(reg) (REG_MEM_BASE + (U16)((reg) - 1)) + + +extern struct global_param G; +extern struct ts_eeprom_param eep_param; +extern struct ts_eeprom_enc eep_enc; + +extern void L3_reg_init(void); +extern int L3_ph4_common_handler(TS_PH4_modbus *pmodbus); +extern int L3_ph4_send_error_pkg(U8 errcode); +extern int L3_mcu_id_ok(); +extern S32 L3_count_std_weight(S32 weight); + + +#endif + diff --git a/source/app/main.c b/source/app/main.c new file mode 100644 index 0000000..4e60ae9 --- /dev/null +++ b/source/app/main.c @@ -0,0 +1,188 @@ +////////////////////////////////////////////////////////////////////////// +/// 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..134dfa8 --- /dev/null +++ b/source/bsp/bsp_485.h @@ -0,0 +1,17 @@ +#ifndef BSP_485_H +#define BSP_485_H + +// #include "../cpu/STC_stc8a8k.h" +// #include "../cpu/c51_macro.h" +// #include "../clib/bit.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.h b/source/bsp/bsp_config.h new file mode 100644 index 0000000..83a9f41 --- /dev/null +++ b/source/bsp/bsp_config.h @@ -0,0 +1,345 @@ +//////////////////////////////////////////////////////////////////////////// +///@copyright Copyright (c) 2017, 传控科技 All rights reserved. +///------------------------------------------------------------------------- +/// @file hard_config.h +/// @brief hard config include +/// @info FILE FOR HARDWARE SETUP AND SOFTWARE SETUP///FOR EXAMPLE: BAORD ,MCU,IDE +/// @info YOU CAN CHANGE OR ADD THE DEFINE IF YOU NEED +/// @info 整个嵌入式项目的入口 首先是确认电路板 然后确认cpu 芯片型号 然后确认编译器 之后是软件框架 最后是应用程序 +/// @info bsp_CONFIG 为其他头文件的始祖 TYPE_BOARD_xx +///------------------------------------------------------------------------- +/// @version 1.1 +/// @author CC +/// @date 20180308 +/// @note +////////////////////////////////////////////////////////////////////////////// +/// @version 5.1 +/// @author CC +/// @date 20200301 +/// @note +////////////////////////////////////////////////////////////////////////////// + + +////////////////////////////////////////////////////////////////////////// +#ifndef _BSP_CONFIG_H +#define _BSP_CONFIG_H +#include + + +#include "bsp_config0.h" + +#define D_version_v 'L' + + +#if 0 + +#define D_leda_OFF(); D_P35_OFF(); +#define D_leda_ON(); D_P35_ON(); +#define D_leda_REV(); D_P35_REV(); +#define D_ledb_OFF(); D_P34_OFF(); +#define D_ledb_ON(); D_P34_ON(); +#define D_ledb_REV(); D_P34_REV(); + +#else +#define D_leda_OFF(); ///D_P35_OFF(); +#define D_leda_ON(); ///D_P35_ON(); +#define D_leda_REV(); ///D_P35_REV(); +#define D_ledb_OFF(); ///D_P34_OFF(); +#define D_ledb_ON(); ///D_P34_ON(); +#define D_ledb_REV(); ///D_P34_REV(); + +#endif + + +#if 0 +#define D_debug_sim +#endif +//#define D_iic_inspect +#define D_open_save_f + +#define TYPE_UASER_BOARD ccSensor_WS_ps5ws //CC_SE_paper_main_m10_smt01.sch + +//STEP 2 TYPE_UASER_BOARD CONFIG >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> + +#if(TYPE_UASER_BOARD == ccSensor_WS_ps5ws)///-------TYPE_UASER_BOARD----------------TYPE_UASER_BOARD---------- +//2.0-5.5 8K 2kram 4k eeprom spi iic 2uart tssop20 stc8f2k08s2 1.2yuan +//2.0-5.5 16K 2kram 4k eeprom spi iic 2uart tssop20 stc8f2k16s2 1.4yuan + + +//1.7-5.5 8K 1kram 3k eeprom spi iic 2uart tssop20 stc8f2k16s2 1.1yuan + + + +#define D_version_h 0x37 +#define D_version_L 0x38 + + + #define TYPE_MCU TYPE_MCU_STC + #define TYPE_IDE TYPE_IDE_KEIL + + #include + #include + #include + + #include "../cpu/STC_stc8a8k.h" + +#if 0//// 烧写配置 + . 内部IRC振荡器的频率: 22.128MHz + . 掉电唤醒定时器的频率: 35.575KHz + . 振荡器放大增益使能 + . P3.2和P3.3与下次下载无关 + . 上电复位时增加额外的复位延时 + . 复位引脚用作普通I/O口 + . 检测到低压时不复位,而产生低压中断 + . 低压检测门槛电压 : 2.20 V + . 上电复位时,硬件不启动内部看门狗 + . 上电自动启动内部看门狗时的预分频数为 : 256 + . 空闲状态时看门狗定时器停止计数 + . 启动看门狗后,软件可以修改分频数,但不能关闭看门狗 + . 下次下载用户程序时,将用户EEPROM区一并擦除 + . 下次下载用户程序时,没有相关的端口控制485 + . 下次下载时不需要校验下载口令 + . TXD脚直通输出RXD脚的电平 + . 芯片复位后,TXD脚为强推挽输出 + . 芯片复位后,P2.0输出高电平 + . 内部参考电压: 1341 mV (参考范围: 1270~1410mV) + . 内部安排测试时间: 2018年1月13日 + + . 芯片出厂序列号 : F64181C6219784 + 单片机型号: STC8F2K08S2 + 固件版本号: 7.3.10U + + . 用户设定频率: 22.118MHz + . 调节后的频率: 22.128MHz + . 频率调节误差: 0.043% + + + 操作成功 !(2019-02-24 18:16:24) + +该单片机的功能: 2.0-5v 8kflash 2kram DPTR EEPROM 4K + SPI IIC T0-T4 5个定时器 掉电唤醒专用定时器 比较器 内部电压检测中断 看门狗 tssop20 1.2元人民币 +#endif + + #include "../cpu/c51_macro.h" +#define D_MCLKO_DIV2 2 +#define D_MCLKO_DIV4 4 +#define D_MCLKO_DIV8 6 +#define D_MCLKO_DIV16 8 +#define D_MCLKO_DIV32 10 +#define D_MCLKO_DIV64 12 + +#define D_CPUfamily_type D_CPUfamily_8bits + + #define D_uart0_BRT BRT_115200 + #define D_uart0_SBIT SBIT_1 +#ifdef D_debug115200 + #if 0 + #define L2_task_L0_uart0_uc(X) L0_uart0_uc(X)/// + #define GC032a_L0_uart0_uc(x) L0_uart0_uc(x)// + #else + + #define L2_task_L0_uart0_uc(X) L0_uart0_uc(X)// + #define GC032a_L0_uart0_uc(x) L0_uart0_uc(x)// + #endif + +#else + #define L2_task_L0_uart0_uc(x) //L0_uart0_uc_debug(x)/////// + #define L2_task_L0_uart0_uchex(x) // L0_uart0_uchex(x)///// + + + #define GC032a_L0_uart0_uc(x) //L0_uart0_uc_debug(x)///// + #define GC032a_L0_uart0_uchex(x) //L0_uart0_uchex(x)//// + + + #define GC032a_L0_uart0_sendArray(x,Y) //L0_uart0_uchex(Y)// + #define GC032a_L0_uart0_us(x) //L0_uart0_us(x)*/ + +#endif +///#define D_sys_MainFre MainFre_16M2 +#define D_sys_MainFre MainFre_11M +///#define D_sys_MainFre MainFre_22M + +#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 10 +#define D_Cdelay_1us 10 ////while p21翻转时测定 500k 2us 一个指令 +#define D_Cdelay_1ms 36// 500 14ms 360--10ms +#define D_Cdelay_5ms 180// 500 14ms 360--10ms +#define D_Cdelay_15ms 900 +#define D_Cdelay_30ms 2400 + +#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 + + + +// 0x01/#define D_MCLKO_set D_MCLKO_DIV16 //1.389MHz/800ns@MCU.22MHz- +#define D_MCLKO_set D_MCLKO_DIV8 ////2.778MHz/400ns@MCU.22MHz- +///#define D_MCLKO_set D_MCLKO_DIV4 ////5.556MHz/ @MCU.22MHz- +///#define D_MCLKO_set D_MCLKO_DIV2 ////5.556MHz/ @MCU.22MHz- +#define D_0xfa 0x33 +//#define D_0xfa 0x11 + +/******************* +#define D_0xf7 0x01 +#define D_0xf8 0x02 + +#define D_P00x46 0x26////pclk /////cccc201805 hs low polarity +#define D_P00x4c 0x00 +#define D_P00x4d 0x04 +#define D_P00x43 0x10 ///EABLE CrCb fixed en 02 +#define D_P00x4a 0x83 ///div_gate+clk_en 82 + +#define D_P00xda 0xff /// Cr fixed +#define D_P00xdb 0xff /// Cb fixed + +#define D_0xfa 0x22 //00000000000000 + + +P0:0x4d Debug_mode3 8 0x04 RW +[7:4] test_image_fix_value + +[3] fix_value_mode +[2] remove_ff_mode +[1] subsample extend opclk disable when SPI +[0] clk2x_bypass +*******************/ + +#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 + +#define D_Cdelay_1ms 36// +#define D_Cdelay_5ms 180// +#define D_Cdelay_15ms 900 +#define D_Cdelay_30ms 2400 +#if 0 +#define L0_delay_1us() Lc_delay_nop(5) // 5个nop() 100ns 50个nop() 1us (20)=10us (2)1.5us +#define L0_delay_10us() Lc_delay_nop(40) // 5个nop() 100ns 50个nop() 1us (20)=10us (2)1.5us +#define L0_delay_40us() Lc_delay_nop(150) // 5个nop() 100ns 50个nop() 1us (20)=10us (2)1.5us +#else +#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 +#endif + +#endif//D_sys_MainFre) +/*******>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> +1， +串口1选择定时器2为波特率发生器 + AUXR &= 0xFB; //定时器2时钟为Fosc/12,即12T, +2， timer0 为task使用 +L1_tick_tick +3， + +///<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<****/ + +#define D_IO_LED1_OFF() D_P35_OFF() +#define D_IO_LED2_OFF() D_P34_OFF() +#define D_IO_485_RE_OFF() D_P33_OFF() +#define D_IO_485_DE_OFF() D_P32_OFF() +#define D_IO_LED1_INIT() ///D_P35_INIT() +#define D_IO_LED2_INIT() ///D_P34_INIT() +#define D_IO_485_RE_INIT() ///D_P33_INIT() +#define D_IO_485_DE_INIT() ///D_P32_INIT() +#define D_IO_LED1_ON() D_P35_ON() +#define D_IO_LED2_ON() D_P34_ON() +#define D_IO_485_RE_ON() D_P33_ON() +#define D_IO_485_DE_ON() D_P32_ON() + + +////////////////////////////////sim iic config +//根据sch的定义 +#define L0_IIC_SIM_INIT() BITN_0(P3M1,5);BITN_0(P3M0,5);\ + BITN_0(P3M1,4);BITN_0(P3M0,4); +///stc独有10 高阻 +#define L0_IIC_SIM_close() BITN_1(P3M1,5);BITN_0(P3M0,5);\ + BITN_1(P3M1,4);BITN_0(P3M0,4); + +#if 10 +#define L0_SDA_ON() D_P34_ON() +#define L0_SDA_OFF() D_P34_OFF() +#define L0_SDA_AT() D_P34_AT() +#define L0_SCL_ON() D_P35_ON() +#define L0_SCL_OFF() D_P35_OFF() +#else + +#define L0_SDA_ON() //D_P34_ON() +#define L0_SDA_OFF() //D_P34_OFF() +#define L0_SDA_AT() //D_P34_AT() +#define L0_SCL_ON() //D_P35_ON() +#define L0_SCL_OFF() //D_P35_OFF() + +#endif + + +#if(BRT_4800 == D_uart0_BRT) +#define D_txd4_wakeup() P31 = 1 // >750us +#define D_txd4_low() P31 = 0 +////为适应433 模块的功耗问题 +////debug的时候切记 此处会对串口造成影响 low有效的情况下其他的发送不会好使,除非事先wakeup + + +#else +#define D_txd4_wakeup() //P31 = 1 // >750us +#define D_txd4_low() //P31 = 0 + + +#endif + + +#define DR_who_wakeup22 i2ctxd + + +///// DR: Define Register DRB:bit of Define Register +#define DR_isr_times SADDR + +#define DR_who_wakeup SADEN +#define DRB_who_wakeup_timer0 BITN0 +#define DRB_who_wakeup_action BITN1 +#define DRB_who_wakeup_voice BITN2 +#ifdef doc342343 +BITN_1(DR_who_wakeup, DRB_who_wakeup_timer0); +BITN_0(DR_who_wakeup, DRB_who_wakeup_timer0); + +if(BITN_G(DR_who_wakeup, DRB_who_wakeup_timer0)) +{ + +} +#endif + + + + +#elif(TYPE_UASER_BOARD == TYPE_BOARD_TI26_MT01_M178)///-------TYPE_UASER_BOARD----------------TYPE_UASER_BOARD---------- + #define TYPE_MCU TYPE_MCU_STC + #define TYPE_IDE TYPE_IDE_KEIL + + #include + #include + #include + + #include "../cpu/STC_stc8a8k.h" + + #define D_CPUfamily_type D_CPUfamily_8bits + +#elif(TYPE_UASER_BOARD == TYPE_BOARD_SMMM_MB_VH032_0E) + +#endif + +#endif//_BSP_CONFIG_H +/*********************************end file*********************************************/ + + + + diff --git a/source/bsp/bsp_config0.h b/source/bsp/bsp_config0.h new file mode 100644 index 0000000..f08fb33 --- /dev/null +++ b/source/bsp/bsp_config0.h @@ -0,0 +1,203 @@ +//////////////////////////////////////////////////////////////////////////// +///@copyright Copyright (c) 2017, 传控科技 All rights reserved. +///------------------------------------------------------------------------- +/// @file hard_config.h +/// @brief hard config include +/// @info FILE FOR HARDWARE SETUP AND SOFTWARE SETUP///FOR EXAMPLE: BAORD ,MCU,IDE +/// @info YOU CAN CHANGE OR ADD THE DEFINE IF YOU NEED +/// @info 整个嵌入式项目的入口 首先是确认电路板 然后确认cpu 芯片型号 然后确认编译器 之后是软件框架 最后是应用程序 +/// @info bsp_CONFIG 为其他头文件的始祖 TYPE_BOARD_xx +///------------------------------------------------------------------------- +/// @version 1.1 +/// @author CC +/// @date 20180308 +/// @note +/// @version 1.6 +/// @author CC +/// @date 20190714 +/// @note add TTSS_tick TYPE +/// @version 1.7 +/// @author CC +/// @date 20191226 +/// @note gsensor + 485 + + +////////////////////////////////////////////////////////////////////////////// + + +////////////////////////////////////////////////////////////////////////// +#ifndef _BSP_CONFIG0_H +#define _BSP_CONFIG0_H +#include + +#include "../clib/Type.h" +#include "../clib/bit.h" +#include "../ctask/task.h" + +#include "../clib/clib.h" +////#define D_debug115200/// + + +//#define D_cameralIndex 0 +//#define D_cameralIndex 1 +//#define D_cameralIndex 2 +#define D_cameralIndex 3 +//#define D_cameralIndex 4 +//#define D_cameralIndex 5 + + +#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 +#define BRT_SIM 900 +#define MainFre_5M 0 +#define MainFre_11M 1 +#define MainFre_22M 2 +#define MainFre_27M 3 +#define MainFre_24M 4 +#define MainFre_33M 5 +#if 0 + +#define D_leda_OFF(); D_P35_OFF(); +#define D_leda_ON(); D_P35_ON(); +#define D_leda_REV(); D_P35_REV(); +#define D_ledb_OFF(); D_P34_OFF(); +#define D_ledb_ON(); D_P34_ON(); +#define D_ledb_REV(); D_P34_REV(); + +#else +#define D_leda_OFF(); ///D_P35_OFF(); +#define D_leda_ON(); ///D_P35_ON(); +#define D_leda_REV(); ///D_P35_REV(); +#define D_ledb_OFF(); ///D_P34_OFF(); +#define D_ledb_ON(); ///D_P34_ON(); +#define D_ledb_REV(); ///D_P34_REV(); + +#endif + + + +#if 0 +#define D_debug_sim +#endif +//#define D_iic_inspect +#define D_open_save_f + +//>>>>>>>>>>>>>>>>>>>>>>.BORAD TYPE +#define TYPE_BOARD_hhnew 16 +#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_paper_main_m10 0x10 //纸张传感器2 CC_SE_paper_main_m10_smt01.sch +#define ccSensor_CG_V02_m08_debug 0x0208 //CG传感器2 +#define TYPE_BOARD_cc_Light_Speed0B 0x11b //LR光电感器2 + +#define TYPE_BOARD_cc_G0A03 0x123 //倾角感器2 +#define ccSensor_WS_ps5ws 0x0258 ///称重传感器 + + +/************************************* +芯片型号 : IRC15W207S +HSY037.XA +关于此芯片的重要说明: + 有定时器0和定时器2 (注意:无定时器1) + 有比较器 (可当作一路ADC使用) +************************/ +///cc_gsm_paper6133_m0a6_debug01 +//STEP 1 <<<<<<<<<<<<<<<<<<<<<<<<<<<.BORAD TYPE + + +// BORAD, +// MCU:SHC6601 +// IDE :KEIL +//>>>>>>>>>>>>>>>>>>>>>>mcu TYPE +#define TYPE_MCU_SHC6601 66 +#define TYPE_MCU_STC 51 +#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 + +//<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>G-SENSOR TYPE + +#define TYPE_ASENSOR_ADXL362 362 +#define TYPE_ASENSOR_MSA300 362 +#define TYPE_ASENSOR TYPE_ASENSOR_MSA300 +//<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>TTSS_tick TYPE + +#define D_TTSS_tick_5ms 5 +#define D_TTSS_tick_10ms 10 +#define D_TTSS_tick_25ms 25 + + +//<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> + + +//#define TYPE_UASER_BOARD TYPE_BOARD_SMMM_MB_VH032_0E +//#define TYPE_UASER_BOARD TYPE_BOARD_stc90c516rd +//#define TYPE_UASER_BOARD TYPE_BOARD_hh_CC_MD_VH06_asMain_m6a7 +//#define TYPE_UASER_BOARD TYPE_BOARD_stc5as32_WIFIBV01 +//#define TYPE_UASER_BOARD TYPE_BOARD_hhnew +//STEP 1 <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< +//>>>>>>>>>>>>>>>>>>>>>>TTSS_tick TYPE + +#define D_TTSS_tick_5ms 5 +#define D_TTSS_tick_10ms 10 +#define D_TTSS_tick_25ms 25 + + +//<<<<<<<<<<<<<<<<<<<<< 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,16); + tss_ads.u16_v = (vU16)(tss_ads.u32_i & 0x0000ffff); + L0_uart0_ushex(tss_ads.u16_v,16);//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..f9b375a --- /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" + + +#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..29b9920 --- /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..078fba9 --- /dev/null +++ b/source/clib/clib.c @@ -0,0 +1,1677 @@ +/***************************************************************************** + * 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) +{ + 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的高八位 +} + + +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..7aecaf3 --- /dev/null +++ b/source/clib/clib.h @@ -0,0 +1,112 @@ +/***************************************************************************** + * 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); +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); + +#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..fbe7294 --- /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 0 +; +; 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..7c5ea25 --- /dev/null +++ b/source/cpu/STC_stc8a8k.H @@ -0,0 +1,617 @@ +#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 VOCTR = 0xBB; //电压控制寄存器 +///BITN_1(VOCTR, BITN7) VOCTR +#define D_VOCTR_SCCIN 0x00 +#define D_VOCTR_SCC 0x80 +#define D_VOCTR_SET(X) VOCTR = (X) + +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 IE2 = 0xAF; //0000,0000 中断控制寄存器2 +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; +/// 不可位寻址 +#define ET4 BITN6 +#define ET3 BITN5 +#define ES4 BITN4 +#define ES3 BITN3 +#define ET2 BITN2 +#define ESPI BITN1 +#define ES2 BITN0 + +sfr IPH = 0xB7; //xxxx,xx00 中断优先级寄存器2 +#define PPCAH BITN7 +#define PLVDH BITN6 +#define PADCH BITN5 +#define PSH BITN4 +#define PT1H BITN3 +#define PX1H BITN2 +#define PT0H BITN1 +#define PX0H BITN0 + + + +sfr IP2 = 0xB5; //xxxx,xx00 中断优先级寄存器2 +#define IP2_7 BITN7 +#define PI2C BITN6 +#define PCMP BITN5 +#define PX4 BITN4 +#define PPWMFD BITN3 +#define PPWM BITN2 +#define PSPI BITN1 +#define PS2 BITN0 + +sfr IP2H = 0xB6; //xxxx,xx00 中断优先级寄存器2 +#define IP2_7 BITN7 +#define PI2CH BITN6 +#define PCMPH BITN5 +#define PX4H BITN4 +#define PPWMFDH BITN3 +#define PPWMH BITN2 +#define PSPIH BITN1 +#define PS2H BITN0 + + + + + +sfr INT_CLKO = 0x8F; //0000,0000 外部中断与时钟输出控制寄存器 +#define INT_EX4 BITN6 +#define INT_EX3 BITN5 +#define INT_EX2 BITN4 +//定时器特殊功能寄存器 +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 掉电唤醒定时器高字节 +sfr16 WKTC = 0xAA; +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 + + + +#define I2CTXD (*(unsigned char volatile xdata *)0xfE86)//423@ST8.PDF + +#define I2CRXD (*(unsigned char volatile xdata *)0xfE87)//423@ST8.PDF + + + +///------------------------------------- + +#define gRccUs01_H (*(unsigned char volatile data *)0xd2) +#define gRccUs01_L (*(unsigned char volatile data *)0xd3) + + + +#define gRccUs01 (*(unsigned short volatile data *)0xd2)//226@ST8.PDF T4H定时器4的高字节 D2H T4H定时器4的低字节 D3H +#define gRccUs02 (*(unsigned short volatile data *)0xEA)//351@ST8.PDF CCAP0l CCAP1L EAH EBH +#define gRccUs03 (*(unsigned short volatile data *)0xEC)//351@ST8.PDF CCAP0l CCAP1L EAH EBH +//#define gRccUs03 s_task_GC032A.n + + + +#define gRccUs04 (*(unsigned short volatile data *)0xFA)///351@ST8.PDF +#define gRccUs05 (*(unsigned short volatile data *)0xFC)///351@ST8.PD CCAP2H + +///////////////////////////////////////////////// + + + +/* 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; + + +sfr AUXINTIF = 0xef; + +#define T2IF 0x01 +#define INT4IF BITN6 +#define INT3IF BITN5 +#define INT2IF BITN4 + +//#define T4IF BITN2 +//#define T3IF BITN1 +//#define T2IF BITN0 + + +/// >>>>> 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/c51_macro.H b/source/cpu/c51_macro.H new file mode 100644 index 0000000..5bbfab9 --- /dev/null +++ b/source/cpu/c51_macro.H @@ -0,0 +1,301 @@ +////////////////////////////////////////////////////////////////////////// +/// COPYRIGHT NOTICE +/// Copyright (c) 2018, 传控科技 +/// All rights reserved. +/// +/// @file __C51_MACRO_H_ +/// @brief macro define 和cpu相关，可以和同一个系列的cpu共享 +/// +///（本文件实现的功能的详述） +/// +/// @version 1.1 CCsens technology +/// @author CC +/// @date 20180102 + +// +////////////////////////////////////////////////////////////////////////// + + + +#ifndef __C51_MACRO_H_ +#define __C51_MACRO_H_ + +#include + +#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 + + + +#endif //__C51_MACRO_H_ + + + + + + + diff --git a/source/ctask/task.c b/source/ctask/task.c new file mode 100644 index 0000000..15e272c --- /dev/null +++ b/source/ctask/task.c @@ -0,0 +1,288 @@ +/***************************************************** +*============================================================================ +* HISTORY +* Below this line, this part is controlled by TSTS. DO NOT MODIFY!! +αʱƬǶʽƽ̨(Task Step by Step Turn by Turn StructureTSTS +*============================================================================ +****************************************************************************/ + +#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->pfun = 0; + s->sh = 0; + s->sh_next= 0; +/// s->sh_pre= 0; + s->n= 0; +} + + +/////ʾtask ṹʹ ɾ +#define D_task_test_01 0x20 +#define D_task_test_02 0x22 +#define D_task_test_03 0x23 +#ifdef D_debug_task_test +////>>>>>>>>>>>>>>>>>>>>>_s_task_test_>>>>>>>>>>>>>>>>>>>>>> +struct _s_task_test_ s_task_test; +void L2_task_test_init(void) +{ +ddd + L1_task_init(&s_task_test.task); + L3_task_s_go(s_task_test,D_task_init); +} + + +///L2_task_test_handle(&s_task_test); +void L2_task_test_handle(struct _s_task_test_ *s) +{ + unsigned char d = 0; + TTSS_Task_init(); + L2_task_go(D_task_test_01); + TTSS_Task_step(D_task_test_01): + if(d > 8) + { + d = 0; + L2_task_go(D_task_test_02); + L1_task_Cdelay(D_Cdelay_200us); + }else + { + d ++; + } + TTSS_Task_step(D_task_test_02): + if(d > 4) + { + d = 0; + L2_task_go(D_task_test_01); + L1_task_Tdelay(D_Tdelay_100ms); + }else + { + d ++; + } + + TTSS_Task_end(); +} +#endif//#ifdef D_debug_task_test +////<<<<<<<<<<<<<<<<<<<<<_s_task_test_<<<<<<<<<<<<<<<<<<<<<< + +/////<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<ʾtask ṹʹ ɾ + + +//example : +#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 + + + + + +//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< + + + + + + + +/***************************************************** +*============================================================== +* HISTORY +* Below this line, this part is controlled by TSTS. DO NOT MODIFY!! +αʱƬǶʽƽ̨(Task Step by Step Turn by Turn StructureTSTS +*============================================================== +****************************************************************************/ + + + + + + +#endif + + diff --git a/source/ctask/task.h b/source/ctask/task.h new file mode 100644 index 0000000..5b08832 --- /dev/null +++ b/source/ctask/task.h @@ -0,0 +1,288 @@ +/******************************** +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 StructureTSTS +*============================================================== + +20190217 and step01 Ұdelay_nű + + + +****************************************************************************/ + +#ifndef _TASK_H_ +#define _TASK_H_ +#include "../clib/type.h" +#include "../msp/time.h" +#include "task.h" +#include "tick.h" + +typedef struct +{ + vU32 n; +/// volatile UN_TYPE en; //ر,ҲΪͣ,ʹidelayĵطʱں̨ʱ˺ͣ,delay൱ͣ + volatile UN_TYPE sh; //ǰ + volatile UN_TYPE sh_next; //һ,һһһ,пмʱ +/// volatile UN_TYPE sh_pre; //ǰһ,һΪʹ +}TS_task; +//extern TS_task ts_task_stcadc; +#define D_task_close 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 + +#define TTS_for_add(i,start,len) for((i) = (start); (i) < (len); (i) ++){ +#define TTS_for_add_end() } + + + +//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>ڲ 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.t_10ms >= 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 0 + +#define L2_task_switch_default_idelay2(); \ + case D_task_Tdelay:\ + if (s_nos_tick.t_10ms >= s->task.n)\ + {\ + L2_task_delay_over();\ + }else\ + {\ + L2_time_beat_heart(D_TBH_ch0,3,'i');\ + }\ + break; \ + case D_task_Cdelay:\ + s->task.n--; \ + if (s->task.n == 0) \ + { \ + s->task.n = 0; \ + L2_task_delay_over();\ + } \ + break;\ + default : \ + break; + + + +//ڵȴĹüʱ,ʱfunxx +//ڵȴĿʱԶʱʾһЩϢ +//ִ + +#define L2_task_switch_fun_idelay(invent,ch) L2_task_switch_default_idelay() +#define L2_task_switch_fun_idelay0000(chhh,invent,funxx); \ + case D_task_Tdelay:\ + if (s_nos_tick.t_10ms >= s->task.n)\ + {\ + L2_task_delay_over();\ + }else\ + {\ + L2_time_beat_heart_fun(chhh,invent,funxx);\ + }\ + break; \ + case D_task_Cdelay:\ + s->task.n--; \ + if (s->task.n == 0) \ + { \ + s->task.n = 0; \ + L2_task_delay_over();\ + } \ + break;\ + default : \ + break; + + + + +//ڵȴĹüʱ,ʱʾַch +//ڵȴĿʱԶʱʾһЩϢch +// ͨchĿǰеĽ׶κϢ +#define L2_task_switch_flag_idelay(invent,ch) L2_task_switch_default_idelay() +#define L2_task_switch_flag_idelay000(invent,ch); \ + case D_task_Tdelay:\ + if (s_nos_tick.t_10ms >= s->task.n)\ + {\ + L2_task_delay_over();\ + }else\ + {\ + L2_time_beat_heart(D_TBH_ch0,invent,ch);\ + }\ + break; \ + case D_task_Cdelay:\ + s->task.n--; \ + if (s->task.n == 0) \ + { \ + s->task.n = 0; \ + L2_task_delay_over();\ + } \ + break;\ + default : \ + break; + + +TTSS_Task_init, Highlight +TTSS_Task_step, Highlight +TTSS_Task_end, Highlight +L2_task_go, Highlight +L1_task_Tdelay, Highlight +L1_task_Cdelay, Highlight +L2_task_go, Highlight + + + + +#endif + + +//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.t_10ms; + + +//>>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) + + +//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<ڲ s->task + +//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⲿ +#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_go(s,next) (s).task.sh = next; +#define L3_task_s_en(s,onf) (s).task.en = onf; +//L1_task_goout(s_task_music.task,D_task_close); + +#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 D_task_uc unsigned char +#define D_task_ui unsigned int +///>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> +#define TTSS_Task_init() switch(s->task.sh){\ + case D_task_init + +#define TTSS_Task_step(step) break;\ + case (step) +#define TTSS_step01(step) break;case (step) +#define TTSS_step02(step) break;case (step) +#define TTSS_step03(step) break;case (step) +#define TTSS_step04(step) break;case (step) +#define TTSS_step05(step) break;case (step) +#define TTSS_step06(step) break;case (step) +#define TTSS_step07(step) break;case (step) +#define TTSS_step08(step) break;case (step) +#define TTSS_step09(step) break;case (step) +#define TTSS_step10(step) break;case (step) +#define TTSS_step11(step) break;case (step) +#define TTSS_step12(step) break;case (step) + + + + + + + +#define TTSS_Task_end(); break;\ + L2_task_switch_default_idelay();} + + +//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< + + +extern void L1_task_init(TS_task *s); + + + +////>>>>>>>>>>>>>>>>>>>_s_task_test_>>>>>>>>>>>>>>>>>>>>>>>> + +#ifdef D_debug_task_test + +struct _s_task_test_ +{ + TS_task task; +}; +extern struct _s_task_test_ s_task_test; +extern void L2_task_test_handle(struct _s_task_test_ *s); +extern void L2_task_test_init(void); +#else + +#define L2_task_test_handle(x); +#define L2_task_test_init(); + +#endif//#ifdef D_debug_task_test + +////<<<<<<<<<<<<<<<<<<<_s_task_test_<<<<<<<<<<<<<<<<<<<<<<<< + + + + + + + + +#endif//_TASK_H_ +/***************************************************** +*============================================================== +* HISTORY +* Below this line, this part is controlled by TSTS. DO NOT MODIFY!! +αʱƬǶʽƽ̨(Task Step by Step Turn by Turn StructureTSTS +*============================================================== +****************************************************************************/ + + + diff --git a/source/ctask/tick.c b/source/ctask/tick.c new file mode 100644 index 0000000..0d3d01d --- /dev/null +++ b/source/ctask/tick.c @@ -0,0 +1,133 @@ +/***************************************************************************** + * 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 + 2019.03.11 ver 1.30 ʱʱΪ25ms ڽܸŵ +****************************************************************************************/ +/***************************************************** +*============================================================================ +* HISTORY +* Below this line, this part is controlled by TSTS. DO NOT MODIFY!! +αʱƬǶʽƽ̨(Task Step by Step Turn by Turn StructureTSTS +*============================================================================ +****************************************************************************/ + +#include "tick.h" + + +struct _s_nos_tick_ s_nos_tick; + + + +#ifdef D_use_tick_fum +void L1_tick_init(void) +{ + s_nos_tick.tp_count = 0; + + s_nos_tick.n_stamp = 0; + s_nos_tick.t1s_heatbeart= 0; + /***** + s_nos_tick.t1s_flag[0] = 0; + s_nos_tick.t1s_flag[1] = 0; + s_nos_tick.t1s_flag[2] = 0; + s_nos_tick.t1s_flag[3] = 0; + s_nos_tick.t1s_flag[4] = 0; + s_nos_tick.t1s_flag[5] = 0; + if(L2_tick_time_interval(n_stamp,7*D_Tdelay_1s)) + {// ʱ + + + L2_tick_time_stamp(s->t_stamp); + + + ********/ + + s_nos_tick.t_10ms = 0; + s_nos_tick.t_1s = 0; + +/// s_nos_tick.flag_1s = 0; + +/// s_nos_tick.t_n = 0; + //s_nos_tick.tmp = 0; + //L0_timer0_ONF(1); +} + +/// ʱ 10ms һж +/// ʱ 25ms һж +void L1_tick_tick (void) +{ /// 65535*65535 /3600/24/365=139nian/s=1.39nian/10ms + ///൱1.39t_10ms ڵعϵͳ ȫ + // 4,294,836,225 = 65535*65535 ;3600*24*60*60 = 31,536,000/ + s_nos_tick.tp_count++; + s_nos_tick.t_10ms ++;//D_led_D1_REV(); 20160522 ֤ + if(s_nos_tick.t_10ms%D_TIMER0_1S_COUNT == 0) + {// 65535*65535/24/60/60/356/10 =12.7 + s_nos_tick.t_1s ++;//// 65535*65535/24/60/60/356/10 =12.7 + s_nos_tick.flag_1s2 = 1; + s_nos_tick.t1s_heatbeart = 1; + } +//<<<<<<<<<<<<<<<<<<<<<< +} +#else + +#endif + +#if 0 +void L1_tick_tick (void) +{ + s_nos_tick.t_n++; + if (s_nos_tick.t_n >= D_TIMER0_10MS_COUNT)// 5500--- 100 10s--556 + /// s 5ms 65535*65535 /3600/24/365=139nian/s + // 4,294,836,225 = 65535*65535 ;3600*24*60*60 = 31,536,000/ + // fixme:˴ һbug:) + { + s_nos_tick.t_10ms ++;//D_led_D1_REV(); 20160522 ֤ + if(s_nos_tick.t_10ms%D_TIMER0_1S_COUNT == 0) + {// 65535*65535/24/60/60/356/10 =12.7 + s_nos_tick.t_1s ++;// + + // led_red =~led_red; + //s_nos_tick.t1s_flag[0] = 1; + //s_nos_tick.t1s_flag[1] = 1; + //s_nos_tick.t1s_flag[2] = 1; + //s_nos_tick.t1s_flag[3] = 1; + //s_nos_tick.t1s_flag[4] = 1; + //s_nos_tick.t1s_flag[5] = 1; + s_nos_tick.flag_1s = 1; + s_nos_tick.t1s_heatbeart = 1; + } + s_nos_tick.t_n = 0; + } + /******************* +// 0.2mm 4/0.2 = 20 20/60s = 333ms/maicong +// 0.2mm 60s 60 100 ms +// 0.2 6000ms +// ƽʱΪ1 ˮһΪ0 +// rain = 1;Ҫijʼ + if(0 == rain) + { + if(1 == s_rain.temp) + {// ````\___ + s_rain.pool = s_rain.t; + s_rain.all ++; + s_rain.t = 0; + } + s_rain.temp = 0; + }else + { + s_rain.temp = 1; + } + s_rain.t ++; + + ******/ +//<<<<<<<<<<<<<<<<<<<<<< +} + + +#endif + diff --git a/source/ctask/tick.h b/source/ctask/tick.h new file mode 100644 index 0000000..dafeb42 --- /dev/null +++ b/source/ctask/tick.h @@ -0,0 +1,210 @@ +/***************************************************************************** + * 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 +******************************************************************************/ +/***************************************************** +*============================================================================ +* HISTORY +* Below this line, this part is controlled by TSTS. DO NOT MODIFY!! +αʱƬǶʽƽ̨(Task Step by Step Turn by Turn StructureTSTS +*============================================================================ +****************************************************************************/ +#ifndef __tick_H +#define __tick_H +#include "../clib/Type.h" +//#include "../bsp/type_hs.h" +#include "../msp/time.h" +#define D_use_tick_fum + + +struct _s_nos_tick_ +{ + vU32 tp_count; //һνʱ䵽Ŀǰtick +/// vU32 sys_clock; +// vU32 t_n; // noosϵͳʱСԪ + vU32 t_10ms; // noos ϵͳʱ10m +#ifdef D_use_tick_fum + + + //volatile INT32U t_100ms; + vU32 t_1s; +/// vU32 t_10s; +// vU32 t_60s; + vU8 flag_1s; + vU8 flag_1s2; +/// volatile INT32U tmp; +/// volatile INT32U time_left; +/// volatile INT32U h; +/// volatile INT32U m; + vU32 n_stamp; +// vU32 t1s_flag[6]; //fixme: INT32U ݲͬϵͳ + //volatile unsigned char t1s_flag; +/// vU8 ts_flag; + vU32 n_stamp3; +#endif + vU8 t1s_heatbeart; //noos ϵͳʱʱ̱־,Ҫ +}; +extern struct _s_nos_tick_ s_nos_tick; + +#ifdef D_timer0_10ms +//10ms ʹã10msСʱ޷ʹ +#define D_Tdelay_ms D_TIMER0_10MS_COUNT//D_TIMER0_10MS_COUNT +#define D_Tdelay_10ms 2 +#define D_Tdelay_20ms (2+D_Tdelay_ms) +#define D_Tdelay_30ms (3+D_Tdelay_ms) +#define D_Tdelay_40ms (4+D_Tdelay_ms) +#define D_Tdelay_50ms (5+D_Tdelay_ms) +#define D_Tdelay_60ms (6+D_Tdelay_ms) + +#define D_Tdelay_80ms (8+D_Tdelay_ms) + + +#define D_Tdelay_100ms (10+D_Tdelay_ms) + +#else +//10ms ʹã10msСʱ޷ʹ +#define D_Tdelay_ms D_TIMER0_10MS_COUNT//D_TIMER0_10MS_COUNT +#define D_Tdelay_10ms 1 +#define D_Tdelay_20ms (0+D_Tdelay_ms) +#define D_Tdelay_30ms (0+D_Tdelay_ms) +#define D_Tdelay_40ms (2+D_Tdelay_ms) +#define D_Tdelay_50ms (2+D_Tdelay_ms) +#define D_Tdelay_60ms (2+D_Tdelay_ms) + +#define D_Tdelay_80ms (3+D_Tdelay_ms) + +#define D_Tdelay_100ms (4+D_Tdelay_ms) + +#endif + + +#define D_Tdelay_200ms (D_Tdelay_100ms*2) +#define D_Tdelay_300ms (D_Tdelay_100ms*3) +#define D_Tdelay_400ms (D_Tdelay_100ms*4) +#define D_Tdelay_500ms (D_Tdelay_100ms*5) + +#define D_Tdelay_600ms (D_Tdelay_100ms*6) +#define D_Tdelay_700ms (D_Tdelay_100ms*7) +#define D_Tdelay_800ms (D_Tdelay_100ms*8) +#define D_Tdelay_900ms (D_Tdelay_100ms*9) + + +#define D_Tdelay_1s (D_Tdelay_100ms*10) +#define D_Tdelay_1s2 (D_Tdelay_100ms*12) +#define D_Tdelay_1s5 (D_Tdelay_100ms*15) +#define D_Tdelay_2s (D_Tdelay_100ms*20) +#define D_Tdelay_2s5 (D_Tdelay_100ms*25) +#define D_Tdelay_3s (D_Tdelay_100ms*30) +#define D_Tdelay_5s (D_Tdelay_100ms*50) +#define D_Tdelay_8s (D_Tdelay_100ms*80) +#define D_Tdelay_9s (D_Tdelay_100ms*90) +#define D_Tdelay_10s (D_Tdelay_100ms*100) + +#define D_Tdelay_1min (D_Tdelay_1s*60) +#define D_Tdelay_1h (D_Tdelay_1min*60) +#define D_Tdelay_1day (D_Tdelay_1h*24) +#define D_TIMER0_1S_COUNT 100 +//#define D_10mS 1//D_TIMER0_10MS_COUNT +//#define D_100mS (D_10mS*10) +//#define D_1S (D_10mS*100) + + + + +//>> ʱ: ʼ ʱ䵽 +// L0_nos_tick10ms_start(s->times); ʼʼs->times 10msΪһλ +// if( L0_nos_tick10ms_interval(s->times) < 20)// s->times ִ20κ,Ҳ ʱ20*10m + + +// +#define L0_nos_tick10ms_start(start_n) start_n = s_nos_tick.t_10ms +#define L0_nos_tick10ms_interval(start_n) (s_nos_tick.t_10ms - 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_10ms; +#define L2_tick_time_interval(time_stamp,time_overflow) (( s_nos_tick.t_10ms - 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); + + +//>>>ʾ: +#if 0 +{ + case D_task_init:// + Lc_print_buf(" \r\n YL_ init"); + s->step = D_AT; + L0_esp_open(); + L2_task_go(D_task_YL_ready); + s_uart0_rec.ok = 0; + L2_tick_time_stamp(s->t_stamp); + // L1_task_Tdelay(1*D_Tdelay_1s); //Լ6s + break; + case D_task_YL_ready: + if(1 == s_uart0_rec.ok) + { + if(strstr(s_uart0_rec.array,"ready") != NULL) + { + + Ldi_print("ready..\r\n"); + s->step = D_AT; + L2_task_go(D_task_YL_ask); + } + s_uart0_rec.ok = 0; + } + if(L2_tick_time_stamp(s->t_stamp,1*D_Tdelay_1s)) + {// ʱ + L0_esp_close(); + Ldi_print("fail esp restart.\r\n"); + L2_task_go(D_task_init); + L1_task_Tdelay(2*D_Tdelay_1s); + } + break; +} +#endif + +// t_10ms ,t_10msΪ1ʱΪ(D_TIMER0_10MS_COUNT*ʱ) +/// #define D_TIMER0_10MS_COUNT 1 //ʱΪ 10msһж +#ifdef D_use_tick_fum +extern void L1_tick_init(void); +extern void L1_tick_tick (void); + +#else + + +#define L1_tick_init() +#define L1_tick_tick() s_nos_tick.t_10ms ++; + +#endif + + + +//L2_time_beat_heart(D_TBH_ch1,2,'t') +#define D_TBH_ch0 0 +#define D_TBH_ch1 1 +#define D_TBH_ch2 2 +#define D_TBH_ch3 3 +#define D_TBH_ch4 4 +#define D_TBH_ch5 5 +extern void L2_time_beat_heart(vU32 ch,U8 invent,U8 s); +//void L2_time_beat_heart_fun(INT32U ch,unsigned char invent,void *fun(void)); +extern void L2_time_beat_heart_fun(vU32 ch,U8 invent,void (*fun)(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/debug2.ini b/source/debug/debug2.ini new file mode 100644 index 0000000..3c56f97 --- /dev/null +++ b/source/debug/debug2.ini @@ -0,0 +1,45 @@ +MODE COM1 9600,0,8,1 +//assign com1 SOUT +ASSIGN COM1 < S0IN > S0OUT +//ASSIGN WIN S0OUT +//S0TIME = 0 +KILL FUNC * +KILL BUTTON * +// + //AA 70 70 71 72 72 75 74 76 77 78 79 24 55 +DEFINE BUTTON "master_send01","master_send01()" +signal void master_send01(void) { + + printf("DD\n"); +// #define rU0IIR rU0FCR /* share the same address */ + + //U0IIR =0x02; +// U0THR = 0x33; U0IIR =0x04; twatch(1000); + U0RBR = 0x34; U0IIR =0x04; twatch(1000); + +//U0RBR=0xaa;twatch(1000); +//U0RBR=0x70;twatch(1000); +//U0RBR=0x70;twatch(1000); +//U0RBR=0x71;twatch(1000); + +} + +DEFINE BUTTON "master_send021","master_send021()" +signal void master_send021(void) { + +// printf("DD\n"); +// #define rU0IIR rU0FCR /* share the same address */ + + //U0IIR =0x02; +// U0THR = 0x33; U0IIR =0x04; twatch(1000); + U0RBR = 0xAA; twatch(1000); + +U0RBR=0x66;twatch(1000); +//U0RBR=0x70;twatch(1000); +//U0RBR=0x70;twatch(1000); +//U0RBR=0x71;twatch(1000); + +} + + + diff --git a/source/debug/debug_M3sfy.ini b/source/debug/debug_M3sfy.ini new file mode 100644 index 0000000..3e88329 --- /dev/null +++ b/source/debug/debug_M3sfy.ini @@ -0,0 +1,83 @@ +MODE COM4 115200,0,8,1 +//assign com1 SOUT +ASSIGN COM4 < S1IN > S1OUT +//ASSIGN WIN S0OUT +//S0TIME = 0 +KILL FUNC * +KILL BUTTON * + +DEFINE BUTTON "A","key_up2()" +signal void key_up2(void) +{ + //s_task_key_up.sim = 1; + s_task_key_up.down = 1; + twatch(1000); + s_task_key_up.up = 1; + //swatch(0.1); + //swatch (0.05); /* wait 50 milliseconds */ + +// swatch(0.1);//twatch(1000); +} + + +DEFINE BUTTON "V","key_down2()" +signal void key_down2(void) +{ + //s_task_key_up.sim = 1; + s_task_key_down.down = 1; + + twatch(1000); + + s_task_key_down.up = 1; + //swatch(0.1); +// swatch(0.1);//twatch(1000); + +} + + +DEFINE BUTTON "key_upanddown","key_upanddown()" +signal void key_upanddown(void) +{ + //s_task_key_up.sim = 1; + s_task_key_down.down = 1; + // twatch(10); + s_task_key_up.down = 1; + twatch(1000); + s_task_key_down.up = 1; +// twatch(10); + s_task_key_up.up = 1; + //swatch(0.1);// + twatch(100); +} + + + +DEFINE BUTTON "key_ent2","key_ent2()" +signal void key_ent2(void) +{ + //s_task_key_up.sim = 1; + s_task_key_ent.down = 1; + twatch(1000); + s_task_key_ent.up = 1; + +} + + + + +DEFINE BUTTON "key_clear","key_clear()" +signal void key_clear(void) +{ + //s_task_key_up.sim = 1; + s_task_key_up.down = 0; + s_task_key_down.down = 0; + s_task_key_ent.down = 0; + + s_task_key_up.up = 0; + s_task_key_down.up = 0; + s_task_key_ent.up = 0; + twatch(1000); + +} + + diff --git a/source/debug/debug_M3sfy2.ini b/source/debug/debug_M3sfy2.ini new file mode 100644 index 0000000..98bd76d --- /dev/null +++ b/source/debug/debug_M3sfy2.ini @@ -0,0 +1,54 @@ +MODE COM4 115200,0,8,1 +//assign com1 SOUT +ASSIGN COM4 < S1IN > S1OUT +//ASSIGN WIN S0OUT +//S0TIME = 0 +KILL FUNC * +KILL BUTTON * + +//#include "key_ext.h" +DEFINE BUTTON "A","key_up2()" +signal void key_up2(void) +{ + s_task_key_ext.value = 1; + twatch(100); +} + + +DEFINE BUTTON "V","key_down2()" +signal void key_down2(void) +{ + s_task_key_ext.value = 2; + twatch(10); +} + +DEFINE BUTTON "key_ent2","key_ent2()" +signal void key_ent2(void) +{ + s_task_key_ext.value = 0x3; + twatch(10); +} + + +DEFINE BUTTON "Setup","key_setup()" +signal void key_setup(void) +{ + s_task_key_ext.value = 0x12; + twatch(10); +} + +DEFINE BUTTON "Adc100","Adc100()" +signal void Adc100(void) +{ + s_adc_read.uiV = 100; + twatch(10); +} + + +DEFINE BUTTON "Adc5000","Adc5000()" +signal void Adc5000(void) +{ + s_adc_read.uiV = 5000; + twatch(10); +} + diff --git a/source/debug/debug_app.c b/source/debug/debug_app.c new file mode 100644 index 0000000..ef467ca --- /dev/null +++ b/source/debug/debug_app.c @@ -0,0 +1,130 @@ +/***************************************************************************** + * uart.c: UART API file for NXP LPC17xx Family Microprocessors + * + * Copyright(C) 2013, cc + * All rights reserved. + * + * History + * 2013.05.24 ver 1.00 Prelimnary version, first Release + + * +******************************************************************************/ + +#include "target_cfg.h" +#include "type.h" +#include "time.h" +#include "uart.h" +//#include "..\Sensor.h" + +#include "debug_app.h" +struct _s_task_debug_led_ s_task_debug_led; + +void L2_task_debug_led_init(void) +{ + D_P1_OUT(15); + D_P1_OFF(15); //ָʾ + D_P1_OUT(16); + D_P1_OFF(16); //ָʾ + + while(0) + { + D_P1_OFF(15) ; + L0_delay_ms(600); + D_P1_ON(15) ; + L0_delay_ms(600); + L0_debugS_uc('a'); L0_USART_print(UART_debug,"\r\n"); + // L2_oled_main(); + } + L3_task_s_go(s_task_debug_led,D_task_debug_led_init); + + +} + +void L2_task_debug_led_handdle(struct _s_task_debug_led_ *s) +{ + switch(s->task.sh) + { + + case D_task_debug_led_init:// + L0_USART_print(UART_debug,"\r\n s_task_debug_led "); + L2_task_go(D_task_debug_led_key); + break; + case D_task_debug_led_key : + D_P1_ON(15); + L0_debugS_uc('^'); + L2_task_go(D_task_debug_led_key2); + L1_task_idelay(D_idelay_1s); + // L0_oled_point(60,50,0x00); + //L2_debug_Au4B48347975); + break; + case D_task_debug_led_key2 : + D_P1_OFF(15); + //L0_debugS_uc('~'); + #if 0 + if((s->x ++)> 64)s->x =0; + if((s->y ++)> 48)s->y =0; + + L0_oled_point(s->x,s->y,0xff); + #else + + + // L0_oled_point(60,50,0xff); + + #endif + L2_task_go(D_task_debug_led_key); + L1_task_idelay(D_idelay_1s); + //L2_debug_Au4B1234567); + + break; + + L2_task_switch_default_idelay(); + + } +} +void L1_debug_rx_handle(struct _s_protocol_ *p) +{ +// unsigned int i; + p->cashe[0] = p->rbr;// + if(p->num > D_s_protocol_len) + { + p->num = 0; + p->buf[p->num] = p->cashe[0]; + }else + { + p->buf[p->num] = p->cashe[0]; + p->num ++; + } +} + + +struct _s_uart_config_ s_debug_config; + + +#define D_debug_buf s_debug_config.puart_config->st->buf +#define D_debug_buf_d(x) s_debug_config.puart_config->st->buf[(x)] +#define D_debug_num (s_debug_config.puart_config->st->num) + +void L1_debug_init(void) +{ + ts_uart1.L1_uart_rx_handle = L1_debug_rx_handle; + ts_uart1.st = (struct _s_protocol_ *)&s_at1; + + s_debug_config.usart = 1; + s_debug_config.puart_config = &ts_uart1; + + + s_debug_config.type = 0; +#if 0 + while(9) + { + if(D_debug_num >= 1) + { + L0_Usend_uc(s_debug_config.usart,D_debug_buf_d(0)); + D_debug_num = 0; + + } + } +#endif +} + +//>>>>>>>>>>>>>>>>>>>>> debug led task diff --git a/source/debug/debug_app.h b/source/debug/debug_app.h new file mode 100644 index 0000000..497c810 --- /dev/null +++ b/source/debug/debug_app.h @@ -0,0 +1,44 @@ +/***************************************************************************** + * uart.h: Header file for NXP LPC17xx Family Microprocessors + * + * Copyright(C) 2013, cc + * All rights reserved. + * + * History + * 2013.05.24 ver 1.00 Prelimnary version, first Release + + * +******************************************************************************/ +#ifndef __DEBUG_APP_H +#define __DEBUG_APP_H +#include "LPC17xxcc.h" +#include "LPC17xxzlg.h" +#include "LPC17xx_macro.h" + +#include "Task.h" +#include "time.h" + +#include "debug_drv.h" + + +struct _s_task_debug_led_ +{ + _ts_task task; + unsigned char x; + unsigned char y; +}; +extern struct _s_task_debug_led_ s_task_debug_led; + +#define D_task_debug_led_init 0x10 +#define D_task_debug_led_key 0x11 +#define D_task_debug_led_key2 0x12 + +void L2_task_debug_led_init(void); + +extern void L2_task_debug_led_handdle(struct _s_task_debug_led_ *s); +extern void L1_debug_init(void); + +#endif /* end __DEBUG_APP_H */ +/***************************************************************************** +** End Of File +******************************************************************************/ diff --git a/source/debug/debug_drv.c b/source/debug/debug_drv.c new file mode 100644 index 0000000..373a01a --- /dev/null +++ b/source/debug/debug_drv.c @@ -0,0 +1,48 @@ +/***************************************************************************** + * debug_drv.c: debug app + * + * Copyright(C) 2013, cc + * All rights reserved. + * + * History + * 2013.05.24 ver 1.00 Prelimnary version, first Release + * +******************************************************************************/ + +#include "debug_drv.h" + +void L3_debug_drv_init(void) +{ + L0pf_send_uc = L0_uart0_uc; + Lc_print("\r\n debug shell init:\t"); +/// io õı׼д + + Lc_print("Mode:"); + #ifdef D_debug_time + Lc_print(" debug"); + #else + //D_debug_time_using + Lc_print(" normal"); + #endif +} + + +#ifdef D_debug_sim + +fff +void L3_debug_cycle(void) +{ + INTERRUPT_UART(); + TIMER0_IRQHandler(); + + + +} + +#else + +#endif + +/****************************************************************************** +** End Of File +******************************************************************************/ diff --git a/source/debug/debug_drv.h b/source/debug/debug_drv.h new file mode 100644 index 0000000..f14c872 --- /dev/null +++ b/source/debug/debug_drv.h @@ -0,0 +1,85 @@ +/***************************************************************************** + * DEBUG_DRV.h: Header file for DEBUY DRIVER FILES + * + * + * Copyright(C) 2013, cc + * All rights reserved. + * + * History + * 2013.05.24 ver 1.00 Prelimnary version, first Release + +******************************************************************************/ +#ifndef __DEBUG_DRV_H +#define __DEBUG_DRV_H + +#include "../clib/type.h" +#include "../clib/clib.h" +#include "../clib/uartlib.h" +#include "../msp/uart0.h" +#include "debug_led.h" + +void L3_debug_drv_init(void); +#define L3_debug_time() L0pf_send_uc = L0_uart0_uc; ///Lc_print("\r\n%s,-%sL:%d,",__DATE__,__TIME__,__LINE__); +extern void L3_debug_cycle(void); + +#if 0 + +#define UART_debug_reg ((LPC_UART1_TypeDef *) LPC_UART1_BASE ) +//#define UART_debug ((LPC_UART1_TypeDef *) LPC_UART1_BASE ) +//#define UART_debug ((LPC_UART_TypeDef *) LPC_UART_BASE ) +//#define UART_debug ((LPC_UART_TypeDef *) LPC_UART_BASE ) +#define UART_debug 1 + +#define L0_debugS_uc(x) //L0_Usend_uc(UART_debug,x) +#define L0_debugS_uc_hex(x) //L0_Usend_uc_hex(UART_debug,x) +#define L0_debug_uc_show(x,y); //L0_USART_print(UART_debug,x,y); +#define L0_debug_us_show(x,y); //L0_USART_print(UART_debug,x,y); +#define L0_debug_ul_show(x,y); //L0_USART_print(UART_debug,x,y); + + +//#define L2_debug_info(x) //L0_USART_print(UART_debug,x); +#define L2_debug_Au4B(x) // L0_Usend_Au4B(UART_debug,x) +#define L0_debug_Au4B_show(x,y); //L0_USART_print(UART_debug,x,y); +#define L0_debug_Aus_show(x,y); //L0_USART_print(UART_debug,x,y); +#define L0_debug_A4B_show(x,y); //L0_USART_print(UART_debug,x,y); + + +//#define debug22(format...) Lc_print("%s (%d): ",__FILE__,__LINE__); + +//#define LOG(format, args...) Lc_print(format, ##args) +//#define RTA_printf(...) Lc_print(__VA_ARGS__) + +//#define L2_debug_info Lc_print + +//#define L3_debug_time() Lc_print(L0_uart0_uc,"\r\n%s,-%sL:%d,",__DATE__,__TIME__,__LINE__); + + + + +#define L2_debug_info(...) \ +Lc_print(L0_uart_uc,__VA_ARGS__); + +//do { +//Lc_print("%s (%d): ", __FILE__, __LINE__); +//Lc_print(format, __VA_ARGS__); +//} while (0) + + +#define CHECK1(x, ...) if (!(x)) { printf(__VA_ARGS__); } + +#define LOG(...) {\ + Lc_print(L0_uart_uc,"%s: Line %d:\t", __FILE__, __LINE__);\ + Lc_print(L0_uart_uc, __VA_ARGS__);\ + Lc_print(L0_uart_uc,"\n");\ +} + +int main() { + int x = 3; + // һЩ... + LOG("x = %d", x); // 2-1-5.cpp: Line 12: x = 3 +} +#endif +#endif /* end __DEBUG_DRV_H */ +/***************************************************************************** +** End Of File +******************************************************************************/ diff --git a/source/debug/debug_led.c b/source/debug/debug_led.c new file mode 100644 index 0000000..e125d7a --- /dev/null +++ b/source/debug/debug_led.c @@ -0,0 +1,37 @@ +/***************************************************************************** + * debug_drv.c: debug app + * + * Copyright(C) 2013, cc + * All rights reserved. + * + * History + * 2013.05.24 ver 1.00 Prelimnary version, first Release + * + + ȡӲ汾 CC-ACC-VH02 +******************************************************************************/ + +#include "debug_led.h" + +void L3_debug_led_init(void) +{ + D_led_THB_init(); + D_led_debug_init(); + //D_led_D0_init(); + D_led_D1_init(); + D_led_D2_init(); + //while(0) + { + D_led_THB_REV(); + D_led_debug_REV(); + D_led_D1_REV(); + D_led_D2_REV(); + + + + } + +} +/****************************************************************************** +** End Of File +******************************************************************************/ diff --git a/source/debug/debug_led.h b/source/debug/debug_led.h new file mode 100644 index 0000000..7dee3ec --- /dev/null +++ b/source/debug/debug_led.h @@ -0,0 +1,138 @@ +/***************************************************************************** + * DEBUG_DRV.h: Header file for DEBUY DRIVER FILES + * + * + * Copyright(C) 2013, cc + * All rights reserved. + * + * History + * 2013.05.24 ver 1.00 Prelimnary version, first Release + + 20160413 CC-ACC-VH02 + + led pin33 P22 LED + P16 P17 + + +******************************************************************************/ +#ifndef __DEBUG_LED_H +#define __DEBUG_LED_H + +#include "../clib/type.h" +#include "../bsp/type_hs.h" + + + +///P22timer heratbeat +#define D_led_THB BIT2 +#define D_led_THB_SEL0 P2_SEL0 +#define D_led_THB_SEL1 P2_SEL1 +#define D_led_THB_SEL2 P2_SEL2 +#define D_led_THB_DIR P2_DIR + +#define D_led_THB_REV() D_P22_REV() +#define D_led_THB_ON() P22 = 1 +#define D_led_THB_OFF() P22 = 0 +#define D_led_THB_init() \ + BITN_0(D_led_THB_SEL2,(D_led_THB));\ + BITN_0(D_led_THB_SEL1,(D_led_THB));\ + BITN_0(D_led_THB_SEL0,(D_led_THB));\ + BITN_0(D_led_THB_DIR, (D_led_THB)); // led_debug output + +//>>>>>>>>>>>>>>>>CC-ACC-VH02 ܽſ + + + + +///P23debug˿ +#define D_led_debug BIT3 +#define D_led_debug_SEL0 P2_SEL0 +#define D_led_debug_SEL1 P2_SEL1 +#define D_led_debug_SEL2 P2_SEL2 +#define D_led_debug_DIR P2_DIR + +#define D_led_debug_REV() D_P23_REV() +#define D_led_debug_ON() P23 = 1 +#define D_led_debug_OFF() P23 = 0 +#define D_led_debug_init() \ + BITN_0(D_led_debug_SEL2,(D_led_debug));\ + BITN_0(D_led_debug_SEL1,(D_led_debug));\ + BITN_0(D_led_debug_SEL0,(D_led_debug));\ + BITN_0(D_led_debug_DIR,( D_led_debug)); // led_debug output + +///P24debug +#define D_led_D1 BIT4 +#define D_led_D1_SEL0 P2_SEL0 +#define D_led_D1_SEL1 P2_SEL1 +#define D_led_D1_DIR P2_DIR +#define D_led_D1_REV() D_P24_REV() +#define D_led_D1_ON() P24 = 0 +#define D_led_D1_OFF() P24 = 1 +#define D_led_D1_init() D_led_D1_OFF();\ + BITN_0(D_led_D1_SEL1,(D_led_D1));\ + BITN_0(D_led_D1_SEL0,(D_led_D1));\ + BITN_0(D_led_D1_DIR, (D_led_D1));\ + BITN_0(P2_PE, (D_led_D1));\ + BITN_1(P2_DS, (D_led_D1));\ + BITN_0(P2_OD, (D_led_D1)); //CMOS or push_Pull +///PE ODds= ǿ + +///P25debug +#define D_led_D2 BIT5 +#define D_led_D2_SEL0 P2_SEL0 +#define D_led_D2_SEL1 P2_SEL1 +#define D_led_D2_DIR P2_DIR +#define D_led_D2_REV() D_P25_REV() +#define D_led_D2_ON() P25 = 0 +#define D_led_D2_OFF() P25 = 1 +#define D_led_D2_init() D_led_D2_OFF();\ + BITN_0(D_led_D2_SEL1,(D_led_D2));\ + BITN_0(D_led_D2_SEL0,(D_led_D2));\ + BITN_0(D_led_D2_DIR, (D_led_D2));\ + BITN_0(P2_PE, (D_led_D2));\ + BITN_1(P2_DS, (D_led_D2));\ + BITN_0(P2_OD, (D_led_D2)); //CMOS or push_Pull +///PE=1 OD=0 ds=1 ǿ + + +// linuxһerronoĽṹ 浱ǰĴϢ + +struct _s_errorno_ +{ + int errono; + char *errostr; +}; + +//#define D_debug_time + + +#ifdef D_debug + +#define D_debug_sim +#define D_debug_spi_sim + +#define D_debug_time +#define D_debug_time_using +#define D_debug_sim_using + +#define D_debug_key + +#define D_debug_adc + +#define D_debug_lcd + + +#define D_debug_flash +#endif + + + +extern void L3_debug_led_init(void); + + +#endif /* end __DEBUG_LED_H */ +/***************************************************************************** +** End Of File +******************************************************************************/ + + 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/debug/复制 2debug_M3sfy.ini b/source/debug/复制 2debug_M3sfy.ini new file mode 100644 index 0000000..2005eca --- /dev/null +++ b/source/debug/复制 2debug_M3sfy.ini @@ -0,0 +1,66 @@ +//MODE COM1 9600,0,8,1 +//assign com1 SOUT +//ASSIGN COM1 < S0IN > S0OUT +//ASSIGN WIN S0OUT +//S0TIME = 0 +KILL FUNC * +KILL BUTTON * + + +DEFINE BUTTON "key_up","key_up()" +signal void key_up(void) +{ + //s_task_key_up.sim = 1; + s_task_key_up.down = 1; + //swatch(0.1); + twatch(1000); + //swatch (0.05); /* wait 50 milliseconds */ + + s_task_key_up.up = 1; +// swatch(0.1);//twatch(1000); +} + + +DEFINE BUTTON "key_down","key_down()" +signal void key_down(void) +{ + //s_task_key_up.sim = 1; + s_task_key_down.down = 1; + swatch(0.1); + //twatch(1000); + s_task_key_down.up = 1; +// swatch(0.1);//twatch(1000); + +} + + +DEFINE BUTTON "key_upanddown","key_upanddown()" +signal void key_upanddown(void) +{ + //s_task_key_up.sim = 1; + s_task_key_down.down = 1; + // twatch(10); + s_task_key_up.down = 1; + twatch(1000); + s_task_key_down.up = 1; +// twatch(10); + s_task_key_up.up = 1; + swatch(0.1);//twatch(1000); +} + + + + +DEFINE BUTTON "key_ent","key_ent()" +signal void key_ent(void) +{ + //s_task_key_up.sim = 1; + s_task_key_ent.down = 1; + twatch(1000); + s_task_key_ent.up = 1; + +} + + + + diff --git a/source/debug/复制 debug_M3sfy.ini b/source/debug/复制 debug_M3sfy.ini new file mode 100644 index 0000000..10e05ba --- /dev/null +++ b/source/debug/复制 debug_M3sfy.ini @@ -0,0 +1,129 @@ +//MODE COM1 9600,0,8,1 +//assign com1 SOUT +//ASSIGN COM1 < S0IN > S0OUT +//ASSIGN WIN S0OUT +//S0TIME = 0 +KILL FUNC * +KILL BUTTON * + + +DEFINE BUTTON "key_up","key_up()" +signal void key_up(void) { + //s_task_key_up.sim = 1; + s_task_key_up.down = 1; + twatch(1000); + s_task_key_up.up = 1; +} +DEFINE BUTTON "key_down","key_down()" +signal void key_down(void) { + //s_task_key_up.sim = 1; + s_task_key_down.down = 1; + twatch(1000); + s_task_key_down.up = 1; + +} + + +DEFINE BUTTON "key_upanddown","key_upanddown()" +signal void key_upanddown(void) { + //s_task_key_up.sim = 1; + s_task_key_down.down = 1; + // twatch(10); + s_task_key_up.down = 1; + twatch(1000); + s_task_key_down.up = 1; +// twatch(10); + s_task_key_up.up = 1; +} + +} + + + +DEFINE BUTTON "key_ent","key_ent()" +signal void key_ent(void) { + //s_task_key_up.sim = 1; + s_task_key_ent.down = 1; + twatch(1000); + s_task_key_ent.up = 1; + +} + + + + + +DEFINE BUTTON "key_up","key_up()" +signal void key_up(void) { + +U1THR = 'e'; + //LPC_GPIO1->FIOSET |= (1<<18); + FIO1SET|= (1<<18); + twatch(1000); +//U0RBR=0xaa;twatch(1000); +//U0RBR=0x70;twatch(1000); + +} +DEFINE BUTTON "key_down","key_down()" +signal void key_down(void) { + + printf("key down\n"); + + FIO1CLR|= (1<<18); + twatch(1000); + +//U0RBR=0xaa;twatch(1000); +//U0RBR=0x70;twatch(1000); + +} + + //AA 70 70 71 72 72 75 74 76 77 78 79 24 55 +DEFINE BUTTON "master_send01","master_send01()" +signal void master_send01(void) { + + printf("DD\n"); +// #define rU0IIR rU0FCR /* share the same address */ + + //U0IIR =0x02; +// U0THR = 0x33; U0IIR =0x04; twatch(1000); + U0RBR = 0x34; U0IIR =0x04; twatch(1000); + +//U0RBR=0xaa;twatch(1000); +//U0RBR=0x70;twatch(1000); +//U0RBR=0x70;twatch(1000); +//U0RBR=0x71;twatch(1000); + +} + + + +DEFINE BUTTON "master_send021","master_send021()" +signal void master_send021(void) { + +// printf("DD\n"); +// #define rU0IIR rU0FCR /* share the same address */ + + //U0IIR =0x02; +// U0THR = 0x33; U0IIR =0x04; twatch(1000); + U0RBR = 0xAA; twatch(1000); + +U0RBR=0x66;twatch(1000); +//U0RBR=0x70;twatch(1000); +//U0RBR=0x70;twatch(1000); +//U0RBR=0x71;twatch(1000); + +} +int SendChar (int ch) +{ + //while (!(USART1->SR & USART_FLAG_TXE)); + U1THR = (ch & 0x1FF); + twatch(200); + return (ch); +} +int GetKey (void) +{ + while (!(USART1->SR & USART_FLAG_RXNE)); + return ((int)(USART1->DR & 0x1FF)); +} + + diff --git a/source/msp/UART0.C b/source/msp/UART0.C new file mode 100644 index 0000000..c7ac5d3 --- /dev/null +++ b/source/msp/UART0.C @@ -0,0 +1,451 @@ +////////////////////////////////////////////////////////////////////////// +/// 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 @201800400 +针对多串口 和 单一串口 有区别 每个串口是独立的还是分开的有讲究 程序是复杂的还是软件应用简单是 +个需要平衡的事情. + +clib/clib.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------UserDef +----------------------------------------------------------------------------------------- +********************************************************************************/ +#include "uart0.h" +//#include "uart2.h" +//#include "uart3.h" +//#include "uart4.h" + #include + #include "../bsp/bsp_485.h" + #include "../ctask/tick.h" + #include "../app/common.h" + #include "../msp/time.h" + #include "../app/app_task_uart0.h" + +// TS_Handle_PH1 volatile s_uart0_rec; +// TS_Handle_PH1A volatile s_uart0_rec; +TS_Handle_PH4 volatile s_uart0_rec; + +///struct _s_uart0_send_buf_ ts_uart_send_shop; +//struct _s_uart0_send_buf_ ts_uart_send_depot; +volatile Ts_uart_send_buf ts_uart_send_shop; +////volatile Ts_uart_send_buf ts_uart_send_depot; + +#if(MainFre_5M == D_sys_MainFre) + void L0_uart0_init32K_290BPS(void) //290bps@32kHz + {//定时器2 16位重载 作为串口波特率 + SCON = 0x50; //8位数据,可变波特率 + AUXR |= 0x01; //串口1选择定时器2为波特率发生器 + BITN_1(AUXR, BITN5);// f/2 + T2L = 0xFE; //设定定时初值 + T2H = 0xFF; //设定定时初值 /// 32K 280---290BPS + AUXR |= 0x10; //启动定时器2 + } + + +#elif(MainFre_27M == D_sys_MainFre) +#elif(MainFre_22M == D_sys_MainFre) + #if(BRT_115200 == D_uart0_BRT) + void L0_uart0_init(void) //115200bps@22.1184MHz + {//定时器2 16位重载 作为串口波特率 + SCON = 0x50; //8位数据,可变波特率 + AUXR |= 0x01; //串口1选择定时器2为波特率发生器 + AUXR &= 0xFB; //定时器2时钟为Fosc/12,即12T + T2L = 0xFC; //设定定时初值 + T2H = 0xFF; //设定定时初值 + AUXR |= 0x10; //启动定时器2 + } + + #elif(BRT_4800 == D_uart0_BRT) + void L0_Uart0_Init(void) //4800bps@22.1184MHz + { + SCON = 0x50; //8位数据,可变波特率 + AUXR |= 0x01; //串口1选择定时器2为波特率发生器 + AUXR |= 0x04; //定时器2时钟为Fosc,即1T + T2L = 0x80; //设定定时初值 + T2H = 0xFB; //设定定时初值 + AUXR |= 0x10; //启动定时器2 + } + #elif(BRT_SIM == D_uart0_BRT) + void L0_uart0_init(void) + { + SCON = 0x50; /* SCON: mode 1, 8-bit UART, enable rcvr */ + TMOD |= 0x20; /* TMOD: timer 1, mode 2, 8-bit reload */ + TH1 = 221; /* TH1: reload value for 1200 baud @ 16MHz */ + TR1 = 1; /* TR1: timer 1 run */ + TI = 1; /* TI: set TI to send first char of UART */ + EA = 1; + AUXR = 0x40; + // TI = 0; + RI = 0; + D_uart0_ES_INT(1); //打开串口中断 + } + #endif + +#else ///MainFre_11M + + #if(BRT_115200 == D_uart0_BRT && SBIT_1 == D_uart0_SBIT) + void L0_uart0_init(void) //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) + void L0_uart0_init(void) //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) + void L0_uart0_init(void) //19200@11.0592MHz + { + //使用第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) + void L0_uart0_init(void) //9600bps@11.0592MHz + { + 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 L1_uart0_buf_init(void) +{ +/// ts_uart_send_depot.p = ts_uart_send_depot.buf; + ts_uart_send_shop.now = 0; + s_uart0_rec.head = 0; + s_uart0_rec.ok = 0; + s_uart0_rec.num = 0; +// L1_s2b_PH4_init(&s_uart0_rec,G.p.slaver_id); +// s_uart0_rec.sp = s_uart0_rec.buf; +// s_uart0_rec.cmd = 0; +// head_0 = D_CMD_Filter1_ff; +// s_uart0_rec.head_1 = D_CMD_Filter2_fe; +// s_uart0_rec.sp = (U8*)&(s_uart0_rec.ts_ccmodbus); + + L0_uart0_init(); + +// L0_uart0_init(); + BITN_0(P3M1,BITN1);BITN_1(P3M0,BITN1);/// p31 01 tuiwan + + ts_uart_send_shop.ok = D_ready; + + D_uart0_ES_INT(1); //打开串口中断 + +} +//115200 0.1ms /Byte 115200/4800=23 0.1*23=2.3ms +/// 4800 uartb波形 2.1ms 一个数据 b8s 共10bits 1000ms 发送480个Bytes 大约就是2.1ms 一个数据 + +//// ````\_b_|___________________________/``s`|```2.1ms 0x00 sscom 测试 + +//// s 1 1 1 1 1 1 1 0 b11111111s + +//// ````\_b_/```````````````````````````|``s`|```200us 0xff + +//// ````\_b_|__/```\__/```\__/```\__/```|``s`|```1.9ms`\0xaa +//// b 1 0 1 0 1 0 1 0 b10101010s + +//// +//// ````\_b_|__/```\__/```\__/```\__/```|``s`|```1.9ms`\0xaa +//// b 1 0 1 0 1 0 1 0 b10101010s + +/// 1.9ms`\0xaa 0xaa 0xaa +//// ````\_b_|__/```\__/```\__/```\__/```|``s`|\_b_|__/```\__/```\__/```\__/```|``s`|\_b_|__/```\__/```\__/```\__/```|``s`| +//// b 1 0 1 0 1 0 1 0 s b 1 0 1 0 1 0 1 0 s b 1 0 1 0 1 0 1 0 s + + +//// ````\_200us_/`````0xff +//// ````\_200us_/`````0xff +void L0_uart0_uc(U8 ww) +{ + L0_uart0_sendArray(&ww,1); +} +extern void L2_waitFree_uart0(void); + + +#define D_waitFree_uart0() L2_waitFree_uart0() + + +/********* +while(ts_uart_send_shop.ok != D_ready)\ + {\ + if(ts_uart_send_shop.over ++ > 600000)\ + {\ + break;\ + }\ + }\ +*********************/ +void L0_uart0_us(vU32 ww) +{ + U_U16 uStemp; + uStemp.word = ww; + L0_uart0_uc(uStemp.BYTE2.h); + L0_uart0_uc(uStemp.BYTE2.l); +} +void L0_uart0_ul(vU32 ww) +{ + L0_uart0_uc(ww >> 24 & 0xFF); + L0_uart0_uc(ww >> 16 & 0xFF); + L0_uart0_uc(ww >> 8 & 0xFF); + L0_uart0_uc(ww >> 0 & 0xFF); +} +void L0_uart0_uchex(U8 ww) +{ + D_waitFree_uart0(); + ts_uart_send_shop.buf3[0] = cguHex2Char[D_uc_high(ww)][1]; + ts_uart_send_shop.buf3[1] = cguHex2Char[D_uc_low(ww)][1]; + L0_uart0_sendArray(ts_uart_send_shop.buf3,2); +} + +// void L0_uart0_ushex(U16 ww) +// { +// L0_uart0_uchex(ww >> 8 & 0xFF); +// L0_uart0_uchex(ww >> 0 & 0xFF); +// } + +void L0_uart0_ulhex(U32 ww) +{ + L0_uart0_uchex(ww >> 24 & 0xFF); + L0_uart0_uchex(ww >> 16 & 0xFF); + L0_uart0_uchex(ww >> 8 & 0xFF); + L0_uart0_uchex(ww >> 0 & 0xFF); +} + +void L0_uart0_uldec(U32 ww) +{ + L0_uart0_uc(ww / 1000000 % 10 + '0'); + L0_uart0_uc(ww / 100000 % 10 + '0'); + L0_uart0_uc(ww / 10000 % 10 + '0'); + L0_uart0_uc(ww / 1000 % 10 + '0'); + L0_uart0_uc(ww / 100 % 10 + '0'); + L0_uart0_uc(ww / 10 % 10 + '0'); + L0_uart0_uc(ww / 1 % 10 + '0'); +} + +/********** +void L0_uart0_uc_debug(U8 ww) +{ + L0_uart0_sendArray(&ww,1); + while(0 != ts_uart_send_shop.now){} +} + +void L0_uart0_ushex(vU16 ww,U8 hex) +{ + U8 buf3[4]; + U_F16 k; + k.us = ww; + if(16 == hex ) + { + buf3[0] = cguHex2Char[D_uc_high(k.BYTE2.H)][1]; + buf3[1] = cguHex2Char[D_uc_low(k.BYTE2.H)][1]; + buf3[2] = cguHex2Char[D_uc_high(k.BYTE2.L)][1]; + buf3[3] = cguHex2Char[D_uc_low(k.BYTE2.L)][1]; + L0_uart0_sendArray(buf3,4); + + }else if(2 == hex) + { + buf3[0] = (k.BYTE2.H); + buf3[1] = (k.BYTE2.L); + L0_uart0_sendArray(buf3,2); + }else + { + + buf3[0] = 0x55; + buf3[1] = 0x66; + + L0_uart0_sendArray(buf3,2); + + } +} +k.us = 0x1234 +uc + [0]=0x12 + [1]=0x34 +byte2 + H=0x12 + L=0x34 + +**********/ + +void L0_uart0_ushex(vU16 ww,U8 hex) +{ + U_F16 k; + k.us = ww; + D_waitFree_uart0(); + if(16 == hex ) + { + ts_uart_send_shop.buf3[0] = cguHex2Char[D_uc_high(k.BYTE2.H)][1]; + ts_uart_send_shop.buf3[1] = cguHex2Char[D_uc_low(k.BYTE2.H)][1]; + ts_uart_send_shop.buf3[2] = cguHex2Char[D_uc_high(k.BYTE2.L)][1]; + ts_uart_send_shop.buf3[3] = cguHex2Char[D_uc_low(k.BYTE2.L)][1]; + L0_uart0_sendArray(ts_uart_send_shop.buf3,4); + + } + + + /**************** + else if(2 == hex) + { + ts_uart_send_shop.buf3[0] = (k.BYTE2.H); + ts_uart_send_shop.buf3[1] = (k.BYTE2.L); + L0_uart0_sendArray(ts_uart_send_shop.buf3,2); + }else + { + ts_uart_send_shop.buf3[0] = 0x55; + ts_uart_send_shop.buf3[1] = 0x66; + L0_uart0_sendArray(ts_uart_send_shop.buf3,2); + } + + */ +} +void L2_waitFree_uart0(void) +{ + while(ts_uart_send_shop.ok != D_ready) + { + if(ts_uart_send_shop.over ++ > 600000) + { + break; + } + } +} + +void L0_uart0_sendArray(U8 *buf,U16 len) +{ + D_485_TX(); //切换到输出状态 + + D_waitFree_uart0(); // P31 = 1; + ts_uart_send_shop.over = 0; + ts_uart_send_shop.p = buf; + ts_uart_send_shop.max = len; + ts_uart_send_shop.now = 1; + ts_uart_send_shop.ok = D_clear; + L0_uart0_set(ts_uart_send_shop.p[0]); +} + + +/************************************************* +UART 中断 +*************************************************/ +void INTERRUPT_UART(void) interrupt D_SERVE_UART// using 2 +{ + NOP(); NOP(); NOP(); + if(L0_uart0_IntRI() /*&& G.e.mcu_enc_id[5] == eep_enc.enc_val[5]*/) //如果是U0接收中断 + { + L0_uart0_IntRIClear(); //清除接收中断标志 + //s_nos_tick.tp_count = 0; + L0_timer1_reset(); + s_uart0_rec.reg = L0_uart0_get(); + L1_s2b_PH4(&s_uart0_rec); + } + if(L0_uart0_IntTI()) //如果是U0发送中断 + { + L0_uart0_IntTIClear(); //清除发送中断标志 + if(ts_uart_send_shop.max != ts_uart_send_shop.now) + { + L0_uart0_set(ts_uart_send_shop.p[ts_uart_send_shop.now]); + ts_uart_send_shop.now ++; + } + else + { + ts_uart_send_shop.ok = D_ready; + ts_uart_send_shop.max = 0; + ts_uart_send_shop.now = 0;//可以发送下一个数据 + // P31 = 0; + //切换到接收状态 + D_485_RX(); + } + } + else + { + //其他中断 + } + NOP(); NOP(); NOP(); +} + +#if 1 +void timer1_isrHanddle (void) interrupt D_ISR_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) interrupt D_ISR_timer1 +{// + TF1 = 0; + //s_nos_tick.uart0_free = 1; + if(s_uart0_rec.head == 1) //收到一条协议 + { + s_uart0_rec.head = 0; + s_uart0_rec.ok = 1; + L3_task_uart0_modbus_handler(&s_uart0_rec); + } +} + + + +#endif + + + + diff --git a/source/msp/UART0.h b/source/msp/UART0.h new file mode 100644 index 0000000..3df7585 --- /dev/null +++ b/source/msp/UART0.h @@ -0,0 +1,152 @@ +////////////////////////////////////////////////////////////////////////// +/// 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: cc +/// Modified date: 20190222 +/// Version: +/// Descriptions: 中断的now和max调整类型 可以支持int型的数据一次发送,前提是指向已有的数组 +////////////////////////////////////////////////////////////////////////// +/***************************************************************************** +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 "../clib/type.h" +//#include "../debug/debug_drv.h" +//#include "../uartcom/urec2protocol.h" +//?include "../uartcom/uprotocol2app.h" +#include "../tpc/tpc_modbus.h" +#define Ldi_print(x) Lc_print_buf(x) +//#include "../uartcom/UProtocol.h" +#include "../ctask/task.h" +#include "../clib/Clib.h" + + +//extern struct _s_uart_rec_ s_uart0_rec; +// extern TS_Handle_PH1 volatile s_uart0_rec; +//extern TS_Handle_PH1A volatile s_uart0_rec; +extern TS_Handle_PH4 s_uart0_rec; + + +///#define D_s_uart0_rec_close(); s_uart0_rec.ok = 2;// 关闭串口协议解析 +///#define D_s_uart0_rec_open(); s_uart0_rec.ok = 0;// 关闭串口协议解析 +#define D_uart0_free() (0 == ts_uart_send_shop.max) +#define D_uart0_busy() (0 != ts_uart_send_shop.max) + + + +//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> +////fixme:和cpu的程序容量息息相关 +#define D_send_buf_max 8 /// 9600bps = 10000bps = 1000 Bps = 1Byte/ms + /// 19200bps = 20000bps = 2000Bps = 2Byte/ms = 1Byte/0.5ms + /// 128Bytes = 128*0.5ms = 64ms + +#define D_send_buf2_max 6 + +typedef struct _ts_uart0_send_buf_ +{//8byte + U8 num; //接收到的数目注意数据长度的范围 + U8 *p; + vU16 now; /// 当前buf所在的位置 0------(max-1) + vU16 max; /// 当前buf的最大值,也就是需要发送的长度 + vU16 over; /// 当前buf的最大值,也就是需要发送的长度 + U8 ok; /// 当前buf的最大值,也就是需要发送的长度 + U8 buf[D_send_buf_max]; +/// U8 buf2[D_send_buf2_max]; + U8 buf3[D_send_buf2_max]; +//// U8 buf4[D_send_buf_max]; + /// U8 buf[D_send_buf_max + 1];//buffer 的第一位是 长度 +}Ts_uart_send_buf; + + +extern volatile Ts_uart_send_buf ts_uart_send_shop; +///extern volatile Ts_uart_send_buf ts_uart_send_depot; + + +#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) +#define L0_uart0_set(x) SBUF = (x); +#define L0_uart0_get() (SBUF) +//#define D_send_us(x) gRccUs01 = x;L0_uart0_uc(gRccUs01_H);L0_uart0_uc(gRccUs01_L); + +#define D_send_ushex(x) L0_uart0_ushex(x,16);///Lc_delay_ms(2);//gRccUs01 = x;L0_uart0_uchex(gRccUs01_H);L0_uart0_uchex(gRccUs01_L); +#define D_uart0_send_over() (D_ready == ts_uart_send_shop.ok) + + +//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< + +void L1_uart0_buf_init(void); + +extern void L0_uart0_init(void); +extern void L0_uart0_init32K_290BPS(void); + +extern void L0_Uart0_Init4800(void) ; + +extern void L0_uart0_uchex(U8 ww); + +extern void L0_uart0_ulhex(vU32 ww); + +extern void L0_uart0_ul(vU32 ww); +extern void L0_uart0_sendstr(U8 *str); +extern void L0_uart0_0d0a(void); +extern void L0_uart0_uc(U8 ww); +extern void L0_uart0_uc_debug(U8 ww); +extern void L0_uart0_us(vU32 ww); +extern void L0_uart0_ushex(vU16 ww,U8 hex); +extern void L0_uart0_uldec(U32 ww); + +/////////////////////////////////////////////////////////////// +extern void L0_uart0_sendArray(U8 *buf,U16 len); +extern void L0_uart0_sendbuf(void); +///extern void L0_uart0_sendArraylong(U8 *buf,U16 usStart,U16 usEnd); + +#endif //#ifndef _uart0_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..d3665bd --- /dev/null +++ b/source/msp/iic_sim.h @@ -0,0 +1,66 @@ +////////////////////////////////////////////////////////////////////////// +/// 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 "../cpu/stc_stc8a8k.h" +#include "../cpu/c51_macro.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..3020f46 --- /dev/null +++ b/source/msp/msp_eeprom.c @@ -0,0 +1,153 @@ +//////////////////////////////////////////////////////////////////////////// +///@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" + +#include "../tpc/tpc_uart.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..61a56e2 --- /dev/null +++ b/source/msp/msp_eeprom.h @@ -0,0 +1,47 @@ +////////////////////////////////////////////////////////////////////////// +/// 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 "../cpu/stc_stc8a8k.h" +#include "../cpu/c51_macro.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 "../cpu/stc_stc8a8k.h" +#include "../cpu/c51_macro.h" +#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..e34f228 --- /dev/null +++ b/source/msp/time.c @@ -0,0 +1,255 @@ +#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) interrupt D_ISR_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) + + +#if 0 +void L0_Timer1Init(void) +{ + #if 0 + + //30毫秒@22.1184MHz + AUXR &= 0xBF; //定时器时钟12T模式 + TMOD &= 0x0F; //设置定时器模式 + TMOD |= 0x10; //设置定时器模式 + TL1 = 0x00; //设置定时初值 + TH1 = 0x28; //设置定时初值 + TF1 = 0; //清除TF1标志 +#else + TMOD = 0x40; //外部计数模式 + TL1 = (0xff-10); + TH1 = 0xff; + + + #endif +// TR1 = 1; //定时器1开始计时 + L0_TIMER1_start(); + //L0_TIMER1_end(); + L0_TIMER1_isr_CLOSE(); +/// ET1 = 1; // add by cc 启动定时器1的中断 +} + +void L0_timer1_Init(void) //计数器1初始化 +{ + + TMOD = 0x40; //外部计数模式 + TL1 = 0x9c; + TH1 = 0xff; + // TR1 = 1; //启动定时器 + ET1 = 1; //使能定时器中断 + // EA = 1; +} +#define L0_timer1_on(); TR1 = 1; //启动计数器 +#define L0_timer1_off(); TR1 = 0; //关闭计数器 //启动计数器 + +//10---87 10s +/********************** Timer0中断函数************************/ +/// 和 L0_timer0_Init 关联,需要配置 bsp_config.h中的 D_sys_MainFre +/// 默认10ms 作为TTSS系统的定时引擎 +void timer1_inr (void) interrupt 3 +{ + +/******* + s_task_GC032A.usN ++; + s_task_GC032A.buf[s_task_GC032A.usN] = P1; + if(s_task_GC032A.usN < D_row_max) + { + + }else + { + s_task_GC032A.status = 1; + } +// task_handler.line_camera++; +****************/ +} + +#endif + + + + + + + + +/******************************END*********************************/ + + + + diff --git a/source/msp/time.h b/source/msp/time.h new file mode 100644 index 0000000..1f49191 --- /dev/null +++ b/source/msp/time.h @@ -0,0 +1,55 @@ +#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_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_modbus.c b/source/tpc/tpc_modbus.c new file mode 100644 index 0000000..54b7561 --- /dev/null +++ b/source/tpc/tpc_modbus.c @@ -0,0 +1,77 @@ + +/***************************************************************************** +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_modbus.h" + +void L1_s2b_PH4_init(TS_Handle_PH4 *p,U8 slaver) +{ + p->max = 0; + p->ok = 0; + p->head = 0; + p->num = 0; + p->slaver = slaver; + p->error = 0; +} + +void L1_s2b_PH4(TS_Handle_PH4 *p) +{ + if(p->head == 0) + { + if(p->reg == p->slaver) + { + p->head = 1; + p->error = 0; + p->max = D_s_PH4_modbus_max; + 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; + } + else + { + //P10 ^= 1; + p->error = 1; + } + } +} + + + +/****************************************************************************** +** End Of File +******************************************************************************/ + diff --git a/source/tpc/tpc_modbus.h b/source/tpc/tpc_modbus.h new file mode 100644 index 0000000..37605e9 --- /dev/null +++ b/source/tpc/tpc_modbus.h @@ -0,0 +1,57 @@ +////////////////////////////////////////////////////////////////////////// +/// 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 "../clib/Type.h" +#include "../bsp/bsp_config.h" +#include "../app/common.h" + +//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< + +typedef struct +{ + U8 reg; + U8 max; //接收到的数目的最大值 + U8 slaver; + vU8 head; //接收标志头标志 + vU8 ok; //接收协议ok标志 + vU8 num; + vU8 error; //错误 + vU8 *sp; + U8 buf[D_s_PH4_modbus_max + 8]; + vU8 crc[2]; +}TS_Handle_PH4; + +extern void L1_s2b_PH4_init(TS_Handle_PH4 *p,U8 slaver); +extern void L1_s2b_PH4(TS_Handle_PH4 *p); + +#endif /* end __TPC_UART_H_ */ +/***************************************************************************** +** End Of File +******************************************************************************/ + + + diff --git a/source/tpc/tpc_uart.c b/source/tpc/tpc_uart.c new file mode 100644 index 0000000..24ea373 --- /dev/null +++ b/source/tpc/tpc_uart.c @@ -0,0 +1,191 @@ + +/***************************************************************************** +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_uart.h" + + +//NUM: 0 1 2 3 4 +// Fx R1 R2 R3 ocr +// F+ӻ R1 R2 R3 У + + + + +/// ʵз յ0d0aĶЭʱ, +/// Э֮ʱ̫,okʱ ֶʧЭ +/// , ڶݵĶЭ ӦһĻ +/// ,ͬʱ Э,Ӧջ,򻺳 +/// ˺Զ +//_s_HRTU_P_rf_ +/// _s_HRTU_Pfx_ +/// fx 11 22 33 oc -- oc = 11+ 22+33 +//buf 0 1 2 3 [4] +// +//// protocol hex 1 serial to buff +#ifdef D_use_uart_rx +void L1_s2b_PH1 (TS_Handle_PH1 *p)// reentrant +{ + if (0 == p->head) + { + if (D_HETU_FX_fi == (p->reg&D_HETU_FX_H4)) + {//p->ok = 1;p->head = 0; + p->head = 1; + p->num = 0; + //p->ocx = 0; + p->buf[p->num]=p->reg; + } + }else + { + p->num ++; + p->buf[p->num] = p->reg; + + if(p->num >= D_HETU_FX_buf_max) // [4] + { + ///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]) + { + // if (p->ok != 1) + { + // D_led_D2_ON(); + p->ok = 1;//յ ,иط0޷ٴνܱ + // D_led_D2_OFF(); + } + } + p->num = 0; //if (p->ok != 1) + p->head = 0; //if (p->ok != 1) + //p->max = 0; + } + } +} +#endif + +////485 +//// ַж +void L1_s2b_PH1A (TS_Handle_PH1A *p)// reentrant +{ + if (0 == p->head) + { + if (D_HETU_FXA == p->reg) + {//p->ok = 1;p->head = 0; + p->head = 1; + p->num = 0; + //p->ocx = 0; + p->buf[p->num]=p->reg; + } + }else + { + p->num ++; + p->buf[p->num] = p->reg; + if(p->num >= D_HETU_FXA_buf_max - 1) // [4] + { + ///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]) + { + //if (p->add == p->buf[1])///ַƥ + { + // D_led_D2_ON(); + p->ok = 1;//յ ,иط0޷ٴνܱ + // D_led_D2_OFF(); + } + // p->ok = 1; + } + p->num = 0; //if (p->ok != 1) + p->head = 0; //if (p->ok != 1) + //p->max = 0; + } + } +} + + +///FF FE 08 52 16 11 22 33 44 F5 9F һmodbusЭ(852 16 11 22 33 44 F5 9F ) +/// 1 2 3 4 5 6 7 8 +/// 0 1 2 3 4 5 6 7 8 9 10 +/// Э˼ΪַΪ0x52Ĵӻ, 16 Ϊ11 22 33 44,У F5 9F + +void L1_s2b_PH3_init(TS_Handle_PH3 *p) +{ + p->max = 0; + p->ok = 0; + p->num = 0; + p->head = 0; + p->head_0 = TS_PH3_FILTER0; + p->head_1 = TS_PH3_FILTER1; +} + +void L1_s2b_PH3(TS_Handle_PH3 *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_s_PH3_ccmodbus_max - 1; + p->sp = p->buf; + p->sp[0] = p->head_0; + p->sp[1] = p->head_1; + p->num = 1; + } + } + else + { + p->num ++; + p->sp[p->num] = p->cashe[0]; + if(p->num == 2)// 3 + { + p->max = p->reg + 2;// + if(p->max >= D_s_PH3_ccmodbus_max) + { + p->max = D_s_PH3_ccmodbus_max - 1; + } + } + if(p->num >= p->max) + { + //p->ts_ccmodbus.crc = (p->sp[p->num-1] | p->sp[p->num]) & 0xFFFF; + if(/*crc()==p->ts_ccmodbus.crc*/ 1) + { + if (p->ok != 1) + { + p->ok = 1;//յ ,иط0޷ٴνܱ + } + } + p->num = 0; + p->head = 0; + } + } +} + + +/****************************************************************************** +** End Of File +******************************************************************************/ diff --git a/source/tpc/tpc_uart.h b/source/tpc/tpc_uart.h new file mode 100644 index 0000000..305c5b2 --- /dev/null +++ b/source/tpc/tpc_uart.h @@ -0,0 +1,408 @@ +////////////////////////////////////////////////////////////////////////// +/// 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_UART_H_ +#define __TPC_UART_H_ + +#include "../clib/Type.h" +#include "../bsp/bsp_config.h" + + +// 20170609 + +///----------------------------------------------------- + + + +//L0_type_byte(ts_cmd_pro0)[] +//#define D_CMD_Filter1 0xA5 +//#define D_CMD_Filter2 0x5A +#define D_CMD_Filter1 0x0a +#define D_CMD_Filter2 0x0d + +#define D_CMD_Filter1_ff 0xFF +#define D_CMD_Filter2_fe 0xFE + + + +///Э: ʮЭ1->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> +/// ͵ΪfxͷʮƵĶЭ飬ͳЭ֡ͷΪ1ֽ⣬ݵijҲDZȽϾ򣬴󲿷ְλģʺϵͲrf433֮Ĵ +///5 ʺڴʱϴ +/// R1 +///λ 7 6 5 4 3 2 1 0 +/// AS1 (0---15) AS2 (0---15) + +/// R2 +///λ 7 6 5 4 3 2 1 0 +/// ѹPress (0---15) open mic + +/// R3 +///λ 7 6 5 4 3 2 1 0 +/// Temp (0---15) Gsensor(0---15) + +typedef struct +{//8byte +///////// + vU8 as2:4; + vU8 as1:4; +///////// + vU8 mic:3; + vU8 open:1; + vU8 press:4; +//////////////// + vU8 Gsensor:4; + vU8 temp:4; +/////////// +}TS_P_pc_dat; + +typedef struct +{//8byte + ///////// + U8 cameraBoardPower; //ǰе4ɼͼ + vU16 paperNum:10; //10bitֽ ʾ1024 ʵ170 + vU16 cameraIndex:4; //ͷ + vU16 cameraWorking:1; //Ƿ + vU16 LowPower:1; // =1 lowPower Ҫ,δӵ +}TS_P_paper; + +//NUM: 0 1 2 3 4 +// Fx R1 R2 R3 ocr +// F+ӻ R1 R2 R3 У +typedef struct _s_P_rf_ +{//8byte + vU8 slave:4; + vU8 filter1:4; +//////////////// + TS_P_paper r123; + vU8 ocr; +}TS_P_rf; + +typedef struct _s_P_rf433_ +{//8byte + vU8 ha; +// vU8 hb; + + vU8 slave:4; + vU8 filter1:4; +//////////////// + TS_P_paper r123; + vU8 ocr; +/// vU8 hc; +}TS_P_rf433; + +//NUM: 0 1 2 3 4 +// Fx R1 R2 R3 ocr +// F+ӻ R1 R2 R3 У + +typedef struct +{//8byte + vU8 slave:4; + vU8 filter1:4; +//////////////// + vU8 G1; +//////////////// + vU8 G2; +//////////////// + vU8 Tmp:4; + vU8 Press:4; +//////////////// + vU8 ocr; +}TS_P_as; + +typedef struct +{//8byte + vU8 slave:4; + vU8 filter1:4; +//////////////// + vU8 cmd; +//////////////// + vU8 R2; +//////////////// + vU8 R3; +//////////////// + vU8 ocr; +}TS_P_debug; + + +#define D_HETU_FX_fi 0xa0 ///2018.7.7 +#define D_HETU_FX_H4 0xf0 ///2018.7.7 + +#define D_HETU_FX_buf_max 4 //max ָʵʵ,numcntָʱ +/// Hex RTU Protocol 0xFx +typedef struct +{//8byte + vU8 reg; + vU8 n; + vU8 head; //ձ־ͷ־ + vU8 ok; //Эok־ + vU8 num; +// vU8 cmd; + vU8 ocr; +// vU8 *sp; + U8 buf[D_HETU_FX_buf_max+1]; +}TS_Handle_PH1; + + +extern void L1_s2b_PH1 (TS_Handle_PH1 *p);// reentrant; + +//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< + +///Э: ʮЭ2->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> +/// ͵Ϊff feͷʮƵijЭ飬 +///FF FE 52 03 98 77 88 99 ַΪ0x52Ĵӻ, PC30x77,0x88,0x99 + +///FF FE 06 03 e5 77 88 99 (0x06)Я30x77,0x88,0x99УΪ0x98(=0x06+0x03+0x77+0x88+0x99ݵĺ) +///:Уλ=0x12+0x34+0x56=0x9c;ȡλֽڵõOCR=0x9c + +typedef struct +{//8byte + vU8 filter1; + vU8 filter2; + vU8 addr; //ͷĵַ + vU8 num; //յݵļ ݽն仯עݳȵķΧ + vU8 ocr; + vU8 buf[4];//--->_s_P_pc_dat_ +}TS_P_pc; + +// FF FE 10 02 0C 51 03 +// cashe[1] cashe[0] У 1 ӻ 2 +// filter2 filter1 +struct _s_PH2_FFFE_ +{//8byte + vU8 cashe[2]; + vU8 reg; + vU8 max; //յĿֵ + vU8 head_0; + vU8 head_1; + // vU8 sub_num; //յĿעݳȵķΧ + vU8 head; //ձ־ͷ־ + vU8 ok; //Эok־ + vU8 num; + vU8 *sp; + TS_P_pc s_FF; + // U8 pro[16]; ///Э +}; + +extern void L1_s2b_PH2(struct _s_PH2_FFFE_ *p);// reentrant; + + +//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< +///Э: ʮЭ3->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> +/// ͵Ϊff feͷʮƵijЭ飬ڰ׼modbusЭ +///FF FE 08 52 16 11 22 33 44 F5 9F һmodbusЭ(852 16 11 22 33 44 F5 9F ) +/// Э˼ΪַΪ0x52Ĵӻ, 16 Ϊ11 22 33 44,У F5 9F +/// УķΧΪ +#define TS_PH3_FILTER0 0xFF +#define TS_PH3_FILTER1 0xFE + +#define D_s_PH3_ccmodbus_max (16 + 8) +typedef struct +{ + U8 filter0; + U8 filter1; + U8 num; + U8 src; //Դ豸ID + U8 dst; //Ŀ豸ID + U8 oper; + U8 buf[D_s_PH3_ccmodbus_max - 8]; + U8 crc[2]; +}TS_PH3_ccmodbus; + +typedef struct +{//8byte + U8 cashe[2]; + U8 reg; + U8 max; //յĿֵ + U8 head_0; + U8 head_1; + // vU8 sub_num; //յĿעݳȵķΧ + vU8 head; //ձ־ͷ־ + vU8 ok; //Эok־ + vU8 num; + vU8 *sp; + U8 _buf[D_s_PH3_ccmodbus_max]; ///Э + U8 buf[D_s_PH3_ccmodbus_max]; +}TS_Handle_PH3; + +extern void L1_s2b_PH3_init(TS_Handle_PH3 *p); +extern void L1_s2b_PH3(TS_Handle_PH3 *p);// reentrant; +//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< + +///Э: ַЭ1->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> +/// ͵ΪԻس(0x0a 0x0d)ΪβַͳЭ飬ȽȷַͶӦݣʺdebugҪ󲻸ߣ +/// ij + +///----------------------------------------------------------------------------------------- +#define D_s_SSTR_0D0A_len 16 //strЭҪȴһЩbugĵطΪ64bytes +struct _s_PC1_0D0A_ +{//8byte + vU8 reg; + // vU8 sub_num; //յĿעݳȵķΧ + vU8 head; //ձ־ͷ־ + + vU8 cashe[2]; + //vU8 filter1; + //vU8 filter2; + vU8 num; //յݵļ ݽն仯עݳȵķΧ + + vU8 ok; //Эok־ + vU8 max; //յĿֵ + vU8 buf[D_s_SSTR_0D0A_len+1];//buffer ĵһλ + // U8 pro[16]; ///Э +}; +extern void L1_s2b_PC1(struct _s_PC1_0D0A_ *p);// reentrant; +//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< + + + + + +///modebusЭͨѶʹ>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> +#ifdef doc_98098908 +///ModbusRTUģʽͨţϢеÿ8Bitֽڰԭֵͣ63HRTUֱӷ01100011 +////ַʽҪŵǣ֮֡ûмͬ´ݵܶҪASCIIߣٶȸ [1] +////ASCIIģʽʹõַRTUģʽASCIIݵʹΪһЩ⣬RTUģʽʱַʽͣ +///ASCIIģʽַ֮ɲ1sļӦٶȽĻ +///01 16 1000 1234 ABCD +///δ˼ ַ 01 д 1000 1234 ô +////ַ ָ վĵַһƵһDZַͨѶַ +/// Ҫ飬ͨѶĿ Ƕдݣ MODBUS Ȼֻܶ࣬dzõģǶд +///Ĺ03 дĹ16ע⣬Ķдһд16λҲһWORD. +///Address Function Data Check +///8-Bits 8-Bits N x 8-Bits 16-Bits +/// ܣFunction +/// ˱Ѱַնִкֹܡ±г˸ϵDZõĹ룬Լǵ͹ܡ +/// Ϊ +/// 03 ݼĴ һĴĵǰֵ +/// 16 ԤöĴ 趨ֵһϵжĴ(ACRXXXE) + + +///ɢǶͬһźŵIJͬ˵ +///0ʾϿ1ʾͨPLCƿ豸Уһֲ͵ı? +///Զ///PLCеY/Q͵ź + + + + +///ccĽmodebusЭ飬һ֡ͷ +/// ff fe num add function dat check +#endif + + +//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< + + + + + +///ЭͨѶʹ>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> +#define D_s_protocol_len 32 +struct _s_protocol_ +{//8byte + vU8 rbr; + vU8 reg; + vU8 cashe[3]; + vU8 filter1; + vU8 filter2; + vU8 (*pfun_get)(void); + vU8 num; //յĿעݳȵķΧ + vU8 sub_num; //յĿעݳȵķΧ + vU8 head; //ձ־ͷ־ + vU8 ok; //Эok־ + vU8 data_ok; //Эok־ + vU8 ucXor; + vU8 array[D_s_protocol_len];//buffer ĵһλ + vU8 buf[D_s_protocol_len];//buffer ĵһλ + vU8 buf2[12];//buffer ĵһλ +}; + +extern void L1_uart_2buf(struct _s_protocol_ *p); + + + +//485 +///Э: ʮЭ2 ַж ڶǵַ->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> +#define D_HETU_FXA 0xaa + +#define D_HETU_FXA_buf_max 8 //max ָʵʵ,numcntָʱ +/// Hex RTU Protocol 0xFx +typedef struct +{//8byte + vU8 reg; + vU8 n; + vU8 head; //ձ־ͷ־ + vU8 ok; //Эok־ + vU8 num; + vU8 add; ///ݵַ + vU8 ocr; +// vU8 *sp; + U8 buf[D_HETU_FXA_buf_max + 1]; +}TS_Handle_PH1A; + +typedef struct +{ + vU8 filter; + vU8 src; + vU8 dst; + vU8 dat[4]; + vU8 ocr; +}TS_PH1A_DAT; + +extern void L1_s2b_PH1A (TS_Handle_PH1A *p); + + +#endif /* end __TPC_UART_H_ */ +/***************************************************************************** +** End Of File +******************************************************************************/ + + diff --git a/source/tpc/协议Transfer Protocol Conversion/.keep b/source/tpc/协议Transfer Protocol Conversion/.keep new file mode 100644 index 0000000..e69de29