ccsens_hardware
/
stc_ttss_868
2
0
Fork 2
Code Issues Pull Requests Releases Wiki Activity
Browse Source

v0.1

pull/1/head
zhangsan 4 years ago
commit
adaa98cc5e
110 changed files with 18651 additions and 0 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 34
      .gitignore
  2. 438
      docs/CS1232称重传感重量计算说明-v2.5-20200917.docx
  3. 464
      docs/CS1232称重传感重量计算说明-v2.6-20200927.docx
  4. BIN
      docs/stc8f2k16s2_encrypt_v1.0.exe
  5. BIN
      docs/称重传感器设计v1.5 20200530.xlsx
  6. 484
      keilp/cc_as_stc02_ps5ws.uvprojx
  7. 152
      si4/keywords.txt
  8. BIN
      si4/ps5ws.si4project/soft_ps5ws.sip_sym
  9. BIN
      si4/ps5ws.si4project/soft_ps5ws.sip_xab
  10. BIN
      si4/ps5ws.si4project/soft_ps5ws.sip_xad
  11. BIN
      si4/ps5ws.si4project/soft_ps5ws.sip_xc
  12. BIN
      si4/ps5ws.si4project/soft_ps5ws.sip_xf
  13. BIN
      si4/ps5ws.si4project/soft_ps5ws.sip_xm
  14. BIN
      si4/ps5ws.si4project/soft_ps5ws.sip_xr
  15. BIN
      si4/ps5ws.si4project/soft_ps5ws.sip_xsb
  16. BIN
      si4/ps5ws.si4project/soft_ps5ws.sip_xsd
  17. BIN
      si4/ps5ws.si4project/soft_ps5ws.siproj
  18. 22
      si4/ps5ws.si4project/soft_ps5ws.siproj_settings.xml
  19. 1005
      source/app/app_algorithm.c
  20. 168
      source/app/app_algorithm.h
  21. 149
      source/app/app_calibration.c
  22. 71
      source/app/app_calibration.h
  23. 95
      source/app/app_flow.c
  24. 84
      source/app/app_flow.h
  25. 124
      source/app/app_paraid.c
  26. 15
      source/app/app_paraid.h
  27. 351
      source/app/app_task_adc.c
  28. 144
      source/app/app_task_adc.h
  29. 31
      source/app/app_task_uart0.c
  30. 11
      source/app/app_task_uart0.h
  31. 230
      source/app/common.c
  32. 75
      source/app/common.h
  33. 183
      source/app/main.c
  34. 96
      source/app/main.h
  35. BIN
      source/app/source.lnk
  36. BIN
      source/bsp/backu/bsp2019低功耗采样line版本 20200301073727.rar
  37. 34
      source/bsp/backu/bsp_433.c
  38. 19
      source/bsp/backu/bsp_433.h
  39. 574
      source/bsp/backu/bsp_cam - 副本 (2).c
  40. 574
      source/bsp/backu/bsp_cam - 副本.c
  41. 706
      source/bsp/backu/bsp_cam.c
  42. 189
      source/bsp/backu/bsp_cam.h
  43. 218
      source/bsp/backu/bsp_cam_isr.c
  44. 62
      source/bsp/backu/bsp_cam_isr.h
  45. 53
      source/bsp/backu/bsp_func.c
  46. 52
      source/bsp/backu/bsp_func.h
  47. 773
      source/bsp/backu/bsp_gc032a.c
  48. 19
      source/bsp/backu/bsp_gc032a.h
  49. 261
      source/bsp/backu/bsp_msa300.c
  50. 473
      source/bsp/backu/bsp_msa300.h
  51. 191
      source/bsp/backu/cw63xx.c
  52. 123
      source/bsp/backu/cw63xx.h
  53. 75
      source/bsp/board support/msa300.c
  54. 63
      source/bsp/board support/msa300.h
  55. 8
      source/bsp/bsp_485.c
  56. 13
      source/bsp/bsp_485.h
  57. 119
      source/bsp/bsp_config.c
  58. 311
      source/bsp/bsp_config.h
  59. 231
      source/bsp/bsp_cs1232.c
  60. 229
      source/bsp/bsp_cs1232.h
  61. 14
      source/bsp/bsp_debug.c
  62. 36
      source/bsp/bsp_debug.h
  63. 128
      source/bsp/bsp_power.c
  64. 132
      source/bsp/bsp_power.h
  65. 405
      source/clib/bit.h
  66. 1715
      source/clib/clib.c
  67. 114
      source/clib/clib.h
  68. 317
      source/clib/type.h
  69. 198
      source/cpu/STARTUP.A51
  70. 589
      source/cpu/STC_stc8a8k.H
  71. 384
      source/cpu/stc_macro.H
  72. 466
      source/cpu/stc_stc15w.H
  73. 746
      source/cpu/stc_stc8G1k.H
  74. 593
      source/cpu/stc_stc8f.h
  75. 234
      source/ctask/task.c
  76. 159
      source/ctask/task.h
  77. 48
      source/ctask/tick.c
  78. 88
      source/ctask/tick.h
  79. 7
      source/debug/cc_as_stc01_main.ini
  80. 6
      source/debug/cc_ls_03_debug.ini
  81. 123
      source/debug/debug.ini
  82. BIN
      source/debug/testiic.uvla
  83. 217
      source/msp/UART0.C
  84. 88
      source/msp/UART0.h
  85. 156
      source/msp/UART2.c
  86. 86
      source/msp/UART2.h
  87. 170
      source/msp/UART3.c
  88. 93
      source/msp/UART3.h
  89. 169
      source/msp/UART4.C
  90. 88
      source/msp/UART4.h
  91. 209
      source/msp/UARTN.C
  92. 114
      source/msp/UARTN.h
  93. 355
      source/msp/iic_sim.c
  94. 64
      source/msp/iic_sim.h
  95. 0
      source/msp/mcu support/.keep
  96. 151
      source/msp/msp_eeprom.c
  97. 43
      source/msp/msp_eeprom.h
  98. 52
      source/msp/msp_id.c
  99. 40
      source/msp/msp_id.h
  100. 205
      source/msp/time.c

34
.gitignore
View File

@ -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/

438
docs/CS1232称重传感重量计算说明-v2.5-20200917.docx
View File

@ -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校验

464
docs/CS1232称重传感重量计算说明-v2.6-20200927.docx
View File

@ -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校验

BIN
docs/stc8f2k16s2_encrypt_v1.0.exe
View File

Binary file not shown.

BIN
docs/称重传感器设计v1.5 20200530.xlsx
View File

Binary file not shown.

484
keilp/cc_as_stc02_ps5ws.uvprojx
View File

@ -0,0 +1,484 @@
<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
<Project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="project_projx.xsd">
<SchemaVersion>2.1</SchemaVersion>
<Header>### uVision Project, (C) Keil Software</Header>
<Targets>
<Target>
<TargetName>STC8F2K16S2</TargetName>
<ToolsetNumber>0x0</ToolsetNumber>
<ToolsetName>MCS-51</ToolsetName>
<uAC6>0</uAC6>
<TargetOption>
<TargetCommonOption>
<Device>STC8F2K64S4</Device>
<Vendor>STC</Vendor>
<Cpu>IRAM(0-0xFF) XRAM(0-0x07FF) IROM(0-0xFFF8) CLOCK(35000000) MODP2</Cpu>
<FlashUtilSpec></FlashUtilSpec>
<StartupFile>"LIB\STARTUP.A51" ("Standard 8051 Startup Code")</StartupFile>
<FlashDriverDll></FlashDriverDll>
<DeviceId>63032</DeviceId>
<RegisterFile>STC8.H</RegisterFile>
<MemoryEnv></MemoryEnv>
<Cmp></Cmp>
<Asm></Asm>
<Linker></Linker>
<OHString></OHString>
<InfinionOptionDll></InfinionOptionDll>
<SLE66CMisc></SLE66CMisc>
<SLE66AMisc></SLE66AMisc>
<SLE66LinkerMisc></SLE66LinkerMisc>
<SFDFile></SFDFile>
<bCustSvd>0</bCustSvd>
<UseEnv>0</UseEnv>
<BinPath>d:\Keil\C51\BIN\</BinPath>
<IncludePath></IncludePath>
<LibPath></LibPath>
<RegisterFilePath>STC\</RegisterFilePath>
<DBRegisterFilePath>STC\</DBRegisterFilePath>
<TargetStatus>
<Error>0</Error>
<ExitCodeStop>0</ExitCodeStop>
<ButtonStop>0</ButtonStop>
<NotGenerated>0</NotGenerated>
<InvalidFlash>1</InvalidFlash>
</TargetStatus>
<OutputDirectory>..\out\</OutputDirectory>
<OutputName>cc_stc02_ps5ws</OutputName>
<CreateExecutable>1</CreateExecutable>
<CreateLib>0</CreateLib>
<CreateHexFile>1</CreateHexFile>
<DebugInformation>1</DebugInformation>
<BrowseInformation>1</BrowseInformation>
<ListingPath>..\out\</ListingPath>
<HexFormatSelection>0</HexFormatSelection>
<Merge32K>0</Merge32K>
<CreateBatchFile>0</CreateBatchFile>
<BeforeCompile>
<RunUserProg1>0</RunUserProg1>
<RunUserProg2>0</RunUserProg2>
<UserProg1Name></UserProg1Name>
<UserProg2Name></UserProg2Name>
<UserProg1Dos16Mode>0</UserProg1Dos16Mode>
<UserProg2Dos16Mode>0</UserProg2Dos16Mode>
<nStopU1X>0</nStopU1X>
<nStopU2X>0</nStopU2X>
</BeforeCompile>
<BeforeMake>
<RunUserProg1>0</RunUserProg1>
<RunUserProg2>0</RunUserProg2>
<UserProg1Name></UserProg1Name>
<UserProg2Name></UserProg2Name>
<UserProg1Dos16Mode>0</UserProg1Dos16Mode>
<UserProg2Dos16Mode>0</UserProg2Dos16Mode>
<nStopB1X>0</nStopB1X>
<nStopB2X>0</nStopB2X>
</BeforeMake>
<AfterMake>
<RunUserProg1>0</RunUserProg1>
<RunUserProg2>0</RunUserProg2>
<UserProg1Name></UserProg1Name>
<UserProg2Name></UserProg2Name>
<UserProg1Dos16Mode>0</UserProg1Dos16Mode>
<UserProg2Dos16Mode>0</UserProg2Dos16Mode>
<nStopA1X>0</nStopA1X>
<nStopA2X>0</nStopA2X>
</AfterMake>
<SelectedForBatchBuild>0</SelectedForBatchBuild>
<SVCSIdString></SVCSIdString>
</TargetCommonOption>
<CommonProperty>
<UseCPPCompiler>0</UseCPPCompiler>
<RVCTCodeConst>0</RVCTCodeConst>
<RVCTZI>0</RVCTZI>
<RVCTOtherData>0</RVCTOtherData>
<ModuleSelection>0</ModuleSelection>
<IncludeInBuild>1</IncludeInBuild>
<AlwaysBuild>0</AlwaysBuild>
<GenerateAssemblyFile>0</GenerateAssemblyFile>
<AssembleAssemblyFile>0</AssembleAssemblyFile>
<PublicsOnly>0</PublicsOnly>
<StopOnExitCode>3</StopOnExitCode>
<CustomArgument></CustomArgument>
<IncludeLibraryModules></IncludeLibraryModules>
<ComprImg>1</ComprImg>
<BankNo>65535</BankNo>
</CommonProperty>
<DllOption>
<SimDllName>S8051.DLL</SimDllName>
<SimDllArguments></SimDllArguments>
<SimDlgDll>DP51.DLL</SimDlgDll>
<SimDlgDllArguments>-pDP8051</SimDlgDllArguments>
<TargetDllName>S8051.DLL</TargetDllName>
<TargetDllArguments></TargetDllArguments>
<TargetDlgDll>TP51.DLL</TargetDlgDll>
<TargetDlgDllArguments>-p51</TargetDlgDllArguments>
</DllOption>
<DebugOption>
<OPTHX>
<HexSelection>0</HexSelection>
<HexRangeLowAddress>0</HexRangeLowAddress>
<HexRangeHighAddress>0</HexRangeHighAddress>
<HexOffset>0</HexOffset>
<Oh166RecLen>16</Oh166RecLen>
</OPTHX>
</DebugOption>
<Utilities>
<Flash1>
<UseTargetDll>0</UseTargetDll>
<UseExternalTool>0</UseExternalTool>
<RunIndependent>0</RunIndependent>
<UpdateFlashBeforeDebugging>0</UpdateFlashBeforeDebugging>
<Capability>0</Capability>
<DriverSelection>-1</DriverSelection>
</Flash1>
<bUseTDR>0</bUseTDR>
<Flash2></Flash2>
<Flash3>"" ()</Flash3>
<Flash4></Flash4>
<pFcarmOut></pFcarmOut>
<pFcarmGrp></pFcarmGrp>
<pFcArmRoot></pFcArmRoot>
<FcArmLst>0</FcArmLst>
</Utilities>
<Target51>
<Target51Misc>
<MemoryModel>2</MemoryModel>
<RTOS>0</RTOS>
<RomSize>2</RomSize>
<DataHold>0</DataHold>
<XDataHold>0</XDataHold>
<UseOnchipRom>0</UseOnchipRom>
<UseOnchipArithmetic>0</UseOnchipArithmetic>
<UseMultipleDPTR>0</UseMultipleDPTR>
<UseOnchipXram>0</UseOnchipXram>
<HadIRAM>1</HadIRAM>
<HadXRAM>1</HadXRAM>
<HadIROM>1</HadIROM>
<Moda2>0</Moda2>
<Moddp2>0</Moddp2>
<Modp2>1</Modp2>
<Mod517dp>0</Mod517dp>
<Mod517au>0</Mod517au>
<Mode2>0</Mode2>
<useCB>0</useCB>
<useXB>0</useXB>
<useL251>1</useL251>
<useA251>0</useA251>
<Mx51>0</Mx51>
<ModC812>0</ModC812>
<ModCont>0</ModCont>
<Lp51>0</Lp51>
<useXBS>0</useXBS>
<ModDA>0</ModDA>
<ModAB2>0</ModAB2>
<Mx51P>0</Mx51P>
<hadXRAM2>0</hadXRAM2>
<uocXram2>0</uocXram2>
<hadXRAM3>0</hadXRAM3>
<ModC2>0</ModC2>
<ModH2>0</ModH2>
<Mdu_R515>0</Mdu_R515>
<Mdu_F120>0</Mdu_F120>
<Psoc>0</Psoc>
<hadIROM2>0</hadIROM2>
<hadIROM3>0</hadIROM3>
<ModSmx2>0</ModSmx2>
<cBanks>0</cBanks>
<xBanks>0</xBanks>
<OnChipMemories>
<RCB>
<Type>0</Type>
<StartAddress>0x0</StartAddress>
<Size>0xffff</Size>
</RCB>
<RXB>
<Type>0</Type>
<StartAddress>0x0</StartAddress>
<Size>0x0</Size>
</RXB>
<Ocm1>
<Type>0</Type>
<StartAddress>0x0</StartAddress>
<Size>0x0</Size>
</Ocm1>
<Ocm2>
<Type>0</Type>
<StartAddress>0x0</StartAddress>
<Size>0x0</Size>
</Ocm2>
<Ocm3>
<Type>0</Type>
<StartAddress>0x0</StartAddress>
<Size>0x0</Size>
</Ocm3>
<Ocr1>
<Type>0</Type>
<StartAddress>0x0</StartAddress>
<Size>0x0</Size>
</Ocr1>
<Ocr2>
<Type>0</Type>
<StartAddress>0x0</StartAddress>
<Size>0x0</Size>
</Ocr2>
<Ocr3>
<Type>0</Type>
<StartAddress>0x0</StartAddress>
<Size>0x0</Size>
</Ocr3>
<IRO>
<Type>1</Type>
<StartAddress>0x0</StartAddress>
<Size>0xfff9</Size>
</IRO>
<IRA>
<Type>0</Type>
<StartAddress>0x0</StartAddress>
<Size>0x100</Size>
</IRA>
<XRA>
<Type>0</Type>
<StartAddress>0x0</StartAddress>
<Size>0x800</Size>
</XRA>
<XRA512>
<Type>0</Type>
<StartAddress>0x0</StartAddress>
<Size>0x0</Size>
</XRA512>
<IROM512>
<Type>0</Type>
<StartAddress>0x0</StartAddress>
<Size>0x0</Size>
</IROM512>
<XRA513>
<Type>0</Type>
<StartAddress>0x0</StartAddress>
<Size>0x0</Size>
</XRA513>
<IROM513>
<Type>0</Type>
<StartAddress>0x0</StartAddress>
<Size>0x0</Size>
</IROM513>
</OnChipMemories>
</Target51Misc>
<C51>
<RegisterColoring>0</RegisterColoring>
<VariablesInOrder>0</VariablesInOrder>
<IntegerPromotion>0</IntegerPromotion>
<uAregs>0</uAregs>
<UseInterruptVector>1</UseInterruptVector>
<Fuzzy>3</Fuzzy>
<Optimize>2</Optimize>
<WarningLevel>2</WarningLevel>
<SizeSpeed>0</SizeSpeed>
<ObjectExtend>1</ObjectExtend>
<ACallAJmp>0</ACallAJmp>
<InterruptVectorAddress>0</InterruptVectorAddress>
<VariousControls>
<MiscControls></MiscControls>
<Define></Define>
<Undefine></Undefine>
<IncludePath></IncludePath>
</VariousControls>
</C51>
<Ax51>
<UseMpl>0</UseMpl>
<UseStandard>1</UseStandard>
<UseCase>0</UseCase>
<UseMod51>0</UseMod51>
<VariousControls>
<MiscControls></MiscControls>
<Define></Define>
<Undefine></Undefine>
<IncludePath></IncludePath>
</VariousControls>
</Ax51>
<Lx51>
<useFile>0</useFile>
<linkonly>0</linkonly>
<UseMemoryFromTarget>1</UseMemoryFromTarget>
<CaseSensitiveSymbols>0</CaseSensitiveSymbols>
<WarningLevel>2</WarningLevel>
<DataOverlaying>1</DataOverlaying>
<OverlayString></OverlayString>
<MiscControls>REMOVEUNUSED</MiscControls>
<DisableWarningNumbers></DisableWarningNumbers>
<LinkerCmdFile></LinkerCmdFile>
<Assign></Assign>
<ReserveString></ReserveString>
<CClasses></CClasses>
<UserClasses></UserClasses>
<CSection></CSection>
<UserSection></UserSection>
<CodeBaseAddress></CodeBaseAddress>
<XDataBaseAddress></XDataBaseAddress>
<PDataBaseAddress></PDataBaseAddress>
<BitBaseAddress></BitBaseAddress>
<DataBaseAddress></DataBaseAddress>
<IDataBaseAddress></IDataBaseAddress>
<Precede></Precede>
<Stack></Stack>
<CodeSegmentName></CodeSegmentName>
<XDataSegmentName></XDataSegmentName>
<BitSegmentName></BitSegmentName>
<DataSegmentName></DataSegmentName>
<IDataSegmentName></IDataSegmentName>
</Lx51>
</Target51>
</TargetOption>
<Groups>
<Group>
<GroupName>app</GroupName>
<Files>
<File>
<FileName>main.c</FileName>
<FileType>1</FileType>
<FilePath>..\source\app\main.c</FilePath>
</File>
<File>
<FileName>common.c</FileName>
<FileType>1</FileType>
<FilePath>..\source\app\common.c</FilePath>
</File>
<File>
<FileName>app_task_uart0.c</FileName>
<FileType>1</FileType>
<FilePath>..\source\app\app_task_uart0.c</FilePath>
</File>
<File>
<FileName>app_task_adc.c</FileName>
<FileType>1</FileType>
<FilePath>..\source\app\app_task_adc.c</FilePath>
</File>
</Files>
</Group>
<Group>
<GroupName>cpu</GroupName>
<Files>
<File>
<FileName>STARTUP.A51</FileName>
<FileType>2</FileType>
<FilePath>..\source\cpu\STARTUP.A51</FilePath>
</File>
</Files>
</Group>
<Group>
<GroupName>msp</GroupName>
<Files>
<File>
<FileName>time.c</FileName>
<FileType>1</FileType>
<FilePath>..\source\msp\time.c</FilePath>
</File>
<File>
<FileName>UART0.C</FileName>
<FileType>1</FileType>
<FilePath>..\source\msp\UART0.C</FilePath>
</File>
<File>
<FileName>msp_eeprom.c</FileName>
<FileType>1</FileType>
<FilePath>..\source\msp\msp_eeprom.c</FilePath>
</File>
<File>
<FileName>msp_id.c</FileName>
<FileType>1</FileType>
<FilePath>..\source\msp\msp_id.c</FilePath>
</File>
<File>
<FileName>UARTN.C</FileName>
<FileType>1</FileType>
<FilePath>..\source\msp\UARTN.C</FilePath>
</File>
</Files>
</Group>
<Group>
<GroupName>bsp</GroupName>
<Files>
<File>
<FileName>bsp_cs1232.c</FileName>
<FileType>1</FileType>
<FilePath>..\source\bsp\bsp_cs1232.c</FilePath>
</File>
<File>
<FileName>bsp_485.c</FileName>
<FileType>1</FileType>
<FilePath>..\source\bsp\bsp_485.c</FilePath>
</File>
<File>
<FileName>bsp_config.c</FileName>
<FileType>1</FileType>
<FilePath>..\source\bsp\bsp_config.c</FilePath>
</File>
</Files>
</Group>
<Group>
<GroupName>ctask</GroupName>
<Files>
<File>
<FileName>task.c</FileName>
<FileType>1</FileType>
<FilePath>..\source\ctask\task.c</FilePath>
</File>
<File>
<FileName>tick.c</FileName>
<FileType>1</FileType>
<FilePath>..\source\ctask\tick.c</FilePath>
</File>
</Files>
</Group>
<Group>
<GroupName>tpc</GroupName>
<Files>
<File>
<FileName>tpc_modbus.c</FileName>
<FileType>1</FileType>
<FilePath>..\source\tpc\tpc_modbus.c</FilePath>
</File>
<File>
<FileName>tpc_0d0a.c</FileName>
<FileType>1</FileType>
<FilePath>..\source\tpc\tpc_0d0a.c</FilePath>
</File>
<File>
<FileName>tpc_ccmodbus.c</FileName>
<FileType>1</FileType>
<FilePath>..\source\tpc\tpc_ccmodbus.c</FilePath>
</File>
<File>
<FileName>tpc_debug.c</FileName>
<FileType>1</FileType>
<FilePath>..\source\tpc\tpc_debug.c</FilePath>
</File>
</Files>
</Group>
<Group>
<GroupName>clib</GroupName>
<Files>
<File>
<FileName>clib.c</FileName>
<FileType>1</FileType>
<FilePath>..\source\clib\clib.c</FilePath>
</File>
</Files>
</Group>
<Group>
<GroupName>debug</GroupName>
<Files>
<File>
<FileName>cc_as_stc01_main.ini</FileName>
<FileType>5</FileType>
<FilePath>..\source\debug\cc_as_stc01_main.ini</FilePath>
</File>
</Files>
</Group>
</Groups>
</Target>
</Targets>
</Project>

152
si4/keywords.txt
View File

@ -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

BIN
si4/ps5ws.si4project/soft_ps5ws.sip_sym
View File

Binary file not shown.

BIN
si4/ps5ws.si4project/soft_ps5ws.sip_xab
View File

Binary file not shown.

BIN
si4/ps5ws.si4project/soft_ps5ws.sip_xad
View File

Binary file not shown.

BIN
si4/ps5ws.si4project/soft_ps5ws.sip_xc
View File

Binary file not shown.

BIN
si4/ps5ws.si4project/soft_ps5ws.sip_xf
View File

Binary file not shown.

BIN
si4/ps5ws.si4project/soft_ps5ws.sip_xm
View File

Binary file not shown.

BIN
si4/ps5ws.si4project/soft_ps5ws.sip_xr
View File

Binary file not shown.

BIN
si4/ps5ws.si4project/soft_ps5ws.sip_xsb
View File

Binary file not shown.

BIN
si4/ps5ws.si4project/soft_ps5ws.sip_xsd
View File

Binary file not shown.

BIN
si4/ps5ws.si4project/soft_ps5ws.siproj
View File

Binary file not shown.

22
si4/ps5ws.si4project/soft_ps5ws.siproj_settings.xml
View File

@ -0,0 +1,22 @@
<?xml version="1.0" encoding="utf-8"?>
<ProjectSettings
AppVer="4.00.0093"
AppVerMinReader="4.00.0034"
GlobalConfiguration="1"
GlobalWorkspace="0"
LocalsInDb="0"
IndexMembers="1"
IndexFragments="1"
UseMasterFileList="0"
SourceDir="..\..\source"
BackupDir="%PROJECT_DATA_DIR%\Backup"
MasterFileList="%PROJECT_SOURCE_DIR%\%PROJECT_NAME%_filelist.txt"
IsImportProject="0"
>
<Imports>
<ImportedLibs/>
</Imports>
<ParseConditions>
<Defines/>
</ParseConditions>
</ProjectSettings>

1005
source/app/app_algorithm.c
View File

File diff suppressed because it is too large

168
source/app/app_algorithm.h
View File

@ -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"
//>>>>>>>>>>>>>>>>>>>>>0开机task
#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
//<<<<<<<<<<<<<<<<<<<0开机task
#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

149
source/app/app_calibration.c
View File

@ -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);
}
//>>>>>>>>>>>>>>>>>>>>>0开机task
///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);
}
*********/

71
source/app/app_calibration.h
View File

@ -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"
//>>>>>>>>>>>>>>>>>>>>>0¿ª»útask
///#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);
//<<<<<<<<<<<<<<<<<<<0¿ª»útask
#endif //_APP_calibration_H calib

95
source/app/app_flow.c
View File

@ -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);
}
//>>>>>>>>>>>>>>>>>>>>>0开机task
#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();
}

84
source/app/app_flow.h
View File

@ -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"
//>>>>>>>>>>>>>>>>>>>>>0¿ª»útask
///#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
//<<<<<<<<<<<<<<<<<<<0¿ª»útask
#endif

124
source/app/app_paraid.c
View File

@ -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;
}

15
source/app/app_paraid.h
View File

@ -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

351
source/app/app_task_adc.c
View File

@ -0,0 +1,351 @@
#include "app_task_adc.h"
#include "../msp/UART0.h"
//TS_ADC_CH_SWITCH ts_adc_ch_switch;
TS_ADC_CH_SAMPLE ts_adc_ch_sample[D_ch_max_num];
TS_ADC_CH_BLUR ts_adc_ch_blur[D_ch_max_num];
TS_ADC_ALL_BLUR ts_adc_all_blur;
TS_ADC_ALL_OUT ts_adc_all_out;
TS_ADC_SHOW ts_adc_show;
void L3_task_adc_init(void)
{
U8 i = 0;
for(i=0;i<D_ch_max_num;i++)
{
L1_task_init(&ts_adc_ch_sample[i].task);
L3_task_s_go(ts_adc_ch_sample[i],D_task_init);
//ts_adc_ch_sample[i].error = 0;
//ts_adc_ch_sample[i].n = 0;
//ts_adc_ch_sample[i].pool = 0;
//ts_adc_ch_sample[i].sum = 0;
ts_adc_ch_sample[i].ch = D_ADCCH_1 + i;
ts_adc_ch_sample[i].ch_n = TS_ADC_CH_01 + i;
L1_task_init(&ts_adc_ch_blur[i].task);
L3_task_s_go(ts_adc_ch_blur[i],D_task_init);
//ts_adc_ch_blur[i].SA_sum = 0;
//ts_adc_ch_blur[i].SA_avg = 0;
//ts_adc_ch_blur[i].SA_n = 0;
//ts_adc_ch_blur[i].SHA_sum = 0;
//ts_adc_ch_blur[i].SHA_avg = 0;
//ts_adc_ch_blur[i].n = 0;
ts_adc_ch_blur[i].ch = D_ADCCH_1 + i;
ts_adc_ch_blur[i].ch_n = TS_ADC_CH_01 + i;
}
L1_task_init(&ts_adc_all_blur.task);
L3_task_s_go(ts_adc_all_blur,D_task_init);
//ts_adc_all_blur.n = 0;
//ts_adc_all_blur.sum = 0;
//ts_adc_all_blur.SHA_sum_0 = 0;
//ts_adc_all_blur.SHA_avg_0 = 0;
//ts_adc_all_blur.SHA_pool_0[0] = ts_adc_all_blur.SHA_pool_0[1] = ts_adc_all_blur.SHA_pool_0[2] = 0;
//ts_adc_all_blur.SHA_sum_1 = 0;
//ts_adc_all_blur.SHA_avg_1 = 0;
////ts_adc_all_blur.SHA_pool_1[0] = ts_adc_all_blur.SHA_pool_1[1] = ts_adc_all_blur.SHA_pool_1[2] = 0;
L1_task_init(&ts_adc_all_out.task);
L3_task_s_go(ts_adc_all_out,D_task_init);
//ts_adc_all_out.n = 0;
//for(i=0;i<D_ADC_CH_BLUE_POOL_NUM;i++)
//{
// ts_adc_all_out.SHA_pool[i] = 0;
//}
L1_task_init(&ts_adc_show.task);
L3_task_s_go(ts_adc_show,D_task_init);
//ts_adc_show.pool_val = 0;
ts_adc_show.pool_gt = 1;
ts_adc_show.val = 0;
//for(i=0;i<D_weight_show_limit_num;i++)
//{
// ts_adc_show.times[i] = 0;
//}
}
//#define D_SA_mid(X); ts_sample[X].midv = Lc_S32_media3(ts_sample[X].mid[0],ts_sample[X].mid[1],ts_sample[X].mid[2]);
#define D_ADC_CHANNEL_READY(X) (R.p.adc_ch_status & (ADC_status_chx_Ready_BASE << X))
#define D_task_ADC_CHx_SAMPLE 0x51
#define D_task_ADC_CHx_WAIT_HIGH_LEVEL 0x52
#define D_task_ADC_CHx_WAIT_LOW_LEVEL 0x53
#define D_task_ADC_CHx_READ 0x54
#define D_task_ADC_CHx_OUT 0x55
void L3_task_adc_ch_sample(TS_ADC_CH_SAMPLE *s)
{
TTSS_Task_init()
L2_task_go(D_task_ADC_CHx_SAMPLE);
TTSS_Task_step(D_task_ADC_CHx_SAMPLE)
if(D_ADC_CHANNEL_READY(s->ch_n))
{
L2_task_go(D_task_ADC_CHx_WAIT_LOW_LEVEL);
}
else
{
s->adcval = s->pool;
L2_task_go(D_task_ADC_CHx_OUT);
}
TTSS_Task_step(D_task_ADC_CHx_WAIT_LOW_LEVEL)
if(0 == L0_2dc_DOUT_AT(s->ch))
{
L2_task_go(D_task_ADC_CHx_READ);
}
TTSS_Task_step(D_task_ADC_CHx_READ)
s->adcval = L0_ADS1231_readCH(s->ch);
L2_task_go(D_task_ADC_CHx_OUT);
TTSS_Task_step(D_task_ADC_CHx_OUT)
s->pool = s->adcval;
s->sum += s->adcval;
++s->n;
if(s->n >= D_ADC_CH_SAMPLE_BUF_MAX)
{
s->n = 0;
s->sum = 0;
}
L2_task_go(D_task_ADC_CHx_SAMPLE);
TTSS_Task_end();
}
//单路滤波任务
#define D_task_ADC_CHx_BLUR_GET 0x51
#define D_task_ADC_CHx_BLUR_AVG 0x52
#define D_task_ADC_CHx_BLUR_SHIFT 0x53
#define D_task_ADC_CHx_BLUR_COUNT 0x54
void L3_task_adc_ch_blur(TS_ADC_CH_BLUR *s)
{
TTSS_Task_init()
L2_task_go(D_task_ADC_CHx_BLUR_GET);
TTSS_Task_step(D_task_ADC_CHx_BLUR_GET)
if(ts_adc_ch_sample[s->ch_n].n >= R.p.cc_blur_ch_avg)
{
s->SA_sum = ts_adc_ch_sample[s->ch_n].sum;
s->SA_n = ts_adc_ch_sample[s->ch_n].n;
ts_adc_ch_sample[s->ch_n].sum = 0;
ts_adc_ch_sample[s->ch_n].n = 0;
L2_task_go(D_task_ADC_CHx_BLUR_AVG);
}
TTSS_Task_step(D_task_ADC_CHx_BLUR_AVG)
s->SA_avg = s->SA_sum / s->SA_n;
L2_task_go(D_task_ADC_CHx_BLUR_SHIFT);
TTSS_Task_step(D_task_ADC_CHx_BLUR_SHIFT)
s->SHA_sum -= s->SHA_avg;
s->SHA_sum += s->SA_avg;
s->SHA_avg = (S32)(s->SHA_sum >> R.p.cc_blur_ch_shift);
s->n++;
L2_task_go(D_task_ADC_CHx_BLUR_COUNT);
TTSS_Task_step(D_task_ADC_CHx_BLUR_COUNT)
G.weight[s->ch_n] = D_COUNT_WEIGHT(s->SHA_avg);
L2_task_go(D_task_ADC_CHx_BLUR_GET);
TTSS_Task_end();
}
//单路滤波任务
#define D_task_ADC_ALL_BLUR_GET 0x51
#define D_task_ADC_ALL_BLUR_SHIFT0 0x52
#define D_task_ADC_ALL_BLUR_SHIFT1 0x53
void L3_task_adc_all_blur(TS_ADC_ALL_BLUR *s)
{
TTSS_Task_init()
L2_task_go(D_task_ADC_CHx_BLUR_GET);
TTSS_Task_step(D_task_ADC_CHx_BLUR_GET)
//if(ts_adc_ch_blur[D_ch_max_num-1].n >= 1)
if(ts_adc_ch_blur[0].n >= 1)
{
ts_adc_ch_blur[0].n = 0;
ts_adc_ch_blur[1].n = 0;
ts_adc_ch_blur[2].n = 0;
ts_adc_ch_blur[3].n = 0;
s->sum = G.weight[0] + G.weight[1] + G.weight[2] + G.weight[3];
L2_task_go(D_task_ADC_ALL_BLUR_SHIFT0);
}
TTSS_Task_step(D_task_ADC_ALL_BLUR_SHIFT0)
s->SHA_sum_0 -= s->SHA_avg_0;
s->SHA_sum_0 += s->sum;
s->SHA_avg_0 = (S32)(s->SHA_sum_0 >> R.p.cc_blur_all_shift0);
s->SHA_pool_0[0] = s->SHA_pool_0[1];
s->SHA_pool_0[1] = s->SHA_pool_0[2];
s->SHA_pool_0[2] = s->SHA_avg_0;
L2_task_go(D_task_ADC_ALL_BLUR_SHIFT1);
TTSS_Task_step(D_task_ADC_ALL_BLUR_SHIFT1)
s->SHA_sum_1 -= s->SHA_avg_1;
s->SHA_sum_1 += s->sum;
s->SHA_avg_1 = (S32)(s->SHA_sum_1 >> R.p.cc_blur_all_shift1);
//s->SHA_pool_1[0] = s->SHA_pool_1[1];
//s->SHA_pool_1[1] = s->SHA_pool_1[2];
//s->SHA_pool_1[2] = s->SHA_avg_1;
s->n++;
L2_task_go(D_task_ADC_CHx_BLUR_GET);
TTSS_Task_end();
}
#define D_task_ADC_ALL_OUT_GET 0x51
#define D_task_ADC_ALL_OUT_DECIDE 0x52
#define D_task_ADC_ALL_OUT_SHOW 0x53
#define D_task_ADC_ALL_OUT_SHOW_1 0x54
#define D_task_ADC_ALL_OUT_DEBUG 0x55
void L3_task_adc_all_out(TS_ADC_ALL_OUT *s)
{
TTSS_Task_init()
//s->diff_threshold = (R.p.cc_blur_all_out_threshold);
//s->diff_threshold1 = (R.p.cc_blur_all_out_threshold1);
//s->diff_threshold2 = (R.p.cc_blur_all_out_threshold2);
//s->should_show_times_threshold = (R.p.cc_blur_all_out_should_show_times_threshold);
L2_task_go(D_task_ADC_ALL_OUT_GET);
TTSS_Task_step(D_task_ADC_ALL_OUT_GET)
if(ts_adc_all_blur.n >= 1)
{
ts_adc_all_blur.n = 0;
Lc_buf_copy_uc((U8*)s->SHA_pool, (U8*)ts_adc_all_blur.SHA_pool_0, D_ADC_CH_BLUE_POOL_NUM * sizeof(S32));
s->SHA_diff[0] = Lc_abs(s->SHA_pool[1] , s->SHA_pool[0]);
s->SHA_diff[1] = Lc_abs(s->SHA_pool[2] , s->SHA_pool[1]);
s->SHA_ddiff[0] = Lc_abs(s->SHA_diff[1] , s->SHA_diff[0]);
L2_task_go(D_task_ADC_ALL_OUT_DECIDE);
}
TTSS_Task_step(D_task_ADC_ALL_OUT_DECIDE)
if((s->SHA_diff[1] >= R.p.cc_blur_all_out_d_threshold) || (s->SHA_diff[0] >= R.p.cc_blur_all_out_d_threshold) || (s->SHA_ddiff[0] >= R.p.cc_blur_all_out_dd_threshold))
{
#if 1
s->sum = s->SHA_pool[2] + s->SHA_pool[1] + s->SHA_pool[0];
ts_adc_all_blur.SHA_sum_1 = s->sum;
ts_adc_all_blur.SHA_sum_1 <<= R.p.cc_blur_all_shift1;
ts_adc_all_blur.SHA_sum_1 /= 3;
ts_adc_all_blur.SHA_avg_1 = (S32)(ts_adc_all_blur.SHA_sum_1 >> R.p.cc_blur_all_shift1);
//s->val = ts_adc_all_blur.SHA_avg_0;
s->val = s->sum / 3;
//s->t = 0;
#else
ts_adc_all_blur.SHA_sum_1 = ts_adc_all_blur.SHA_avg_0 << R.p.cc_blur_all_shift1;
ts_adc_all_blur.SHA_avg_1 = ts_adc_all_blur.SHA_avg_0;
s->val = ts_adc_all_blur.SHA_avg_0;
//s->t = 0;
#endif
}
else
{
s->val = ts_adc_all_blur.SHA_avg_1;
//s->t = 1;
}
s->n++;
L2_task_go(D_task_ADC_ALL_OUT_GET);
TTSS_Task_end();
}
#define D_task_ADC_SHOW_GET 0x53
#define D_task_ADC_SHOW_1 0x54
#define D_task_ADC_SHOW_DEBUG 0x55
void L3_task_adc_show(TS_ADC_SHOW *s)
{
U8 i = 0,find = 0,j = 0;
TTSS_Task_init()
L2_task_go(D_task_ADC_SHOW_GET);
TTSS_Task_step(D_task_ADC_SHOW_GET)
if(ts_adc_all_out.n >= 1)
{
ts_adc_all_out.n = 0;
s->val = ts_adc_all_out.val;
L2_task_go(D_task_ADC_SHOW_1);
}
TTSS_Task_step(D_task_ADC_SHOW_1)
if((s->val - s->pool_val) * s->pool_gt < 0)
{
//符号改变，计数清0
//L0_uart0_uc('-');
L3_task_show_times_reset();
}
s->pool_gt = (s->val >= s->pool_val) ? 1 : -1;
s->diff_val = Lc_abs(s->val,s->pool_val);
for(i=0;i<D_weight_show_limit_num;i++)
{
if(R.p.weight_show_limit[i].times == 0)
{
break;
}
if(s->diff_val >= R.p.weight_show_limit[i].weight)
{
find = 1;
break;
}
}
if(find)
{
s->times[i]++;
for(j=0;j<D_weight_show_limit_num;j++)
{
if(j != i)
{
s->times[j] = 0;
}
}
}
else //小于显示分辨率(<0.02kg)
{
L3_task_show_times_reset();
}
for(i=0;i<D_weight_show_limit_num;i++)
{
if(s->times[i] >= R.p.weight_show_limit[i].times)
{
L3_task_show_times_reset();
s->pool_val = s->val;
G._total_weight = s->pool_val;
R.total_weight = L3_count_std_weight(G._total_weight);
break;
}
}
L2_task_go(D_task_ADC_SHOW_GET);
//L2_task_go(D_task_ADC_SHOW_DEBUG);
#if 0
TTSS_Task_step(D_task_ADC_SHOW_DEBUG)
//L0_uart0_uc(s->t == 0 ? '0' : '1');
s->u16_v = (vU16)(s->pool_val >> 16);
L0_uart0_ushex(s->u16_v);
s->u16_v = (vU16)(s->pool_val & 0x0000ffff);
L0_uart0_ushex(s->u16_v);//Lc_delay_us(500);
//L0_uart0_uc(0x0d); L0_uart0_uc(0x0a);
//L0_uart0_uc(' ');
//L0_uart0_uc(' ');
L2_task_go(D_task_ADC_SHOW_GET);
#endif
TTSS_Task_end();
}
void L3_task_show_times_reset()
{
U8 i = 0;
for(i=0;i<D_weight_show_limit_num;i++)
{
ts_adc_show.times[i] = 0;
}
}

144
source/app/app_task_adc.h
View File

@ -0,0 +1,144 @@
#ifndef APP_TASK_ADC_H
#define APP_TASK_ADC_H
#include "common.h"
#include "../ctask/task.h"
#include "../bsp/bsp_cs1232.h"
#define D_ADC_BLUR_MID_MAX 5
enum D_TASK_ADC_CHANNEL
{
TS_ADC_CH_01 = 0x00,
TS_ADC_CH_02 = 0x01,
TS_ADC_CH_03 = 0x02,
TS_ADC_CH_04 = 0x03,
};
//对每一路进行采样
#define D_ADC_CH_SAMPLE_BUF_MAX 50
#define D_ADC_CH_BLUE_POOL_NUM 3
typedef struct
{
TS_task task;
vU8 pending_ch;
}TS_ADC_CH_SWITCH;
typedef struct
{
TS_task task;
vS32 adcval;
vS32 pool;
vS32 sum;
vU8 error;
vU8 ch;
vU8 ch_n;
vU8 n;
}TS_ADC_CH_SAMPLE;
//对每一路进行滤波
typedef struct
{
TS_task task;
vU8 ch;
vU8 ch_n;
//平均滤波
vS32 SA_sum;
vS32 SA_avg;
vS32 SA_n;
//移位滤波
vS32 SHA_sum;
vS32 SHA_avg;
vU8 n;
}TS_ADC_CH_BLUR;
//和值滤波
typedef struct
{
TS_task task;
vU8 n;
vS32 sum;
vS32 SHA_sum_0;
vS32 SHA_avg_0;
vS32 SHA_pool_0[D_ADC_CH_BLUE_POOL_NUM];
vS32 SHA_sum_1;
vS32 SHA_avg_1;
//vS32 SHA_pool_1[D_ADC_CH_BLUE_POOL_NUM];
}TS_ADC_ALL_BLUR;
//和值阈值判定(滤波方式切换)决定输出
#define D_ADC_ALL_OUT_POOL_NUM 5
typedef struct
{
TS_task task;
vS32 val;
vS32 SHA_pool[D_ADC_CH_BLUE_POOL_NUM];
vU32 SHA_diff[D_ADC_CH_BLUE_POOL_NUM-1];
vU32 SHA_ddiff[D_ADC_CH_BLUE_POOL_NUM-2];
vU8 n;
vS32 sum;
}TS_ADC_ALL_OUT;
typedef struct
{
TS_task task;
vS8 pool_gt;
vS32 pool_val;
vS32 val;
vU16 u16_v;
U32 diff_val;
vU8 times[D_weight_show_limit_num];
}TS_ADC_SHOW;
#if 0
typedef struct _TS_ADC_SampleM_
{
//中值滤波
vS32 mid[D_ADC_BLUR_MID_MAX];
vS32 midv;
//均值滤波
vS32 SA_sum;
vS32 SA_avg;
//移位滤波
vS32 SHA_sum;
vS32 SHA_avg;
}TS_ADC_SampleM;
typedef struct
{
TS_task task;
vU8 error;
vU8 m_n;
vU8 a_n;
vU8 ch;
vU8 ch_n;
vU16 u16_v;
TS_ADC_SampleM ts_sample;
}TS_task_ADC_;
#endif
extern TS_ADC_CH_SWITCH ts_adc_ch_switch;
extern TS_ADC_CH_SAMPLE ts_adc_ch_sample[D_ch_max_num];
extern TS_ADC_CH_BLUR ts_adc_ch_blur[D_ch_max_num];
extern TS_ADC_ALL_BLUR ts_adc_all_blur;
extern TS_ADC_ALL_OUT ts_adc_all_out;
extern TS_ADC_SHOW ts_adc_show;
extern void L3_task_adc_init(void);
extern void L3_task_adc_ch_sample(TS_ADC_CH_SAMPLE *s);
extern void L3_task_adc_ch_blur(TS_ADC_CH_BLUR *s);
extern void L3_task_adc_all_blur(TS_ADC_ALL_BLUR *s);
extern void L3_task_adc_all_out(TS_ADC_ALL_OUT *s);
extern void L3_task_adc_show(TS_ADC_SHOW *s);
extern void L3_task_show_times_reset();
#endif

31
source/app/app_task_uart0.c
View File

@ -0,0 +1,31 @@
#include "app_task_uart0.h"
#include "../msp/uart0.h"
#include "../app/common.h"
void L3_task_uart0_modbus_handler(TP_Handler_X *ph4)
{
#if 1
if(ph4->ok)
{
TS_PH4_modbus *ts_modbus = (TS_PH4_modbus *)ph4->buf;
if(ts_modbus->slaver == R.p.slaver_id || ts_modbus->slaver == D_UART0_485_SLAVER_ID_BROADCAST) //从机
{
U16 acklen = L3_modbus_slaver_ack(ts_modbus,&s_uart0_ack);
L0_uart0_sendArray((U8*)&s_uart0_ack, acklen);
switch(ts_modbus->oper)
{
case 0x06:
case 0x10:
//重新计算重量
R.total_weight = L3_count_std_weight(G._total_weight);
//持久化
L3_eeprom_persist_param();
break;
}
}
}
#endif
}

11
source/app/app_task_uart0.h
View File

@ -0,0 +1,11 @@
#ifndef APP_TASK_UART0_H
#define APP_TASK_UART0_H
#include "common.h"
#include "../ctask/task.h"
#include "../tpc/tpc_modbus.h"
//extern void L3_task_uart0_handler(TS_Handle_PH3 *ph3);
extern void L3_task_uart0_modbus_handler(TP_Handler_X *ph4);
#endif

230
source/app/common.c
View File

@ -0,0 +1,230 @@
#include "common.h"
//#include "../tpc/tpc_uart.h"
#include "../bsp/bsp_cs1232.h"
#include "../msp/msp_eeprom.h"
#include "../msp/msp_id.h"
struct global_param G;
struct ts_eeprom_param eep_param;
struct ts_eeprom_enc eep_enc;
#define EEP_SECTOR_SIZE 0x200
#define EEP_PARAM_ADDR (EEP_SECTOR_SIZE * 1)
#define EEP_ENC_ADDR (EEP_SECTOR_SIZE * 0)
void L3_eeprom_read_param()
{
U8 dlen = 0;
L0_Iap_Read_array(EEP_PARAM_ADDR, (U8*)&eep_param, 2 + EEPROM_PARAM_DATA_MAX + 2);
if(eep_param.filter == EEPROM_PARAM_FILTER)
{
dlen = eep_param.len - 2;
crc16(eep_param.crc,(U8*)&eep_param,2+dlen);
if(eep_param.crc[0] == eep_param.buf[dlen] && eep_param.crc[1] == eep_param.buf[dlen+1])
{
L0_uart0_uc('#');
//Lc_buf_copy_uc((U8*)&G.p,(U8*)eep_param.buf,dlen);
Lc_buf_copy_uc((U8*)&R.p,(U8*)eep_param.buf,sizeof(R.p));//防止dlen>sizeof(G.P)引起的内存错误
}
}
}
void L3_eeprom_persist_param()
{
U8 dlen = sizeof(R.p);
eep_param.filter = EEPROM_PARAM_FILTER;
eep_param.len = dlen + 2;
Lc_buf_copy_uc((U8*)eep_param.buf,(U8*)&R.p,dlen);
crc16(eep_param.crc, &eep_param, 2+dlen);
eep_param.buf[dlen] = eep_param.crc[0];
eep_param.buf[dlen+1] = eep_param.crc[1];
L0_Iap_Erase(EEP_PARAM_ADDR);
L0_Iap_Program_array(EEP_PARAM_ADDR, (U8*)&eep_param, 2 + dlen + 2);
}
int L3_mcu_id_ok(void)
{
U8 i = 0,crc[2];
U32 enc_key;
//1.获取MCU_ID
L0_id_get_rom(G.e.mcu_id);
for(i=0;i<MCU_ID_LEN;i++)
{
L0_uart0_uchex(G.e.mcu_id[i]);
}
//2.读取eeprom中的加密信息
L0_Iap_Read_array(EEP_ENC_ADDR, (U8*)&eep_enc, MCU_ID_KEY_LEN + MCU_ID_LEN + 2);
crc16(crc,(U8*)&eep_enc,MCU_ID_KEY_LEN + MCU_ID_LEN);
if(eep_enc.crc[0] != crc[0] || eep_enc.crc[1] != crc[1])
{
L0_uart0_uc('-');
return 0;
}
//3.根据mcu_id和enc_key计算enc_val
enc_key = ((U32)eep_enc.enc_key[0] << 24) | (eep_enc.enc_key[1] << 16) | (eep_enc.enc_key[2] << 8) |(eep_enc.enc_key[3] << 0);
Lc_encrypt_id((U8*)G.e.mcu_enc_id, (U8*)G.e.mcu_id, enc_key, MCU_ID_LEN);
//4.判断enc_val是否一致
for(i=0;i<MCU_ID_KEY_LEN;i++)
{
if(G.e.mcu_enc_id[i] != eep_enc.enc_val[i])
{
return 0;
}
}
return 1;
}
void L3_param_init(void)
{
int i;
for(i=0;i<D_ch_max_num;i++)
{
G.weight[i] = 0;
}
G._total_weight = 0;
G._total_zweight = 0;
L3_eeprom_read_param();
}
S32 L3_count_std_weight(S32 weight)
{
U8 i = 0;
U16 ratio = 100;
weight = (weight - G._total_zweight)/10;
for(i=0;i<D_weight_std_num;i++)
{
if(R.p.weight_std[i].weight_range == 0 || (R.p.weight_std[i].weight_range * 100) >= weight)
{
break;
}
}
if(i<D_weight_std_num && R.p.weight_std[i].ratio != 0)
{
ratio = R.p.weight_std[i].ratio;
}
return (S32)(weight * 1.0 * ratio / 100) ;
}
#if 0
U8 L3_pack_PH4(TS_PH4_modbus *pmodbus ,U8 oper, void *buf,U8 bufsize)
{
pmodbus->salver = G.p.slaver_id;
pmodbus->oper = oper;
Lc_buf_copy_uc(pmodbus->buf,buf,bufsize);
crc16(pmodbus->crc,&pmodbus->salver,2 + bufsize);
pmodbus->buf[bufsize] = pmodbus->crc[0];
pmodbus->buf[bufsize + 1] = pmodbus->crc[1];
return bufsize + 2 + 2;
}
TS_PH4_modbus modbusack;
Modbus03 modbus03;
Modbus03Ack modbus03Ack;
Modbus06 modbus06;
Modbus06Ack modbus06Ack;
Modbus10 modbus10;
Modbus10Ack modbus10Ack;
int L3_ph4_common_handler(TS_PH4_modbus *pmodbus)
{
U8 handlerStatus = TP_HANDLED, modbuslen = 0;
switch(pmodbus->oper)
{
case 0x03:
{
U16 i = 0,j = 0,regval = 0;
modbus03.reg = ((U16)pmodbus->buf[0]) << 8 | ((U16)pmodbus->buf[1]);
modbus03.num = ((U16)pmodbus->buf[2]) << 8 | ((U16)pmodbus->buf[3]);
if((modbus03.num < 5) && (modbus03.reg < sizeof(G)/2)) //每次最多读取4个寄存器 8个字节，以防止越界
{
for(i=0; i<modbus03.num; i++)
{
regval = *(REG_2_MEM(modbus03.reg + i));
modbus03Ack.buf[j++] = regval >> 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; i<modbus10.num; i++)
{
regval = ((U16)pmodbus->buf[5+i*2]) << 8 | ((U16)pmodbus->buf[5+i*2+1]);
*(REG_2_MEM(modbus10.reg + i)) = regval;
}
modbus10Ack.reg = modbus10.reg;
modbus10Ack.num = modbus10.num;
modbuslen = L3_pack_PH4(&modbusack, 0x10, &modbus10Ack, 4);
L0_uart0_sendArray((U8*)&modbusack, modbuslen);
}
//重新计算重量
G.total_weight = L3_count_std_weight(G._total_weight);
//持久化
if(modbus10.reg > MEM_2_REG(&G.reserved2) && modbus10.reg < MEM_2_REG(&G.reserved3))
{
L3_eeprom_persist_param();
}
break;
}
default:
//L3_ph4_send_error_pkg(MODBUS_ERR_OPCODE);
break;
}
return handlerStatus;
}
#endif

75
source/app/common.h
View File

@ -0,0 +1,75 @@
#ifndef APP_COMMON_H
#define APP_COMMON_H
#include "../clib/type.h"
#define APP_VERSION 0x10
#define D_MCU_BIGENDIAN 1
// #define D_MCU_LITTLEENDIAN 1
#define D_COUNT_WEIGHT(adc) ((S32)((1000.0 * R.p.weight_max * (adc)) / (2 * 0x7FFFFF / 1000 * D_ADS1213_GAIN_VAL * R.p.lmd)))
enum tp_handle
{
TP_HANDLED,
TP_UNHANDLE
};
/**
* EEPROM 存储结构
*/
#define EEPROM_PARAM_DATA_MAX 90
#define EEPROM_PARAM_FILTER 0xAA
typedef struct ts_eeprom_param
{
U8 filter;
U8 len;
U8 buf[EEPROM_PARAM_DATA_MAX];
U8 crc[2];
}EEPROM_PARAM;
#define MCU_ID_LEN 7
#define MCU_ID_KEY_LEN 4
#define EEPROM_ENC_DATA_MAX 64
#define EEPROM_ENC_FILTER 0xAA
typedef struct ts_eeprom_enc
{
U8 enc_key[MCU_ID_KEY_LEN];
U8 enc_val[MCU_ID_LEN];
U8 crc[2];
}EEPROM_ENC;
#define baud_rade L3_baud_rate_change(G.p.baud_rate)
typedef struct mcu_encrypt_info
{
U8 enc_key[MCU_ID_KEY_LEN];
U8 mcu_id[MCU_ID_LEN];
U8 mcu_enc_id[MCU_ID_LEN];
}McuEncryptInfo;
#define D_ch_max_num 4
typedef struct global_param
{
//EncryptInfo
McuEncryptInfo e;
//Global Variables
S32 weight[D_ch_max_num]; //4路重量
S32 _total_weight; //实际重量*1000
S32 _total_zweight; //实际皮重*1000
}GlobalParam;
extern struct global_param G;
extern struct ts_eeprom_param eep_param;
extern struct ts_eeprom_enc eep_enc;
extern void L3_param_init(void);
extern int L3_mcu_id_ok();
extern S32 L3_count_std_weight(S32 weight);
extern void L3_eeprom_persist_param(void);
#endif

183
source/app/main.c
View File

@ -0,0 +1,183 @@
//////////////////////////////////////////////////////////////////////////
/// COPYRIGHT NOTICE
/// Copyright (c) 2015, 传控科技
/// All rights reserved.
///
/// @file main.c
/// @brief main app
///
///（本文件实现的功能的详述）
///
/// @version 1.1 CCsens technology
/// @author CC
/// @date 20150102
/// @note
///
/// @version 1.2 CCsens technology
/// @author CC
/// @date 20180903
/// @note cc_gsm_PD03SM_vh03_m10_debug01
//20160413 CC-ACC-VH02
//20170111 CC-ls_02
//
//20170608 cc_as_stc01_main
//
//20180903 cc_gsm_PD03SM_vh03_m10_debug01
//
//
/// @version 1.3 CCsens technology
/// @author CC
/// @date 20180903
/// @note add calibrationg function
/// @version 1.4 CCsens technology
/// @author CC
/// @date 20190101
/// @note add calibrationg function
//////////////////////////////////////////////////////////////////////////
/// 下面是一个含有两个参数的函数的注释说明（简述）
///
/// 这里写该函数的详述信息
/// @param a 被测试的变量（param描述参数）
/// @param s 指向描述测试信息的字符串
/// @return 测试结果（return描述返回值）
/// @see Test() （本函数参考其它的相关的函数，这里作一个链接）
/// @note (note描述需要注意的问题)
/************************************************
stc5ac32s
程序结构
有动静
并且采集的值小于c200 设置采集间隔缩短
采集值 在 c200<val<cff 设置采集时间间隔
采集值大于cff 进入校准模式 ，采集5次求平均 写入曲线中
、、、、、、、、、、
应用： 定期采集cam 参数：间隔时间 采集方式（热采集还是冷采集，也就是是否对cam
重新上电）
驱动： cam 参数设置及中断
************************************************/
//===============================================
//寄存器头文件
//===============================================
#include "main.h"
/// main init
/// @param a 被测试的变量（param描述参数）
/// @param s 指向描述测试信息的字符串
/// @return 测试结果（return描述返回值）
/// @see Test() （本函数参考其它的相关的函数，这里作一个链接）
/// @note (note描述需要注意的问题)
void L0_main_init(void)
{
//Lc_delay_ms(200);
L0_uart0_buf_init();//串口初始化
EA = 1;
//Lc_delay_ms(100);
L1_tick_init();
L0_timer0_Init();
//L0_timer1_Init();
}
//===============================================
//主函数
//===============================================
void main(void)
{
//-----------------------------------------------
//系统初始化
//----------------------------------------------
L0_main_init();
L0_reg_init();
L3_param_init();
L2_485_init();
L0_ADS1213_INIT();
L3_task_adc_init();
L0_uart0_sendArray("v2.7",4);
P35 = 0;//led on
//-----------------------------------------------
//系统主循环
//-----------------------------------------------
#if 0 //看门狗
if(!L3_mcu_id_ok())
{
P35 = 0;
P10 = 0;
while(1)
{
if(1 == s_nos_tick.t1s_heatbeart)
{
s_nos_tick.t1s_heatbeart = 0;
L0_uart0_uc('X');
}
}
}
#endif
//L1_ADS1213_main();
while(1)
{
if(1 == s_nos_tick.t1s_heatbeart)
{
s_nos_tick.t1s_heatbeart = 0;
LED1 ^= 1;
//L0_uart0_sendArray("abcdefg",7);
}
#if 1
//单路采集
L3_task_adc_ch_sample(&ts_adc_ch_sample[0]);
L3_task_adc_ch_sample(&ts_adc_ch_sample[1]);
L3_task_adc_ch_sample(&ts_adc_ch_sample[2]);
L3_task_adc_ch_sample(&ts_adc_ch_sample[3]);
//单路滤波
L3_task_adc_ch_blur(&ts_adc_ch_blur[0]);
L3_task_adc_ch_blur(&ts_adc_ch_blur[1]);
L3_task_adc_ch_blur(&ts_adc_ch_blur[2]);
L3_task_adc_ch_blur(&ts_adc_ch_blur[3]);
//和值滤波
L3_task_adc_all_blur(&ts_adc_all_blur);
//移位切换输出最终数据
L3_task_adc_all_out(&ts_adc_all_out);
//更新显示数据
L3_task_adc_show(&ts_adc_show);
#endif
//输出,响应485协议
L3_task_uart0_modbus_handler(&s_uart0_rec);
}
}
//end main

96
source/app/main.h
View File

@ -0,0 +1,96 @@
//////////////////////////////////////////////////////////////////////////
/// COPYRIGHT NOTICE
/// Copyright (c) 2017, 传控科技
/// All rights reserved.
///
/// @file main.c
/// @brief main app
///
///（本文件实现的功能的详述）
///
/// @version 1.1 CCsens technology
/// @author CC
/// @date 20150102
///
///
/// 修订说明：最初版本
/// Modified by:
/// Modified date:
/// Version:
/// Descriptions:
///
///
///
///
///
///
///
/// msp: humtemp flow
/// bsp: i2c adc
///
///
///
///
///
//////////////////////////////////////////////////////////////////////////
#ifndef _MAIN_H
#define _MAIN_H
#include "../bsp/bsp_config.h"
//#include "../bsp/adxl362.h"
//#include "../msp/stc_adc.h"
#include "../msp/uart0.h"
//#include "../msp/uart2.h"
//#include "../msp/uart4.h"
//#include "../msp/uart3.h"
//#include "../msp/time.h"
//#include "../msp/msp_buzz.h"
//#include "../msp/msp_rtc.h"
//#include "../msp/msp_plcd.h"
//#include "../msp/iic_sim.h"
#include "../msp/msp_eeprom.h"
#include "../msp/msp_id.h"
#include "../clib/Clib.h"
#include "../clib/bit.h"
//#include "../debug/debug_drv.h"
//#include "../uartcom/uprotocol.h"
//#include "../uartcom/Uartcom0.h"
#include "../ctask/task.h"
#include "../ctask/tick.h"
//#include "../bsp/bsp_led.h"
#include "../bsp/bsp_power.h"
//#include "../bsp/Bsp_debug.h"
//#include "app_yeelink.h"
//#include "app_flow.h"
//#include "app_Gsensor.h"
//#include "app_io.h"
//#include "../tpc/tpc_uart.h"
//#include "stdio.h"
#include "app_paraid.h"
//#include "app_algorithm.h"///
#include "../bsp/bsp_cs1232.h"
#include "../bsp/bsp_485.h"
#include "../app/app_task_uart0.h"
#include "../app/app_task_adc.h"
//////////////////////////////////////////////////////////////////
#endif //#ifndef _MAIN_H

BIN
source/app/source.lnk
View File

Binary file not shown.

BIN
source/bsp/backu/bsp2019低功耗采样line版本 20200301073727.rar
View File

Binary file not shown.

34
source/bsp/backu/bsp_433.c
View File

@ -0,0 +1,34 @@
////////////////////////////////////////////////////////////////////////////
///@copyright Copyright (c) 2018, ´«¿Ø¿Æ¼¼ All rights reserved.
///-------------------------------------------------------------------------
/// @file APP_433.c
/// @brief APP_POWER driver app µçÔ´¹ÜÀí
///-------------------------------------------------------------------------
/// @version 1.0
/// @author CC
/// @date 20181010
/// @note cc_AS_stc01
//////////////////////////////////////////////////////////////////////////////
/******************************************************************************/
/***************************** Include Files **********************************/
/******************************************************************************/
//#include "app_Gsensor.h"
#include "bsp_433.h"
////L0_uart0_sendArray( (unsigned char *)&TS_paer_value,5);

19
source/bsp/backu/bsp_433.h
View File

@ -0,0 +1,19 @@
////////////////////////////////////////////////////////////////////////////
///@copyright Copyright (c) 2018, ´«¿Ø¿Æ¼¼ All rights reserved.
///-------------------------------------------------------------------------
/// @file APP_433.c
/// @brief APP_POWER driver app µçÔ´¹ÜÀí
///-------------------------------------------------------------------------
/// @version 1.0
/// @author CC
/// @date 20181010
/// @note cc_AS_stc01
//////////////////////////////////////////////////////////////////////////////
#ifndef _BSP_433_H
#define _BSP_433_H
#include "../msp/uart0.h"
#endif // #ifndef _BSP_433_H

574
source/bsp/backu/bsp_cam - 副本 (2).c
View File

@ -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,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

574
source/bsp/backu/bsp_cam - 副本.c
View File

@ -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

706
source/bsp/backu/bsp_cam.c
View File

@ -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;
}
//// 采集单行的程序 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();///上升沿 1ms后433 从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

189
source/bsp/backu/bsp_cam.h
View File

@ -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; /// 开始一帧的采样 代表收到了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

218
source/bsp/backu/bsp_cam_isr.c
View File

@ -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_get个hs，也就是一个画面中的第几行数据
///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 每个点的采样
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_get个hs，也就是一个画面中的第几行数据
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 每个点的采样
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

62
source/bsp/backu/bsp_cam_isr.h
View File

@ -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

53
source/bsp/backu/bsp_func.c
View File

@ -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);
}

52
source/bsp/backu/bsp_func.h
View File

@ -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

773
source/bsp/backu/bsp_gc032a.c
View File

@ -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 5’h03: Y Cr Y Cb
{0x44,B1001_0000},///P0:0x44 Output_format [7] YUV420_row_switch 5’h10: 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 5’h03: Y Cr Y Cb
{0x44,B1001_0000},///P0:0x44 Output_format [7] YUV420_row_switch 5’h10: 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

19
source/bsp/backu/bsp_gc032a.h
View File

@ -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_

261
source/bsp/backu/bsp_msa300.c
View File

@ -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 /// z轴调到25算是临界值
////#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 初始化 调用前必须使用iic的初始化
/// 如需使用中断 还必须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

473
source/bsp/backu/bsp_msa300.h
View File

@ -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

191
source/bsp/backu/cw63xx.c
View File

@ -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

123
source/bsp/backu/cw63xx.h
View File

@ -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 依靠这个实现电源的测量
///--------------------------------------------------------------------
#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

75
source/bsp/board support/msa300.c
View File

@ -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

63
source/bsp/board support/msa300.h
View File

@ -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

8
source/bsp/bsp_485.c
View File

@ -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);
}

13
source/bsp/bsp_485.h
View File

@ -0,0 +1,13 @@
#ifndef BSP_485_H
#define BSP_485_H
#include "../bsp/bsp_config.h"
#include "../msp/uart0.h"
//485_RE P33
//485_DE P32
#define D_485_TX() P32 = 1;// >750us
#define D_485_RX() P32 = 0;
extern void L2_485_init(void);
#endif

119
source/bsp/bsp_config.c
View File

@ -0,0 +1,119 @@
#include "bsp_config.h"
#include "../tpc/tpc_modbus.h"
////////////////////////////////////////////////////////////////////////////
///@copyright Copyright (c) 2018, 传控科技 All rights reserved.
///-------------------------------------------------------------------------
/// @file bsp_func.c
/// @brief bsp @ fuctiong ; io复用选择等，和cpu型号息息相关
///-------------------------------------------------------------------------
/// @version 1.0
/// @author CC
/// @date 20180308
/// @note cc_AS_stc02
//////////////////////////////////////////////////////////////////////////////
//struct _s_sysclk s_sysclk;
GlobalRegister R;
void L0_reg_reset()
{
U8 i = 0;
//R.p.reset = 0;
R.p.adc_ch_status = ADC_status_ch2_Ready | ADC_status_ch3_Ready | ADC_status_ch4_Ready; //修改采集通道
R.p.slaver_id = D_UART0_485_SLAVER_ID;
//R.p.zero = 0;
R.p.weight_max = 500; //500kg
R.p.lmd = 2; //2mv/v
R.p.cc_blur_ch_avg = 6;
R.p.cc_blur_ch_shift = 2;
R.p.cc_blur_all_shift0 = 2;
R.p.cc_blur_all_shift1 = 4;
R.p.cc_blur_all_out_d_threshold = 200; //0.2kg
R.p.cc_blur_all_out_dd_threshold = 200; //0.2kg
for(i=0;i<D_weight_show_limit_num;i++)
{
R.p.weight_show_limit[i].weight = 0;
R.p.weight_show_limit[i].times = 0;
}
R.p.weight_show_limit[0].weight = 300; //0.3kg
R.p.weight_show_limit[0].times = 1;
R.p.weight_show_limit[1].weight = 200; //0.2kg
R.p.weight_show_limit[1].times = 9;
R.p.weight_show_limit[2].weight = 100; //0.1kg
R.p.weight_show_limit[2].times = 18;
R.p.weight_show_limit[3].weight = 50; //0.05kg
R.p.weight_show_limit[3].times = 18;
R.p.weight_show_limit[4].weight = 20; //0.02kg
R.p.weight_show_limit[4].times = 30;
//for(i=0;i<D_weight_std_num;i++)
//{
// R.p.weight_std[i].weight_range = 0;
// R.p.weight_std[i].ratio = 0;
//}
R.p.baud_rate = 19200;
R.p.stop_bits = 1;
}
void L0_reg_init(void)
{
R.reserved1 = R.reserved2 = R.reserved3 = 0x55;
//R.total_weight = R.total_zweight = 0;
L0_reg_reset();
}
//==========================================================
//系统定时器回调
//初始化为NULL，timer0_isr中判断为NULL则不调用
//==========================================================
void L0_board_config(void)
{
#if (PIN_UART0_Rxd_30_Txd_31 == D_PIN_UART0)
BITN_0(P_SW1 ,BITN7);//
BITN_0(P_SW1 ,BITN6);// rxd p3.0 txd p3.1
#elif (PIN_UART0_Rxd_36_Txd_37 == D_PIN_UART0)
BITN_0(P_SW1 ,BITN7);//
BITN_1(P_SW1 ,BITN6);// rxd p3.6 txd p3.7
#elif (PIN_UART0_Rxd_16_Txd_17 == D_PIN_UART0)
BITN_1(P_SW1 ,BITN7);//
BITN_0(P_SW1 ,BITN6);// rxd p1.6 txd p1.7
#elif (PIN_UART0_Rxd_43_Txd_44 == D_PIN_UART0)
BITN_1(P_SW1 ,BITN7);//
BITN_1(P_SW1 ,BITN6);// rxd p4.3 txd p4.4
#else
BITN_0(P_SW1 ,BITN7);//
BITN_0(P_SW1 ,BITN6);// rxd p3.0 txd p3.1
#endif
//uart2
BITN_0(P_SW2 ,BITN0);// rxd2 p1.0 txd2 p1.1
//BITN_1(P_SW2 ,BITN0);// rxd2 p4.0 txd2 p4.2
//uart3
//P_SW2 = 0x02; // RXD3_2/P5.0, TXD3_2/P5.1
//uart4
//BITN_1(P_SW2 ,BITN2);// rxd4 p5.2 txd4 p5.3
//BITN_0(P_SW2 ,BITN2);// rxd4 p0.2 txd4 p0.3
//485 RE/DE 配置推完输出 P32
BITN_0(P3M1,BITN2);BITN_1(P3M0,BITN2);
#if (TYPE_WDT_ENABLE == D_WDT_STATUS)
WDT_CONTR = 0x27; //使能看门狗,22M时钟下溢出时间约为5s，请注意添加喂狗程序
#else
WDT_CONTR = 0x00;
#endif
//Lp0_Sys_timer_extern_handler被timer0中断调用
//Lp0_Sys_timer_extern_handler = L1_Sys_timer_extern_handler;
}

311
source/bsp/bsp_config.h
View File

@ -0,0 +1,311 @@
////////////////////////////////////////////////////////////////////////////
///@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 <INTRINS.H>
#include "../clib/type.h"
#include "../clib/bit.h"
//>>>>>>>>>>>>>>>>>>>>>>.BORAD TYPE
#define TYPE_BOARD_hhnew 1
#define TYPE_BOARD_st_sleep04_01 4
#define TYPE_BOARD_st_sleep03 5
#define TYPE_BOARD_SMMM_MB_VH032_0E 6
#define TYPE_BOARD_LPC17xx_ 8
#define TYPE_BOARD_STM32F_103ZET6_READBULL 1036
#define TYPE_BOARD_hh_CC_MD_VH05_anyriny_simple_m51 0x0551
#define TYPE_BOARD_hh_CC_MD_VH06_asMain_m6a7 0x6a7
#define TYPE_BOARD_TI26_MT01_M178 0x178 //会议计时器版v TI26_MT01-M178
#define TYPE_BOARD_stc5as32_WIFIBV01 532
#define TYPE_BOARD_SHC16LAXXQN32 1632 //SHC16LAXXQN32
#define TYPE_BOARD_PAPER6133_M0A6 0xa6 //打印机纸张传感
#define TYPE_BOARD_GSM_MAIN_V07 0xa7 //打印机运维板
#define TYPE_BOARD_ADDA_MAIN_V02 0xa8 //ADDA
#define TYPE_BOARD_433_0A 0xa9 //433
#define TYPE_BOARD_WEIGH_0B 0xaa //称重
//<<<<<<<<<<<<<<<<<<<<<<<<<<<.BORAD TYPE end
//>>>>>>>>>>>>>>>>>>>>>>MCU TYPE
#define TYPE_MCU_STC_8A 51
#define TYPE_MCU_STC_8F 52
#define TYPE_MCU_STC_8G 53
#define TYPE_MCU_SHC6601 66
#define TYPE_MCU_LPC17xx 3217
#define TYPE_MCU_STM32 3232
#define D_CPUfamily_8bits 8
#define D_CPUfamily_16bits 16
#define D_CPUfamily_32bits 32
//<<<<<<<<<<<<<<<<<<<<<<mcu TYPE end
//>>>>>>>>>>>>>>>>>>>>>>IDE TYPE
#define TYPE_IDE_KEIL 1
#define TYPE_IDE_MDK 2
#define TYPE_IDE_IAR 3
//<<<<<<<<<<<<<<<<<<<<<<IDE TYPE end
//>>>>>>>>>>>>>>>>>>>>>>.SysTimer TYPE
#define TYPE_JIFFIES_5MS 1
#define TYPE_JIFFIES_10MS 2
#define TYPE_JIFFIES_25MS 3
//<<<<<<<<<<<<<<<<<<<<<<<<<<<.SysTimer TYPE end
//>>>>>>>>>>>>>>>>>>>>>>.WDT TYPE
#define TYPE_WDT_DISABLE 1
#define TYPE_WDT_ENABLE 2
#define WDT_FEED() WDT_CONTR |= 0x10
//<<<<<<<<<<<<<<<<<<<<<<<<<<<.SysTimer TYPE end
//>>>>>>>>>>>>>>>>>>>>>>.ByteOrder TYPE
#define TYPE_MCU_BIGENDIAN 1
#define TYPE_MCU_LITENDIAN 2
//<<<<<<<<<<<<<<<<<<<<<<<<<<<.ByteOrder TYPE end
//>>>>>>>>>>>>>>>>>>>>>>BUADRATE & StopBit
#define SBIT_1 1 //1 stop bit
#define SBIT_2 2 //2 stop bit
#define BRT_115200 115200
#define BRT_19200 19200
#define BRT_9600 9600
#define BRT_4800 4800
//<<<<<<<<<<<<<<<<<<<<<<BUADRATE & StopBit end
//>>>>>>>>>>>>>>>>>>>>>>MainFre
#define MainFre_5M 5529600L
#define MainFre_11M 11059200L
#define MainFre_22M 22118400L
#define MainFre_24M 24000000L
#define MainFre_27M 27000000L
//<<<<<<<<<<<<<<<<<<<<<<MainFre end
//>>>>>>>>>>>>>>>>>>>>>>UART0 PIN
#define PIN_UART0_Rxd_30_Txd_31 1
#define PIN_UART0_Rxd_36_Txd_37 2
#define PIN_UART0_Rxd_16_Txd_17 3
#define PIN_UART0_Rxd_43_Txd_44 4
//<<<<<<<<<<<<<<<<<<<<<<<<<<<.UART0 PIN
//>>>>>>>>>>>>>>>>>>>>>>485 Type
#define TYPE_485_NONE 0
#define TYPE_485_MASTER 1
#define TYPE_485_SLAVER 2
//<<<<<<<<<<<<<<<<<<<<<<485 Type end
//>>>>>>>>>>>>>>>>>>>>>>G-SENSOR TYPE
#define TYPE_ASENSOR_ADXL362 362
#define TYPE_ASENSOR_MSA300 300
#define TYPE_ASENSOR TYPE_ASENSOR_MSA300
//<<<<<<<<<<<<<<<<<<<<<<G-SENSOR TYPE end
//STEP 1 TYPE_UASER_BOARD SELECT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
#define TYPE_UASER_BOARD TYPE_BOARD_WEIGH_0B
//STEP 2 TYPE_UASER_BOARD CONFIG >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
#if(TYPE_UASER_BOARD == TYPE_BOARD_WEIGH_0B)
#include <stdio.h>
#include <string.h>
#include <intrins.h>
#include "../cpu/stc_stc8f.h"
#include "../cpu/stc_macro.h"
//基本配置(工作频率、时钟、看门狗、字节序)
#define TYPE_MCU TYPE_MCU_STC_8F
#define TYPE_IDE TYPE_IDE_KEIL
#define D_CPUfamily_type D_CPUfamily_8bits
#define D_sys_MainFre MainFre_11M
#define D_sys_Jiffies TYPE_JIFFIES_10MS
#define D_WDT_STATUS TYPE_WDT_DISABLE //如果配置为enable，请在bsp_config.c中设置wdt溢出时间
#define D_MCU_ENDIAN TYPE_MCU_BIGENDIAN
//串口配置
#define D_uart0_BRT BRT_115200
#define D_uart0_SBIT SBIT_1
#define D_PIN_UART0 PIN_UART0_Rxd_30_Txd_31
#define D_uart2_BRT BRT_115200
#define D_uart3_BRT BRT_115200
#define D_uart4_BRT BRT_115200
//485配置
#define D_UART0_485_TYPE TYPE_485_SLAVER //UART0启用485
#define D_UART0_485_SLAVER_ID_BROADCAST 0xFF //485从机总是响应0xFF消息
#define D_UART0_485_SLAVER_ID 0x01 //板卡作为485从机 slaverId
#define D_UART0_485_TX() P32 = 1;
#define D_UART0_485_RX() P32 = 0;
#define D_UART2_485_TYPE TYPE_485_NONE //UART2不启用485
#define D_UART3_485_TYPE TYPE_485_NONE //UART2不启用485
#define D_UART4_485_TYPE TYPE_485_NONE //UART2不启用485
//MODBUS协议配置
#define D_MODBUS_ENABLE //MODBS启用开关，如果不使用modbus，可以注释掉本行
#define D_MODBUS_SPLIT_ENTRY L1_modbus_split //modbus切割函数，在tpc_modbus.c中实现，依据实际情况修改
#define D_MODBUS_REG_MAX_NUM 32 //每次最多读取/写入的寄存器数量，此处的数量要注意和 D_tp_handle_x_len 对应
//外设定义
#define LED0 P10 //D4
#define LED1 P35 //D4
//EEP存储地址定义
#define D_EEP_SECTOR_SIZE 0x200
#define D_EEP_PARAM_ADDR (D_EEP_SECTOR_SIZE * 0) //eeprom参数区扇区地址
#if(MainFre_5M == D_sys_MainFre)
#define D_Cdelay_200us 20
#define D_Cdelay_1us 1 ////while p21翻转时测定 500k 2us 一个指令
#elif(MainFre_22M == D_sys_MainFre)
#define D_Cdelay_200us 20
#define D_Cdelay_1us 1 ////while p21翻转时测定 500k 2us 一个指令
#define D_Cdelay_1us 1 ////while p21翻转时测定 500k 2us 一个指令
#define L0_delay_1us() Lc_delay_nop(0) // 5个nop() 100ns 50个nop() 1us (20)=10us (2)1.5us
#define L0_delay_10us() Lc_delay_nop(4) // 5个nop() 100ns 50个nop() 1us (20)=10us (2)1.5us
#define L0_delay_40us() Lc_delay_nop(18) // 5个nop() 100ns 50个nop() 1us (20)=10us (2)1.5us
#elif(MainFre_27M == D_sys_MainFre)
#define D_Cdelay_200us 20
#define D_Cdelay_1us 1 ////while p21翻转时测定 500k 2us 一个指令
#else ///MainFre_11M
#define D_Cdelay_200us 20
#define D_Cdelay_1us 1 ////while p21翻转时测定 500k 2us 一个指令
#define L0_delay_1us() Lc_delay_nop(0) // 5个nop() 100ns 50个nop() 1us (20)=10us (2)1.5us
#define L0_delay_10us() Lc_delay_nop(4) // 5个nop() 100ns 50个nop() 1us (20)=10us (2)1.5us
#define L0_delay_40us() Lc_delay_nop(18) // 5个nop() 100ns 50个nop() 1us (20)=10us (2)1.5us
//xx
#endif//D_sys_MainFre)
#elif(TYPE_UASER_BOARD == TYPE_BOARD_433_0A)
xxx
#endif
//STEP 3 Register CONFIG >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
#if 0
序号 量程 系数
1 100kg 100%
2 200kg 100%
3 300kg 100%
4 400kg 100%
5 500kg 100%
6 600kg 100%
7 700kg 100%
8 800kg 100%
9 900kg 100%
10 1000kg 100%
#endif
#define ADC_status_chx_Ready_BASE 0x01
#define ADC_status_ch1_Ready 0x01
#define ADC_status_ch2_Ready 0x02
#define ADC_status_ch3_Ready 0x04
#define ADC_status_ch4_Ready 0x08
#define D_weight_show_limit_num 5
#define D_weight_std_num 10
typedef struct global_register
{
//RO Register
S16 reserved1;
S32 total_weight; //净重（显示重量）*100
S32 total_zweight; //皮重*100
//RW Register
S16 reserved2;
struct { //需要持久化的参数，不能超过72字节，否则会导致eeprom溢出
U16 reset; //reset标志，写入任何值，所有参数恢复初始值
U16 adc_ch_status;
S16 slaver_id;
S16 zero; //清0标志，写入任何值清0（去皮）
S16 weight_max; //量程
S16 lmd; //2mv/v
S16 cc_blur_ch_avg; //均值滤波点数
S16 cc_blur_ch_shift; //移位滤波点数
S16 cc_blur_all_shift0; //和值移位滤波点数1
S16 cc_blur_all_shift1; //和值移位滤波点数2
S16 cc_blur_all_out_d_threshold; //移位阈值1
S16 cc_blur_all_out_dd_threshold;//移位阈值2
struct{
S16 weight;
S16 times;
} weight_show_limit[D_weight_show_limit_num];
struct {
S16 weight_range; //量程 x 100
S16 ratio; //重量计算系数，默认100，保留两位小数，相当于x1
} weight_std[D_weight_std_num];
U16 baud_rate; //波特率
U16 stop_bits; //停止位
}p;
S16 reserved3;
}GlobalRegister;
//寄存器内存基地址
#define REG_MEM_BASE ((U16*)(&R)) //寄存器基础地址（本文件外部不应该使用该宏定义）
//变量地址转寄存器
#define MEM_2_REG(mem) (((U16*)(mem) - REG_MEM_BASE) + 1)
//寄存器转变量地址
#define REG_2_MEM(reg) (REG_MEM_BASE + (U16)((reg) - 1))
extern GlobalRegister R;
//Step4: IRQ Config
#if (TYPE_MCU == TYPE_MCU_STC_8A || TYPE_MCU == TYPE_MCU_STC_8F)
#define D_SERVE_INT0 interrupt 0
#define D_SERVE_TIMER0 interrupt 1
#define D_SERVE_INT1 interrupt 2
#define D_SERVE_TIMER1 interrupt 3
#define D_SERVE_UART interrupt 4
#define D_SERVE_ADC interrupt 5
#define D_SERVE_LVD interrupt 6
#define D_SERVE_PCA interrupt 7
#define D_SERVE_UART2 interrupt 8
#define D_SERVE_SPI interrupt 9
#define D_SERVE_INT2 interrupt 10
#define D_SERVE_INT3 interrupt 11
#define D_SERVE_TIMER2 interrupt 12
#define D_SERVE_INT4 interrupt 16
#define D_SERVE_UART3 interrupt 17
#define D_SERVE_UART4 interrupt 18
#define D_SERVE_TIMER3 interrupt 19
#define D_SERVE_TIMER4 interrupt 20
#define D_SERVE_CMP interrupt 21
#define D_SERVE_PWM interrupt 22
#define D_SERVE_PWMFD interrupt 23
#define D_SERVE_I2C interrupt 24
#endif
//======================================================== 以下为协议配置 ====================================================
#define D_CMD_Filter1_ff 0xFF
#define D_CMD_Filter2_fe 0xFE
#define D_HETU_FX_fi 0xF0
#define D_HETU_FX_MASK 0x0F
#define D_tp_handle_x_len 64
extern void L0_board_config(void);
extern void L0_reg_init(void);
#endif//_BSP_CONFIG_H
/*********************************end file*********************************************/

231
source/bsp/bsp_cs1232.c
View File

@ -0,0 +1,231 @@
////////////////////////////////////////////////////////////////////////////
///@copyright Copyright (c) 2020, 传控科技 All rights reserved.
///-------------------------------------------------------------------------
/// @file cs1232.h
/// @brief hard cs1232 include
/// @info FILE FOR HARDWARE cs1232
///-------------------------------------------------------------------------
//////////////////////////////////////////////////////////////////////////////
/// @version 1.0
/// @author CC
/// @date 20200530
/// @note
//////////////////////////////////////////////////////////////////////////////
#include "bsp_cs1232.h"
TSS_FLOW_ tss_ads;
//#define D_ADC_GATHER_Way1 1
u8 Read_byte_adcIC(void)
{
u8 i;
u8 rdata = 0; //初始化返回值为 0
for(i = 0; i < 8; i++)
{
D_ADC_SCLK1_ON();
rdata <<= 1; //返回值左移 1 位
/// CS1231_Clk(); //上升沿接收数据,下降沿更新数据
D_ADC_SCLK1_OFF();
if(D_ADC_DOUT1_AT())
{
rdata += 1; //若数据线上数据为 1，则返回值加 1
}
}
return(rdata);
}
void L0_ADS1213_INIT(void)
{
D_ADS1213_INIT();
L0_ADS1213_CH(D_ADCCH_1);
Lc_delay_ms(100);///57ms 建立时间
//L0_ADS1213_CH(D_ADCCH_3);
//Lc_delay_ms(100);///57ms 建立时间
}
void L0_ADS1213_CH(u8 ch)
{
/// /// SPEED = 1 57--57 ms 硬件配置成高电平
D_ADC_PDWN_OFF();
switch(ch)
{
case D_ADCCH_T:
L0_ADS1213_T(1);
break;
case D_ADCCH_1:
D_ADC_CS_A0_OFF();
break;
case D_ADCCH_2:
D_ADC_CS_A0_ON();
break;
case D_ADCCH_3:
//D_ADC_CS2_A0_OFF();
break;
case D_ADCCH_4:
//D_ADC_CS2_A0_ON();
break;
default:///
L0_ADS1213_T(0);
break;
};
Lc_delay_us(50);
D_ADC_PDWN_ON();
}
//channel-温度
void L0_ADS1213_T(u8 onff)
{
if(onff)
{
D_ADC_PDWN_OFF();
D_ADC_TEMP_ON();
Lc_delay_us(50);
D_ADC_PDWN_ON();
}
else
{
D_ADC_PDWN_OFF();
D_ADC_TEMP_OFF();
Lc_delay_us(50);
D_ADC_PDWN_ON();
}
}
void L0_2dc_SCLK(vtype ch,vtype onf)
{
switch (ch)
{
case D_ADCCH_1:
if(onf){D_ADC_SCLK1_ON();}else{D_ADC_SCLK1_OFF();}
break;
case D_ADCCH_2:
if(onf){D_ADC_SCLK2_ON();}else{D_ADC_SCLK2_OFF();}
break;
case D_ADCCH_3:
if(onf){D_ADC_SCLK3_ON();}else{D_ADC_SCLK3_OFF();}
break;
case D_ADCCH_4:
if(onf){D_ADC_SCLK4_ON();}else{D_ADC_SCLK4_OFF();}
break;
default:
break;
}
}
vtype L0_2dc_DOUT_AT(vtype ch)
{
vtype r = 9;
switch (ch)
{
case D_ADCCH_1:
r = D_ADC_DOUT1_AT();
break;
case D_ADCCH_2:
r = D_ADC_DOUT2_AT();
break;
case D_ADCCH_3:
r = D_ADC_DOUT3_AT();
break;
case D_ADCCH_4:
r = D_ADC_DOUT4_AT();
break;
default:
break;
}
return r;
}
vtype i; vU32 rdata = 0;
vS32 L0_ADS1231_readCH(vtype ch)
{
rdata = 0;
for(i = 0; i < 24; i++)
{
L0_2dc_SCLK(ch,1);/// D_ADC_SCLK1_ON();
rdata <<= 1;
L0_2dc_SCLK(ch,0);///D_ADC_SCLK1_OFF();
if(L0_2dc_DOUT_AT(ch))
{
rdata += 1;
}
}
///25 puls make DOUT high
L0_2dc_SCLK(ch,1);
if(rdata & 0x800000) //最高位为1，<0则
{
rdata |= 0xFF000000;
}
L0_2dc_SCLK(ch,0);
return rdata;
}
vS32 L0_ADS1231_read(U8 ch)
{
vU32 e = 0;u8 i;vS32 rdata = 0;
while(0 == L0_2dc_DOUT_AT(ch))
{
if(e ++ > 100000)
{
return 0;
}
}
e = 0;
while(1 == L0_2dc_DOUT_AT(ch))
{
if(e ++ > 100000)
{
return 0;
}
}
for(i = 0; i < 24; i++)
{
L0_2dc_SCLK(ch,1);
rdata <<= 1;
L0_2dc_SCLK(ch,0);
if(L0_2dc_DOUT_AT(ch))
{
rdata += 1;
}
}
if(rdata & 0x800000) //???λ?1??<0??
{
rdata |= 0xFF000000;
}
return rdata;
}
void L1_ADS1213_main(void)
{
U8 ch = D_ADCCH_4;
while(1)
{
while(1 == L0_2dc_DOUT_AT(ch))
;
tss_ads.u32_i = L0_ADS1231_readCH(ch);
tss_ads.u16_v = (vU16)( tss_ads.u32_i >> 16);
L0_uart0_ushex(tss_ads.u16_v);
tss_ads.u16_v = (vU16)(tss_ads.u32_i & 0x0000ffff);
L0_uart0_ushex(tss_ads.u16_v);//Lc_delay_us(500);
L0_uart0_uc(0x0d); L0_uart0_uc(0x0a);
}
}
/*********************************end file*********************************************/

229
source/bsp/bsp_cs1232.h
View File

@ -0,0 +1,229 @@
////////////////////////////////////////////////////////////////////////////
///@copyright Copyright (c) 2020, 传控科技 All rights reserved.
///-------------------------------------------------------------------------
/// @file cs1232.h
/// @brief hard cs1232 include
/// @info FILE FOR HARDWARE cs1232
///-------------------------------------------------------------------------
//////////////////////////////////////////////////////////////////////////////
/// @version 1.0
/// @author CC
/// @date 20200530
/// @note
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
#ifndef _BSP_cs1232_H
#define _BSP_cs1232_H
#include "../bsp/bsp_config.h"
#include "../msp/uart0.h"
#include "../ctask/task.h"
#define D_ADCCH_T 0
#define D_ADCCH_1 1
#define D_ADCCH_2 2
#define D_ADCCH_3 3
#define D_ADCCH_4 4
#define D_ADCCH_Toff 5
///数字部分需要有四个数据转换周期满足模拟输入信号的建立和滤波器的建立时间要求。芯
///片从外部差分输入信号切换到温度传感器、从温度传感器切换到外部差分输入信号，或通
///道间切换，到新的正确的数据到来都需要四个数据转换周期。整个建立过程如下图所示：
///A0/TEMP _______________/````````
///'DRDY/DOUT----------------/``\'
///改变 A0 或 TEMP 后的建立时间 40--50 us
//// 建立时间 ( 保持高电 平)
/// SPEED = 1 57--57 ms
/// SPEED = 0 407--407 ms
////值是在 fclk=4.9152MHz 时对应的值，不同的 fclk 频率，数值等比例变化
/// CS1232 在连续转换过程中，若外部差分输入信号发生突然变化，同样需要建立时间。突变
///的信号需要 4 个转换周期进行建立，第 5 个转换周期得到最终的 AD 值。图 7 描述突变信
///号建立的过程。若在建立的过程中，信号再发生突变，则忽略之前的建立，需要新的 4 个
///转换周期进行建立，之后紧接着的第 5 个转换周期得到最终的 AD 值。
/// 内部振荡器频率 4.6 5 5.4 MHz
/// 内置时钟温漂 250 ppm/℃----40``85 125*250= 31250 /1000000 = 0.03125 变化为3.125%
/// 电阻的2113温度系数值（TCR）的单位为PPM或者PPM/摄氏度5261。
/// 其含义为当温度上升或者下降1摄氏度时，电阻的41021653阻值的变化为百万分之几。
/// 例如15PPM 1kΩ的 0.1%精度的电阻，如下图。
/// 温漂的含义在这回里为，当温度上升或下降1摄氏度时，阻值上升或者降低，百万分之答15.
//// 温度系数：±ppm/℃，bai即单位温度引起的电阻值的变化。ppm（Part Per Million）表示百万分之几，
////比如：标称阻值为1k的电du阻，温度系数为±100ppm/℃，意为温度变化一摄zhi氏度，
///电阻值的变化为1k±0.1Ω，变化100℃，阻值变化为1k±10Ω，精度非常高了。
////电阻的温度系数精密级的在几十ppm，普通dao的是200～250ppm，最差的也不过500ppm。
#define D_adc_delay() Lc_delay_nop(2)
#define D_adc_delay2() Lc_delay_nop(1)
/**************
IO DEFINE PIN
P1.2 TEMP 1
P1.3 SCLK3 2
P1.4 DOUT1 3
P1.5 SCLK1 4
P1.6 DOUT2 5
P1.7 SCLK2 6
P5.4 PDWN 7
P5.5 CS_A0 9
P1.1 DOUT3 20
P1.0 LED1 19
P3.7 GAIN1 18
P3.6 GAIN0 17
P3.5 LED2 16
P3.4 DOUT4 15
P3.3 SCLK4 14
P3.2 485_RE 13
P3.1 TXD0 12
P3.0 RXD0 11
*****************/
#define D_ADC_DOUT1_INIT() ///D_P16_INIT()
#define D_ADC_SCLK1_INIT() ///D_P17_INIT()
#define D_ADC_CS_A0_INIT() ///D_P55_INIT()
#define D_ADC_DOUT1_AT() D_P14_AT()
#define D_ADC_DOUT1_ON() D_P14_ON()
#define D_ADC_SCLK1_ON() D_P15_ON();D_adc_delay2();
#define D_ADC_CS_A0_ON() D_P55_ON()
#define D_ADC_DOUT1_OFF() D_P14_OFF()
#define D_ADC_SCLK1_OFF() D_P15_OFF();D_adc_delay();
#define D_ADC_CS_A0_OFF() D_P55_OFF()
//#define D_ADC_CS2_A0_ON() D_P13_ON()
#define D_ADC_DOUT2_ON() D_P16_ON()
#define D_ADC_DOUT2_AT() D_P16_AT()
#define D_ADC_SCLK2_ON() D_P17_ON();D_adc_delay2();
//#define D_ADC_CS2_A0_INIT() ///D_P13_INIT()
#define D_ADC_DOUT2_INIT() ///D_P14_IN() ///D_P14_INIT()
#define D_ADC_SCLK2_INIT() ///D_P15_INIT()
//#define D_ADC_CS2_A0_OFF() D_P13_OFF()
#define D_ADC_DOUT2_OFF() D_P16_OFF()
#define D_ADC_SCLK2_OFF() D_P17_OFF();D_adc_delay();
#define D_ADC_DOUT3_INIT() ///D_P11_INIT()
#define D_ADC_SCLK3_INIT() ///D_P13_INIT()
#define D_ADC_DOUT3_AT() D_P11_AT()
#define D_ADC_DOUT3_ON() D_P11_ON()
#define D_ADC_SCLK3_ON() D_P13_ON();D_adc_delay2();
#define D_ADC_DOUT3_OFF() D_P11_OFF()
#define D_ADC_SCLK3_OFF() D_P13_OFF();D_adc_delay();
#define D_ADC_DOUT4_INIT() ///D_P34_INIT()
#define D_ADC_SCLK4_INIT() ///D_P33_INIT()
#define D_ADC_DOUT4_AT() D_P34_AT()
#define D_ADC_DOUT4_ON() D_P34_ON()
#define D_ADC_SCLK4_ON() D_P33_ON();D_adc_delay2();
#define D_ADC_DOUT4_OFF() D_P34_OFF()
#define D_ADC_SCLK4_OFF() D_P33_OFF();D_adc_delay();
#define D_ADC_TEMP_INIT() ///D_P12_INIT()
#define D_ADC_TEMP_ON() D_P12_ON()
#define D_ADC_TEMP_OFF() D_P12_OFF()
#define D_ADC_PDWN_INIT() ///D_P54_INIT()
#define D_ADC_PDWN_OFF() D_P54_OFF()
#define D_ADC_PDWN_ON() D_P54_ON()
#define D_ADC_GAIN1_INIT() ///D_P37_INIT()
#define D_ADC_GAIN0_INIT() ///D_P36_INIT()
#define D_ADC_GAIN1_OFF() D_P37_OFF()
#define D_ADC_GAIN0_OFF() D_P36_OFF()
#define D_ADC_GAIN1_ON() D_P37_ON()
#define D_ADC_GAIN0_ON() D_P36_ON()
// #define D_ADS1213_GAIN_VAL 1
// #define D_ADS1213_GAIN_VAL 2
//#define D_ADS1213_GAIN_VAL 64
#define D_ADS1213_GAIN_VAL 128
#if (D_ADS1213_GAIN_VAL == 128)
#define D_ADS1213_INIT() D_ADC_GAIN1_ON();D_ADC_GAIN0_ON();\
D_ADC_TEMP_OFF();\
D_ADC_CS_A0_ON();\
D_ADC_SCLK1_OFF();D_ADC_SCLK2_OFF();\
D_ADC_SCLK3_OFF();D_ADC_SCLK4_OFF();
#elif (D_ADS1213_GAIN_VAL == 64)
#define D_ADS1213_INIT() D_ADC_GAIN1_ON();D_ADC_GAIN0_OFF();\
D_ADC_TEMP_OFF();\
D_ADC_CS_A0_ON();\
D_ADC_SCLK1_OFF();D_ADC_SCLK2_OFF();\
D_ADC_SCLK3_OFF();D_ADC_SCLK4_OFF();
#elif (D_ADS1213_GAIN_VAL == 2)//浠呴檺U1ADS1232浣跨敤
xx
#define D_ADS1213_INIT() D_ADC_GAIN1_OFF();D_ADC_GAIN0_ON();\
D_ADC_TEMP_OFF();\
D_ADC_CS_A0_ON();D_ADC_CS2_A0_ON();\
D_ADC_SCLK1_OFF();D_ADC_SCLK2_OFF();
#elif (D_ADS1213_GAIN_VAL == 1)
xx
#define D_ADS1213_INIT() D_ADC_GAIN1_OFF();D_ADC_GAIN0_OFF();\
D_ADC_TEMP_OFF();\
D_ADC_CS_A0_ON();D_ADC_CS2_A0_ON();\
D_ADC_SCLK1_OFF();D_ADC_SCLK2_OFF();
#endif
extern void L0_ADS1213_INIT(void);
extern void L0_ADS1213_T(u8 onff);
extern void L0_ADS1213_CH(u8 ch);
//extern vS32 L0_ADS1213_read1(U8 *error);
//extern vS32 L0_ADS1213_read2(U8 *error);
//extern vS32 L0_ADS1213_read(U8 ch,U8 *error);
//extern U8 L0_ADS1213_is_low(U8 ch);
//extern U8 L0_ADS1213_is_high(U8 ch);
extern void L0_2dc_SCLK(vtype ch,vtype onf);
extern vtype L0_2dc_DOUT_AT(vtype ch);
extern vS32 L0_ADS1231_readCH(vtype ch);
extern vS32 L0_ADS1231_read(U8 ch);
typedef struct
{
TS_task task;
vU8 t_stamp;
vU16 t_stamp2;
vU16 wakeup_timer;
vU8 long_hit;
// vU8 first_run;
vU32 u32_i;//
vU32 u32_m;//
vU16 u16_v;//
// unsigned char status;//
// unsigned char key;//
}TSS_FLOW_;
extern TSS_FLOW_ tss_ads;
extern void L1_ADS1213_main(void);
#endif//_BSP_cs1232_H
/*********************************end file*********************************************/

14
source/bsp/bsp_debug.c
View File

@ -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"

36
source/bsp/bsp_debug.h
View File

@ -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

128
source/bsp/bsp_power.c
View File

@ -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

132
source/bsp/bsp_power.h
View File

@ -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

405
source/clib/bit.h
View File

@ -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__ */

1715
source/clib/clib.c
View File

File diff suppressed because it is too large

114
source/clib/clib.h
View File

@ -0,0 +1,114 @@
/*****************************************************************************
* uart.h: Header file for NXP LPC17xx Family Microprocessors
*
* Copyright(C) 2009, NXP Semiconductor
* All rights reserved.
*
* History
* 2009.05.27 ver 1.00 Prelimnary version, first Release
*
******************************************************************************/
#ifndef _CLIB_H_
#define _CLIB_H_
#include <stdarg.h>
#include <stdlib.h>
#include "../clib/type.h"
//#include "../clib/Clib.h"
//#include "../debug/debug_drv.h"
//extern char guc_send[128];
extern unsigned char code cguHex2Char[16][2];
typedef struct
{
vU16 up_point;
vU16 down_point;
}TS_up_down_p_;
extern U8 Lc_Hex2Char(U8 CharStr);
//extern void Lc_int2str(U32 ui_in,UN_TYPE len,UN_TYPE point,char *d);
// input: 123456d
// output: '1' '2' '3'....
//对应的点阵 为 0123456789. ，最后为空格，专为显示点阵类的数值使用
//extern void Lc_int2number(U32 ui_in,UN_TYPE len,UN_TYPE point,char *d);
//extern U32 L2_fun_number_show(int i,char str[4]);
#if 0
struct _s_temp_
{
U8 d[16];
};
extern struct _s_temp_ s_temp22;
extern U8 s_temp[16];
extern U32 ul2fun2[10];
extern void Lc_Byte_cp(BYTE *src,BYTE *dis, int len);
extern void L1_buf22ui(volatile BYTE in[],vU32 *ui_t2,vU32 *ui_t3);
extern void Lc_2ui2buf(vU32 ui_t2,vU32 ui_t3,volatile BYTE out[]);
extern void Lc_int2str_3(U32 ui_in,char *d);
extern U32 Lc_abs(vU32 a,vU32 b,vU32 *diff);
extern void Lc_int2str_4(U32 ui_in,char *d);
extern void Lc_sint2str_3(int i_in,char *d);
#define Lc_WEI(WEIx,WEIn) (U8)((WEIx/ul2fun2[WEIn])%10);
#define Lc_eee(WEIn) ul2fun2[WEIn]
#endif
extern char *Lc_int2a(vS32 value, char *string, UN_TYPE radix);
extern void Lc_int2D(vS16 value, char *string,char bits);
extern char *strstr(const char *str1, const char *str2);
extern unsigned char catch_protocol (const char d_src[],char d_protocol[]) ;
#define Lc_delay_1us() L0_delay_1us()
extern void Lc_delay_us(vU16 i);
extern void Lc_delay_ms(vU16 i);
extern void Lc_delay_nop(U8 i);
////////////////
extern void Lc_uc_hex(char ww);
extern void Lc_us_hex(U16 ww);
//extern void Lc_print(void (*L0pf_send_uc)(char ww), char *dat,...);
extern void Lc_print(char *dat4,...);
extern void Lc_print_NC(char *dat,...);
extern void Lc_print_buf(char *dat4,...);
extern void L3_us_big(U16 *d);
extern void L3_ui_big(vU32 *d);
extern void Lc_buf_copy_uc(U8 *d,const U8 *s,U16 num);
///void L2_line_algo_media(U8 *buf,vU16 len);
extern vU8 Lc_U8_media3(vU8 a,vU8 b,vU8 c);
extern vS32 Lc_S32_media3(vS32 a,vS32 b,vS32 c);
extern vS32 Lc_S32_media(vS32 val[],S16 num);
extern void Lc_array_sort(S32 arr[],int n);
/// 0x11 0x22 ---> 0x31 0x31 0x32 0x32 '1' '1' '2' '2'
extern void Lc_hex2ascii(U8 *buf,U16 len,U8 *ascii);
extern void crc16(unsigned char *CRC,void *dat,unsigned int len) reentrant;
//extern void crc16_irq(unsigned char *CRC,void *dat,unsigned int len);
extern int isBigEndianOrder(void);
extern U32 ntohl(U32 dat);
extern U32 htonl(U32 dat);
extern U16 ntohs(U16 dat);
extern U16 htons(U16 dat);
extern U32 Lc_abs(vS32 a,vS32 b);
extern void Lc_encrypt_id(U8 *enc_dst, U8 *enc_src, U32 enc_key, U8 src_len);
extern int libc_strlen(char *str);
#endif /* end __UART_H */
/*****************************************************************************
** End Of File
******************************************************************************/

317
source/clib/type.h
View File

@ -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 <stdint.h>
#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 <ctype.h>
#include <stdlib.h>
#include <setjmp.h>
//#include <rt_misc.h>
#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__ */

198
source/cpu/STARTUP.A51
View File

@ -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 <h> Power-On Initialization of Memory
;
; With the following EQU statements the initialization of memory
; at processor reset can be defined:
;
; <o> IDATALEN: IDATA memory size <0x0-0x100>
; <i> Note: The absolute start-address of IDATA memory is always 0
; <i> The IDATA space overlaps physically the DATA and BIT areas.
IDATALEN EQU 80H
;
; <o> XDATASTART: XDATA memory start address <0x0-0xFFFF>
; <i> The absolute start address of XDATA memory
XDATASTART EQU 0
;
; <o> XDATALEN: XDATA memory size <0x0-0xFFFF>
; <i> The length of XDATA memory in bytes.
XDATALEN EQU 2048
;
; <o> PDATASTART: PDATA memory start address <0x0-0xFFFF>
; <i> The absolute start address of PDATA memory
PDATASTART EQU 0H
;
; <o> PDATALEN: PDATA memory size <0x0-0xFF>
; <i> The length of PDATA memory in bytes.
PDATALEN EQU 0H
;
;</h>
;------------------------------------------------------------------------------
;
;<h> Reentrant Stack Initialization
;
; The following EQU statements define the stack pointer for reentrant
; functions and initialized it:
;
; <h> Stack Space for reentrant functions in the SMALL model.
; <q> IBPSTACK: Enable SMALL model reentrant stack
; <i> Stack space for reentrant functions in the SMALL model.
IBPSTACK EQU 0 ; set to 1 if small reentrant is used.
; <o> IBPSTACKTOP: End address of SMALL model stack <0x0-0xFF>
; <i> Set the top of the stack to the highest location.
IBPSTACKTOP EQU 0xFF +1 ; default 0FFH+1
; </h>
;
; <h> Stack Space for reentrant functions in the LARGE model.
; <q> XBPSTACK: Enable LARGE model reentrant stack
; <i> Stack space for reentrant functions in the LARGE model.
XBPSTACK EQU 1 ; set to 1 if large reentrant is used.
; <o> XBPSTACKTOP: End address of LARGE model stack <0x0-0xFFFF>
; <i> Set the top of the stack to the highest location.
XBPSTACKTOP EQU 0xFFFF +1 ; default 0FFFFH+1
; </h>
;
; <h> Stack Space for reentrant functions in the COMPACT model.
; <q> PBPSTACK: Enable COMPACT model reentrant stack
; <i> Stack space for reentrant functions in the COMPACT model.
PBPSTACK EQU 0 ; set to 1 if compact reentrant is used.
;
; <o> PBPSTACKTOP: End address of COMPACT model stack <0x0-0xFFFF>
; <i> Set the top of the stack to the highest location.
PBPSTACKTOP EQU 0xFF +1 ; default 0FFH+1
; </h>
;</h>
;------------------------------------------------------------------------------
;
; Memory Page for Using the Compact Model with 64 KByte xdata RAM
; <e>Compact Model Page Definition
;
; <i>Define the XDATA page used for PDATA variables.
; <i>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.
;
; <o> PPAGE number <0x0-0xFF>
; <i> uppermost 256-byte address of the page used for PDATA variables.
PPAGE EQU 0
;
; <o> SFR address which supplies uppermost address byte <0x0-0xFF>
; <i> most 8051 variants use P2 as uppermost address byte
PPAGE_SFR DATA 0A0H
;
; </e>
;------------------------------------------------------------------------------
; 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
;<h> Code Banking
; <q> Select Bank 0 for L51_BANK.A51 Mode 4
#if 0
; <i> 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
;</h>
LJMP ?C_START
END

589
source/cpu/STC_stc8a8k.H
View File

@ -0,0 +1,589 @@
#ifndef __STC_stc8a8k_H_
#define __STC_stc8a8k_H_
// STC_stc8a8k.h
#include<intrins.h>
/////////////////////////////////////////////////
//注意: STC15W4K32S4系列的芯片,上电后所有与PWM相关的IO口均为
// 高阻态,需将这些口设置为准双向口或强推挽模式方可正常使用
//相关IO: P0.6/P0.7/P1.6/P1.7/P2.1/P2.2
// P2.3/P2.7/P3.7/P4.2/P4.4/P4.5
/////////////////////////////////////////////////
/////////////////////////////////////////////////
//包含本头文件后,不用另外再包含"REG51.H"
//内核特殊功能寄存器 // 复位值 描述
sfr ACC = 0xE0; //0000,0000 累加器Accumulator
sfr B = 0xF0; //0000,0000 B寄存器
sfr PSW = 0xD0; //0000,0000 程序状态字
sbit CY = PSW^7;
sbit AC = PSW^6;
sbit F0 = PSW^5;
sbit RS1 = PSW^4;
sbit RS0 = PSW^3;
sbit OV = PSW^2;
sbit P = PSW^0;
sfr SP = 0x81; //0000,0111 堆栈指针
sfr DPL = 0x82; //0000,0000 数据指针低字节
sfr DPH = 0x83; //0000,0000 数据指针高字节
//I/O 口特殊功能寄存器
sfr P0 = 0x80; //1111,1111 端口0
sbit P00 = P0^0;
sbit P01 = P0^1;
sbit P02 = P0^2;
sbit P03 = P0^3;
sbit P04 = P0^4;
sbit P05 = P0^5;
sbit P06 = P0^6;
sbit P07 = P0^7;
sfr P1 = 0x90; //1111,1111 端口1
sbit P10 = P1^0;
sbit P11 = P1^1;
sbit P12 = P1^2;
sbit P13 = P1^3;
sbit P14 = P1^4;
sbit P15 = P1^5;
sbit P16 = P1^6;
sbit P17 = P1^7;
sfr P2 = 0xA0; //1111,1111 端口2
sbit P20 = P2^0;
sbit P21 = P2^1;
sbit P22 = P2^2;
sbit P23 = P2^3;
sbit P24 = P2^4;
sbit P25 = P2^5;
sbit P26 = P2^6;
sbit P27 = P2^7;
sfr P3 = 0xB0; //1111,1111 端口3
sbit P30 = P3^0;
sbit P31 = P3^1;
sbit P32 = P3^2;
sbit P33 = P3^3;
sbit P34 = P3^4;
sbit P35 = P3^5;
sbit P36 = P3^6;
sbit P37 = P3^7;
sfr P4 = 0xC0; //1111,1111 端口4
sbit P40 = P4^0;
sbit P41 = P4^1;
sbit P42 = P4^2;
sbit P43 = P4^3;
sbit P44 = P4^4;
sbit P45 = P4^5;
sbit P46 = P4^6;
sbit P47 = P4^7;
sfr P5 = 0xC8; //xxxx,1111 端口5
sbit P50 = P5^0;
sbit P51 = P5^1;
sbit P52 = P5^2;
sbit P53 = P5^3;
sbit P54 = P5^4;
sbit P55 = P5^5;
sbit P56 = P5^6;
sbit P57 = P5^7;
sfr P6 = 0xE8; //0000,0000 端口6
sbit P60 = P6^0;
sbit P61 = P6^1;
sbit P62 = P6^2;
sbit P63 = P6^3;
sbit P64 = P6^4;
sbit P65 = P6^5;
sbit P66 = P6^6;
sbit P67 = P6^7;
sfr P7 = 0xF8; //0000,0000 端口7
sbit P70 = P7^0;
sbit P71 = P7^1;
sbit P72 = P7^2;
sbit P73 = P7^3;
sbit P74 = P7^4;
sbit P75 = P7^5;
sbit P76 = P7^6;
sbit P77 = P7^7;
///00 准双向口 灌电流20mA 拉电流270-150uS
///01 推挽输出 20mA 加限流
///10 高阻
///11 开漏 open-Drain 内部上拉电阻断开 开漏模式既可以度外部状态也可以对外输出高低电平
sfr P0M0 = 0x94; //0000,0000 端口0模式寄存器0
sfr P0M1 = 0x93; //0000,0000 端口0模式寄存器1
sfr P1M0 = 0x92; //0000,0000 端口1模式寄存器0
sfr P1M1 = 0x91; //0000,0000 端口1模式寄存器1
sfr P2M0 = 0x96; //0000,0000 端口2模式寄存器0
sfr P2M1 = 0x95; //0000,0000 端口2模式寄存器1
sfr P3M0 = 0xB2; //0000,0000 端口3模式寄存器0
sfr P3M1 = 0xB1; //0000,0000 端口3模式寄存器1
sfr P4M0 = 0xB4; //0000,0000 端口4模式寄存器0
sfr P4M1 = 0xB3; //0000,0000 端口4模式寄存器1
sfr P5M0 = 0xCA; //0000,0000 端口5模式寄存器0
sfr P5M1 = 0xC9; //0000,0000 端口5模式寄存器1
sfr P6M0 = 0xCC; //0000,0000 端口6模式寄存器0
sfr P6M1 = 0xCB; //0000,0000 端口6模式寄存器1
sfr P7M0 = 0xE2; //0000,0000 端口7模式寄存器0
sfr P7M1 = 0xE1; //0000,0000 端口7模式寄存器1
//系统管理特殊功能寄存器
sfr PCON = 0x87; //0001,0000 电源控制寄存器
sfr AUXR = 0x8E; //0000,0000 辅助寄存器
#define TOx12 BITN7
#define T1x12 BITN6
#define UART_M0x6 BITN5 //串口1模式0速度 =0 12倍 = 1 两倍
#define T2R BITN4 //定时器2 运行 =1
#define T2_C BITN3 //定时器/计数器选择
#define T2x12 BITN2
#define EXTRAM BITN1
#define S1ST2 BITN0 //串口1选择定时器1 =0 选择定时器2 =1
sfr AUXR1 = 0xA2; //0000,0000 辅助寄存器1
sfr P_SW1 = 0xA2; //0000,0000 外设端口切换寄存器1
sfr CLK_DIV = 0x97; //0000,0000 时钟分频控制寄存器
sfr BUS_SPEED = 0xA1; //xx10,x011 总线速度控制寄存器
sfr P1ASF = 0x9D; //0000,0000 端口1模拟功能配置寄存器
//-----------------------------------------------------------------
sfr P_SW2 = 0xBA; //0xxx,x000 外设端口切换寄存器
#define EAXFR BITN7
#define I2C_S1 BITN5
#define I2C_S2 BITN4
#define CMPO_S BITN3
#define S4_S BITN2
#define S3_S BITN1
#define S2_S BITN0
//-----------------------------------------------------------------
//中断特殊功能寄存器
sfr IE = 0xA8; //0000,0000 中断控制寄存器
sbit EA = IE^7;
sbit ELVD = IE^6;
sbit EADC = IE^5;
sbit ES = IE^4;
sbit ET1 = IE^3;
sbit EX1 = IE^2;
sbit ET0 = IE^1;
sbit EX0 = IE^0;
sfr IP = 0xB8; //0000,0000 中断优先级寄存器
sbit PPCA = IP^7;
sbit PLVD = IP^6;
sbit PADC = IP^5;
sbit PS = IP^4;
sbit PT1 = IP^3;
sbit PX1 = IP^2;
sbit PT0 = IP^1;
sbit PX0 = IP^0;
sfr IE2 = 0xAF; //0000,0000 中断控制寄存器2
/// 不可位寻址
#define ET4 BITN6
#define ET3 BITN5
#define ES4 BITN4
#define ES3 BITN3
#define ET2 BITN2
#define ESPI BITN1
#define ES2 BITN0
sfr IP2 = 0xB5; //xxxx,xx00 中断优先级寄存器2
sfr INT_CLKO = 0x8F; //0000,0000 外部中断与时钟输出控制寄存器
//定时器特殊功能寄存器
sfr TCON = 0x88; //0000,0000 T0/T1控制寄存器
sbit TF1 = TCON^7;
sbit TR1 = TCON^6;
sbit TF0 = TCON^5;
sbit TR0 = TCON^4;
sbit IE1 = TCON^3;
sbit IT1 = TCON^2;
sbit IE0 = TCON^1;
sbit IT0 = TCON^0;
sfr TMOD = 0x89; //0000,0000 T0/T1模式寄存器
sfr TL0 = 0x8A; //0000,0000 T0低字节
sfr TL1 = 0x8B; //0000,0000 T1低字节
sfr TH0 = 0x8C; //0000,0000 T0高字节
sfr TH1 = 0x8D; //0000,0000 T1高字节
sfr T4T3M = 0xD1; //0000,0000 T3/T4模式寄存器
sfr T3T4M = 0xD1; //0000,0000 T3/T4模式寄存器
sfr T4H = 0xD2; //0000,0000 T4高字节
sfr T4L = 0xD3; //0000,0000 T4低字节
sfr T3H = 0xD4; //0000,0000 T3高字节
sfr T3L = 0xD5; //0000,0000 T3低字节
sfr T2H = 0xD6; //0000,0000 T2高字节
sfr T2L = 0xD7; //0000,0000 T2低字节
sfr WKTCL = 0xAA; //0000,0000 掉电唤醒定时器低字节
sfr WKTCH = 0xAB; //0000,0000 掉电唤醒定时器高字节
sfr WDT_CONTR = 0xC1; //0000,0000 看门狗控制寄存器
//串行口特殊功能寄存器
sfr SCON = 0x98; //0000,0000 串口1控制寄存器
sbit SM0 = SCON^7;
sbit SM1 = SCON^6;
sbit SM2 = SCON^5;
sbit REN = SCON^4;
sbit TB8 = SCON^3;
sbit RB8 = SCON^2;
sbit TI = SCON^1;
sbit RI = SCON^0;
//sfr SBUF = 0x99; //xxxx,xxxx 串口1数据寄存器
//sfr S2CON = 0x9A; //0000,0000 串口2控制寄存器
//sfr S2BUF = 0x9B; //xxxx,xxxx 串口2数据寄存器
//sfr SADDR = 0xA9; //0000,0000 从机地址寄存器
//sfr SADEN = 0xB9; //0000,0000 从机地址屏蔽寄存器
sfr SBUF = 0x99; //Serial Data Buffer
sfr SBUF0 = 0x99; //Serial Data Buffer xxxx,xxxx
sfr SADEN = 0xB9; //Slave Address Mask 0000,0000
sfr SADDR = 0xA9; //Slave Address 0000,0000
//-----------------------------------
// 7 6 5 4 3 2 1 0 Reset Value
sfr S2CON = 0x9A; //S2 Control S2SM0 S2SM1 S2SM2 S2REN S2TB8 S2RB8 S2TI S2RI 00000000B
#define S2SM0 BITN7
#define S2ST4 BITN6
#define S2SM2 BITN5
#define S2REN BITN4
#define S2TB8 BITN3
#define S2RB8 BITN2
#define S2TI BITN1
#define S2RI BITN0
sfr S2BUF = 0x9B; //S2 Serial Buffer xxxx,xxxx
//sfr BRT = 0x9C; //S2 Baud-Rate Timer 0000,0000
//---------------------------------------------------------------
sfr S3CON = 0xAC; //0000,0000 串口3控制寄存器
#define S3SM0 BITN7
#define S3ST4 BITN6
#define S3SM2 BITN5
#define S3REN BITN4
#define S3TB8 BITN3
#define S3RB8 BITN2
#define S3TI BITN1
#define S3RI BITN0
sfr S3BUF = 0xAD; //xxxx,xxxx 串口3数据寄存器
//---------------------------------------------------------------
sfr S4CON = 0x84; //0000,0000 串口4控制寄存器
#define S4SM0 BITN7
#define S4ST4 BITN6
#define S4SM2 BITN5
#define S4REN BITN4
#define S4TB8 BITN3
#define S4RB8 BITN2
#define S4TI BITN1
#define S4RI BITN0
sfr S4BUF = 0x85; //xxxx,xxxx 串口4数据寄存器
//ADC 特殊功能寄存器
sfr ADC_CONTR = 0xBC; //0000,0000 A/D转换控制寄存器
sfr ADC_RES = 0xBD; //0000,0000 A/D转换结果高8位
sfr ADC_RESL = 0xBE; //0000,0000 A/D转换结果低2位
//SPI 特殊功能寄存器
sfr SPSTAT = 0xCD; //00xx,xxxx SPI状态寄存器
sfr SPCTL = 0xCE; //0000,0100 SPI控制寄存器
sfr SPDAT = 0xCF; //0000,0000 SPI数据寄存器
//IAP/ISP 特殊功能寄存器
sfr IAP_DATA = 0xC2; //0000,0000 EEPROM数据寄存器
sfr IAP_ADDRH = 0xC3; //0000,0000 EEPROM地址高字节
sfr IAP_ADDRL = 0xC4; //0000,0000 EEPROM地址第字节
sfr IAP_CMD = 0xC5; //xxxx,xx00 EEPROM命令寄存器
sfr IAP_TRIG = 0xC6; //0000,0000 EEPRPM命令触发寄存器
sfr IAP_CONTR = 0xC7; //0000,x000 EEPROM控制寄存器
//PCA/PWM 特殊功能寄存器
sfr CCON = 0xD8; //00xx,xx00 PCA控制寄存器
sbit CF = CCON^7;
sbit CR = CCON^6;
sbit CCF2 = CCON^2;
sbit CCF1 = CCON^1;
sbit CCF0 = CCON^0;
sfr CMOD = 0xD9; //0xxx,x000 PCA 工作模式寄存器
sfr CL = 0xE9; //0000,0000 PCA计数器低字节
sfr CH = 0xF9; //0000,0000 PCA计数器高字节
sfr CCAPM0 = 0xDA; //0000,0000 PCA模块0的PWM寄存器
sfr CCAPM1 = 0xDB; //0000,0000 PCA模块1的PWM寄存器
sfr CCAPM2 = 0xDC; //0000,0000 PCA模块2的PWM 寄存器
sfr CCAP0L = 0xEA; //0000,0000 PCA模块0的捕捉/比较寄存器低字节
sfr CCAP1L = 0xEB; //0000,0000 PCA模块1的捕捉/比较寄存器低字节
sfr CCAP2L = 0xEC; //0000,0000 PCA模块2的捕捉/比较寄存器低字节
sfr PCA_PWM0 = 0xF2; //xxxx,xx00 PCA模块0的PWM寄存器
sfr PCA_PWM1 = 0xF3; //xxxx,xx00 PCA模块1的PWM寄存器
sfr PCA_PWM2 = 0xF4; //xxxx,xx00 PCA模块1的PWM寄存器
sfr CCAP0H = 0xFA; //0000,0000 PCA模块0的捕捉/比较寄存器高字节
sfr CCAP1H = 0xFB; //0000,0000 PCA模块1的捕捉/比较寄存器高字节
sfr CCAP2H = 0xFC; //0000,0000 PCA模块2的捕捉/比较寄存器高字节
//比较器特殊功能寄存器
sfr CMPCR1 = 0xE6; //0000,0000 比较器控制寄存器1
sfr CMPCR2 = 0xE7; //0000,0000 比较器控制寄存器2
//sfr P_SW2 = 0xba;
sfr PWMCFG = 0xf1;
sfr PWMIF = 0xf6;
sfr PWMFDCR = 0xf7;
sfr PWMCR = 0xfe;
#define PWMC (*(unsigned int volatile xdata *)0xfff0)
#define PWMCKS (*(unsigned char volatile xdata *)0xfff2)
#define TADCP (*(unsigned int volatile xdata *)0xfff3)
#define PWM0T1 (*(unsigned int volatile xdata *)0xff00)
#define PWM0T2 (*(unsigned int volatile xdata *)0xff02)
#define PWM0CR (*(unsigned char volatile xdata *)0xff04)
#define PWM0HLD (*(unsigned char volatile xdata *)0xff05)
#define PWM1T1 (*(unsigned int volatile xdata *)0xff10)
#define PWM1T2 (*(unsigned int volatile xdata *)0xff12)
#define PWM1CR (*(unsigned char volatile xdata *)0xff14)
#define PWM1HLD (*(unsigned char volatile xdata *)0xff15)
#define PWM2T1 (*(unsigned int volatile xdata *)0xff20)
#define PWM2T2 (*(unsigned int volatile xdata *)0xff22)
#define PWM2CR (*(unsigned char volatile xdata *)0xff24)
#define PWM2HLD (*(unsigned char volatile xdata *)0xff25)
#define PWM3T1 (*(unsigned int volatile xdata *)0xff30)
#define PWM3T2 (*(unsigned int volatile xdata *)0xff32)
#define PWM3CR (*(unsigned char volatile xdata *)0xff34)
#define PWM3HLD (*(unsigned char volatile xdata *)0xff35)
#define PWM4T1 (*(unsigned int volatile xdata *)0xff40)
#define PWM4T2 (*(unsigned int volatile xdata *)0xff42)
#define PWM4CR (*(unsigned char volatile xdata *)0xff44)
#define PWM4HLD (*(unsigned char volatile xdata *)0xff45)
#define PWM5T1 (*(unsigned int volatile xdata *)0xff50)
#define PWM5T2 (*(unsigned int volatile xdata *)0xff52)
#define PWM5CR (*(unsigned char volatile xdata *)0xff54)
#define PWM5HLD (*(unsigned char volatile xdata *)0xff55)
#define PWM6T1 (*(unsigned int volatile xdata *)0xff60)
#define PWM6T2 (*(unsigned int volatile xdata *)0xff62)
#define PWM6CR (*(unsigned char volatile xdata *)0xff64)
#define PWM6HLD (*(unsigned char volatile xdata *)0xff65)
#define PWM7T1 (*(unsigned int volatile xdata *)0xff70)
#define PWM7T2 (*(unsigned int volatile xdata *)0xff72)
#define PWM7CR (*(unsigned char volatile xdata *)0xff74)
#define PWM7HLD (*(unsigned char volatile xdata *)0xff75)
#define CKSEL (*(unsigned char volatile xdata *)0xfE00)//108@ST8.PDF
#define MCLKODIV BIT4
#define MCLKO_S BITN3
#define MCLKSEL BIT0
#define CLKDIV (*(unsigned char volatile xdata *)0xfE01)//108@ST8.PDF
#define IRC24MCR (*(unsigned char volatile xdata *)0xfE02)//108@ST8.PDF
#define XOSCCR (*(unsigned char volatile xdata *)0xfE03)//108@ST8.PDF
#define IRC32KCR (*(unsigned char volatile xdata *)0xfE04)//108@ST8.PDF
/////////////////////////////////////////////////
/* P3 */
sbit RD = 0xB7;
sbit WR = 0xB6;
sbit T1 = 0xB5;
sbit T0 = 0xB4;
sbit INT1 = 0xB3;
sbit INT0 = 0xB2;
sbit TXD = 0xB1;
sbit RXD = 0xB0;
#if 0
/// >>>>> add by cc
//sbit P34=P3^4; //定义SDA数据线
//sbit P35=P3^5; //定义SCL时钟线
#define mBIT_1(X,N) X|= (1<<N)
#define mBIT_0(X,N) X&=~(1<<N)
#define mBIT_G(X,N) (X&(1<<N))
/// add by cc 20181118
#define D_IO_normal_P0(n); mBIT_0(P0M1,n);mBIT_0(P0M0,n);
#define D_IO_normal_P1(n); mBIT_0(P1M1,n);mBIT_0(P1M0,n);
#define D_IO_normal_P2(n); mBIT_0(P2M1,n);mBIT_0(P2M0,n);
#define D_IO_normal_P3(n); mBIT_0(P3M1,n);mBIT_0(P3M0,n);
#define D_IO_HighOut_P0(n); mBIT_0(P0M1,n);mBIT_1(P0M0,n);
#define D_IO_HighOut_P1(n); mBIT_0(P1M1,n);mBIT_1(P1M0,n);
#define D_IO_HighOut_P2(n); mBIT_0(P2M1,n);mBIT_1(P2M0,n);
#define D_IO_HighOut_P3(n); mBIT_0(P3M1,n);mBIT_1(P3M0,n);
//高阻状态
#define D_IO_HighR_P0(n); mBIT_1(P0M1,n);mBIT_0(P0M0,n);
#define D_IO_HighR_P1(n); mBIT_1(P1M1,n);mBIT_0(P1M0,n);
#define D_IO_HighR_P2(n); mBIT_1(P2M1,n);mBIT_0(P2M0,n);
#define D_IO_HighR_P3(n); mBIT_1(P3M1,n);mBIT_0(P3M0,n);
#define D_IO_OpenDrain_P0(n); mBIT_1(P0M1,n);mBIT_1(P0M0,n);
#define D_IO_OpenDrain_P1(n); mBIT_1(P1M1,n);mBIT_1(P1M0,n);
#define D_IO_OpenDrain_P2(n); mBIT_1(P2M1,n);mBIT_1(P2M0,n);
#define D_IO_OpenDrain_P3(n); mBIT_1(P3M1,n);mBIT_1(P3M0,n);
//高阻状态
#define P0_conf_in(n) mBIT_1(P0M1,n);mBIT_0(P0M0,n);
#define P1_conf_in(n) mBIT_1(P1M1,n);mBIT_0(P1M0,n);
#define P2_conf_in(n) mBIT_1(P2M1,n);mBIT_0(P2M0,n);
#define P2_conf_port(n) mBIT_0(P2M1,n);mBIT_0(P2M0,n);
#define P3_conf_in(n) mBIT_1(P3M1,n);mBIT_0(P3M0,n);
#define P3_conf_port(n) mBIT_0(P3M1,n);mBIT_0(P3M0,n);
#define P4_conf_in(n) mBIT_1(P4M1,n);mBIT_0(P4M0,n);
#define P5_conf_in(n) mBIT_1(P5M1,n);mBIT_0(P5M0,n);
#define NOP() _nop_()
//added by cc
#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;
//// n: BITN0---BITN7
#define D_stdIO_P0(BITN) BITN_0(P0M1,BITN);BITN_0(P0M0,BITN); //////00 准双向口 灌电流20mA 拉电流270-150uS
#define D_HighI_P0(BITN) BITN_0(P0M1,BITN);BITN_1(P0M0,BITN); //////01 推挽输出 20mA 加限流
#define D_HighR_P0(BITN) BITN_1(P0M1,BITN);BITN_0(P0M0,BITN); /////////10 高阻
#define D_OpenD_P0(BITN) BITN_1(P0M1,BITN);BITN_1(P0M0,BITN); /////11 开漏 open-Drain 内部上拉电阻断开 开漏模式既可以度外部状态也可以对外输出高低电平
#define D_stdIO_P1(BITN) BITN_0(P1M1,BITN);BITN_0(P1M0,BITN); //////00 准双向口 灌电流20mA 拉电流270-150uS
#define D_HighI_P1(BITN) BITN_0(P1M1,BITN);BITN_1(P1M0,BITN); //////01 推挽输出 20mA 加限流
#define D_HighR_P1(BITN) BITN_1(P1M1,BITN);BITN_0(P1M0,BITN); /////////10 高阻
#define D_OpenD_P1(BITN) BITN_1(P1M1,BITN);BITN_1(P1M0,BITN); /////11 开漏 open-Drain 内部上拉电阻断开 开漏模式既可以度外部状态也可以对外输出高低电平
#define D_stdIO_P2(BITN) BITN_0(P2M1,BITN);BITN_0(P2M0,BITN); //////00 准双向口 灌电流20mA 拉电流270-150uS
#define D_HighI_P2(BITN) BITN_0(P2M1,BITN);BITN_1(P2M0,BITN); //////01 推挽输出 20mA 加限流
#define D_HighR_P2(BITN) BITN_1(P2M1,BITN);BITN_0(P2M0,BITN); /////////10 高阻
#define D_OpenD_P2(BITN) BITN_1(P2M1,BITN);BITN_1(P2M0,BITN); /////11 开漏 open-Drain 内部上拉电阻断开 开漏模式既可以度外部状态也可以对外输出高低电平
#define D_stdIO_P3(BITN) BITN_0(P3M1,BITN);BITN_0(P3M0,BITN); //////00 准双向口 灌电流20mA 拉电流270-150uS
#define D_HighI_P3(BITN) BITN_0(P3M1,BITN);BITN_1(P3M0,BITN); //////01 推挽输出 20mA 加限流
#define D_HighR_P3(BITN) BITN_1(P3M1,BITN);BITN_0(P3M0,BITN); /////////10 高阻
#define D_OpenD_P3(BITN) BITN_1(P3M1,BITN);BITN_1(P3M0,BITN); /////11 开漏 open-Drain 内部上拉电阻断开 开漏模式既可以度外部状态也可以对外输出高低电平
#define D_stdIO_P4(BITN) BITN_0(P4M1,BITN);BITN_0(P4M0,BITN); //////00 准双向口 灌电流20mA 拉电流270-150uS
#define D_HighI_P4(BITN) BITN_0(P4M1,BITN);BITN_1(P4M0,BITN); //////01 推挽输出 20mA 加限流
#define D_HighR_P4(BITN) BITN_1(P4M1,BITN);BITN_0(P4M0,BITN); /////////10 高阻
#define D_OpenD_P4(BITN) BITN_1(P4M1,BITN);BITN_1(P4M0,BITN); /////11 开漏 open-Drain 内部上拉电阻断开 开漏模式既可以度外部状态也可以对外输出高低电平
#define D_stdIO_P5(BITN) BITN_0(P5M1,BITN);BITN_0(P5M0,BITN); //////00 准双向口 灌电流20mA 拉电流270-150uS
#define D_HighI_P5(BITN) BITN_0(P5M1,BITN);BITN_1(P5M0,BITN); //////01 推挽输出 20mA 加限流
#define D_HighR_P5(BITN) BITN_1(P5M1,BITN);BITN_0(P5M0,BITN); /////////10 高阻
#define D_OpenD_P5(BITN) BITN_1(P5M1,BITN);BITN_1(P5M0,BITN); /////11 开漏 open-Drain 内部上拉电阻断开 开漏模式既可以度外部状态也可以对外输出高低电平
#define D_stdIO_P6(BITN) BITN_0(P6M1,BITN);BITN_0(P6M0,BITN); //////00 准双向口 灌电流20mA 拉电流270-150uS
#define D_HighI_P6(BITN) BITN_0(P6M1,BITN);BITN_1(P6M0,BITN); //////01 推挽输出 20mA 加限流
#define D_HighR_P6(BITN) BITN_1(P6M1,BITN);BITN_0(P6M0,BITN); /////////10 高阻
#define D_OpenD_P6(BITN) BITN_1(P6M1,BITN);BITN_1(P6M0,BITN); /////11 开漏 open-Drain 内部上拉电阻断开 开漏模式既可以度外部状态也可以对外输出高低电平
#define D_stdIO_P7(BITN) BITN_0(P7M1,BITN);BITN_0(P7M0,BITN); //////00 准双向口 灌电流20mA 拉电流270-150uS
#define D_HighI_P7(BITN) BITN_0(P7M1,BITN);BITN_1(P7M0,BITN); //////01 推挽输出 20mA 加限流
#define D_HighR_P7(BITN) BITN_1(P7M1,BITN);BITN_0(P7M0,BITN); /////////10 高阻
#define D_OpenD_P7(BITN) BITN_1(P7M1,BITN);BITN_1(P7M0,BITN); /////11 开漏 open-Drain 内部上拉电阻断开 开漏模式既可以度外部状态也可以对外输出高低电平
#endif
/***
#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 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

384
source/cpu/stc_macro.H
View File

@ -0,0 +1,384 @@
//////////////////////////////////////////////////////////////////////////
/// 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 __STC_MACRO_H_
#define __STC_MACRO_H_
#include<intrins.h>
#include "../clib/bit.h"
#define NOP() _nop_()
#define D_P07_ON() P07 = 1
#define D_P06_ON() P06 = 1
#define D_P05_ON() P05 = 1
#define D_P04_ON() P04 = 1
#define D_P03_ON() P03 = 1
#define D_P02_ON() P02 = 1
#define D_P01_ON() P01 = 1
#define D_P00_ON() P00 = 1
#define D_P07_OFF() P07 = 0
#define D_P06_OFF() P06 = 0
#define D_P05_OFF() P05 = 0
#define D_P04_OFF() P04 = 0
#define D_P03_OFF() P03 = 0
#define D_P02_OFF() P02 = 0
#define D_P01_OFF() P01 = 0
#define D_P00_OFF() P00 = 0
#define D_P07_AT() (P07)
#define D_P06_AT() (P06)
#define D_P05_AT() (P05)
#define D_P04_AT() (P04)
#define D_P03_AT() (P03)
#define D_P02_AT() (P02)
#define D_P01_AT() (P01)
#define D_P00_AT() (P00)
#define D_P07_REV() P07 = ~P07
#define D_P06_REV() P06 = ~P06
#define D_P05_REV() P05 = ~P05
#define D_P04_REV() P04 = ~P04
#define D_P03_REV() P03 = ~P03
#define D_P02_REV() P02 = ~P02
#define D_P01_REV() P01 = ~P01
#define D_P00_REV() P00 = ~P00
#define D_P17_ON() P17 = 1
#define D_P16_ON() P16 = 1
#define D_P15_ON() P15 = 1
#define D_P14_ON() P14 = 1
#define D_P13_ON() P13 = 1
#define D_P12_ON() P12 = 1
#define D_P11_ON() P11 = 1
#define D_P10_ON() P10 = 1
#define D_P17_OFF() P17 = 0
#define D_P16_OFF() P16 = 0
#define D_P15_OFF() P15 = 0
#define D_P14_OFF() P14 = 0
#define D_P13_OFF() P13 = 0
#define D_P12_OFF() P12 = 0
#define D_P11_OFF() P11 = 0
#define D_P10_OFF() P10 = 0
#define D_P17_AT() (P17)
#define D_P16_AT() (P16)
#define D_P15_AT() (P15)
#define D_P14_AT() (P14)
#define D_P13_AT() (P13)
#define D_P12_AT() (P12)
#define D_P11_AT() (P11)
#define D_P10_AT() (P10)
#define D_P17_REV() P17 = ~P17
#define D_P16_REV() P16 = ~P16
#define D_P15_REV() P15 = ~P15
#define D_P14_REV() P14 = ~P14
#define D_P13_REV() P13 = ~P13
#define D_P12_REV() P12 = ~P12
#define D_P11_REV() P11 = ~P11
#define D_P10_REV() P10 = ~P10
#define D_P27_ON() P27 = 1
#define D_P26_ON() P26 = 1
#define D_P25_ON() P25 = 1
#define D_P24_ON() P24 = 1
#define D_P23_ON() P23 = 1
#define D_P22_ON() P22 = 1
#define D_P21_ON() P21 = 1
#define D_P20_ON() P20 = 1
#define D_P27_OFF() P27 = 0
#define D_P26_OFF() P26 = 0
#define D_P25_OFF() P25 = 0
#define D_P24_OFF() P24 = 0
#define D_P23_OFF() P23 = 0
#define D_P22_OFF() P22 = 0
#define D_P21_OFF() P21 = 0
#define D_P20_OFF() P20 = 0
#define D_P27_AT() (P27)
#define D_P26_AT() (P26)
#define D_P25_AT() (P25)
#define D_P24_AT() (P24)
#define D_P23_AT() (P23)
#define D_P22_AT() (P22)
#define D_P21_AT() (P21)
#define D_P20_AT() (P20)
#define D_P27_REV() P27 = ~P27
#define D_P26_REV() P26 = ~P26
#define D_P25_REV() P25 = ~P25
#define D_P24_REV() P24 = ~P24
#define D_P23_REV() P23 = ~P23
#define D_P22_REV() P22 = ~P22
#define D_P21_REV() P21 = ~P21
#define D_P20_REV() P20 = ~P20
#define D_P37_ON() P37 = 1
#define D_P36_ON() P36 = 1
#define D_P35_ON() P35 = 1
#define D_P34_ON() P34 = 1
#define D_P33_ON() P33 = 1
#define D_P32_ON() P32 = 1
#define D_P31_ON() P31 = 1
#define D_P30_ON() P30 = 1
#define D_P37_OFF() P37 = 0
#define D_P36_OFF() P36 = 0
#define D_P35_OFF() P35 = 0
#define D_P34_OFF() P34 = 0
#define D_P33_OFF() P33 = 0
#define D_P32_OFF() P32 = 0
#define D_P31_OFF() P31 = 0
#define D_P30_OFF() P30 = 0
#define D_P37_AT() (P37)
#define D_P36_AT() (P36)
#define D_P35_AT() (P35)
#define D_P34_AT() (P34)
#define D_P33_AT() (P33)
#define D_P32_AT() (P32)
#define D_P31_AT() (P31)
#define D_P30_AT() (P30)
#define D_P37_REV() P37 = ~P37
#define D_P36_REV() P36 = ~P36
#define D_P35_REV() P35 = ~P35
#define D_P34_REV() P34 = ~P34
#define D_P33_REV() P33 = ~P33
#define D_P32_REV() P32 = ~P32
#define D_P31_REV() P31 = ~P31
#define D_P30_REV() P30 = ~P30
#define D_P47_ON() P47 = 1
#define D_P46_ON() P46 = 1
#define D_P45_ON() P45 = 1
#define D_P44_ON() P44 = 1
#define D_P43_ON() P43 = 1
#define D_P42_ON() P42 = 1
#define D_P41_ON() P41 = 1
#define D_P40_ON() P40 = 1
#define D_P47_OFF() P47 = 0
#define D_P46_OFF() P46 = 0
#define D_P45_OFF() P45 = 0
#define D_P44_OFF() P44 = 0
#define D_P43_OFF() P43 = 0
#define D_P42_OFF() P42 = 0
#define D_P41_OFF() P41 = 0
#define D_P40_OFF() P40 = 0
#define D_P47_AT() (P47)
#define D_P46_AT() (P46)
#define D_P45_AT() (P45)
#define D_P44_AT() (P44)
#define D_P43_AT() (P43)
#define D_P42_AT() (P42)
#define D_P41_AT() (P41)
#define D_P40_AT() (P40)
#define D_P47_REV() P47 = ~P47
#define D_P46_REV() P46 = ~P46
#define D_P45_REV() P45 = ~P45
#define D_P44_REV() P44 = ~P44
#define D_P43_REV() P43 = ~P43
#define D_P42_REV() P42 = ~P42
#define D_P41_REV() P41 = ~P41
#define D_P40_REV() P40 = ~P40
#define D_P57_ON() P57 = 1
#define D_P56_ON() P56 = 1
#define D_P55_ON() P55 = 1
#define D_P54_ON() P54 = 1
#define D_P53_ON() P53 = 1
#define D_P52_ON() P52 = 1
#define D_P51_ON() P51 = 1
#define D_P50_ON() P50 = 1
#define D_P57_OFF() P57 = 0
#define D_P56_OFF() P56 = 0
#define D_P55_OFF() P55 = 0
#define D_P54_OFF() P54 = 0
#define D_P53_OFF() P53 = 0
#define D_P52_OFF() P52 = 0
#define D_P51_OFF() P51 = 0
#define D_P50_OFF() P50 = 0
#define D_P57_AT() (P57)
#define D_P56_AT() (P56)
#define D_P55_AT() (P55)
#define D_P54_AT() (P54)
#define D_P53_AT() (P53)
#define D_P52_AT() (P52)
#define D_P51_AT() (P51)
#define D_P50_AT() (P50)
#define D_P57_REV() P57 = ~P57
#define D_P56_REV() P56 = ~P56
#define D_P55_REV() P55 = ~P55
#define D_P54_REV() P54 = ~P54
#define D_P53_REV() P53 = ~P53
#define D_P52_REV() P52 = ~P52
#define D_P51_REV() P51 = ~P51
#define D_P50_REV() P50 = ~P50
#define D_P67_ON() P67 = 1
#define D_P66_ON() P66 = 1
#define D_P65_ON() P65 = 1
#define D_P64_ON() P64 = 1
#define D_P63_ON() P63 = 1
#define D_P62_ON() P62 = 1
#define D_P61_ON() P61 = 1
#define D_P60_ON() P60 = 1
#define D_P67_OFF() P67 = 0
#define D_P66_OFF() P66 = 0
#define D_P65_OFF() P65 = 0
#define D_P64_OFF() P64 = 0
#define D_P63_OFF() P63 = 0
#define D_P62_OFF() P62 = 0
#define D_P61_OFF() P61 = 0
#define D_P60_OFF() P60 = 0
#define D_P67_AT() (P67)
#define D_P66_AT() (P66)
#define D_P65_AT() (P65)
#define D_P64_AT() (P64)
#define D_P63_AT() (P63)
#define D_P62_AT() (P62)
#define D_P61_AT() (P61)
#define D_P60_AT() (P60)
#define D_P67_REV() P67 = ~P67
#define D_P66_REV() P66 = ~P66
#define D_P65_REV() P65 = ~P65
#define D_P64_REV() P64 = ~P64
#define D_P63_REV() P63 = ~P63
#define D_P62_REV() P62 = ~P62
#define D_P61_REV() P61 = ~P61
#define D_P60_REV() P60 = ~P60
#define D_P77_ON() P77 = 1
#define D_P76_ON() P76 = 1
#define D_P75_ON() P75 = 1
#define D_P74_ON() P74 = 1
#define D_P73_ON() P73 = 1
#define D_P72_ON() P72 = 1
#define D_P71_ON() P71 = 1
#define D_P70_ON() P70 = 1
#define D_P77_OFF() P77 = 0
#define D_P76_OFF() P76 = 0
#define D_P75_OFF() P75 = 0
#define D_P74_OFF() P74 = 0
#define D_P73_OFF() P73 = 0
#define D_P72_OFF() P72 = 0
#define D_P71_OFF() P71 = 0
#define D_P70_OFF() P70 = 0
#define D_P77_AT() (P77)
#define D_P76_AT() (P76)
#define D_P75_AT() (P75)
#define D_P74_AT() (P74)
#define D_P73_AT() (P73)
#define D_P72_AT() (P72)
#define D_P71_AT() (P71)
#define D_P70_AT() (P70)
#define D_P77_REV() P77 = ~P77
#define D_P76_REV() P76 = ~P76
#define D_P75_REV() P75 = ~P75
#define D_P74_REV() P74 = ~P74
#define D_P73_REV() P73 = ~P73
#define D_P72_REV() P72 = ~P72
#define D_P71_REV() P71 = ~P71
#define D_P70_REV() P70 = ~P70
#define D_stdIO_P0_ALL() P0M1=0;P0M0=0;
#define D_HighI_P0_ALL() P0M1=0;P0M0=0XFF;
#define D_HighR_P0_ALL() P0M1=0XFF;P0M0=0;
#define D_OpenD_P0_ALL() P0M1=0XFF;P0M0=0XFF;
#define D_stdIO_P1_ALL() P1M1=0;P1M0=0;
#define D_HighI_P1_ALL() P1M1=0;P1M0=0XFF;
#define D_HighR_P1_ALL() P1M1=0XFF;P1M0=0;
#define D_OpenD_P1_ALL() P1M1=0XFF;P1M0=0XFF;
#define D_stdIO_P2_ALL() P2M1=0;P2M0=0;
#define D_HighI_P2_ALL() P2M1=0;P2M0=0XFF;
#define D_HighR_P2_ALL() P2M1=0XFF;P2M0=0;
#define D_OpenD_P2_ALL() P2M1=0XFF;P2M0=0XFF;
#define D_stdIO_P3_ALL() P3M1=0;P3M0=0;
#define D_HighI_P3_ALL() P3M1=0;P3M0=0XFF;
#define D_HighR_P3_ALL() P3M1=0XFF;P3M0=0;
#define D_OpenD_P3_ALL() P3M1=0XFF;P3M0=0XFF;
#define D_stdIO_P4_ALL() P4M1=0;P4M0=0;
#define D_HighI_P4_ALL() P4M1=0;P4M0=0XFF;
#define D_HighR_P4_ALL() P4M1=0XFF;P4M0=0;
#define D_OpenD_P4_ALL() P4M1=0XFF;P4M0=0XFF;
#define D_stdIO_P5_ALL() P5M1=0;P5M0=0;
#define D_HighI_P5_ALL() P5M1=0;P5M0=0XFF;
#define D_HighR_P5_ALL() P5M1=0XFF;P5M0=0;
#define D_OpenD_P5_ALL() P5M1=0XFF;P5M0=0XFF;
#define D_stdIO_P6_ALL() P6M1=0;P6M0=0;
#define D_HighI_P6_ALL() P6M1=0;P6M0=0XFF;
#define D_HighR_P6_ALL() P6M1=0XFF;P6M0=0;
#define D_OpenD_P6_ALL() P6M1=0XFF;P6M0=0XFF;
#define D_stdIO_P7_ALL() P7M1=0;P7M0=0;
#define D_HighI_P7_ALL() P7M1=0;P7M0=0XFF;
#define D_HighR_P7_ALL() P7M1=0XFF;P7M0=0;
#define D_OpenD_P7_ALL() P7M1=0XFF;P7M0=0XFF;
////Notice: n: BITN0---BITN7 不是0-7 eg:D_stdIO_P0(BITN0)
#define D_stdIO_P0(n) BITN_0(P0M1,n);BITN_0(P0M0,n); //////00 准双向口 灌电流20mA 拉电流270-150uS
#define D_HighI_P0(n) BITN_0(P0M1,n);BITN_1(P0M0,n); //////01 推挽输出 20mA 加限流
#define D_HighR_P0(n) BITN_1(P0M1,n);BITN_0(P0M0,n); /////////10 高阻
#define D_OpenD_P0(n) BITN_1(P0M1,n);BITN_1(P0M0,n); /////11 开漏 open-Drain 内部上拉电阻断开 开漏模式既可以度外部状态也可以对外输出高低电平
#define D_stdIO_P1(n) BITN_0(P1M1,n);BITN_0(P1M0,n); //////00 准双向口 灌电流20mA 拉电流270-150uS
#define D_HighI_P1(n) BITN_0(P1M1,n);BITN_1(P1M0,n); //////01 推挽输出 20mA 加限流
#define D_HighR_P1(n) BITN_1(P1M1,n);BITN_0(P1M0,n); /////////10 高阻
#define D_OpenD_P1(n) BITN_1(P1M1,n);BITN_1(P1M0,n); /////11 开漏 open-Drain 内部上拉电阻断开 开漏模式既可以度外部状态也可以对外输出高低电平
#define D_stdIO_P2(n) BITN_0(P2M1,n);BITN_0(P2M0,n); //////00 准双向口 灌电流20mA 拉电流270-150uS
#define D_HighI_P2(n) BITN_0(P2M1,n);BITN_1(P2M0,n); //////01 推挽输出 20mA 加限流
#define D_HighR_P2(n) BITN_1(P2M1,n);BITN_0(P2M0,n); /////////10 高阻
#define D_OpenD_P2(n) BITN_1(P2M1,n);BITN_1(P2M0,n); /////11 开漏 open-Drain 内部上拉电阻断开 开漏模式既可以度外部状态也可以对外输出高低电平
#define D_stdIO_P3(n) BITN_0(P3M1,n);BITN_0(P3M0,n); //////00 准双向口 灌电流20mA 拉电流270-150uS
#define D_HighI_P3(n) BITN_0(P3M1,n);BITN_1(P3M0,n); //////01 推挽输出 20mA 加限流
#define D_HighR_P3(n) BITN_1(P3M1,n);BITN_0(P3M0,n); /////////10 高阻
#define D_OpenD_P3(n) BITN_1(P3M1,n);BITN_1(P3M0,n); /////11 开漏 open-Drain 内部上拉电阻断开 开漏模式既可以度外部状态也可以对外输出高低电平
#define D_stdIO_P4(n) BITN_0(P4M1,n);BITN_0(P4M0,n); //////00 准双向口 灌电流20mA 拉电流270-150uS
#define D_HighI_P4(n) BITN_0(P4M1,n);BITN_1(P4M0,n); //////01 推挽输出 20mA 加限流
#define D_HighR_P4(n) BITN_1(P4M1,n);BITN_0(P4M0,n); /////////10 高阻
#define D_OpenD_P4(n) BITN_1(P4M1,n);BITN_1(P4M0,n); /////11 开漏 open-Drain 内部上拉电阻断开 开漏模式既可以度外部状态也可以对外输出高低电平
#define D_stdIO_P5(n) BITN_0(P5M1,n);BITN_0(P5M0,n); //////00 准双向口 灌电流20mA 拉电流270-150uS
#define D_HighI_P5(n) BITN_0(P5M1,n);BITN_1(P5M0,n); //////01 推挽输出 20mA 加限流
#define D_HighR_P5(n) BITN_1(P5M1,n);BITN_0(P5M0,n); /////////10 高阻
#define D_OpenD_P5(n) BITN_1(P5M1,n);BITN_1(P5M0,n); /////11 开漏 open-Drain 内部上拉电阻断开 开漏模式既可以度外部状态也可以对外输出高低电平
#define D_stdIO_P6(n) BITN_0(P6M1,n);BITN_0(P6M0,n); //////00 准双向口 灌电流20mA 拉电流270-150uS
#define D_HighI_P6(n) BITN_0(P6M1,n);BITN_1(P6M0,n); //////01 推挽输出 20mA 加限流
#define D_HighR_P6(n) BITN_1(P6M1,n);BITN_0(P6M0,n); /////////10 高阻
#define D_OpenD_P6(n) BITN_1(P6M1,n);BITN_1(P6M0,n); /////11 开漏 open-Drain 内部上拉电阻断开 开漏模式既可以度外部状态也可以对外输出高低电平
#define D_stdIO_P7(n) BITN_0(P7M1,n);BITN_0(P7M0,n); //////00 准双向口 灌电流20mA 拉电流270-150uS
#define D_HighI_P7(n) BITN_0(P7M1,n);BITN_1(P7M0,n); //////01 推挽输出 20mA 加限流
#define D_HighR_P7(n) BITN_1(P7M1,n);BITN_0(P7M0,n); /////////10 高阻
#define D_OpenD_P7(n) BITN_1(P7M1,n);BITN_1(P7M0,n); /////11 开漏 open-Drain 内部上拉电阻断开 开漏模式既可以度外部状态也可以对外输出高低电平
#endif //__STC_MACRO_H_

466
source/cpu/stc_stc15w.H
View File

@ -0,0 +1,466 @@
#ifndef __STC15F2K60S2_H_
#define __STC15F2K60S2_H_
// stc_stc15w.h
#include<intrins.h>
/////////////////////////////////////////////////
//注意: STC15W4K32S4系列的芯片,上电后所有与PWM相关的IO口均为
// 高阻态,需将这些口设置为准双向口或强推挽模式方可正常使用
//相关IO: P0.6/P0.7/P1.6/P1.7/P2.1/P2.2
// P2.3/P2.7/P3.7/P4.2/P4.4/P4.5
/////////////////////////////////////////////////
/////////////////////////////////////////////////
//包含本头文件后,不用另外再包含"REG51.H"
//内核特殊功能寄存器 // 复位值 描述
sfr ACC = 0xE0; //0000,0000 累加器Accumulator
sfr B = 0xF0; //0000,0000 B寄存器
sfr PSW = 0xD0; //0000,0000 程序状态字
sbit CY = PSW^7;
sbit AC = PSW^6;
sbit F0 = PSW^5;
sbit RS1 = PSW^4;
sbit RS0 = PSW^3;
sbit OV = PSW^2;
sbit P = PSW^0;
sfr SP = 0x81; //0000,0111 堆栈指针
sfr DPL = 0x82; //0000,0000 数据指针低字节
sfr DPH = 0x83; //0000,0000 数据指针高字节
//I/O 口特殊功能寄存器
sfr P0 = 0x80; //1111,1111 端口0
sbit P00 = P0^0;
sbit P01 = P0^1;
sbit P02 = P0^2;
sbit P03 = P0^3;
sbit P04 = P0^4;
sbit P05 = P0^5;
sbit P06 = P0^6;
sbit P07 = P0^7;
sfr P1 = 0x90; //1111,1111 端口1
sbit P10 = P1^0;
sbit P11 = P1^1;
sbit P12 = P1^2;
sbit P13 = P1^3;
sbit P14 = P1^4;
sbit P15 = P1^5;
sbit P16 = P1^6;
sbit P17 = P1^7;
sfr P2 = 0xA0; //1111,1111 端口2
sbit P20 = P2^0;
sbit P21 = P2^1;
sbit P22 = P2^2;
sbit P23 = P2^3;
sbit P24 = P2^4;
sbit P25 = P2^5;
sbit P26 = P2^6;
sbit P27 = P2^7;
sfr P3 = 0xB0; //1111,1111 端口3
sbit P30 = P3^0;
sbit P31 = P3^1;
sbit P32 = P3^2;
sbit P33 = P3^3;
sbit P34 = P3^4;
sbit P35 = P3^5;
sbit P36 = P3^6;
sbit P37 = P3^7;
sfr P4 = 0xC0; //1111,1111 端口4
sbit P40 = P4^0;
sbit P41 = P4^1;
sbit P42 = P4^2;
sbit P43 = P4^3;
sbit P44 = P4^4;
sbit P45 = P4^5;
sbit P46 = P4^6;
sbit P47 = P4^7;
sfr P5 = 0xC8; //xxxx,1111 端口5
sbit P50 = P5^0;
sbit P51 = P5^1;
sbit P52 = P5^2;
sbit P53 = P5^3;
sbit P54 = P5^4;
sbit P55 = P5^5;
sbit P56 = P5^6;
sbit P57 = P5^7;
sfr P6 = 0xE8; //0000,0000 端口6
sbit P60 = P6^0;
sbit P61 = P6^1;
sbit P62 = P6^2;
sbit P63 = P6^3;
sbit P64 = P6^4;
sbit P65 = P6^5;
sbit P66 = P6^6;
sbit P67 = P6^7;
sfr P7 = 0xF8; //0000,0000 端口7
sbit P70 = P7^0;
sbit P71 = P7^1;
sbit P72 = P7^2;
sbit P73 = P7^3;
sbit P74 = P7^4;
sbit P75 = P7^5;
sbit P76 = P7^6;
sbit P77 = P7^7;
sfr P0M0 = 0x94; //0000,0000 端口0模式寄存器0
sfr P0M1 = 0x93; //0000,0000 端口0模式寄存器1
sfr P1M0 = 0x92; //0000,0000 端口1模式寄存器0
sfr P1M1 = 0x91; //0000,0000 端口1模式寄存器1
sfr P2M0 = 0x96; //0000,0000 端口2模式寄存器0
sfr P2M1 = 0x95; //0000,0000 端口2模式寄存器1
sfr P3M0 = 0xB2; //0000,0000 端口3模式寄存器0
sfr P3M1 = 0xB1; //0000,0000 端口3模式寄存器1
sfr P4M0 = 0xB4; //0000,0000 端口4模式寄存器0
sfr P4M1 = 0xB3; //0000,0000 端口4模式寄存器1
sfr P5M0 = 0xCA; //0000,0000 端口5模式寄存器0
sfr P5M1 = 0xC9; //0000,0000 端口5模式寄存器1
sfr P6M0 = 0xCC; //0000,0000 端口6模式寄存器0
sfr P6M1 = 0xCB; //0000,0000 端口6模式寄存器1
sfr P7M0 = 0xE2; //0000,0000 端口7模式寄存器0
sfr P7M1 = 0xE1; //0000,0000 端口7模式寄存器1
//系统管理特殊功能寄存器
sfr PCON = 0x87; //0001,0000 电源控制寄存器
sfr AUXR = 0x8E; //0000,0000 辅助寄存器
#define TOx12 BITN7
#define T1x12 BITN6
#define UART_M0x6 BITN5 //串口1模式0速度 =0 12倍 = 1 两倍
#define T2R BITN4 //定时器2 运行 =1
#define T2_C BITN3 //定时器/计数器选择
#define T2x12 BITN2
#define EXTRAM BITN1
#define S1ST2 BITN0 //串口1选择定时器1 =0 选择定时器2 =1
sfr AUXR1 = 0xA2; //0000,0000 辅助寄存器1
sfr P_SW1 = 0xA2; //0000,0000 外设端口切换寄存器1
sfr CLK_DIV = 0x97; //0000,0000 时钟分频控制寄存器
sfr BUS_SPEED = 0xA1; //xx10,x011 总线速度控制寄存器
sfr P1ASF = 0x9D; //0000,0000 端口1模拟功能配置寄存器
sfr P_SW2 = 0xBA; //0xxx,x000 外设端口切换寄存器
//中断特殊功能寄存器
sfr IE = 0xA8; //0000,0000 中断控制寄存器
sbit EA = IE^7;
sbit ELVD = IE^6;
sbit EADC = IE^5;
sbit ES = IE^4;
sbit ET1 = IE^3;
sbit EX1 = IE^2;
sbit ET0 = IE^1;
sbit EX0 = IE^0;
sfr IP = 0xB8; //0000,0000 中断优先级寄存器
sbit PPCA = IP^7;
sbit PLVD = IP^6;
sbit PADC = IP^5;
sbit PS = IP^4;
sbit PT1 = IP^3;
sbit PX1 = IP^2;
sbit PT0 = IP^1;
sbit PX0 = IP^0;
sfr IE2 = 0xAF; //0000,0000 中断控制寄存器2
/// 不可位寻址
#define ET4 BITN6
#define ET3 BITN5
#define ES4 BITN4
#define ES3 BITN3
#define ET2 BITN2
#define ESPI BITN1
#define ES2 BITN0
sfr IP2 = 0xB5; //xxxx,xx00 中断优先级寄存器2
sfr INT_CLKO = 0x8F; //0000,0000 外部中断与时钟输出控制寄存器
//定时器特殊功能寄存器
sfr TCON = 0x88; //0000,0000 T0/T1控制寄存器
sbit TF1 = TCON^7;
sbit TR1 = TCON^6;
sbit TF0 = TCON^5;
sbit TR0 = TCON^4;
sbit IE1 = TCON^3;
sbit IT1 = TCON^2;
sbit IE0 = TCON^1;
sbit IT0 = TCON^0;
sfr TMOD = 0x89; //0000,0000 T0/T1模式寄存器
sfr TL0 = 0x8A; //0000,0000 T0低字节
sfr TL1 = 0x8B; //0000,0000 T1低字节
sfr TH0 = 0x8C; //0000,0000 T0高字节
sfr TH1 = 0x8D; //0000,0000 T1高字节
sfr T4T3M = 0xD1; //0000,0000 T3/T4模式寄存器
sfr T3T4M = 0xD1; //0000,0000 T3/T4模式寄存器
sfr T4H = 0xD2; //0000,0000 T4高字节
sfr T4L = 0xD3; //0000,0000 T4低字节
sfr T3H = 0xD4; //0000,0000 T3高字节
sfr T3L = 0xD5; //0000,0000 T3低字节
sfr T2H = 0xD6; //0000,0000 T2高字节
sfr T2L = 0xD7; //0000,0000 T2低字节
sfr WKTCL = 0xAA; //0000,0000 掉电唤醒定时器低字节
sfr WKTCH = 0xAB; //0000,0000 掉电唤醒定时器高字节
sfr WDT_CONTR = 0xC1; //0000,0000 看门狗控制寄存器
//串行口特殊功能寄存器
sfr SCON = 0x98; //0000,0000 串口1控制寄存器
sbit SM0 = SCON^7;
sbit SM1 = SCON^6;
sbit SM2 = SCON^5;
sbit REN = SCON^4;
sbit TB8 = SCON^3;
sbit RB8 = SCON^2;
sbit TI = SCON^1;
sbit RI = SCON^0;
//sfr SBUF = 0x99; //xxxx,xxxx 串口1数据寄存器
//sfr S2CON = 0x9A; //0000,0000 串口2控制寄存器
//sfr S2BUF = 0x9B; //xxxx,xxxx 串口2数据寄存器
//sfr SADDR = 0xA9; //0000,0000 从机地址寄存器
//sfr SADEN = 0xB9; //0000,0000 从机地址屏蔽寄存器
sfr SBUF = 0x99; //Serial Data Buffer
sfr SBUF0 = 0x99; //Serial Data Buffer xxxx,xxxx
sfr SADEN = 0xB9; //Slave Address Mask 0000,0000
sfr SADDR = 0xA9; //Slave Address 0000,0000
//-----------------------------------
// 7 6 5 4 3 2 1 0 Reset Value
sfr S2CON = 0x9A; //S2 Control S2SM0 S2SM1 S2SM2 S2REN S2TB8 S2RB8 S2TI S2RI 00000000B
#define S2SM0 BITN7
#define S2ST4 BITN6
#define S2SM2 BITN5
#define S2REN BITN4
#define S2TB8 BITN3
#define S2RB8 BITN2
#define S2TI BITN1
#define S2RI BITN0
sfr S2BUF = 0x9B; //S2 Serial Buffer xxxx,xxxx
//sfr BRT = 0x9C; //S2 Baud-Rate Timer 0000,0000
//---------------------------------------------------------------
sfr S3CON = 0xAC; //0000,0000 串口3控制寄存器
#define S3SM0 BITN7
#define S3ST4 BITN6
#define S3SM2 BITN5
#define S3REN BITN4
#define S3TB8 BITN3
#define S3RB8 BITN2
#define S3TI BITN1
#define S3RI BITN0
sfr S3BUF = 0xAD; //xxxx,xxxx 串口3数据寄存器
//---------------------------------------------------------------
sfr S4CON = 0x84; //0000,0000 串口4控制寄存器
#define S4SM0 BITN7
#define S4ST4 BITN6
#define S4SM2 BITN5
#define S4REN BITN4
#define S4TB8 BITN3
#define S4RB8 BITN2
#define S4TI BITN1
#define S4RI BITN0
sfr S4BUF = 0x85; //xxxx,xxxx 串口4数据寄存器
//ADC 特殊功能寄存器
sfr ADC_CONTR = 0xBC; //0000,0000 A/D转换控制寄存器
sfr ADC_RES = 0xBD; //0000,0000 A/D转换结果高8位
sfr ADC_RESL = 0xBE; //0000,0000 A/D转换结果低2位
//SPI 特殊功能寄存器
sfr SPSTAT = 0xCD; //00xx,xxxx SPI状态寄存器
sfr SPCTL = 0xCE; //0000,0100 SPI控制寄存器
sfr SPDAT = 0xCF; //0000,0000 SPI数据寄存器
//IAP/ISP 特殊功能寄存器
sfr IAP_DATA = 0xC2; //0000,0000 EEPROM数据寄存器
sfr IAP_ADDRH = 0xC3; //0000,0000 EEPROM地址高字节
sfr IAP_ADDRL = 0xC4; //0000,0000 EEPROM地址第字节
sfr IAP_CMD = 0xC5; //xxxx,xx00 EEPROM命令寄存器
sfr IAP_TRIG = 0xC6; //0000,0000 EEPRPM命令触发寄存器
sfr IAP_CONTR = 0xC7; //0000,x000 EEPROM控制寄存器
//PCA/PWM 特殊功能寄存器
sfr CCON = 0xD8; //00xx,xx00 PCA控制寄存器
sbit CF = CCON^7;
sbit CR = CCON^6;
sbit CCF2 = CCON^2;
sbit CCF1 = CCON^1;
sbit CCF0 = CCON^0;
sfr CMOD = 0xD9; //0xxx,x000 PCA 工作模式寄存器
sfr CL = 0xE9; //0000,0000 PCA计数器低字节
sfr CH = 0xF9; //0000,0000 PCA计数器高字节
sfr CCAPM0 = 0xDA; //0000,0000 PCA模块0的PWM寄存器
sfr CCAPM1 = 0xDB; //0000,0000 PCA模块1的PWM寄存器
sfr CCAPM2 = 0xDC; //0000,0000 PCA模块2的PWM 寄存器
sfr CCAP0L = 0xEA; //0000,0000 PCA模块0的捕捉/比较寄存器低字节
sfr CCAP1L = 0xEB; //0000,0000 PCA模块1的捕捉/比较寄存器低字节
sfr CCAP2L = 0xEC; //0000,0000 PCA模块2的捕捉/比较寄存器低字节
sfr PCA_PWM0 = 0xF2; //xxxx,xx00 PCA模块0的PWM寄存器
sfr PCA_PWM1 = 0xF3; //xxxx,xx00 PCA模块1的PWM寄存器
sfr PCA_PWM2 = 0xF4; //xxxx,xx00 PCA模块1的PWM寄存器
sfr CCAP0H = 0xFA; //0000,0000 PCA模块0的捕捉/比较寄存器高字节
sfr CCAP1H = 0xFB; //0000,0000 PCA模块1的捕捉/比较寄存器高字节
sfr CCAP2H = 0xFC; //0000,0000 PCA模块2的捕捉/比较寄存器高字节
//比较器特殊功能寄存器
sfr CMPCR1 = 0xE6; //0000,0000 比较器控制寄存器1
sfr CMPCR2 = 0xE7; //0000,0000 比较器控制寄存器2
//增强型PWM波形发生器特殊功能寄存器
sfr PWMCFG = 0xf1; //x000,0000 PWM配置寄存器
sfr PWMCR = 0xf5; //0000,0000 PWM控制寄存器
sfr PWMIF = 0xf6; //x000,0000 PWM中断标志寄存器
sfr PWMFDCR = 0xf7; //xx00,0000 PWM外部异常检测控制寄存器
//如下特殊功能寄存器位于扩展RAM区域
//访问这些寄存器,需先将P_SW2的BIT7设置为1,才可正常读写
#define PWMC (*(unsigned int volatile xdata *)0xfff0)
#define PWMCH (*(unsigned char volatile xdata *)0xfff0)
#define PWMCL (*(unsigned char volatile xdata *)0xfff1)
#define PWMCKS (*(unsigned char volatile xdata *)0xfff2)
#define PWM2T1 (*(unsigned int volatile xdata *)0xff00)
#define PWM2T1H (*(unsigned char volatile xdata *)0xff00)
#define PWM2T1L (*(unsigned char volatile xdata *)0xff01)
#define PWM2T2 (*(unsigned int volatile xdata *)0xff02)
#define PWM2T2H (*(unsigned char volatile xdata *)0xff02)
#define PWM2T2L (*(unsigned char volatile xdata *)0xff03)
#define PWM2CR (*(unsigned char volatile xdata *)0xff04)
#define PWM3T1 (*(unsigned int volatile xdata *)0xff10)
#define PWM3T1H (*(unsigned char volatile xdata *)0xff10)
#define PWM3T1L (*(unsigned char volatile xdata *)0xff11)
#define PWM3T2 (*(unsigned int volatile xdata *)0xff12)
#define PWM3T2H (*(unsigned char volatile xdata *)0xff12)
#define PWM3T2L (*(unsigned char volatile xdata *)0xff13)
#define PWM3CR (*(unsigned char volatile xdata *)0xff14)
#define PWM4T1 (*(unsigned int volatile xdata *)0xff20)
#define PWM4T1H (*(unsigned char volatile xdata *)0xff20)
#define PWM4T1L (*(unsigned char volatile xdata *)0xff21)
#define PWM4T2 (*(unsigned int volatile xdata *)0xff22)
#define PWM4T2H (*(unsigned char volatile xdata *)0xff22)
#define PWM4T2L (*(unsigned char volatile xdata *)0xff23)
#define PWM4CR (*(unsigned char volatile xdata *)0xff24)
#define PWM5T1 (*(unsigned int volatile xdata *)0xff30)
#define PWM5T1H (*(unsigned char volatile xdata *)0xff30)
#define PWM5T1L (*(unsigned char volatile xdata *)0xff31)
#define PWM5T2 (*(unsigned int volatile xdata *)0xff32)
#define PWM5T2H (*(unsigned char volatile xdata *)0xff32)
#define PWM5T2L (*(unsigned char volatile xdata *)0xff33)
#define PWM5CR (*(unsigned char volatile xdata *)0xff34)
#define PWM6T1 (*(unsigned int volatile xdata *)0xff40)
#define PWM6T1H (*(unsigned char volatile xdata *)0xff40)
#define PWM6T1L (*(unsigned char volatile xdata *)0xff41)
#define PWM6T2 (*(unsigned int volatile xdata *)0xff42)
#define PWM6T2H (*(unsigned char volatile xdata *)0xff42)
#define PWM6T2L (*(unsigned char volatile xdata *)0xff43)
#define PWM6CR (*(unsigned char volatile xdata *)0xff44)
#define PWM7T1 (*(unsigned int volatile xdata *)0xff50)
#define PWM7T1H (*(unsigned char volatile xdata *)0xff50)
#define PWM7T1L (*(unsigned char volatile xdata *)0xff51)
#define PWM7T2 (*(unsigned int volatile xdata *)0xff52)
#define PWM7T2H (*(unsigned char volatile xdata *)0xff52)
#define PWM7T2L (*(unsigned char volatile xdata *)0xff53)
#define PWM7CR (*(unsigned char volatile xdata *)0xff54)
/////////////////////////////////////////////////
/* P3 */
sbit RD = 0xB7;
sbit WR = 0xB6;
sbit T1 = 0xB5;
sbit T0 = 0xB4;
sbit INT1 = 0xB3;
sbit INT0 = 0xB2;
sbit TXD = 0xB1;
sbit RXD = 0xB0;
/// >>>>> add by cc
//sbit P34=P3^4; //定义SDA数据线
//sbit P35=P3^5; //定义SCL时钟线
#define mBIT_1(X,N) X|= (1<<N)
#define mBIT_0(X,N) X&=~(1<<N)
#define mBIT_G(X,N) (X&(1<<N))
//高阻状态
#define P0_conf_in(n) mBIT_1(P0M1,n);mBIT_0(P0M0,n);
#define P1_conf_in(n) mBIT_1(P1M1,n);mBIT_0(P1M0,n);
#define P2_conf_in(n) mBIT_1(P2M1,n);mBIT_0(P2M0,n);
#define P2_conf_port(n) mBIT_0(P2M1,n);mBIT_0(P2M0,n);
#define P3_conf_in(n) mBIT_1(P3M1,n);mBIT_0(P3M0,n);
#define P3_conf_port(n) mBIT_0(P3M1,n);mBIT_0(P3M0,n);
#define P4_conf_in(n) mBIT_1(P4M1,n);mBIT_0(P4M0,n);
#define P5_conf_in(n) mBIT_1(P5M1,n);mBIT_0(P5M0,n);
#define NOP() _nop_()
#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;
//// n: BITN0---BITN7
#define D_stdIO_P0(BITN) BITN_0(P0M1,BITN);BITN_0(P0M0,BITN); //////00 准双向口 灌电流20mA 拉电流270-150uS
#define D_HighI_P0(BITN) BITN_0(P0M1,BITN);BITN_1(P0M0,BITN); //////01 推挽输出 20mA 加限流
#define D_HighR_P0(BITN) BITN_1(P0M1,BITN);BITN_0(P0M0,BITN); /////////10 高阻
#define D_OpenD_P0(BITN) BITN_1(P0M1,BITN);BITN_1(P0M0,BITN); /////11 开漏 open-Drain 内部上拉电阻断开 开漏模式既可以度外部状态也可以对外输出高低电平
#define D_stdIO_P1(BITN) BITN_0(P1M1,BITN);BITN_0(P1M0,BITN); //////00 准双向口 灌电流20mA 拉电流270-150uS
#define D_HighI_P1(BITN) BITN_0(P1M1,BITN);BITN_1(P1M0,BITN); //////01 推挽输出 20mA 加限流
#define D_HighR_P1(BITN) BITN_1(P1M1,BITN);BITN_0(P1M0,BITN); /////////10 高阻
#define D_OpenD_P1(BITN) BITN_1(P1M1,BITN);BITN_1(P1M0,BITN); /////11 开漏 open-Drain 内部上拉电阻断开 开漏模式既可以度外部状态也可以对外输出高低电平
#define D_stdIO_P2(BITN) BITN_0(P2M1,BITN);BITN_0(P2M0,BITN); //////00 准双向口 灌电流20mA 拉电流270-150uS
#define D_HighI_P2(BITN) BITN_0(P2M1,BITN);BITN_1(P2M0,BITN); //////01 推挽输出 20mA 加限流
#define D_HighR_P2(BITN) BITN_1(P2M1,BITN);BITN_0(P2M0,BITN); /////////10 高阻
#define D_OpenD_P2(BITN) BITN_1(P2M1,BITN);BITN_1(P2M0,BITN); /////11 开漏 open-Drain 内部上拉电阻断开 开漏模式既可以度外部状态也可以对外输出高低电平
#define D_stdIO_P3(BITN) BITN_0(P3M1,BITN);BITN_0(P3M0,BITN); //////00 准双向口 灌电流20mA 拉电流270-150uS
#define D_HighI_P3(BITN) BITN_0(P3M1,BITN);BITN_1(P3M0,BITN); //////01 推挽输出 20mA 加限流
#define D_HighR_P3(BITN) BITN_1(P3M1,BITN);BITN_0(P3M0,BITN); /////////10 高阻
#define D_OpenD_P3(BITN) BITN_1(P3M1,BITN);BITN_1(P3M0,BITN); /////11 开漏 open-Drain 内部上拉电阻断开 开漏模式既可以度外部状态也可以对外输出高低电平
#define D_stdIO_P4(BITN) BITN_0(P4M1,BITN);BITN_0(P4M0,BITN); //////00 准双向口 灌电流20mA 拉电流270-150uS
#define D_HighI_P4(BITN) BITN_0(P4M1,BITN);BITN_1(P4M0,BITN); //////01 推挽输出 20mA 加限流
#define D_HighR_P4(BITN) BITN_1(P4M1,BITN);BITN_0(P4M0,BITN); /////////10 高阻
#define D_OpenD_P4(BITN) BITN_1(P4M1,BITN);BITN_1(P4M0,BITN); /////11 开漏 open-Drain 内部上拉电阻断开 开漏模式既可以度外部状态也可以对外输出高低电平
#define D_stdIO_P5(BITN) BITN_0(P5M1,BITN);BITN_0(P5M0,BITN); //////00 准双向口 灌电流20mA 拉电流270-150uS
#define D_HighI_P5(BITN) BITN_0(P5M1,BITN);BITN_1(P5M0,BITN); //////01 推挽输出 20mA 加限流
#define D_HighR_P5(BITN) BITN_1(P5M1,BITN);BITN_0(P5M0,BITN); /////////10 高阻
#define D_OpenD_P5(BITN) BITN_1(P5M1,BITN);BITN_1(P5M0,BITN); /////11 开漏 open-Drain 内部上拉电阻断开 开漏模式既可以度外部状态也可以对外输出高低电平
#define D_stdIO_P6(BITN) BITN_0(P6M1,BITN);BITN_0(P6M0,BITN); //////00 准双向口 灌电流20mA 拉电流270-150uS
#define D_HighI_P6(BITN) BITN_0(P6M1,BITN);BITN_1(P6M0,BITN); //////01 推挽输出 20mA 加限流
#define D_HighR_P6(BITN) BITN_1(P6M1,BITN);BITN_0(P6M0,BITN); /////////10 高阻
#define D_OpenD_P6(BITN) BITN_1(P6M1,BITN);BITN_1(P6M0,BITN); /////11 开漏 open-Drain 内部上拉电阻断开 开漏模式既可以度外部状态也可以对外输出高低电平
#define D_stdIO_P7(BITN) BITN_0(P7M1,BITN);BITN_0(P7M0,BITN); //////00 准双向口 灌电流20mA 拉电流270-150uS
#define D_HighI_P7(BITN) BITN_0(P7M1,BITN);BITN_1(P7M0,BITN); //////01 推挽输出 20mA 加限流
#define D_HighR_P7(BITN) BITN_1(P7M1,BITN);BITN_0(P7M0,BITN); /////////10 高阻
#define D_OpenD_P7(BITN) BITN_1(P7M1,BITN);BITN_1(P7M0,BITN); /////11 开漏 open-Drain 内部上拉电阻断开 开漏模式既可以度外部状态也可以对外输出高低电平
#endif

746
source/cpu/stc_stc8G1k.H
View File

@ -0,0 +1,746 @@
#ifndef __STC8G_H_
#define __STC8G_H_
// STC_stc8a8k.h
#include<intrins.h>
/////////////////////////////////////////////////
//注意: STC15W4K32S4系列的芯片,上电后所有与PWM相关的IO口均为
// 高阻态,需将这些口设置为准双向口或强推挽模式方可正常使用
//相关IO: P0.6/P0.7/P1.6/P1.7/P2.1/P2.2
// P2.3/P2.7/P3.7/P4.2/P4.4/P4.5
/////////////////////////////////////////////////
/////////////////////////////////////////////////
//包含本头文件后,不用另外再包含"REG51.H"
/////////////////////////////////////////////////
//包含本头文件后,不用另外再包含"REG51.H"
sfr P0 = 0x80;
sbit P00 = P0^0;
sbit P01 = P0^1;
sbit P02 = P0^2;
sbit P03 = P0^3;
sbit P04 = P0^4;
sbit P05 = P0^5;
sbit P06 = P0^6;
sbit P07 = P0^7;
sfr SP = 0x81;
sfr DPL = 0x82;
sfr DPH = 0x83;
sfr S4CON = 0x84;
sfr S4BUF = 0x85;
sfr PCON = 0x87;
sfr TCON = 0x88;
sbit TF1 = TCON^7;
sbit TR1 = TCON^6;
sbit TF0 = TCON^5;
sbit TR0 = TCON^4;
sbit IE1 = TCON^3;
sbit IT1 = TCON^2;
sbit IE0 = TCON^1;
sbit IT0 = TCON^0;
sfr TMOD = 0x89;
sfr TL0 = 0x8A;
sfr TL1 = 0x8B;
sfr TH0 = 0x8C;
sfr TH1 = 0x8D;
sfr AUXR = 0x8E;
sfr INTCLKO = 0x8F;
sfr P1 = 0x90;
sbit P10 = P1^0;
sbit P11 = P1^1;
sbit P12 = P1^2;
sbit P13 = P1^3;
sbit P14 = P1^4;
sbit P15 = P1^5;
sbit P16 = P1^6;
sbit P17 = P1^7;
sfr P1M1 = 0x91;
sfr P1M0 = 0x92;
sfr P0M1 = 0x93;
sfr P0M0 = 0x94;
sfr P2M1 = 0x95;
sfr P2M0 = 0x96;
sfr SCON = 0x98;
sbit SM0 = SCON^7;
sbit SM1 = SCON^6;
sbit SM2 = SCON^5;
sbit REN = SCON^4;
sbit TB8 = SCON^3;
sbit RB8 = SCON^2;
sbit TI = SCON^1;
sbit RI = SCON^0;
sfr SBUF = 0x99;
sfr S2CON = 0x9A;
sfr S2BUF = 0x9B;
sfr IRCBAND = 0x9D;
sfr LIRTRIM = 0x9E;
sfr IRTRIM = 0x9F;
sfr P2 = 0xA0;
sbit P20 = P2^0;
sbit P21 = P2^1;
sbit P22 = P2^2;
sbit P23 = P2^3;
sbit P24 = P2^4;
sbit P25 = P2^5;
sbit P26 = P2^6;
sbit P27 = P2^7;
sfr P_SW1 = 0xA2;
sfr IE = 0xA8;
sbit EA = IE^7;
sbit ELVD = IE^6;
sbit EADC = IE^5;
sbit ES = IE^4;
sbit ET1 = IE^3;
sbit EX1 = IE^2;
sbit ET0 = IE^1;
sbit EX0 = IE^0;
sfr SADDR = 0xA9;
sfr WKTCL = 0xAA;
sfr WKTCH = 0xAB;
sfr S3CON = 0xAC;
sfr S3BUF = 0xAD;
sfr TA = 0xAE;
sfr IE2 = 0xAF;
sfr P3 = 0xB0;
sbit P30 = P3^0;
sbit P31 = P3^1;
sbit P32 = P3^2;
sbit P33 = P3^3;
sbit P34 = P3^4;
sbit P35 = P3^5;
sbit P36 = P3^6;
sbit P37 = P3^7;
sfr P3M1 = 0xB1;
sfr P3M0 = 0xB2;
sfr P4M1 = 0xB3;
sfr P4M0 = 0xB4;
sfr IP2 = 0xB5;
sfr IP2H = 0xB6;
sfr IPH = 0xB7;
sfr IP = 0xB8;
sbit PPCA = IP^7;
sbit PLVD = IP^6;
sbit PADC = IP^5;
sbit PS = IP^4;
sbit PT1 = IP^3;
sbit PX1 = IP^2;
sbit PT0 = IP^1;
sbit PX0 = IP^0;
sfr SADEN = 0xB9;
sfr P_SW2 = 0xBA;
sfr ADC_CONTR = 0xBC;
sfr ADC_RES = 0xBD;
sfr ADC_RESL = 0xBE;
sfr P4 = 0xC0;
sbit P40 = P4^0;
sbit P41 = P4^1;
sbit P42 = P4^2;
sbit P43 = P4^3;
sbit P44 = P4^4;
sbit P45 = P4^5;
sbit P46 = P4^6;
sbit P47 = P4^7;
sfr WDT_CONTR = 0xC1;
sfr IAP_DATA = 0xC2;
sfr IAP_ADDRH = 0xC3;
sfr IAP_ADDRL = 0xC4;
sfr IAP_CMD = 0xC5;
sfr IAP_TRIG = 0xC6;
sfr IAP_CONTR = 0xC7;
sfr P5 = 0xC8;
sbit P50 = P5^0;
sbit P51 = P5^1;
sbit P52 = P5^2;
sbit P53 = P5^3;
sbit P54 = P5^4;
sbit P55 = P5^5;
sbit P56 = P5^6;
sbit P57 = P5^7;
sfr P5M1 = 0xC9;
sfr P5M0 = 0xCA;
sfr SPSTAT = 0xCD;
sfr SPCTL = 0xCE;
sfr SPDAT = 0xCF;
sfr PSW = 0xD0;
sbit CY = PSW^7;
sbit AC = PSW^6;
sbit F0 = PSW^5;
sbit RS1 = PSW^4;
sbit RS0 = PSW^3;
sbit OV = PSW^2;
sbit P = PSW^0;
sfr T4T3M = 0xD1;
sfr T4H = 0xD2;
sfr T4L = 0xD3;
sfr T3H = 0xD4;
sfr T3L = 0xD5;
sfr T2H = 0xD6;
sfr T2L = 0xD7;
sfr CCON = 0xD8;
sbit CF = CCON^7;
sbit CR = CCON^6;
sbit CCF2 = CCON^2;
sbit CCF1 = CCON^1;
sbit CCF0 = CCON^0;
sfr CMOD = 0xD9;
sfr CCAPM0 = 0xDA;
sfr CCAPM1 = 0xDB;
sfr CCAPM2 = 0xDC;
sfr ADCCFG = 0xDE;
sfr IP3 = 0xDF;
sfr ACC = 0xE0;
sfr DPS = 0xE3;
sfr DPL1 = 0xE4;
sfr DPH1 = 0xE5;
sfr CMPCR1 = 0xE6;
sfr CMPCR2 = 0xE7;
sfr CL = 0xE9;
sfr CCAP0L = 0xEA;
sfr CCAP1L = 0xEB;
sfr CCAP2L = 0xEC;
sfr IP3H = 0xEE;
sfr AUXINTIF = 0xEF;
sfr B = 0xF0;
sfr PWMSET = 0xF1;
sfr PCA_PWM0 = 0xF2;
sfr PCA_PWM1 = 0xF3;
sfr PCA_PWM2 = 0xF4;
sfr IAP_TPS = 0xF5;
sfr PWMCFG01 = 0xF6;
sfr PWMCFG23 = 0xF7;
sfr CH = 0xF9;
sfr CCAP0H = 0xFA;
sfr CCAP1H = 0xFB;
sfr CCAP2H = 0xFC;
sfr PWMCFG45 = 0xFE;
sfr RSTCFG = 0xFF;
//如下特殊功能寄存器位于扩展RAM区域
//访问这些寄存器,需先将P_SW2的BIT7设置为1,才可正常读写
#define CKSEL (*(unsigned char volatile xdata *)0xFE00)
#define CLKDIV (*(unsigned char volatile xdata *)0xFE01)
#define HIRCCR (*(unsigned char volatile xdata *)0xFE02)
#define XOSCCR (*(unsigned char volatile xdata *)0xFE03)
#define IRC32KCR (*(unsigned char volatile xdata *)0xFE04)
#define MCLKOCR (*(unsigned char volatile xdata *)0xFE05)
#define IRCDB (*(unsigned char volatile xdata *)0xFE06)
#define P0PU (*(unsigned char volatile xdata *)0xFE10)
#define P1PU (*(unsigned char volatile xdata *)0xFE11)
#define P2PU (*(unsigned char volatile xdata *)0xFE12)
#define P3PU (*(unsigned char volatile xdata *)0xFE13)
#define P4PU (*(unsigned char volatile xdata *)0xFE14)
#define P5PU (*(unsigned char volatile xdata *)0xFE15)
#define P0NCS (*(unsigned char volatile xdata *)0xFE18)
#define P1NCS (*(unsigned char volatile xdata *)0xFE19)
#define P2NCS (*(unsigned char volatile xdata *)0xFE1A)
#define P3NCS (*(unsigned char volatile xdata *)0xFE1B)
#define P4NCS (*(unsigned char volatile xdata *)0xFE1C)
#define P5NCS (*(unsigned char volatile xdata *)0xFE1D)
#define P0SR (*(unsigned char volatile xdata *)0xFE20)
#define P1SR (*(unsigned char volatile xdata *)0xFE21)
#define P2SR (*(unsigned char volatile xdata *)0xFE22)
#define P3SR (*(unsigned char volatile xdata *)0xFE23)
#define P4SR (*(unsigned char volatile xdata *)0xFE24)
#define P5SR (*(unsigned char volatile xdata *)0xFE25)
#define P0DR (*(unsigned char volatile xdata *)0xFE28)
#define P1DR (*(unsigned char volatile xdata *)0xFE29)
#define P2DR (*(unsigned char volatile xdata *)0xFE2A)
#define P3DR (*(unsigned char volatile xdata *)0xFE2B)
#define P4DR (*(unsigned char volatile xdata *)0xFE2C)
#define P5DR (*(unsigned char volatile xdata *)0xFE2D)
#define P0IE (*(unsigned char volatile xdata *)0xFE30)
#define P1IE (*(unsigned char volatile xdata *)0xFE31)
#define P3IE (*(unsigned char volatile xdata *)0xFE33)
#define I2CCFG (*(unsigned char volatile xdata *)0xFE80)
#define I2CMSCR (*(unsigned char volatile xdata *)0xFE81)
#define I2CMSST (*(unsigned char volatile xdata *)0xFE82)
#define I2CSLCR (*(unsigned char volatile xdata *)0xFE83)
#define I2CSLST (*(unsigned char volatile xdata *)0xFE84)
#define I2CSLADR (*(unsigned char volatile xdata *)0xFE85)
#define I2CTXD (*(unsigned char volatile xdata *)0xFE86)
#define I2CRXD (*(unsigned char volatile xdata *)0xFE87)
#define I2CMSAUX (*(unsigned char volatile xdata *)0xFE88)
#define TM2PS (*(unsigned char volatile xdata *)0xFEA2)
#define TM3PS (*(unsigned char volatile xdata *)0xFEA3)
#define TM4PS (*(unsigned char volatile xdata *)0xFEA4)
#define ADCTIM (*(unsigned char volatile xdata *)0xFEA8)
#define PWM0CH (*(unsigned char volatile xdata *)0xFF00)
#define PWM0CL (*(unsigned char volatile xdata *)0xFF01)
#define PWM0CKS (*(unsigned char volatile xdata *)0xFF02)
#define PWM0TADCH (*(unsigned char volatile xdata *)0xFF03)
#define PWM0TADCL (*(unsigned char volatile xdata *)0xFF04)
#define PWM0IF (*(unsigned char volatile xdata *)0xFF05)
#define PWM0FDCR (*(unsigned char volatile xdata *)0xFF06)
#define PWM00T1H (*(unsigned char volatile xdata *)0xFF10)
#define PWM00T1L (*(unsigned char volatile xdata *)0xFF11)
#define PWM00T2H (*(unsigned char volatile xdata *)0xFF12)
#define PWM00T2L (*(unsigned char volatile xdata *)0xFF13)
#define PWM00CR (*(unsigned char volatile xdata *)0xFF14)
#define PWM00HLD (*(unsigned char volatile xdata *)0xFF15)
#define PWM01T1H (*(unsigned char volatile xdata *)0xFF18)
#define PWM01T1L (*(unsigned char volatile xdata *)0xFF19)
#define PWM01T2H (*(unsigned char volatile xdata *)0xFF1A)
#define PWM01T2L (*(unsigned char volatile xdata *)0xFF1B)
#define PWM01CR (*(unsigned char volatile xdata *)0xFF1C)
#define PWM01HLD (*(unsigned char volatile xdata *)0xFF1D)
#define PWM02T1H (*(unsigned char volatile xdata *)0xFF20)
#define PWM02T1L (*(unsigned char volatile xdata *)0xFF21)
#define PWM02T2H (*(unsigned char volatile xdata *)0xFF22)
#define PWM02T2L (*(unsigned char volatile xdata *)0xFF23)
#define PWM02CR (*(unsigned char volatile xdata *)0xFF24)
#define PWM02HLD (*(unsigned char volatile xdata *)0xFF25)
#define PWM03T1H (*(unsigned char volatile xdata *)0xFF28)
#define PWM03T1L (*(unsigned char volatile xdata *)0xFF29)
#define PWM03T2H (*(unsigned char volatile xdata *)0xFF2A)
#define PWM03T2L (*(unsigned char volatile xdata *)0xFF2B)
#define PWM03CR (*(unsigned char volatile xdata *)0xFF2C)
#define PWM03HLD (*(unsigned char volatile xdata *)0xFF2D)
#define PWM04T1H (*(unsigned char volatile xdata *)0xFF30)
#define PWM04T1L (*(unsigned char volatile xdata *)0xFF31)
#define PWM04T2H (*(unsigned char volatile xdata *)0xFF32)
#define PWM04T2L (*(unsigned char volatile xdata *)0xFF33)
#define PWM04CR (*(unsigned char volatile xdata *)0xFF34)
#define PWM04HLD (*(unsigned char volatile xdata *)0xFF35)
#define PWM05T1H (*(unsigned char volatile xdata *)0xFF38)
#define PWM05T1L (*(unsigned char volatile xdata *)0xFF39)
#define PWM05T2H (*(unsigned char volatile xdata *)0xFF3A)
#define PWM05T2L (*(unsigned char volatile xdata *)0xFF3B)
#define PWM05CR (*(unsigned char volatile xdata *)0xFF3C)
#define PWM05HLD (*(unsigned char volatile xdata *)0xFF3D)
#define PWM06T1H (*(unsigned char volatile xdata *)0xFF40)
#define PWM06T1L (*(unsigned char volatile xdata *)0xFF41)
#define PWM06T2H (*(unsigned char volatile xdata *)0xFF42)
#define PWM06T2L (*(unsigned char volatile xdata *)0xFF43)
#define PWM06CR (*(unsigned char volatile xdata *)0xFF44)
#define PWM06HLD (*(unsigned char volatile xdata *)0xFF45)
#define PWM07T1H (*(unsigned char volatile xdata *)0xFF48)
#define PWM07T1L (*(unsigned char volatile xdata *)0xFF49)
#define PWM07T2H (*(unsigned char volatile xdata *)0xFF4A)
#define PWM07T2L (*(unsigned char volatile xdata *)0xFF4B)
#define PWM07CR (*(unsigned char volatile xdata *)0xFF4C)
#define PWM07HLD (*(unsigned char volatile xdata *)0xFF4D)
#define PWM1CH (*(unsigned char volatile xdata *)0xFF50)
#define PWM1CL (*(unsigned char volatile xdata *)0xFF51)
#define PWM1CKS (*(unsigned char volatile xdata *)0xFF52)
#define PWM1IF (*(unsigned char volatile xdata *)0xFF55)
#define PWM1FDCR (*(unsigned char volatile xdata *)0xFF56)
#define PWM10T1H (*(unsigned char volatile xdata *)0xFF60)
#define PWM10T1L (*(unsigned char volatile xdata *)0xFF61)
#define PWM10T2H (*(unsigned char volatile xdata *)0xFF62)
#define PWM10T2L (*(unsigned char volatile xdata *)0xFF63)
#define PWM10CR (*(unsigned char volatile xdata *)0xFF64)
#define PWM10HLD (*(unsigned char volatile xdata *)0xFF65)
#define PWM11T1H (*(unsigned char volatile xdata *)0xFF68)
#define PWM11T1L (*(unsigned char volatile xdata *)0xFF69)
#define PWM11T2H (*(unsigned char volatile xdata *)0xFF6A)
#define PWM11T2L (*(unsigned char volatile xdata *)0xFF6B)
#define PWM11CR (*(unsigned char volatile xdata *)0xFF6C)
#define PWM11HLD (*(unsigned char volatile xdata *)0xFF6D)
#define PWM12T1H (*(unsigned char volatile xdata *)0xFF70)
#define PWM12T1L (*(unsigned char volatile xdata *)0xFF71)
#define PWM12T2H (*(unsigned char volatile xdata *)0xFF72)
#define PWM12T2L (*(unsigned char volatile xdata *)0xFF73)
#define PWM12CR (*(unsigned char volatile xdata *)0xFF74)
#define PWM12HLD (*(unsigned char volatile xdata *)0xFF75)
#define PWM13T1H (*(unsigned char volatile xdata *)0xFF78)
#define PWM13T1L (*(unsigned char volatile xdata *)0xFF79)
#define PWM13T2H (*(unsigned char volatile xdata *)0xFF7A)
#define PWM13T2L (*(unsigned char volatile xdata *)0xFF7B)
#define PWM13CR (*(unsigned char volatile xdata *)0xFF7C)
#define PWM13HLD (*(unsigned char volatile xdata *)0xFF7D)
#define PWM14T1H (*(unsigned char volatile xdata *)0xFF80)
#define PWM14T1L (*(unsigned char volatile xdata *)0xFF81)
#define PWM14T2H (*(unsigned char volatile xdata *)0xFF82)
#define PWM14T2L (*(unsigned char volatile xdata *)0xFF83)
#define PWM14CR (*(unsigned char volatile xdata *)0xFF84)
#define PWM14HLD (*(unsigned char volatile xdata *)0xFF85)
#define PWM15T1H (*(unsigned char volatile xdata *)0xFF88)
#define PWM15T1L (*(unsigned char volatile xdata *)0xFF89)
#define PWM15T2H (*(unsigned char volatile xdata *)0xFF8A)
#define PWM15T2L (*(unsigned char volatile xdata *)0xFF8B)
#define PWM15CR (*(unsigned char volatile xdata *)0xFF8C)
#define PWM15HLD (*(unsigned char volatile xdata *)0xFF8D)
#define PWM16T1H (*(unsigned char volatile xdata *)0xFF90)
#define PWM16T1L (*(unsigned char volatile xdata *)0xFF91)
#define PWM16T2H (*(unsigned char volatile xdata *)0xFF92)
#define PWM16T2L (*(unsigned char volatile xdata *)0xFF93)
#define PWM16CR (*(unsigned char volatile xdata *)0xFF94)
#define PWM16HLD (*(unsigned char volatile xdata *)0xFF95)
#define PWM17T1H (*(unsigned char volatile xdata *)0xFF98)
#define PWM17T1L (*(unsigned char volatile xdata *)0xFF99)
#define PWM17T2H (*(unsigned char volatile xdata *)0xFF9A)
#define PWM17T2L (*(unsigned char volatile xdata *)0xFF9B)
#define PWM17CR (*(unsigned char volatile xdata *)0xFF9C)
#define PWM17HLD (*(unsigned char volatile xdata *)0xFF9D)
#define PWM2CH (*(unsigned char volatile xdata *)0xFFA0)
#define PWM2CL (*(unsigned char volatile xdata *)0xFFA1)
#define PWM2CKS (*(unsigned char volatile xdata *)0xFFA2)
#define PWM2TADCH (*(unsigned char volatile xdata *)0xFFA3)
#define PWM2TADCL (*(unsigned char volatile xdata *)0xFFA4)
#define PWM2IF (*(unsigned char volatile xdata *)0xFFA5)
#define PWM2FDCR (*(unsigned char volatile xdata *)0xFFA6)
#define PWM20T1H (*(unsigned char volatile xdata *)0xFFB0)
#define PWM20T1L (*(unsigned char volatile xdata *)0xFFB1)
#define PWM20T2H (*(unsigned char volatile xdata *)0xFFB2)
#define PWM20T2L (*(unsigned char volatile xdata *)0xFFB3)
#define PWM20CR (*(unsigned char volatile xdata *)0xFFB4)
#define PWM20HLD (*(unsigned char volatile xdata *)0xFFB5)
#define PWM21T1H (*(unsigned char volatile xdata *)0xFFB8)
#define PWM21T1L (*(unsigned char volatile xdata *)0xFFB9)
#define PWM21T2H (*(unsigned char volatile xdata *)0xFFBA)
#define PWM21T2L (*(unsigned char volatile xdata *)0xFFBB)
#define PWM21CR (*(unsigned char volatile xdata *)0xFFBC)
#define PWM21HLD (*(unsigned char volatile xdata *)0xFFBD)
#define PWM22T1H (*(unsigned char volatile xdata *)0xFFC0)
#define PWM22T1L (*(unsigned char volatile xdata *)0xFFC1)
#define PWM22T2H (*(unsigned char volatile xdata *)0xFFC2)
#define PWM22T2L (*(unsigned char volatile xdata *)0xFFC3)
#define PWM22CR (*(unsigned char volatile xdata *)0xFFC4)
#define PWM22HLD (*(unsigned char volatile xdata *)0xFFC5)
#define PWM23T1H (*(unsigned char volatile xdata *)0xFFC8)
#define PWM23T1L (*(unsigned char volatile xdata *)0xFFC9)
#define PWM23T2H (*(unsigned char volatile xdata *)0xFFCA)
#define PWM23T2L (*(unsigned char volatile xdata *)0xFFCB)
#define PWM23CR (*(unsigned char volatile xdata *)0xFFCC)
#define PWM23HLD (*(unsigned char volatile xdata *)0xFFCD)
#define PWM24T1H (*(unsigned char volatile xdata *)0xFFD0)
#define PWM24T1L (*(unsigned char volatile xdata *)0xFFD1)
#define PWM24T2H (*(unsigned char volatile xdata *)0xFFD2)
#define PWM24T2L (*(unsigned char volatile xdata *)0xFFD3)
#define PWM24CR (*(unsigned char volatile xdata *)0xFFD4)
#define PWM24HLD (*(unsigned char volatile xdata *)0xFFD5)
#define PWM25T1H (*(unsigned char volatile xdata *)0xFFD8)
#define PWM25T1L (*(unsigned char volatile xdata *)0xFFD9)
#define PWM25T2H (*(unsigned char volatile xdata *)0xFFDA)
#define PWM25T2L (*(unsigned char volatile xdata *)0xFFDB)
#define PWM25CR (*(unsigned char volatile xdata *)0xFFDC)
#define PWM25HLD (*(unsigned char volatile xdata *)0xFFDD)
#define PWM26T1H (*(unsigned char volatile xdata *)0xFFE0)
#define PWM26T1L (*(unsigned char volatile xdata *)0xFFE1)
#define PWM26T2H (*(unsigned char volatile xdata *)0xFFE2)
#define PWM26T2L (*(unsigned char volatile xdata *)0xFFE3)
#define PWM26CR (*(unsigned char volatile xdata *)0xFFE4)
#define PWM26HLD (*(unsigned char volatile xdata *)0xFFE5)
#define PWM27T1H (*(unsigned char volatile xdata *)0xFFE8)
#define PWM27T1L (*(unsigned char volatile xdata *)0xFFE9)
#define PWM27T2H (*(unsigned char volatile xdata *)0xFFEA)
#define PWM27T2L (*(unsigned char volatile xdata *)0xFFEB)
#define PWM27CR (*(unsigned char volatile xdata *)0xFFEC)
#define PWM27HLD (*(unsigned char volatile xdata *)0xFFED)
#define PWM3CH (*(unsigned char volatile xdata *)0xFC00)
#define PWM3CL (*(unsigned char volatile xdata *)0xFC01)
#define PWM3CKS (*(unsigned char volatile xdata *)0xFC02)
#define PWM3IF (*(unsigned char volatile xdata *)0xFC05)
#define PWM3FDCR (*(unsigned char volatile xdata *)0xFC06)
#define PWM30T1H (*(unsigned char volatile xdata *)0xFC10)
#define PWM30T1L (*(unsigned char volatile xdata *)0xFC11)
#define PWM30T2H (*(unsigned char volatile xdata *)0xFC12)
#define PWM30T2L (*(unsigned char volatile xdata *)0xFC13)
#define PWM30CR (*(unsigned char volatile xdata *)0xFC14)
#define PWM30HLD (*(unsigned char volatile xdata *)0xFC15)
#define PWM31T1H (*(unsigned char volatile xdata *)0xFC18)
#define PWM31T1L (*(unsigned char volatile xdata *)0xFC19)
#define PWM31T2H (*(unsigned char volatile xdata *)0xFC1A)
#define PWM31T2L (*(unsigned char volatile xdata *)0xFC1B)
#define PWM31CR (*(unsigned char volatile xdata *)0xFC1C)
#define PWM31HLD (*(unsigned char volatile xdata *)0xFC1D)
#define PWM32T1H (*(unsigned char volatile xdata *)0xFC20)
#define PWM32T1L (*(unsigned char volatile xdata *)0xFC21)
#define PWM32T2H (*(unsigned char volatile xdata *)0xFC22)
#define PWM32T2L (*(unsigned char volatile xdata *)0xFC23)
#define PWM32CR (*(unsigned char volatile xdata *)0xFC24)
#define PWM32HLD (*(unsigned char volatile xdata *)0xFC25)
#define PWM33T1H (*(unsigned char volatile xdata *)0xFC28)
#define PWM33T1L (*(unsigned char volatile xdata *)0xFC29)
#define PWM33T2H (*(unsigned char volatile xdata *)0xFC2A)
#define PWM33T2L (*(unsigned char volatile xdata *)0xFC2B)
#define PWM33CR (*(unsigned char volatile xdata *)0xFC2C)
#define PWM33HLD (*(unsigned char volatile xdata *)0xFC2D)
#define PWM34T1H (*(unsigned char volatile xdata *)0xFC30)
#define PWM34T1L (*(unsigned char volatile xdata *)0xFC31)
#define PWM34T2H (*(unsigned char volatile xdata *)0xFC32)
#define PWM34T2L (*(unsigned char volatile xdata *)0xFC33)
#define PWM34CR (*(unsigned char volatile xdata *)0xFC34)
#define PWM34HLD (*(unsigned char volatile xdata *)0xFC35)
#define PWM35T1H (*(unsigned char volatile xdata *)0xFC38)
#define PWM35T1L (*(unsigned char volatile xdata *)0xFC39)
#define PWM35T2H (*(unsigned char volatile xdata *)0xFC3A)
#define PWM35T2L (*(unsigned char volatile xdata *)0xFC3B)
#define PWM35CR (*(unsigned char volatile xdata *)0xFC3C)
#define PWM35HLD (*(unsigned char volatile xdata *)0xFC3D)
#define PWM36T1H (*(unsigned char volatile xdata *)0xFC40)
#define PWM36T1L (*(unsigned char volatile xdata *)0xFC41)
#define PWM36T2H (*(unsigned char volatile xdata *)0xFC42)
#define PWM36T2L (*(unsigned char volatile xdata *)0xFC43)
#define PWM36CR (*(unsigned char volatile xdata *)0xFC44)
#define PWM36HLD (*(unsigned char volatile xdata *)0xFC45)
#define PWM37T1H (*(unsigned char volatile xdata *)0xFC48)
#define PWM37T1L (*(unsigned char volatile xdata *)0xFC49)
#define PWM37T2H (*(unsigned char volatile xdata *)0xFC4A)
#define PWM37T2L (*(unsigned char volatile xdata *)0xFC4B)
#define PWM37CR (*(unsigned char volatile xdata *)0xFC4C)
#define PWM37HLD (*(unsigned char volatile xdata *)0xFC4D)
#define PWM4CH (*(unsigned char volatile xdata *)0xFC50)
#define PWM4CL (*(unsigned char volatile xdata *)0xFC51)
#define PWM4CKS (*(unsigned char volatile xdata *)0xFC52)
#define PWM4TADCH (*(unsigned char volatile xdata *)0xFC53)
#define PWM4TADCL (*(unsigned char volatile xdata *)0xFC54)
#define PWM4IF (*(unsigned char volatile xdata *)0xFC55)
#define PWM4FDCR (*(unsigned char volatile xdata *)0xFC56)
#define PWM40T1H (*(unsigned char volatile xdata *)0xFC60)
#define PWM40T1L (*(unsigned char volatile xdata *)0xFC61)
#define PWM40T2H (*(unsigned char volatile xdata *)0xFC62)
#define PWM40T2L (*(unsigned char volatile xdata *)0xFC63)
#define PWM40CR (*(unsigned char volatile xdata *)0xFC64)
#define PWM40HLD (*(unsigned char volatile xdata *)0xFC65)
#define PWM41T1H (*(unsigned char volatile xdata *)0xFC68)
#define PWM41T1L (*(unsigned char volatile xdata *)0xFC69)
#define PWM41T2H (*(unsigned char volatile xdata *)0xFC6A)
#define PWM41T2L (*(unsigned char volatile xdata *)0xFC6B)
#define PWM41CR (*(unsigned char volatile xdata *)0xFC6C)
#define PWM41HLD (*(unsigned char volatile xdata *)0xFC6D)
#define PWM42T1H (*(unsigned char volatile xdata *)0xFC70)
#define PWM42T1L (*(unsigned char volatile xdata *)0xFC71)
#define PWM42T2H (*(unsigned char volatile xdata *)0xFC72)
#define PWM42T2L (*(unsigned char volatile xdata *)0xFC73)
#define PWM42CR (*(unsigned char volatile xdata *)0xFC74)
#define PWM42HLD (*(unsigned char volatile xdata *)0xFC75)
#define PWM43T1H (*(unsigned char volatile xdata *)0xFC78)
#define PWM43T1L (*(unsigned char volatile xdata *)0xFC79)
#define PWM43T2H (*(unsigned char volatile xdata *)0xFC7A)
#define PWM43T2L (*(unsigned char volatile xdata *)0xFC7B)
#define PWM43CR (*(unsigned char volatile xdata *)0xFC7C)
#define PWM43HLD (*(unsigned char volatile xdata *)0xFC7D)
#define PWM44T1H (*(unsigned char volatile xdata *)0xFC80)
#define PWM44T1L (*(unsigned char volatile xdata *)0xFC81)
#define PWM44T2H (*(unsigned char volatile xdata *)0xFC82)
#define PWM44T2L (*(unsigned char volatile xdata *)0xFC83)
#define PWM44CR (*(unsigned char volatile xdata *)0xFC84)
#define PWM44HLD (*(unsigned char volatile xdata *)0xFC85)
#define PWM45T1H (*(unsigned char volatile xdata *)0xFC88)
#define PWM45T1L (*(unsigned char volatile xdata *)0xFC89)
#define PWM45T2H (*(unsigned char volatile xdata *)0xFC8A)
#define PWM45T2L (*(unsigned char volatile xdata *)0xFC8B)
#define PWM45CR (*(unsigned char volatile xdata *)0xFC8C)
#define PWM45HLD (*(unsigned char volatile xdata *)0xFC8D)
#define PWM46T1H (*(unsigned char volatile xdata *)0xFC90)
#define PWM46T1L (*(unsigned char volatile xdata *)0xFC91)
#define PWM46T2H (*(unsigned char volatile xdata *)0xFC92)
#define PWM46T2L (*(unsigned char volatile xdata *)0xFC93)
#define PWM46CR (*(unsigned char volatile xdata *)0xFC94)
#define PWM46HLD (*(unsigned char volatile xdata *)0xFC95)
#define PWM47T1H (*(unsigned char volatile xdata *)0xFC98)
#define PWM47T1L (*(unsigned char volatile xdata *)0xFC99)
#define PWM47T2H (*(unsigned char volatile xdata *)0xFC9A)
#define PWM47T2L (*(unsigned char volatile xdata *)0xFC9B)
#define PWM47CR (*(unsigned char volatile xdata *)0xFC9C)
#define PWM47HLD (*(unsigned char volatile xdata *)0xFC9D)
#define PWM5CH (*(unsigned char volatile xdata *)0xFCA0)
#define PWM5CL (*(unsigned char volatile xdata *)0xFCA1)
#define PWM5CKS (*(unsigned char volatile xdata *)0xFCA2)
#define PWM5IF (*(unsigned char volatile xdata *)0xFCA5)
#define PWM5FDCR (*(unsigned char volatile xdata *)0xFCA6)
#define PWM50T1H (*(unsigned char volatile xdata *)0xFCB0)
#define PWM50T1L (*(unsigned char volatile xdata *)0xFCB1)
#define PWM50T2H (*(unsigned char volatile xdata *)0xFCB2)
#define PWM50T2L (*(unsigned char volatile xdata *)0xFCB3)
#define PWM50CR (*(unsigned char volatile xdata *)0xFCB4)
#define PWM50HLD (*(unsigned char volatile xdata *)0xFCB5)
#define PWM51T1H (*(unsigned char volatile xdata *)0xFCB8)
#define PWM51T1L (*(unsigned char volatile xdata *)0xFCB9)
#define PWM51T2H (*(unsigned char volatile xdata *)0xFCBA)
#define PWM51T2L (*(unsigned char volatile xdata *)0xFCBB)
#define PWM51CR (*(unsigned char volatile xdata *)0xFCBC)
#define PWM51HLD (*(unsigned char volatile xdata *)0xFCBD)
#define PWM52T1H (*(unsigned char volatile xdata *)0xFCC0)
#define PWM52T1L (*(unsigned char volatile xdata *)0xFCC1)
#define PWM52T2H (*(unsigned char volatile xdata *)0xFCC2)
#define PWM52T2L (*(unsigned char volatile xdata *)0xFCC3)
#define PWM52CR (*(unsigned char volatile xdata *)0xFCC4)
#define PWM52HLD (*(unsigned char volatile xdata *)0xFCC5)
#define PWM53T1H (*(unsigned char volatile xdata *)0xFCC8)
#define PWM53T1L (*(unsigned char volatile xdata *)0xFCC9)
#define PWM53T2H (*(unsigned char volatile xdata *)0xFCCA)
#define PWM53T2L (*(unsigned char volatile xdata *)0xFCCB)
#define PWM53CR (*(unsigned char volatile xdata *)0xFCCC)
#define PWM53HLD (*(unsigned char volatile xdata *)0xFCCD)
#define PWM54T1H (*(unsigned char volatile xdata *)0xFCD0)
#define PWM54T1L (*(unsigned char volatile xdata *)0xFCD1)
#define PWM54T2H (*(unsigned char volatile xdata *)0xFCD2)
#define PWM54T2L (*(unsigned char volatile xdata *)0xFCD3)
#define PWM54CR (*(unsigned char volatile xdata *)0xFCD4)
#define PWM54HLD (*(unsigned char volatile xdata *)0xFCD5)
#define PWM55T1H (*(unsigned char volatile xdata *)0xFCD8)
#define PWM55T1L (*(unsigned char volatile xdata *)0xFCD9)
#define PWM55T2H (*(unsigned char volatile xdata *)0xFCDA)
#define PWM55T2L (*(unsigned char volatile xdata *)0xFCDB)
#define PWM55CR (*(unsigned char volatile xdata *)0xFCDC)
#define PWM55HLD (*(unsigned char volatile xdata *)0xFCDD)
#define PWM56T1H (*(unsigned char volatile xdata *)0xFCE0)
#define PWM56T1L (*(unsigned char volatile xdata *)0xFCE1)
#define PWM56T2H (*(unsigned char volatile xdata *)0xFCE2)
#define PWM56T2L (*(unsigned char volatile xdata *)0xFCE3)
#define PWM56CR (*(unsigned char volatile xdata *)0xFCE4)
#define PWM56HLD (*(unsigned char volatile xdata *)0xFCE5)
#define PWM57T1H (*(unsigned char volatile xdata *)0xFCE8)
#define PWM57T1L (*(unsigned char volatile xdata *)0xFCE9)
#define PWM57T2H (*(unsigned char volatile xdata *)0xFCEA)
#define PWM57T2L (*(unsigned char volatile xdata *)0xFCEB)
#define PWM57CR (*(unsigned char volatile xdata *)0xFCEC)
#define PWM57HLD (*(unsigned char volatile xdata *)0xFCED)
/////////////////////////////////////////////////
/// >>>>> add by cc
#include "../clib/bit.h"
#define D_stdIO_P0_ALL() P0M1=0;P0M0=0;
#define D_HighI_P0_ALL() P0M1=0;P0M0=0XFF;
#define D_HighR_P0_ALL() P0M1=0XFF;P0M0=0;
#define D_OpenD_P0_ALL() P0M1=0XFF;P0M0=0XFF;
#define D_stdIO_P1_ALL() P1M1=0;P1M0=0;
#define D_HighI_P1_ALL() P1M1=0;P1M0=0XFF;
#define D_HighR_P1_ALL() P1M1=0XFF;P1M0=0;
#define D_OpenD_P1_ALL() P1M1=0XFF;P1M0=0XFF;
#define D_stdIO_P0(n) BITN_0(P0M1,n);BITN_0(P0M0,n); //////00 准双向口 灌电流20mA 拉电流270-150uS
#define D_HighI_P0(n) BITN_0(P0M1,n);BITN_1(P0M0,n); //////01 推挽输出 20mA 加限流
#define D_HighR_P0(n) BITN_1(P0M1,n);BITN_0(P0M0,n); /////////10 高阻
#define D_OpenD_P0(n) BITN_1(P0M1,n);BITN_1(P0M0,n); /////11 开漏 open-Drain 内部上拉电阻断开 开漏模式既可以度外部状态也可以对外输出高低电平
#define D_stdIO_P1(n) BITN_0(P1M1,n);BITN_0(P1M0,n); //////00 准双向口 灌电流20mA 拉电流270-150uS
#define D_HighI_P1(n) BITN_0(P1M1,n);BITN_1(P1M0,n); //////01 推挽输出 20mA 加限流
#define D_HighR_P1(n) BITN_1(P1M1,n);BITN_0(P1M0,n); /////////10 高阻
#define D_OpenD_P1(n) BITN_1(P1M1,n);BITN_1(P1M0,n); /////11 开漏 open-Drain 内部上拉电阻断开 开漏模式既可以度外部状态也可以对外输出高低电平
#define D_stdIO_P2(n) BITN_0(P2M1,n);BITN_0(P2M0,n); //////00 准双向口 灌电流20mA 拉电流270-150uS
#define D_HighI_P2(n) BITN_0(P2M1,n);BITN_1(P2M0,n); //////01 推挽输出 20mA 加限流
#define D_HighR_P2(n) BITN_1(P2M1,n);BITN_0(P2M0,n); /////////10 高阻
#define D_OpenD_P2(n) BITN_1(P2M1,n);BITN_1(P2M0,n); /////11 开漏 open-Drain 内部上拉电阻断开 开漏模式既可以度外部状态也可以对外输出高低电平
#define D_stdIO_P3(n) BITN_0(P3M1,n);BITN_0(P3M0,n); //////00 准双向口 灌电流20mA 拉电流270-150uS
#define D_HighI_P3(n) BITN_0(P3M1,n);BITN_1(P3M0,n); //////01 推挽输出 20mA 加限流
#define D_HighR_P3(n) BITN_1(P3M1,n);BITN_0(P3M0,n); /////////10 高阻
#define D_OpenD_P3(n) BITN_1(P3M1,n);BITN_1(P3M0,n); /////11 开漏 open-Drain 内部上拉电阻断开 开漏模式既可以度外部状态也可以对外输出高低电平
#define D_stdIO_P4(n) BITN_0(P4M1,n);BITN_0(P4M0,n); //////00 准双向口 灌电流20mA 拉电流270-150uS
#define D_HighI_P4(n) BITN_0(P4M1,n);BITN_1(P4M0,n); //////01 推挽输出 20mA 加限流
#define D_HighR_P4(n) BITN_1(P4M1,n);BITN_0(P4M0,n); /////////10 高阻
#define D_OpenD_P4(n) BITN_1(P4M1,n);BITN_1(P4M0,n); /////11 开漏 open-Drain 内部上拉电阻断开 开漏模式既可以度外部状态也可以对外输出高低电平
#define D_stdIO_P5(n) BITN_0(P5M1,n);BITN_0(P5M0,n); //////00 准双向口 灌电流20mA 拉电流270-150uS
#define D_HighI_P5(n) BITN_0(P5M1,n);BITN_1(P5M0,n); //////01 推挽输出 20mA 加限流
#define D_HighR_P5(n) BITN_1(P5M1,n);BITN_0(P5M0,n); /////////10 高阻
#define D_OpenD_P5(n) BITN_1(P5M1,n);BITN_1(P5M0,n); /////11 开漏 open-Drain 内部上拉电阻断开 开漏模式既可以度外部状态也可以对外输出高低电平
#define D_stdIO_P6(n) BITN_0(P6M1,n);BITN_0(P6M0,n); //////00 准双向口 灌电流20mA 拉电流270-150uS
#define D_HighI_P6(n) BITN_0(P6M1,n);BITN_1(P6M0,n); //////01 推挽输出 20mA 加限流
#define D_HighR_P6(n) BITN_1(P6M1,n);BITN_0(P6M0,n); /////////10 高阻
#define D_OpenD_P6(n) BITN_1(P6M1,n);BITN_1(P6M0,n); /////11 开漏 open-Drain 内部上拉电阻断开 开漏模式既可以度外部状态也可以对外输出高低电平
#define D_stdIO_P7(n) BITN_0(P7M1,n);BITN_0(P7M0,n); //////00 准双向口 灌电流20mA 拉电流270-150uS
#define D_HighI_P7(n) BITN_0(P7M1,n);BITN_1(P7M0,n); //////01 推挽输出 20mA 加限流
#define D_HighR_P7(n) BITN_1(P7M1,n);BITN_0(P7M0,n); /////////10 高阻
#define D_OpenD_P7(n) BITN_1(P7M1,n);BITN_1(P7M0,n); /////11 开漏 open-Drain 内部上拉电阻断开 开漏模式既可以度外部状态也可以对外输出高低电平
/***
#define P0_conf_in(n) BITN_1(P0M1,n);BITN_0(P0M0,n);
#define P1_conf_in(n) BITN_1(P1M1,n);BITN_0(P1M0,n);
#define P2_conf_in(n) BITN_1(P2M1,n);BITN_0(P2M0,n);
#define P2_conf_port(n) BITN_0(P2M1,n);BITN_0(P2M0,n);
#define P3_conf_in(n) BITN_1(P3M1,n);BITN_0(P3M0,n);
#define P3_conf_port(n) BITN_0(P3M1,n);BITN_0(P3M0,n);
#define P4_conf_in(n) BITN_1(P4M1,n);BITN_0(P4M0,n);
#define P5_conf_in(n) BITN_1(P5M1,n);BITN_0(P5M0,n);
***/
#define NOP() _nop_()
#define L0_INT4_OPEN() BITN_1(INT_CLKO, INT_EX4)
#define L0_INT4_CLOSE() BITN_0(INT_CLKO, INT_EX4)
#define L0_INT4_AT() BITN_G(INT_CLKO, INT_EX4)
#define L0_INT4_CLEAR() BITN_0(AUXINTIF, INT4IF)
#define L0_INT3_CLEAR() BITN_0(AUXINTIF, INT3IF)
#define L0_INT2_CLEAR() BITN_0(AUXINTIF, INT2IF)
//////
#define L0_INT3_OPEN() BITN_1(INT_CLKO, INT_EX3);
#define L0_INT3_CLOSE() BITN_0(INT_CLKO, INT_EX3);
#define L0_INT2_OPEN() BITN_1(INT_CLKO, INT_EX2);
#define L0_INT2_CLOSE() BITN_0(INT_CLKO, INT_EX2);
#define L0_INT1_OPEN() EX1 = 1;
#define L0_INT1_CLOSE() EX1 = 0;
#define L0_INT0_OPEN() EX0 = 1;
#define L0_INT0_CLOSE() EX0 = 0;
#define D_ISR_int0 0 ///int0 下降沿触发 = 0 上下沿均可触发
#define D_ISR_timer0 1
#define D_ISR_int1 2 ///int1 下降沿触发 = 0 上下沿均可触发
#define D_ISR_timer1 3
#define D_ISR_int2 10 /////只有下降沿
#define D_ISR_int3 11 /////只有下降沿
#define D_SERVE_UART 4
#define D_ISR_int4 16 /////只有下降沿
#if 0
#define L0_TIMER1_start() TR1 = 1;
#define L0_TIMER1_end() TR1 = 0;
#define L0_TIMER1_isr_OPEN() ET1 = 1;
#define L0_TIMER1_isr_CLOSE() ET1 = 0;
#else
#define L0_TIMER1_start() ET1 = 1;
#define L0_TIMER1_end() ET1 = 0;
#define L0_TIMER1_isr_OPEN() TR1 = 1;
#define L0_TIMER1_isr_CLOSE() TR1 = 0;
#endif
/// fixme 颠倒定义会让c51锁死#define _nop_() NOP()
///#define L0_INT3_OPEN() BITN_1(INT_CLKO,INT_EX3); //使能INT3中断
///#define L0_INT3_CLOSE() BITN_0(INT_CLKO,INT_EX3);
#endif //STC_stc8a8k

593
source/cpu/stc_stc8f.h
View File

@ -0,0 +1,593 @@
#ifndef __STC8F_H_
#define __STC8F_H_
/////////////////////////////////////////////////
//包含本头文件后,不用另外再包含"REG51.H"
//内核特殊功能寄存器
sfr ACC = 0xe0;
sfr B = 0xf0;
sfr PSW = 0xd0;
sbit CY = PSW^7;
sbit AC = PSW^6;
sbit F0 = PSW^5;
sbit RS1 = PSW^4;
sbit RS0 = PSW^3;
sbit OV = PSW^2;
sbit F1 = PSW^1;
sbit P = PSW^0;
sfr SP = 0x81;
sfr DPL = 0x82;
sfr DPH = 0x83;
sfr TA = 0xae;
sfr DPS = 0xe3;
sfr DPL1 = 0xe4;
sfr DPH1 = 0xe5;
//I/O 口特殊功能寄存器
sfr P0 = 0x80;
sfr P1 = 0x90;
sfr P2 = 0xa0;
sfr P3 = 0xb0;
sfr P4 = 0xc0;
sfr P5 = 0xc8;
sfr P6 = 0xe8;
sfr P7 = 0xf8;
sfr P0M0 = 0x94;
sfr P0M1 = 0x93;
sfr P1M0 = 0x92;
sfr P1M1 = 0x91;
sfr P2M0 = 0x96;
sfr P2M1 = 0x95;
sfr P3M0 = 0xb2;
sfr P3M1 = 0xb1;
sfr P4M0 = 0xb4;
sfr P4M1 = 0xb3;
sfr P5M0 = 0xca;
sfr P5M1 = 0xc9;
sfr P6M0 = 0xcc;
sfr P6M1 = 0xcb;
sfr P7M0 = 0xe2;
sfr P7M1 = 0xe1;
sbit P00 = P0^0;
sbit P01 = P0^1;
sbit P02 = P0^2;
sbit P03 = P0^3;
sbit P04 = P0^4;
sbit P05 = P0^5;
sbit P06 = P0^6;
sbit P07 = P0^7;
sbit P10 = P1^0;
sbit P11 = P1^1;
sbit P12 = P1^2;
sbit P13 = P1^3;
sbit P14 = P1^4;
sbit P15 = P1^5;
sbit P16 = P1^6;
sbit P17 = P1^7;
sbit P20 = P2^0;
sbit P21 = P2^1;
sbit P22 = P2^2;
sbit P23 = P2^3;
sbit P24 = P2^4;
sbit P25 = P2^5;
sbit P26 = P2^6;
sbit P27 = P2^7;
sbit P30 = P3^0;
sbit P31 = P3^1;
sbit P32 = P3^2;
sbit P33 = P3^3;
sbit P34 = P3^4;
sbit P35 = P3^5;
sbit P36 = P3^6;
sbit P37 = P3^7;
sbit P40 = P4^0;
sbit P41 = P4^1;
sbit P42 = P4^2;
sbit P43 = P4^3;
sbit P44 = P4^4;
sbit P45 = P4^5;
sbit P46 = P4^6;
sbit P47 = P4^7;
sbit P50 = P5^0;
sbit P51 = P5^1;
sbit P52 = P5^2;
sbit P53 = P5^3;
sbit P54 = P5^4;
sbit P55 = P5^5;
sbit P56 = P5^6;
sbit P57 = P5^7;
sbit P60 = P6^0;
sbit P61 = P6^1;
sbit P62 = P6^2;
sbit P63 = P6^3;
sbit P64 = P6^4;
sbit P65 = P6^5;
sbit P66 = P6^6;
sbit P67 = P6^7;
sbit P70 = P7^0;
sbit P71 = P7^1;
sbit P72 = P7^2;
sbit P73 = P7^3;
sbit P74 = P7^4;
sbit P75 = P7^5;
sbit P76 = P7^6;
sbit P77 = P7^7;
//如下特殊功能寄存器位于扩展RAM区域
//访问这些寄存器,需先将P_SW2的BIT7设置为1,才可正常读写
#define P0PU (*(unsigned char volatile xdata *)0xfe10)
#define P1PU (*(unsigned char volatile xdata *)0xfe11)
#define P2PU (*(unsigned char volatile xdata *)0xfe12)
#define P3PU (*(unsigned char volatile xdata *)0xfe13)
#define P4PU (*(unsigned char volatile xdata *)0xfe14)
#define P5PU (*(unsigned char volatile xdata *)0xfe15)
#define P6PU (*(unsigned char volatile xdata *)0xfe16)
#define P7PU (*(unsigned char volatile xdata *)0xfe17)
#define P0NCS (*(unsigned char volatile xdata *)0xfe18)
#define P1NCS (*(unsigned char volatile xdata *)0xfe19)
#define P2NCS (*(unsigned char volatile xdata *)0xfe1a)
#define P3NCS (*(unsigned char volatile xdata *)0xfe1b)
#define P4NCS (*(unsigned char volatile xdata *)0xfe1c)
#define P5NCS (*(unsigned char volatile xdata *)0xfe1d)
#define P6NCS (*(unsigned char volatile xdata *)0xfe1e)
#define P7NCS (*(unsigned char volatile xdata *)0xfe1f)
//系统管理特殊功能寄存器
sfr PCON = 0x87;
#define SMOD 0x80
#define SMOD0 0x40
#define LVDF 0x20
#define POF 0x10
#define GF1 0x08
#define GF0 0x04
#define PD 0x02
#define IDL 0x01
sfr AUXR = 0x8e;
#define T0x12 0x80
#define T1x12 0x40
#define UART_M0x6 0x20
#define T2R 0x10
#define T2_CT 0x08
#define T2x12 0x04
#define EXTRAM 0x02
#define S1ST2 0x01
sfr AUXR2 = 0x97;
#define TXLNRX 0x10
sfr BUS_SPEED = 0xa1;
sfr P_SW1 = 0xa2;
sfr P_SW2 = 0xba;
#define EAXFR 0x80
sfr VOCTRL = 0xbb;
sfr RSTCFG = 0xff;
//如下特殊功能寄存器位于扩展RAM区域
//访问这些寄存器,需先将P_SW2的BIT7设置为1,才可正常读写
#define CKSEL (*(unsigned char volatile xdata *)0xfe00)
#define CLKDIV (*(unsigned char volatile xdata *)0xfe01)
#define IRC24MCR (*(unsigned char volatile xdata *)0xfe02)
#define XOSCCR (*(unsigned char volatile xdata *)0xfe03)
#define IRC32KCR (*(unsigned char volatile xdata *)0xfe04)
//中断特殊功能寄存器
sfr IE = 0xa8;
sbit EA = IE^7;
sbit ELVD = IE^6;
sbit EADC = IE^5;
sbit ES = IE^4;
sbit ET1 = IE^3;
sbit EX1 = IE^2;
sbit ET0 = IE^1;
sbit EX0 = IE^0;
sfr IE2 = 0xaf;
#define ET4 0x40
#define ET3 0x20
#define ES4 0x10
#define ES3 0x08
#define ET2 0x04
#define ESPI 0x02
#define ES2 0x01
sfr IP = 0xb8;
sbit PPCA = IP^7;
sbit PLVD = IP^6;
sbit PADC = IP^5;
sbit PS = IP^4;
sbit PT1 = IP^3;
sbit PX1 = IP^2;
sbit PT0 = IP^1;
sbit PX0 = IP^0;
sfr IP2 = 0xb5;
#define PI2C 0x40
#define PCMP 0x20
#define PX4 0x10
#define PPWMFD 0x08
#define PPWM 0x04
#define PSPI 0x02
#define PS2 0x01
sfr IPH = 0xb7;
#define PPCAH 0x80
#define PLVDH 0x40
#define PADCH 0x20
#define PSH 0x10
#define PT1H 0x08
#define PX1H 0x04
#define PT0H 0x02
#define PX0H 0x01
sfr IP2H = 0xb6;
#define PI2CH 0x40
#define PCMPH 0x20
#define PX4H 0x10
#define PPWMFDH 0x08
#define PPWMH 0x04
#define PSPIH 0x02
#define PS2H 0x01
sfr INTCLKO = 0x8f;
#define EX4 0x40
#define EX3 0x20
#define EX2 0x10
#define T2CLKO 0x04
#define T1CLKO 0x02
#define T0CLKO 0x01
sfr AUXINTIF = 0xef;
#define INT4IF 0x40
#define INT3IF 0x20
#define INT2IF 0x10
#define T4IF 0x04
#define T3IF 0x02
#define T2IF 0x01
//定时器特殊功能寄存器
sfr TCON = 0x88;
sbit TF1 = TCON^7;
sbit TR1 = TCON^6;
sbit TF0 = TCON^5;
sbit TR0 = TCON^4;
sbit IE1 = TCON^3;
sbit IT1 = TCON^2;
sbit IE0 = TCON^1;
sbit IT0 = TCON^0;
sfr TMOD = 0x89;
#define T1_GATE 0x80
#define T1_CT 0x40
#define T1_M1 0x20
#define T1_M0 0x10
#define T0_GATE 0x08
#define T0_CT 0x04
#define T0_M1 0x02
#define T0_M0 0x01
sfr TL0 = 0x8a;
sfr TL1 = 0x8b;
sfr TH0 = 0x8c;
sfr TH1 = 0x8d;
sfr T4T3M = 0xd1;
#define T4R 0x80
#define T4_CT 0x40
#define T4x12 0x20
#define T4CLKO 0x10
#define T3R 0x08
#define T3_CT 0x04
#define T3x12 0x02
#define T3CLKO 0x01
sfr T4H = 0xd2;
sfr T4L = 0xd3;
sfr T3H = 0xd4;
sfr T3L = 0xd5;
sfr T2H = 0xd6;
sfr T2L = 0xd7;
sfr TH4 = 0xd2;
sfr TL4 = 0xd3;
sfr TH3 = 0xd4;
sfr TL3 = 0xd5;
sfr TH2 = 0xd6;
sfr TL2 = 0xd7;
sfr WKTCL = 0xaa;
sfr WKTCH = 0xab;
#define WKTEN 0x80
sfr WDT_CONTR = 0xc1;
#define WDT_FLAG 0x80
#define EN_WDT 0x20
#define CLR_WDT 0x10
#define IDL_WDT 0x08
//串行口特殊功能寄存器
sfr SCON = 0x98;
sbit SM0 = SCON^7;
sbit SM1 = SCON^6;
sbit SM2 = SCON^5;
sbit REN = SCON^4;
sbit TB8 = SCON^3;
sbit RB8 = SCON^2;
sbit TI = SCON^1;
sbit RI = SCON^0;
sfr SBUF = 0x99;
sfr S2CON = 0x9a;
#define S2SM0 0x80
#define S2ST4 0x40
#define S2SM2 0x20
#define S2REN 0x10
#define S2TB8 0x08
#define S2RB8 0x04
#define S2TI 0x02
#define S2RI 0x01
sfr S2BUF = 0x9b;
sfr S3CON = 0xac;
#define S3SM0 0x80
#define S3ST4 0x40
#define S3SM2 0x20
#define S3REN 0x10
#define S3TB8 0x08
#define S3RB8 0x04
#define S3TI 0x02
#define S3RI 0x01
sfr S3BUF = 0xad;
sfr S4CON = 0x84;
#define S4SM0 0x80
#define S4ST4 0x40
#define S4SM2 0x20
#define S4REN 0x10
#define S4TB8 0x08
#define S4RB8 0x04
#define S4TI 0x02
#define S4RI 0x01
sfr S4BUF = 0x85;
sfr SADDR = 0xa9;
sfr SADEN = 0xb9;
//ADC 特殊功能寄存器
sfr ADC_CONTR = 0xbc;
#define ADC_POWER 0x80
#define ADC_START 0x40
#define ADC_FLAG 0x20
sfr ADC_RES = 0xbd;
sfr ADC_RESL = 0xbe;
sfr ADCCFG = 0xde;
#define ADC_RESFMT 0x20
//SPI 特殊功能寄存器
sfr SPSTAT = 0xcd;
#define SPIF 0x80
#define WCOL 0x40
sfr SPCTL = 0xce;
#define SSIG 0x80
#define SPEN 0x40
#define DORD 0x20
#define MSTR 0x10
#define CPOL 0x08
#define CPHA 0x04
sfr SPDAT = 0xcf;
//IAP/ISP 特殊功能寄存器
sfr IAP_DATA = 0xc2;
sfr IAP_ADDRH = 0xc3;
sfr IAP_ADDRL = 0xc4;
sfr IAP_CMD = 0xc5;
#define IAP_IDL 0x00
#define IAP_READ 0x01
#define IAP_WRITE 0x02
#define IAP_ERASE 0x03
sfr IAP_TRIG = 0xc6;
sfr IAP_CONTR = 0xc7;
#define IAPEN 0x80
#define SWBS 0x40
#define SWRST 0x20
#define CMD_FAIL 0x10
sfr ISP_DATA = 0xc2;
sfr ISP_ADDRH = 0xc3;
sfr ISP_ADDRL = 0xc4;
sfr ISP_CMD = 0xc5;
sfr ISP_TRIG = 0xc6;
sfr ISP_CONTR = 0xc7;
//比较器特殊功能寄存器
sfr CMPCR1 = 0xe6;
#define CMPEN 0x80
#define CMPIF 0x40
#define PIE 0x20
#define NIE 0x10
#define PIS 0x08
#define NIS 0x04
#define CMPOE 0x02
#define CMPRES 0x01
sfr CMPCR2 = 0xe7;
#define INVCMPO 0x80
#define DISFLT 0x40
//PCA/PWM 特殊功能寄存器
sfr CCON = 0xd8;
sbit CF = CCON^7;
sbit CR = CCON^6;
sbit CCF3 = CCON^3;
sbit CCF2 = CCON^2;
sbit CCF1 = CCON^1;
sbit CCF0 = CCON^0;
sfr CMOD = 0xd9;
#define CIDL 0x80
#define ECF 0x01
sfr CL = 0xe9;
sfr CH = 0xf9;
sfr CCAPM0 = 0xda;
#define ECOM0 0x40
#define CCAPP0 0x20
#define CCAPN0 0x10
#define MAT0 0x08
#define TOG0 0x04
#define PWM0 0x02
#define ECCF0 0x01
sfr CCAPM1 = 0xdb;
#define ECOM1 0x40
#define CCAPP1 0x20
#define CCAPN1 0x10
#define MAT1 0x08
#define TOG1 0x04
#define PWM1 0x02
#define ECCF1 0x01
sfr CCAPM2 = 0xdc;
#define ECOM2 0x40
#define CCAPP2 0x20
#define CCAPN2 0x10
#define MAT2 0x08
#define TOG2 0x04
#define PWM2 0x02
#define ECCF2 0x01
sfr CCAPM3 = 0xdd;
#define ECOM3 0x40
#define CCAPP3 0x20
#define CCAPN3 0x10
#define MAT3 0x08
#define TOG3 0x04
#define PWM3 0x02
#define ECCF3 0x01
sfr CCAP0L = 0xea;
sfr CCAP1L = 0xeb;
sfr CCAP2L = 0xec;
sfr CCAP3L = 0xed;
sfr CCAP0H = 0xfa;
sfr CCAP1H = 0xfb;
sfr CCAP2H = 0xfc;
sfr CCAP3H = 0xfd;
sfr PCA_PWM0 = 0xf2;
sfr PCA_PWM1 = 0xf3;
sfr PCA_PWM2 = 0xf4;
sfr PCA_PWM3 = 0xf5;
//增强型PWM波形发生器特殊功能寄存器
sfr PWMCFG = 0xf1;
#define CBIF 0x80
#define ETADC 0x40
sfr PWMIF = 0xf6;
#define C7IF 0x80
#define C6IF 0x40
#define C5IF 0x20
#define C4IF 0x10
#define C3IF 0x08
#define C2IF 0x04
#define C1IF 0x02
#define C0IF 0x01
sfr PWMFDCR = 0xf7;
#define INVCMP 0x80
#define INVIO 0x40
#define ENFD 0x20
#define FLTFLIO 0x10
#define EFDI 0x08
#define FDCMP 0x04
#define FDIO 0x02
#define FDIF 0x01
sfr PWMCR = 0xfe;
#define ENPWM 0x80
#define ECBI 0x40
//如下特殊功能寄存器位于扩展RAM区域
//访问这些寄存器,需先将P_SW2的BIT7设置为1,才可正常读写
#define PWMC (*(unsigned int volatile xdata *)0xfff0)
#define PWMCH (*(unsigned char volatile xdata *)0xfff0)
#define PWMCL (*(unsigned char volatile xdata *)0xfff1)
#define PWMCKS (*(unsigned char volatile xdata *)0xfff2)
#define TADCP (*(unsigned char volatile xdata *)0xfff3)
#define TADCPH (*(unsigned char volatile xdata *)0xfff3)
#define TADCPL (*(unsigned char volatile xdata *)0xfff4)
#define PWM0T1 (*(unsigned int volatile xdata *)0xff00)
#define PWM0T1H (*(unsigned char volatile xdata *)0xff00)
#define PWM0T1L (*(unsigned char volatile xdata *)0xff01)
#define PWM0T2 (*(unsigned int volatile xdata *)0xff02)
#define PWM0T2H (*(unsigned char volatile xdata *)0xff02)
#define PWM0T2L (*(unsigned char volatile xdata *)0xff03)
#define PWM0CR (*(unsigned char volatile xdata *)0xff04)
#define PWM0HLD (*(unsigned char volatile xdata *)0xff05)
#define PWM1T1 (*(unsigned int volatile xdata *)0xff10)
#define PWM1T1H (*(unsigned char volatile xdata *)0xff10)
#define PWM1T1L (*(unsigned char volatile xdata *)0xff11)
#define PWM1T2 (*(unsigned int volatile xdata *)0xff12)
#define PWM1T2H (*(unsigned char volatile xdata *)0xff12)
#define PWM1T2L (*(unsigned char volatile xdata *)0xff13)
#define PWM1CR (*(unsigned char volatile xdata *)0xff14)
#define PWM1HLD (*(unsigned char volatile xdata *)0xff15)
#define PWM2T1 (*(unsigned int volatile xdata *)0xff20)
#define PWM2T1H (*(unsigned char volatile xdata *)0xff20)
#define PWM2T1L (*(unsigned char volatile xdata *)0xff21)
#define PWM2T2 (*(unsigned int volatile xdata *)0xff22)
#define PWM2T2H (*(unsigned char volatile xdata *)0xff22)
#define PWM2T2L (*(unsigned char volatile xdata *)0xff23)
#define PWM2CR (*(unsigned char volatile xdata *)0xff24)
#define PWM2HLD (*(unsigned char volatile xdata *)0xff25)
#define PWM3T1 (*(unsigned int volatile xdata *)0xff30)
#define PWM3T1H (*(unsigned char volatile xdata *)0xff30)
#define PWM3T1L (*(unsigned char volatile xdata *)0xff31)
#define PWM3T2 (*(unsigned int volatile xdata *)0xff32)
#define PWM3T2H (*(unsigned char volatile xdata *)0xff32)
#define PWM3T2L (*(unsigned char volatile xdata *)0xff33)
#define PWM3CR (*(unsigned char volatile xdata *)0xff34)
#define PWM3HLD (*(unsigned char volatile xdata *)0xff35)
#define PWM4T1 (*(unsigned int volatile xdata *)0xff40)
#define PWM4T1H (*(unsigned char volatile xdata *)0xff40)
#define PWM4T1L (*(unsigned char volatile xdata *)0xff41)
#define PWM4T2 (*(unsigned int volatile xdata *)0xff42)
#define PWM4T2H (*(unsigned char volatile xdata *)0xff42)
#define PWM4T2L (*(unsigned char volatile xdata *)0xff43)
#define PWM4CR (*(unsigned char volatile xdata *)0xff44)
#define PWM4HLD (*(unsigned char volatile xdata *)0xff45)
#define PWM5T1 (*(unsigned int volatile xdata *)0xff50)
#define PWM5T1H (*(unsigned char volatile xdata *)0xff50)
#define PWM5T1L (*(unsigned char volatile xdata *)0xff51)
#define PWM5T2 (*(unsigned int volatile xdata *)0xff52)
#define PWM5T2H (*(unsigned char volatile xdata *)0xff52)
#define PWM5T2L (*(unsigned char volatile xdata *)0xff53)
#define PWM5CR (*(unsigned char volatile xdata *)0xff54)
#define PWM5HLD (*(unsigned char volatile xdata *)0xff55)
#define PWM6T1 (*(unsigned int volatile xdata *)0xff60)
#define PWM6T1H (*(unsigned char volatile xdata *)0xff60)
#define PWM6T1L (*(unsigned char volatile xdata *)0xff61)
#define PWM6T2 (*(unsigned int volatile xdata *)0xff62)
#define PWM6T2H (*(unsigned char volatile xdata *)0xff62)
#define PWM6T2L (*(unsigned char volatile xdata *)0xff63)
#define PWM6CR (*(unsigned char volatile xdata *)0xff64)
#define PWM6HLD (*(unsigned char volatile xdata *)0xff65)
#define PWM7T1 (*(unsigned int volatile xdata *)0xff70)
#define PWM7T1H (*(unsigned char volatile xdata *)0xff70)
#define PWM7T1L (*(unsigned char volatile xdata *)0xff71)
#define PWM7T2 (*(unsigned int volatile xdata *)0xff72)
#define PWM7T2H (*(unsigned char volatile xdata *)0xff72)
#define PWM7T2L (*(unsigned char volatile xdata *)0xff73)
#define PWM7CR (*(unsigned char volatile xdata *)0xff74)
#define PWM7HLD (*(unsigned char volatile xdata *)0xff75)
//I2C特殊功能寄存器
//如下特殊功能寄存器位于扩展RAM区域
//访问这些寄存器,需先将P_SW2的BIT7设置为1,才可正常读写
#define I2CCFG (*(unsigned char volatile xdata *)0xfe80)
#define ENI2C 0x80
#define MSSL 0x40
#define I2CMSCR (*(unsigned char volatile xdata *)0xfe81)
#define EMSI 0x80
#define I2CMSST (*(unsigned char volatile xdata *)0xfe82)
#define MSBUSY 0x80
#define MSIF 0x40
#define MSACKI 0x02
#define MSACKO 0x01
#define I2CSLCR (*(unsigned char volatile xdata *)0xfe83)
#define ESTAI 0x40
#define ERXI 0x20
#define ETXI 0x10
#define ESTOI 0x08
#define SLRST 0x01
#define I2CSLST (*(unsigned char volatile xdata *)0xfe84)
#define SLBUSY 0x80
#define STAIF 0x40
#define RXIF 0x20
#define TXIF 0x10
#define STOIF 0x08
#define TXING 0x04
#define SLACKI 0x02
#define SLACKO 0x01
#define I2CSLADR (*(unsigned char volatile xdata *)0xfe85)
#define I2CTXD (*(unsigned char volatile xdata *)0xfe86)
#define I2CRXD (*(unsigned char volatile xdata *)0xfe87)
/////////////////////////////////////////////////
#endif

234
source/ctask/task.c
View File

@ -0,0 +1,234 @@
/*****************************************************
*============================================================================
* HISTORY
* Below this line, this part is controlled by TSTS. DO NOT MODIFY!!
伪时间片嵌入式平台(Task Step by Step Turn by Turn Structure，简称TSTS）
*============================================================================
****************************************************************************/
#include "task.h"
//任务命名规则:
// 1:第一层
/// 0驱动芯片级 flash
/// 1芯片应用级 save
/// 2任务应用级 jilu_save
//
// 2:第二层/flash/i2c/7290/等各类芯片
// 3:任务序号/不同的芯片/
//
void L1_task_init(TS_task *s)
{
s->en = 1;
s->sh = 0;
s->sh_next= 0;
s->n= 0;
}
#if 0
//L2_task_voice_handle(&s_task_music.task);
//L1_task_go(D_task_close);
//if(L1_task_busy(s)){ L1_task_goout(s_task_music.task,D_task_voice_send_single) }
void L2_task_voice_handle(struct _s_task_music_ *s)
{ //s_task_music.task.sh
switch(s->task.sh)
{
case D_task_voice_init://
s->sector = 0;
break;
case D_task_voice_cuimian :
s->sector = D_voice_music_wantsleep;
L2_task_go_son(D_task_voice_play,D_task_voice_cuimian1);
break;
case D_task_voice_cuimian1://
L2_task_go(D_task_voice_cuimian2);
break;
case D_task_voice_cuimian2://
if(0 == s->volume_change)
{
//L3_voice_stop();
s->sector = D_voice_stop;
s->status = D_voice_status_stop;
//L2_task_go(D_task_voice_play);
L2_task_go_son(D_task_voice_play,0);
}else
{
s->volume_change --;
s->volume_temp = s->volume;
s->volume = s->volume_change*s->volume_shop/20;//
if (s->volume_temp != s->volume)
{
s->sector = D_voice_volume|s->volume;
//s->status = D_voice_status_stop;
//L2_task_go(D_task_voice_volume3);
L2_task_go_son(D_task_voice_play,D_task_voice_cuimian2);
}
//else
{
L2_task_delay(D_task_delay_1m);
}
}
break;
//>>>>>>>>>>>>>>>>>> son function
case D_task_voice_play://
if(L3_task_s_busy(s_task_wt558d))
{
}else
{
s_task_wt558d.reg = s_task_music.sector;
L3_task_s_go(s_task_wt558d,D_task_wt558d_fun);
L2_task_go(D_task_voice_ask);
}
break;
case D_task_voice_ask://
if(L3_task_s_busy(s_task_wt558d))
{
}else
{
L2_task_go_father();//回到
}
break;
//<<<<<<<<<<<<<<<<<<<<<< son function
//-----------------------task standerd code
case D_task_Tdelay://----
s->task.n--;
if (s->task.n == 0)
{
s->task.n = 0;
L2_task_delay_over();
}
break;
default :
break;
}
L2_task_wt558d_handle(&s_task_wt558d);
}
void L2_task_voice_handle(struct _s_task_music_ *s)
{ //s_task_music.task.sh
switch(s->task.sh)
{
case D_task_voice_init://
s->sector = 0;
break;
case D_task_voice_cuimian :
s->sector = D_voice_music_wantsleep;
L2_task_go_son(D_task_voice_play,D_task_voice_cuimian1);
break;
case D_task_voice_cuimian1://
L2_task_go(D_task_voice_cuimian2);
break;
//-----------------------task standerd code
case D_task_Tdelay://----
s->task.n--;
if (s->task.n == 0)
{
s->task.n = 0;
L2_task_delay_over();
}
break;
default :
break;
}
L2_task_wt558d_handle(&s_task_wt558d);
}
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//>>>>>>>>>>>>>>>>>>>>>记录task
struct _s_task_4ChuShengRiQi_
{
TS_task task;
unsigned char pic_id;//画面ID
};
extern struct _s_task_4ChuShengRiQi_ s_task_4ChuShengRiQi_;
#define D_task_4ChuShengRiQi_init 0x10
#define D_task_4ChuShengRiQi_key 0x11
extern void L2_task_4ChuShengRiQi_handle(struct _s_task_4ChuShengRiQi_ *s);
void L2_task_4ChuShengRiQi_handle(struct _s_task_4ChuShengRiQi_ *s)
{
switch(s->task.sh)
{
case D_task_4ChuShengRiQi_init://
s->pic_id= 0;
break;
case D_task_4ChuShengRiQi_key :
if(1 == s_task_keyx1.down )
{
s_task_keyx1.down = 0;
if(D_keyx_left == s_task_keyx1.key_value)
{}
}else if(1 == s_task_keyx_4.down)
{
s_task_keyx_4.down = 0;
}
else {}
//L2_task_go_son(D_task_4ChuShengRiQi_play,D_task_4ChuShengRiQi_cuimian1);
break;
L0_task_delay();
}
}
//<<<<<<<<<<<<<<<<<<<记录task
//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
/*****************************************************
*==============================================================
* HISTORYmm
* Below this line, this part is controlled by TSTS. DO NOT MODIFY!!
伪时间片嵌入式平台(Task Step by Step Turn by Turn Structure，简称TSTS）
*==============================================================
****************************************************************************/
#endif

159
source/ctask/task.h
View File

@ -0,0 +1,159 @@
/********************************
2013.7.23 add dictionary and task step by cc
任务:task
任务段:task step
任务标志:sh ( struct handle)
下一个任务段sh_next
缓存的任务段,sh_next执行完后执行sh_pre
***************************/
/*****************************************************
*==============================================================
* HISTORY
* Below this line, this part is controlled by TSTS. DO NOT MODIFY!!
伪时间片嵌入式平台(Task Step by Step Turn by Turn Structure，简称TSTS）
*==============================================================
****************************************************************************/
#ifndef _TASK_H_
#define _TASK_H_
#include "../clib/type.h"
#include "../msp/time.h"
#include "task.h"
#include "tick.h"
typedef struct _ts_task
{
volatile UN_TYPE en; //关闭任务,也可以理解为暂停,但是使用idelay的地方时间在后台计数任务在延时到了后才暂停,而的delay相当于暂停
volatile UN_TYPE sh; //当前任务段
volatile UN_TYPE sh_next; //下一个任务段,并不代表一定下一任务段一定是他,有可能中间插入延时等任务段
volatile UN_TYPE sh_pre; //前一个任务段,一般为调出缓存任务段使用
vU32 n;
}TS_task;
#define D_task_close 0
#if 0
#define D_task_Tdelay 0x01
#define D_task_stop 0x04
#define D_task_Cdelay 0x09
#define D_task_init 0x10
#define D_task_quit 0xf0
#else
#define D_task_init 0xf0
#define D_task_Tdelay 0xf1
#define D_task_Cdelay 0xf2
#define D_task_stop 0xf3
#define D_task_quit 0xf4
#endif
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>内部调用 s->task
#define L2_task_delay_over() s->task.sh = s->task.sh_next
#define L2_task_go(next) s->task.sh = next;
#define L2_task_en(onf) s->task.en = onf;
#define L2_task_busy(s) (D_task_close != s.task.sh)
#define L2_task_free(s) (D_task_close == s.task.sh)
#define L2_task_go_father() s->task.sh = s->task.sh_pre;
#define L2_task_go_son(fun,pre) s->task.sh = fun;s->task.sh_pre = pre;
/// task 定时>>>>>>>>>>>>>>TTSS
/// D_task_Tdelay == task timer delay 需要额外有个定时单元 和time0定时器设置相关
/// Delay_cycle适用于 时间短的,其一次循环取决于主循环的时间,和Tdelay比,Cdelay长时间计时误差大
#define L2_task_switch_default_idelay(); \
case D_task_Tdelay:\
if (s_nos_tick.jiffies >= s->task.n)\
{\
L2_task_delay_over();\
}\
break; \
case D_task_Cdelay:\
s->task.n--; \
if (s->task.n == 0) \
{ \
s->task.n = 0; \
L2_task_delay_over();\
} \
break;\
default : \
break;
//if(delay_n+s_time0.t_10ms > 655340)
//{s_time0.t_10ms = 0;}
//fix 201312 防止s_time0.t_10ms 溢出
// 但是有风险
//>>L2_task_delay一定要放在L2_task_go之后
#define L1_task_Tdelay(delay_n) s->task.sh_next = s->task.sh;\
s->task.sh = D_task_Tdelay;\
s->task.n = delay_n + s_nos_tick.jiffies;
//>>L2_task_delay一定要放在L2_task_go之后
#define L1_task_Cdelay(delay_n) s->task.sh_next = s->task.sh;\
s->task.sh = D_task_Cdelay;\
s->task.n = delay_n
#define L2_task_go_Tdelay(next,delay_n) do{ \
if(delay_n) \
{ \
s->task.sh_next = next;\
s->task.sh = D_task_Tdelay;\
s->task.n = (delay_n) + s_nos_tick.jiffies; \
} \
else \
{ \
s->task.sh = next; \
} \
}while(0)
#define L2_task_go_Cdelay(next,delay_n) do{ \
if(delay_n) \
{ \
s->task.sh_next = next;\
s->task.sh = D_task_Cdelay;\
s->task.n = (delay_n); \
} \
else \
{ \
s->task.sh = next; \
} \
}while(0)
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 外部调用
#define L3_task_s_go(s,next) (s).task.sh = next;
#define L2_task_s_go_son(s,fun,pre) (s).task.sh = fun;(s).task.sh_pre = pre;
#define L3_task_s_time_start(s,delay) (s).task.n = delay+s_nos_tick.t_1s;
#define L3_task_s_en(s,onf) (s).task.en = onf;
#define L3_task_s_busy(s) (D_task_close != (s).task.sh)
#define L3_task_s_free(s) (D_task_close == (s).task.sh)
#define L3_task_s_step(s) ((s).task.sh)
///>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
#define TTSS_Task_init(); switch(s->task.sh)\
{\
case D_task_init:{\
#define TTSS_Task_step(step); break;}\
case (step):{
#define TTSS_Task_end(); break;}\
L2_task_switch_default_idelay();}
#define TTSS_Task_fun(step); break;}\
case (step):{
//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
extern void L1_task_init(TS_task *s);
#endif//_TASK_H_
/*****************************************************
*==============================================================
* HISTORY
* Below this line, this part is controlled by TSTS. DO NOT MODIFY!!
伪时间片嵌入式平台(Task Step by Step Turn by Turn Structure，简称TSTS）
*==============================================================
****************************************************************************/

48
source/ctask/tick.c
View File

@ -0,0 +1,48 @@
/*****************************************************************************
* uart.h: Header file for NXP LPC17xx Family Microprocessors
*
* Copyright(C) 2017,SensorControl
* All rights reserved.
*
* History
* 2009.05.27 ver 1.00 Prelimnary version, first Release
*2017.01.10 ver 1.10 rename tick.h tick.c
****************************************************************************************/
#include "tick.h"
struct _s_nos_tick_ s_nos_tick;
/*********************************************************************************************************
* Function Name: timer0Isr
* Description: TIMER0 中断处�函数
* Input: æ—?
* Output: æ—?
* Return: æ—?
*********************************************************************************************************/
void L1_tick_init(void)
{
s_nos_tick.jiffies = 0;
s_nos_tick.t_1s = 0;
s_nos_tick.t1s_heatbeart= 0;
}
//JIFFIES回绕问题没有解决 �� linux time_after�定义
void L1_tick_tick (void)
{
///65535*65535/3600/24/365=139nian/s=1.39nian/10ms
///相当于1.39年�t_10ms 溢出，对于电池供电的系统而言 完全�以满足
// 4,294,836,225 = 65535*65535 ;3600*24*60*60 = 31,536,000秒/年
//s_nos_tick.t_50ms ++;//D_led_D1_REV(); 20160522验�
s_nos_tick.jiffies++;
if(s_nos_tick.jiffies % HZ == 0)
{
// 65535*65535/24/60/60/356/10 =12.7å¹´
s_nos_tick.t_1s ++;
s_nos_tick.t1s_heatbeart = 1;
}
}

88
source/ctask/tick.h
View File

@ -0,0 +1,88 @@
/*****************************************************************************
* uart.h: Header file for NXP LPC17xx Family Microprocessors
*
* Copyright(C) 2017,SensorControl
* All rights reserved.
*
* History
* 2009.05.27 ver 1.00 Prelimnary version, first Release
*2017.01.10 ver 1.10 rename tick.h tick.c
******************************************************************************/
#ifndef __tick_H
#define __tick_H
#include "../clib/Type.h"
#include "../msp/time.h"
struct _s_nos_tick_
{
vU32 jiffies; // noos系统定时器最小技术单元
vU32 t_1s;
vU8 t1s_heatbeart; //noos 系统定时器整秒时刻标志,需要软件清除
};
extern struct _s_nos_tick_ s_nos_tick;
#if(TYPE_JIFFIES_5MS == D_sys_Jiffies)
#define HZ 200
#elif(TYPE_JIFFIES_10MS == D_sys_Jiffies)
#define HZ 100
#elif(TYPE_JIFFIES_25MS == D_sys_Jiffies)
#define HZ 50
#endif
#define JIFFIES (1000/HZ)
#define D_sys_now (s_nos_tick.jiffies)
//D_sys_delay_msec以jiffies为最小计时单位，jiffies是10ms为例，参数n=12ms时，最终延时了20ms
#define D_sys_delay_msec(n) do{ \
if(n>0) \
{ \
U32 mstmp = D_sys_now; \
while(D_sys_now - mstmp < (((n)-1)/JIFFIES) + 1); \
} \
}while(0)
#define D_Tdelay_Msec(n) (((n)-1) / JIFFIES + 1)
#define D_Tdelay_Sec(n) (((n)*1000-1) /JIFFIES + 1)
#define D_Tdelay_5ms ((5-1) / JIFFIES + 1)
#define D_Tdelay_10ms ((10-1) / JIFFIES + 1)
#define D_Tdelay_100ms ((100-1) / JIFFIES + 1)
#define D_Tdelay_200ms ((200-1) / JIFFIES+ 1)
#define D_Tdelay_300ms ((300-1) / JIFFIES + 1)
#define D_Tdelay_400ms ((400-1) / JIFFIES + 1)
#define D_Tdelay_1s (1 * HZ)
#define D_Tdelay_2s (2 * HZ)
#define D_Tdelay_3s (3 * HZ)
#define D_Tdelay_4s (4 * HZ)
#define D_Tdelay_5s (5 * HZ)
#define D_Tdelay_10s (10 * HZ)
#define D_Tdelay_15s (15 * HZ)
#define D_Tdelay_1min (1 * 60 * HZ)
#define D_Tdelay_10min (10 * 60 * HZ)
#define D_Tdelay_1h (60 * 60 * HZ)
#define D_Tdelay_1day (24 * 60 * 60 * HZ)
//必须配对
#define L0_nos_tick10ms_start(start_n) start_n = s_nos_tick.t_50ms
#define L0_nos_tick10ms_interval(start_n) (s_nos_tick.t_50ms - start_n)
#define L0_nos_tick1s_start(start_n) start_n = s_nos_tick.t_1s
#define L0_nos_tick1s_interval(start_n) (s_nos_tick.t_1s - start_n)
//>>>//必须配对
#define L2_tick_time_stamp(time_stamp) time_stamp = s_nos_tick.t_50ms;
#define L2_tick_time_interval(time_stamp,time_overflow) (( s_nos_tick.t_50ms - time_stamp) > time_overflow)
#define L3_tick_interval(x) L2_tick_time_interval(s_nos_tick.n_stamp,x)
#define L2_tick_stamp() L2_tick_time_stamp(s_nos_tick.n_stamp);
extern void L1_tick_init(void);
extern void L1_tick_tick (void);
#endif /* end __tick_H */
/*****************************************************************************
** End Of File
******************************************************************************/

7
source/debug/cc_as_stc01_main.ini
View File

@ -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

6
source/debug/cc_ls_03_debug.ini
View File

@ -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

123
source/debug/debug.ini
View File

@ -0,0 +1,123 @@
MODE COM1 9600,0,8,1
//assign com1 SOUT
ASSIGN COM1 < SIN > SOUT
//ASSIGN WIN <SIN >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)

BIN
source/debug/testiic.uvla
View File

Binary file not shown.

217
source/msp/UART0.C
View File

@ -0,0 +1,217 @@
//////////////////////////////////////////////////////////////////////////
/// COPYRIGHT NOTICE
/// Copyright (c) 2015, 传控科技
/// All rights reserved.
///
/// @file main.c
/// @brief main app
///
///（本文件实现的功能的详述）
///
/// @version 1.1 CCsens technology
/// @author CC
/// @date 20150102
///
///
/// 修订说明：最初版本
/// Modified by:
/// Modified date:
/// Version:
/// Descriptions:
// 20160413 CC-ACC-VH02
// 连接至 J22 RXD0 TXD0
//P5_DIR &= ~BITN1; //p5.1输出TXD
//P5_DIR |= BITN0; //p5.0输入RXD
//P5_SEL0 &= ~(BITN0 +BITN1); //设置P5.0 P5.1为UART0 RXD TXD
//P5_SEL1 |= BITN0 +BITN1;
/*****************************************************************************
update by cc @201700110
针对多串口 和 单一串口 有区别 每个串口是独立的还是分开的有讲究 程序是复杂的还是软件应用简单是
个需要平衡的事情.
clib/clib.c:
公用的函数 和硬件无关
放置串行模式(串口等其他通讯总线类的输出)输出的函数,
一些覆盖模式输出的(lcd等固屏输出的)的也可使用
void Lc_print(void (*L0pf_send_uc)(char ww), char *dat,...)
-----------------------------------------------------------------------------------------
uartcom/Uprotocol2app
协议到应用
为了适应不同的通讯协议需要不同的uart口来对应 和应用相关
typedef struct _ts_lcm_pro_; 应用协议包的定义? LCM的协议------------
L3_UARTcom0_exp_protocol 解析应用协议
-----------------------------------------------------------------------------------------
uartcom/urec2protocol: 接收到的数据放入到指向特定协议的缓存中，和协议的格式有关 一般分为 标头式或者标尾式
公用的串口通讯定义
struct _s_uart_rec_ 的公共协议包(关键的结构体)的声明------struct _s_uart_rec_
void L1_uart_2buf(struct _s_uart_rec_ *p)串行数据保存到指向特定协议的缓冲中
--------------------------------------------------------------------------------------------
msp/uartx.c 底层代码 和cpu相关 缓存发送也放在里面
L0_UART0_Init
UART0_IRQHandler
L0_Usend_uc------UserDef
-----------------------------------------------------------------------------------------
********************************************************************************/
#include "uart0.h"
#include "../msp/time.h"
//#define _USE_485
static volatile Ts_uart_send_buf idata ts_uart_send_shop;
TP_Handler_X s_uart0_rec;
TS_PH4_modbus s_uart0_ack;
void L0_uart0_init(void)
{
#if(MainFre_22M == D_sys_MainFre) //115200bps@22.1184MHz
SCON = 0x50; //8位数据,可变波特率
AUXR |= 0x40; //定时器1时钟为Fosc,即1T
AUXR &= 0xFE; //串口1选择定时器1为波特率发生器
TMOD &= 0x0F; //设定定时器1为16位自动重装方式
TL1 = 0xD0; //设定定时初值
TH1 = 0xFF; //设定定时初值
ET1 = 0; //禁止定时器1中断
TR1 = 1; //启动定时器1
#elif(MainFre_11M == D_sys_MainFre) //115200bps@22.1184MHz
#if(BRT_115200 == D_uart0_BRT && SBIT_1 == D_uart0_SBIT) //115200bps@11.0592MHz
SCON = 0x50; //8位数据,可变波特率
AUXR |= 0x01; //串口1选择定时器2为波特率发生器
AUXR &= 0xFB; //定时器2时钟为Fosc/12,即12T
T2L = 0xFE; //设定定时初值
T2H = 0xFF; //设定定时初值
AUXR |= 0x10; //启动定时器2
#elif(BRT_19200 == D_uart0_BRT && SBIT_1 == D_uart0_SBIT) //19200@11.0592MHz
xxxx
SCON = 0x50; //8位数据,可变波特率
AUXR |= 0x01; //串口1选择定时器2为波特率发生器
AUXR |= 0x04; //定时器2时钟为Fosc,即1T
T2L = 0x70; //设定定时初值
T2H = 0xFF; //设定定时初值
AUXR |= 0x10; //启动定时器2
#elif(BRT_19200 == D_uart0_BRT && SBIT_2 == D_uart0_SBIT) //19200@11.0592MHz
xxx
//使用第9位数据模拟1个停止位,可变波特率;SM2=0, TB8=1(第9bit总为1模拟1个停止位)
SCON = 0xD8;
AUXR |= 0x01; //串口1选择定时器2为波特率发生器
AUXR |= 0x04; //定时器2时钟为Fosc,即1T
T2L = 0x70; //设定定时初值
T2H = 0xFF; //设定定时初值
AUXR |= 0x10; //启动定时器2
#elif (BRT_9600 == D_uart0_BRT) //9600bps@11.0592MHz
xxx
SCON = 0x50; //8位数据,可变波特率
AUXR |= 0x01; //串口1选择定时器2为波特率发生器
AUXR &= 0xFB; //定时器2时钟为Fosc/12,即12T
T2L = 0xE8; //设定定时初值
T2H = 0xFF; //设定定时初值
AUXR |= 0x10; //启动定时器2
#endif
#endif//D_sys_MainFre)
}
void L0_uart0_buf_init(void)
{
ts_uart[uNum0].p = &ts_uart_send_shop;
ts_uart[uNum0].p->now = 0;
ts_uart[uNum0].p->ok = D_ready;
ts_uart[uNum0].t = &s_uart0_rec;
//ts_uart[uNum0].t->head_0 = D_CMD_Filter1_ff;
//ts_uart[uNum0].t->head_1 = D_CMD_Filter1_fe;
ts_uart[uNum0].t->head = 0;
ts_uart[uNum0].t->ok = 0;
ts_uart[uNum0].tp_handler = L1_s2b_PH4;
ts_uart[uNum0].ack = (U8*)&s_uart0_ack;
L0_uart0_init();
D_uart0_ES_INT(1); //打开串口中断
#if (D_UART0_485_TYPE != TYPE_485_NONE)
D_UART0_485_RX() //默认处于接收状态
#endif
}
void L0_uart0_sendArray(U8 * buf, U16 len)
{
#if (D_UART0_485_TYPE != TYPE_485_NONE)
D_UART0_485_TX() //切换到输出状态
#endif
L0_uartN_sendArray(uNum0,buf,len);
}
/*************************************************
UART 中断
*************************************************/
void INTERRUPT_UART(void) D_SERVE_UART
{
//NOP(); NOP(); NOP();
if(L0_uart0_IntRI()) //如果是U0接收中断
{
L0_uart0_IntRIClear(); //清除接收中断标志
L0_timer1_start(0);
ts_uart[uNum0].t->reg = L0_uartN_get(uNum0);
ts_uart[uNum0].tp_handler(ts_uart[uNum0].t);
}
if(L0_uart0_IntTI()) //如果是U0发送中断
{
L0_uart0_IntTIClear(); //清除发送中断标志
if(ts_uart[uNum0].p->max != ts_uart[uNum0].p->now)
{
L0_uartN_set(uNum0,ts_uart[uNum0].p->p[ts_uart[uNum0].p->now]);
ts_uart[uNum0].p->now ++;
}
else
{
ts_uart[uNum0].p->ok = D_ready;
ts_uart[uNum0].p->max = 0;
ts_uart[uNum0].p->now = 0;//可以发送下一个数据
#if (D_UART0_485_TYPE != TYPE_485_NONE)
D_UART0_485_RX() //切换到接收状态
#endif
}
}
//NOP(); NOP(); NOP();
}
#if 0
void timer1_isrHanddle (void) D_SERVE_TIMER1
{//
TF1 = 0;
//s_nos_tick.uart0_free = 1;
//if(s_uart0_rec.head == 1) //收到一条协议
if(s_uart0_rec.head == 1) //收到一条协议
{
s_uart0_rec.head = 0;
P10 ^= 1;
if(s_uart0_rec.ok == 0)
{
s_uart0_rec.ok = 1;
//Lc_buf_copy_uc();
}
}
}
#else
void timer1_isrHanddle(void) D_SERVE_TIMER1
{
struct _tp_handler_x *p = &s_uart0_rec;
if((p->head == 1) && (p->num >= D_s_modbus_min))
{
p->head = 0;
crc16(p->crc,p->buf,p->num - 2); //校验CRC
if(p->crc[0] == p->buf[p->num-2] && p->crc[1] == p->buf[p->num-1])
{
if(p->ok == 0)
{
p->ok = 1;
}
}
LED0 ^= 1;
}
L0_timer1_stop();
}
#endif

88
source/msp/UART0.h
View File

@ -0,0 +1,88 @@
//////////////////////////////////////////////////////////////////////////
/// COPYRIGHT NOTICE
/// Copyright (c) 2015, 传控科技
/// All rights reserved.
///
/// @file main.c
/// @brief main app
///
///（本文件实现的功能的详述）
///
/// @version 1.1 CCsens technology
/// @author CC
/// @date 20150102
///
///
/// 修订说明：最初版本
/// Modified by:
/// Modified date:
/// Version:
/// Descriptions:
//////////////////////////////////////////////////////////////////////////
/*****************************************************************************
update by cc @201700110
针对多串口 和 单一串口 有区别 每个串口是独立的还是分开的有讲究 程序是复杂的还是软件应用简单是
个需要平衡的事情.
clib/clib.c:
公用的函数 和硬件无关
放置串行模式(串口等其他通讯总线类的输出)输出的函数,
一些覆盖模式输出的(lcd等固屏输出的)的也可使用
void Lc_print(void (*L0pf_send_uc)(char ww), char *dat,...)
-----------------------------------------------------------------------------------------
uartcom/Uprotocol2app
协议到应用
为了适应不同的通讯协议需要不同的uart口来对应 和应用相关
typedef struct _ts_lcm_pro_; 应用协议包的定义? LCM的协议------------
L3_UARTcom0_exp_protocol 解析应用协议
-----------------------------------------------------------------------------------------
uartcom/urec2protocol: 接收到的数据放入到指向特定协议的缓存中，和协议的格式有关 一般分为 标头式或者标尾式
公用的串口通讯定义
struct _s_uart_rec_ 的公共协议包(关键的结构体)的声明------struct _s_uart_rec_
void L1_uart_2buf(struct _s_uart_rec_ *p)串行数据保存到指向特定协议的缓冲中
--------------------------------------------------------------------------------------------
msp/uartx.c 底层代码 和cpu相关 缓存发送也放在里面
L0_UART0_Init
UART0_IRQHandler
L0_Usend_uc------UserDef
-----------------------------------------------------------------------------------------
********************************************************************************/
#ifndef _uart0_H
#define _uart0_H
#include "../bsp/bsp_config.h"
#include "../tpc/tpc_modbus.h"
#include "uartN.h"
//#include "../tpc/tpc_x.h"
#define uNum0 0
#define D_uart0_ES_INT(x) ES = (x)
#define L0_uart0_IntRI() (RI)//BITN_G(SCON,U0RI)
#define L0_uart0_IntTI() (TI)//BITN_G(SCON,U0TI)
#define L0_uart0_IntRIClear(); RI = 0;//BITN_0(SCON,U0RI)
#define L0_uart0_IntTIClear(); TI = 0;//BITN_0(SCON,U0TI)
//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
void L0_uart0_buf_init(void);
void L0_uart0_sendArray(U8 * buf, U16 len);
#define L0_uart0_uc(X) L0_uartN_uc(uNum0,X)
#define L0_uart0_us(X) L0_uartN_us(uNum0,X)
#define L0_uart0_ul(X) L0_uartN_ul(uNum0,X)
#define L0_uart0_0d0a() L0_uartN_0d0a(0)
#define L0_uart0_uchex(X) L0_uartN_uchex(uNum0,X)
#define L0_uart0_ushex(X) L0_uartN_ushex(uNum0,X)
#define L0_uart0_ulhex(X) L0_uartN_ulhex(uNum0,X)
#define L0_uart0_sendstr(buf) L0_uartN_sendstr(uNum0,buf)
#define L1_uart0_uchexArray(buf) L1_uartN_uchexArray(uNum0,buf)
extern TP_Handler_X s_uart0_rec;
extern TS_PH4_modbus s_uart0_ack;
#endif //#ifndef _uart0_H

156
source/msp/UART2.c
View File

@ -0,0 +1,156 @@
//////////////////////////////////////////////////////////////////////////
/// COPYRIGHT NOTICE
/// Copyright (c) 2015, 传控科技
/// All rights reserved.
///
/// @file main.c
/// @brief main app
///
///（本文件实现的功能的详述）
///
/// @version 1.1 CCsens technology
/// @author CC
/// @date 20150102
///
///
/// 修订说明：最初版本
/// Modified by:
/// Modified date:
/// Version:
/// Descriptions:
// 20160413 CC-ACC-VH02
// 连接至 J22 RXD0 TXD0
//P5_DIR &= ~BITN1; //p5.1输出TXD
//P5_DIR |= BITN0; //p5.0输入RXD
//P5_SEL0 &= ~(BITN0 +BITN1); //设置P5.0 P5.1为UART0 RXD TXD
//P5_SEL1 |= BITN0 +BITN1;
/*****************************************************************************
update by cc @201700110
针对多串口 和 单一串口 有区别 每个串口是独立的还是分开的有讲究 程序是复杂的还是软件应用简单是
个需要平衡的事情.
clib/clib.c:
公用的函数 和硬件无关
放置串行模式(串口等其他通讯总线类的输出)输出的函数,
一些覆盖模式输出的(lcd等固屏输出的)的也可使用
void Lc_print(void (*L0pf_send_uc)(char ww), char *dat,...)
-----------------------------------------------------------------------------------------
uartcom/Uprotocol2app
协议到应用
为了适应不同的通讯协议需要不同的uart口来对应 和应用相关
typedef struct _ts_lcm_pro_; 应用协议包的定义? LCM的协议------------
L3_UARTcom0_exp_protocol 解析应用协议
-----------------------------------------------------------------------------------------
uartcom/urec2protocol: 接收到的数据放入到指向特定协议的缓存中，和协议的格式有关 一般分为 标头式或者标尾式
公用的串口通讯定义
struct _s_uart_rec_ 的公共协议包(关键的结构体)的声明------struct _s_uart_rec_
void L1_uart_2buf(struct _s_uart_rec_ *p)串行数据保存到指向特定协议的缓冲中
--------------------------------------------------------------------------------------------
msp/uartx.c 底层代码 和cpu相关 缓存发送也放在里面
L0_UART0_Init
UART0_IRQHandler
L0_Usend_uc------UserDef
-----------------------------------------------------------------------------------------
********************************************************************************/
#include "uart2.h"
#include "../app/common.h"
//#define _USE_485
static volatile Ts_uart_send_buf idata ts_uart_send_shop;
TP_Handler_X s_uart2_rec;
TS_PH3_ccmodbus s_uart2_ack;
void L0_uart2_init(void)
{
#if(MainFre_11M == D_sys_MainFre) //115200bps@11.0592MHz
S2CON = 0x50; //8位数据,可变波特率
AUXR |= 0x04; //定时器2时钟为Fosc,即1T
T2L = 0xE8; //设定定时初值
T2H = 0xFF; //设定定时初值
AUXR |= 0x10; //启动定时器2
#elif (MainFre_22M == D_sys_MainFre) //115200bps@22.1184MHz
S2CON = 0x50; //8位数据,可变波特率
AUXR |= 0x04; //定时器2时钟为Fosc,即1T
T2L = 0xD0; //设定定时初值
T2H = 0xFF; //设定定时初值
AUXR |= 0x10; //启动定时器2
#endif
}
void L0_uart2_buf_init(void)
{
ts_uart[uNum2].p = &ts_uart_send_shop;
ts_uart[uNum2].p->now = 0;
ts_uart[uNum2].p->ok = D_ready;
ts_uart[uNum2].t = &s_uart2_rec;
ts_uart[uNum2].t->head_0 = D_CMD_Filter1_ff;
ts_uart[uNum2].t->head_1 = D_CMD_Filter2_fe;
ts_uart[uNum2].t->head = 0;
ts_uart[uNum2].t->ok = 0;
ts_uart[uNum2].tp_handler = L1_s2b_PH3;
ts_uart[uNum2].ack = (U8*)&s_uart2_ack;
L0_uart2_init();
D_uart2_ES_INT(1); //打开串口中断
#if (D_UART2_485_TYPE != TYPE_485_NONE)
D_UART2_485_RX() //默认处于接收状态
#endif
}
void L0_uart2_sendArray(U8 * buf, U16 len)
{
#if (D_UART2_485_TYPE != TYPE_485_NONE)
D_UART2_485_TX() //切换到输出状态
#endif
L0_uartN_sendArray(uNum2,buf,len);
}
/*************************************************
UART 中断
*************************************************/
#define D_SERVE_uart2 interrupt 8
void INTERRUPT_uart2(void) D_SERVE_uart2// using 2
{
//NOP(); NOP(); NOP();
if(L0_uart2_IntRI()) //如果是U2接收中断
{
L0_uart2_IntRIClear(); //清除接收中断标志
ts_uart[uNum2].t->reg = L0_uartN_get(uNum2);
ts_uart[uNum2].tp_handler(ts_uart[uNum2].t);
}
if(L0_uart2_IntTI()) //如果是U0发送中断
{
L0_uart2_IntTIClear(); //清除发送中断标志
if(ts_uart[uNum2].p->max != ts_uart[uNum2].p->now)
{
L0_uartN_set(uNum2,ts_uart[uNum2].p->p[ts_uart[uNum2].p->now]);
ts_uart[uNum2].p->now ++;
}
else
{
ts_uart[uNum2].p->ok = D_ready;
ts_uart[uNum2].p->max = 0;
ts_uart[uNum2].p->now = 0;//可以发送下一个数据
#if (D_UART2_485_TYPE != TYPE_485_NONE)
D_UART2_485_RX() //切换到接收状态
#endif
}
}
//NOP(); NOP(); NOP();
}

86
source/msp/UART2.h
View File

@ -0,0 +1,86 @@
//////////////////////////////////////////////////////////////////////////
/// COPYRIGHT NOTICE
/// Copyright (c) 2015, 传控科技
/// All rights reserved.
///
/// @file main.c
/// @brief main app
///
///（本文件实现的功能的详述）
///
/// @version 1.1 CCsens technology
/// @author CC
/// @date 20150102
///
///
/// 修订说明：最初版本
/// Modified by:
/// Modified date:
/// Version:
/// Descriptions:
//////////////////////////////////////////////////////////////////////////
/*****************************************************************************
update by cc @201700110
针对多串口 和 单一串口 有区别 每个串口是独立的还是分开的有讲究 程序是复杂的还是软件应用简单是
个需要平衡的事情.
clib/clib.c:
公用的函数 和硬件无关
放置串行模式(串口等其他通讯总线类的输出)输出的函数,
一些覆盖模式输出的(lcd等固屏输出的)的也可使用
void Lc_print(void (*L0pf_send_uc)(char ww), char *dat,...)
-----------------------------------------------------------------------------------------
uartcom/Uprotocol2app
协议到应用
为了适应不同的通讯协议需要不同的uart口来对应 和应用相关
typedef struct _ts_lcm_pro_; 应用协议包的定义? LCM的协议------------
L3_UARTcom0_exp_protocol 解析应用协议
-----------------------------------------------------------------------------------------
uartcom/urec2protocol: 接收到的数据放入到指向特定协议的缓存中，和协议的格式有关 一般分为 标头式或者标尾式
公用的串口通讯定义
struct _s_uart_rec_ 的公共协议包(关键的结构体)的声明------struct _s_uart_rec_
void L1_uart_2buf(struct _s_uart_rec_ *p)串行数据保存到指向特定协议的缓冲中
--------------------------------------------------------------------------------------------
msp/uartx.c 底层代码 和cpu相关 缓存发送也放在里面
L0_uart2_Init
uart2_IRQHandler
L0_Usend_uc------UserDef
-----------------------------------------------------------------------------------------
********************************************************************************/
#ifndef _uart2_H
#define _uart2_H
#include "../bsp/bsp_config.h"
#include "../tpc/tpc_ccmodbus.h"
#include "uartN.h"
#define uNum2 1
#define D_uart2_ES_INT(x) (x) ? (BITN_1(IE2,ES2)) : (BITN_0(IE2,ES2))
#define L0_uart2_IntRI() (S2CON & S2RI)//BITN_G(SCON,U0RI)
#define L0_uart2_IntTI() (S2CON & S2TI)//BITN_G(SCON,U0TI)
#define L0_uart2_IntRIClear(); BITN_0(S2CON,S2RI)
#define L0_uart2_IntTIClear(); BITN_0(S2CON,S2TI)
//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
void L0_uart2_buf_init(void);
void L0_uart2_sendArray(U8 * buf, U16 len);
#define L0_uart2_uc(X) L0_uartN_uc(uNum2,X)
#define L0_uart2_us(X) L0_uartN_us(uNum2,X)
#define L0_uart2_ul(X) L0_uartN_ul(uNum2,X)
#define L0_uart2_0d0a() L0_uartN_0d0a(0)
#define L0_uart2_uchex(X) L0_uartN_uchex(uNum2,X)
#define L0_uart2_ushex(X) L0_uartN_ushex(uNum2,X)
#define L0_uart2_ulhex(X) L0_uartN_ulhex(uNum2,X)
#define L0_uart2_sendstr(buf) L0_uartN_sendstr(uNum2,buf)
extern TP_Handler_X s_uart2_rec;
extern TS_PH3_ccmodbus s_uart2_ack;
#endif //#ifndef _uart2_H

170
source/msp/UART3.c
View File

@ -0,0 +1,170 @@
//////////////////////////////////////////////////////////////////////////
/// COPYRIGHT NOTICE
/// Copyright (c) 2015, 传控科技
/// All rights reserved.
///
/// @file main.c
/// @brief main app
///
///（本文件实现的功能的详述）
///
/// @version 1.1 CCsens technology
/// @author CC
/// @date 20150102
///
///
/// 修订说明：最初版本
/// Modified by:
/// Modified date:
/// Version:
/// Descriptions:
// 20160413 CC-ACC-VH02
// 连接至 J22 RXD0 TXD0
//P5_DIR &= ~BITN1; //p5.1输出TXD
//P5_DIR |= BITN0; //p5.0输入RXD
//P5_SEL0 &= ~(BITN0 +BITN1); //设置P5.0 P5.1为UART0 RXD TXD
//P5_SEL1 |= BITN0 +BITN1;
/*****************************************************************************
update by cc @201700110
针对多串口 和 单一串口 有区别 每个串口是独立的还是分开的有讲究 程序是复杂的还是软件应用简单是
个需要平衡的事情.
clib/clib.c:
公用的函数 和硬件无关
放置串行模式(串口等其他通讯总线类的输出)输出的函数,
一些覆盖模式输出的(lcd等固屏输出的)的也可使用
void Lc_print(void (*L0pf_send_uc)(char ww), char *dat,...)
-----------------------------------------------------------------------------------------
uartcom/Uprotocol2app
协议到应用
为了适应不同的通讯协议需要不同的uart口来对应 和应用相关
typedef struct _ts_lcm_pro_; 应用协议包的定义? LCM的协议------------
L3_UARTcom0_exp_protocol 解析应用协议
-----------------------------------------------------------------------------------------
uartcom/urec2protocol: 接收到的数据放入到指向特定协议的缓存中，和协议的格式有关 一般分为 标头式或者标尾式
公用的串口通讯定义
struct _s_uart_rec_ 的公共协议包(关键的结构体)的声明------struct _s_uart_rec_
void L1_uart_2buf(struct _s_uart_rec_ *p)串行数据保存到指向特定协议的缓冲中
--------------------------------------------------------------------------------------------
msp/uartx.c 底层代码 和cpu相关 缓存发送也放在里面
L0_UART0_Init
UART0_IRQHandler
L0_Usend_uc------UserDef
-----------------------------------------------------------------------------------------
********************************************************************************/
#include "uart3.h"
#include "time.h"
#include <stdio.h>
static volatile Ts_uart_send_buf idata ts_uart_send_shop;
struct _tp_handler_x s_uart3_rec;
TS_PH4_modbus s_uart3_ack;
void L0_uart3_init(void)
{
#if(MainFre_11M == D_sys_MainFre) //115200bps@11.0592MHz
S3CON = 0x10; //8位数据,可变波特率
S3CON |= 0x40; //串口3选择定时器3为波特率发生器
T4T3M |= 0x02; //定时器3时钟为Fosc,即1T
T3L = 0xE8; //设定定时初值
T3H = 0xFF; //设定定时初值
T4T3M |= 0x08; //启动定时器3
#elif (MainFre_22M == D_sys_MainFre) //115200bps@22.1184MHz
S3CON = 0x10; //8位数据,可变波特率
S3CON |= 0x40; //串口3选择定时器3为波特率发生器
T4T3M |= 0x02; //定时器3时钟为Fosc,即1T
T3L = 0xD0; //设定定时初值
T3H = 0xFF; //设定定时初值
T4T3M |= 0x08; //启动定时器3
#endif
}
void L0_uart3_buf_init(void)
{
ts_uart[uNum3].p = &ts_uart_send_shop;
ts_uart[uNum3].p->now = 0;
ts_uart[uNum3].p->ok = D_ready;
ts_uart[uNum3].t = &s_uart3_rec;
ts_uart[uNum3].t->head = 0;
ts_uart[uNum3].t->ok = 0;
ts_uart[uNum3].tp_handler = L1_s2b_PH4;
ts_uart[uNum3].ack = (U8*)&s_uart3_ack;
L0_uart3_init();
//D_uart3_ES_INT_OPEN(); //打开串口中断
D_uart3_ES_INT(1); //打开串口中断
#if (D_UART3_485_TYPE != TYPE_485_NONE)
D_UART3_485_RX() //默认处于接收状态
#endif
}
void L0_uart3_sendArray(U8 * buf, U16 len)
{
#if (D_UART3_485_TYPE != TYPE_485_NONE)
D_UART3_485_TX() //切换到输出状态
#endif
L0_uartN_sendArray(uNum3,buf,len);
}
/*************************************************
UART 中断
*************************************************/
#define D_SERVE_UART3 interrupt 17
void INTERRUPT_UART3(void) D_SERVE_UART3// using 3
{
NOP(); NOP(); NOP();
if(L0_uart3_IntRI()) //如果是U0接收中断
{
L0_uart3_IntRIClear(); //清除接收中断标志
ts_uart[uNum3].t->reg = L0_uartN_get(uNum3);
ts_uart[uNum3].tp_handler(ts_uart[uNum3].t);
//L0_timer4_start(0);
}
if(L0_uart3_IntTI())
{
if(L0_uart3_IntTI()) //如果是U0发送中断
{
L0_uart3_IntTIClear(); //清除发送中断标志
if(ts_uart[uNum3].p->max != ts_uart[uNum3].p->now)
{
L0_uartN_set(uNum3,ts_uart[uNum3].p->p[ts_uart[uNum3].p->now]);
ts_uart[uNum3].p->now ++;
}
else
{
ts_uart[uNum3].p->ok = D_ready;
ts_uart[uNum3].p->max = 0;
ts_uart[uNum3].p->now = 0;//可以发送下一个数据
#if (D_UART3_485_TYPE != TYPE_485_NONE)
D_UART3_485_RX() //切换到接收状态
#endif
}
}
}
NOP(); NOP(); NOP();
}
void timer4_isrHanddle(void) D_SERVE_TIMER4
{
struct _tp_handler_x *p = &s_uart3_rec;
if((p->head == 1) && (p->num >= D_s_modbus_min))
{
p->head = 0;
crc16_irq(p->crc,p->buf,p->num - 2); //校验CRC
if(p->crc[0] == p->buf[p->num-2] && p->crc[1] == p->buf[p->num-1])
{
if(p->ok == 0)
{
p->ok = 1;
}
}
LED0 ^= 1;
}
L0_timer4_stop();
}

93
source/msp/UART3.h
View File

@ -0,0 +1,93 @@
//////////////////////////////////////////////////////////////////////////
/// COPYRIGHT NOTICE
/// Copyright (c) 2015, 传控科技
/// All rights reserved.
///
/// @file main.c
/// @brief main app
///
///（本文件实现的功能的详述）
///
/// @version 1.1 CCsens technology
/// @author CC
/// @date 20150102
///
///
/// 修订说明：最初版本
/// Modified by:
/// Modified date:
/// Version:
/// Descriptions:
//////////////////////////////////////////////////////////////////////////
/*****************************************************************************
update by cc @201700110
针对多串口 和 单一串口 有区别 每个串口是独立的还是分开的有讲究 程序是复杂的还是软件应用简单是
个需要平衡的事情.
clib/clib.c:
公用的函数 和硬件无关
放置串行模式(串口等其他通讯总线类的输出)输出的函数,
一些覆盖模式输出的(lcd等固屏输出的)的也可使用
void Lc_print(void (*L0pf_send_uc)(char ww), char *dat,...)
-----------------------------------------------------------------------------------------
uartcom/Uprotocol2app
协议到应用
为了适应不同的通讯协议需要不同的uart口来对应 和应用相关
typedef struct _ts_lcm_pro_; 应用协议包的定义? LCM的协议------------
L3_UARTcom0_exp_protocol 解析应用协议
-----------------------------------------------------------------------------------------
uartcom/urec2protocol: 接收到的数据放入到指向特定协议的缓存中，和协议的格式有关 一般分为 标头式或者标尾式
公用的串口通讯定义
struct _s_uart_rec_ 的公共协议包(关键的结构体)的声明------struct _s_uart_rec_
void L1_uart_2buf(struct _s_uart_rec_ *p)串行数据保存到指向特定协议的缓冲中
--------------------------------------------------------------------------------------------
msp/uartx.c 底层代码 和cpu相关 缓存发送也放在里面
L0_uart3_Init
uart3_IRQHandler
L0_Usend_uc------UserDef
-----------------------------------------------------------------------------------------
********************************************************************************/
#ifndef _uart3_H
#define _uart3_H
#include "../bsp/bsp_config.h"
#include "../tpc/tpc_modbus.h"
#include "uartN.h"
#define uNum3 2
//#define S4SM0 BITN7
#define D_uart3_ES_INT(x) (x) ? (BITN_1(IE2,ES3)) : (BITN_0(IE2,ES3))
//#define D_uart3_ES_INT_CLOSE() BITN_0(IE2,ES3)
//#define D_uart3_ES_INT_OPEN() BITN_1(IE2,ES3)
#define L0_uart3_IntRI() (S3CON & S3RI)//BITN_G(SCON,U0RI)
#define L0_uart3_IntTI() (S3CON & S3TI)//BITN_G(SCON,U0TI)
#define L0_uart3_IntRIClear(); BITN_0(S3CON,S3RI)
#define L0_uart3_IntTIClear(); BITN_0(S3CON,S3TI)
#define L0_uart3_set(x) S3BUF = (x);
#define L0_uart3_get() (S3BUF)
//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
void L0_uart3_buf_init(void);
void L0_uart3_sendArray(U8 * buf, U16 len);
#define L0_uart3_uc(X) L0_uartN_uc(uNum3,X)
#define L0_uart3_us(X) L0_uartN_us(uNum3,X)
#define L0_uart3_ul(X) L0_uartN_ul(uNum3,X)
#define L0_uart3_0d0a() L0_uartN_0d0a(uNum3)
#define L0_uart3_uchex(X) L0_uartN_uchex(uNum3,X)
#define L0_uart3_ushex(X) L0_uartN_ushex(uNum3,X)
#define L0_uart3_ulhex(X) L0_uartN_ulhex(uNum3,X)
#define L0_uart3_sendstr(buf) L0_uartN_sendstr(uNum3,buf)
#define L1_uart3_uchexArray(buf) L1_uartN_uchexArray(uNum3,buf)
extern TP_Handler_X s_uart3_rec;
extern TS_PH4_modbus s_uart3_ack;
#endif //#ifndef _uart3_H

169
source/msp/UART4.C
View File

@ -0,0 +1,169 @@
//////////////////////////////////////////////////////////////////////////
/// COPYRIGHT NOTICE
/// Copyright (c) 2015, 传控科技
/// All rights reserved.
///
/// @file main.c
/// @brief main app
///
///（本文件实现的功能的详述）
///
/// @version 1.1 CCsens technology
/// @author CC
/// @date 20150102
///
///
/// 修订说明：最初版本
/// Modified by:
/// Modified date:
/// Version:
/// Descriptions:
// 20160413 CC-ACC-VH02
// 连接至 J22 RXD0 TXD0
//P5_DIR &= ~BITN1; //p5.1输出TXD
//P5_DIR |= BITN0; //p5.0输入RXD
//P5_SEL0 &= ~(BITN0 +BITN1); //设置P5.0 P5.1为uart4 RXD TXD
//P5_SEL1 |= BITN0 +BITN1;
/*****************************************************************************
update by cc @201700110
针对多串口 和 单一串口 有区别 每个串口是独立的还是分开的有讲究 程序是复杂的还是软件应用简单是
个需要平衡的事情.
clib/clib.c:
公用的函数 和硬件无关
放置串行模式(串口等其他通讯总线类的输出)输出的函数,
一些覆盖模式输出的(lcd等固屏输出的)的也可使用
void Lc_print(void (*L0pf_send_uc)(char ww), char *dat,...)
-----------------------------------------------------------------------------------------
uartcom/Uprotocol2app
协议到应用
为了适应不同的通讯协议需要不同的uart口来对应 和应用相关
typedef struct _ts_lcm_pro_; 应用协议包的定义? LCM的协议------------
L3_UARTcom0_exp_protocol 解析应用协议
-----------------------------------------------------------------------------------------
uartcom/urec2protocol: 接收到的数据放入到指向特定协议的缓存中，和协议的格式有关 一般分为 标头式或者标尾式
公用的串口通讯定义
struct _s_uart_rec_ 的公共协议包(关键的结构体)的声明------struct _s_uart_rec_
void L1_uart_2buf(struct _s_uart_rec_ *p)串行数据保存到指向特定协议的缓冲中
--------------------------------------------------------------------------------------------
msp/uartx.c 底层代码 和cpu相关 缓存发送也放在里面
L0_uart4_Init
uart4_IRQHandler
L0_Usend_uc------UserDef
-----------------------------------------------------------------------------------------
********************************************************************************/
#include "uart4.h"
//#define _USE_485
static volatile Ts_uart_send_buf idata ts_uart_send_shop;
//TP_Handler_X s_uart4_at_rec;
//TP_Handler_X s_uart4_tcp_rec;
TP_Handler_X s_uart4_rec;
TS_PH3_ccmodbus s_uart4_ack;
//#define FOSC 11059200L //系统频率
//#define BAUD4 115200 //串口波特率
void L0_uart4_init(void)//115200bps@11.0592MHz
{
#if(MainFre_11M == D_sys_MainFre)
#if 0
S4CON = 0x50; //8位可变波特率
T4L = (65536 - (FOSC/4/BAUD4)); //设置波特率重装值
T4H = (65536 - (FOSC/4/BAUD4))>>8;
T4T3M |= 0x20; //定时器4为1T模式
T4T3M |= 0x80; //定时器4开始计时
#else
S4CON = 0x10; //8位数据,可变波特率
S4CON |= 0x40; //串口4选择定时器4为波特率发生器
T4T3M |= 0x20; //定时器4时钟为Fosc,即1T
T4L = 0xE8; //设定定时初值
T4H = 0xFF; //设定定时初值
T4T3M |= 0x80; //启动定时器4
#endif
#elif (MainFre_22M == D_sys_MainFre) //115200bps@22.1184MHz
S4CON = 0x10; //8位数据,可变波特率
S4CON |= 0x40; //串口4选择定时器4为波特率发生器
T4T3M |= 0x20; //定时器4时钟为Fosc,即1T
T4L = 0xD0; //设定定时初值
T4H = 0xFF; //设定定时初值
T4T3M |= 0x80; //启动定时器4
#endif
}
void L0_uart4_buf_init(void)
{
ts_uart[uNum4].p = &ts_uart_send_shop;
ts_uart[uNum4].p->now = 0;
ts_uart[uNum4].p->ok = D_ready;
ts_uart[uNum4].t = &s_uart4_rec;
ts_uart[uNum4].t->head_0 = D_CMD_Filter1_ff;
ts_uart[uNum4].t->head_1 = D_CMD_Filter2_fe;
ts_uart[uNum4].t->head = 0;
ts_uart[uNum4].t->ok = 0;
ts_uart[uNum4].tp_handler = L1_s2b_PH3;
ts_uart[uNum4].ack = (U8*)&s_uart4_ack;
//s_uart4_tcp_rec.head_0 = D_CMD_Filter1_ff;
//s_uart4_tcp_rec.head_1 = D_CMD_Filter2_fe;
//s_uart4_tcp_rec.head = 0;
//s_uart4_tcp_rec.ok = 0;
L0_uart4_init();
D_uart4_ES_INT(1); //打开串口中断
#if (D_UART4_485_TYPE != TYPE_485_NONE)
D_UART4_485_RX() //默认处于接收状态
#endif
}
void L0_uart4_sendArray(U8 * buf, U16 len)
{
#if (D_UART4_485_TYPE != TYPE_485_NONE)
D_UART4_485_TX() //切换到输出状态
#endif
L0_uartN_sendArray(uNum4,buf,len);
}
/*************************************************
UART 中断
*************************************************/
#define D_SERVE_uart4 interrupt 18
void INTERRUPT_uart4(void) D_SERVE_uart4// using 2
{
#if 1
//NOP(); NOP(); NOP();
if(L0_uart4_IntRI()) //如果是U0接收中断
{
L0_uart4_IntRIClear(); //清除接收中断标志
ts_uart[uNum4].t->reg = L0_uartN_get(uNum4);
ts_uart[uNum4].tp_handler(ts_uart[uNum4].t);
}
if(L0_uart4_IntTI()) //如果是U0发送中断
{
L0_uart4_IntTIClear(); //清除发送中断标志
if(ts_uart[uNum4].p->max != ts_uart[uNum4].p->now)
{
L0_uartN_set(uNum4,ts_uart[uNum4].p->p[ts_uart[uNum4].p->now]);
ts_uart[uNum4].p->now ++;
}
else
{
ts_uart[uNum4].p->ok = D_ready;
ts_uart[uNum4].p->max = 0;
ts_uart[uNum4].p->now = 0;//可以发送下一个数据
#if (D_UART4_485_TYPE != TYPE_485_NONE)
D_UART4_485_RX() //切换到接收状态
#endif
}
}
//NOP(); NOP(); NOP();
#endif
}

88
source/msp/UART4.h
View File

@ -0,0 +1,88 @@
//////////////////////////////////////////////////////////////////////////
/// COPYRIGHT NOTICE
/// Copyright (c) 2015, 传控科技
/// All rights reserved.
///
/// @file main.c
/// @brief main app
///
///（本文件实现的功能的详述）
///
/// @version 1.1 CCsens technology
/// @author CC
/// @date 20150102
///
///
/// 修订说明：最初版本
/// Modified by:
/// Modified date:
/// Version:
/// Descriptions:
//////////////////////////////////////////////////////////////////////////
/*****************************************************************************
update by cc @201700110
针对多串口 和 单一串口 有区别 每个串口是独立的还是分开的有讲究 程序是复杂的还是软件应用简单是
个需要平衡的事情.
clib/clib.c:
公用的函数 和硬件无关
放置串行模式(串口等其他通讯总线类的输出)输出的函数,
一些覆盖模式输出的(lcd等固屏输出的)的也可使用
void Lc_print(void (*L0pf_send_uc)(char ww), char *dat,...)
-----------------------------------------------------------------------------------------
uartcom/Uprotocol2app
协议到应用
为了适应不同的通讯协议需要不同的uart口来对应 和应用相关
typedef struct _ts_lcm_pro_; 应用协议包的定义? LCM的协议------------
L3_UARTcom0_exp_protocol 解析应用协议
-----------------------------------------------------------------------------------------
uartcom/urec2protocol: 接收到的数据放入到指向特定协议的缓存中，和协议的格式有关 一般分为 标头式或者标尾式
公用的串口通讯定义
struct _s_uart_rec_ 的公共协议包(关键的结构体)的声明------struct _s_uart_rec_
void L1_uart_2buf(struct _s_uart_rec_ *p)串行数据保存到指向特定协议的缓冲中
--------------------------------------------------------------------------------------------
msp/uartx.c 底层代码 和cpu相关 缓存发送也放在里面
L0_uart4_Init
uart4_IRQHandler
L0_Usend_uc------UserDef
-----------------------------------------------------------------------------------------
********************************************************************************/
#ifndef _uart4_H
#define _uart4_H
#include "../bsp/bsp_config.h"
#include "../tpc/tpc_ccmodbus.h"
#include "uartN.h"
#define uNum4 3
#define D_uart4_ES_INT(x) (x) ? (BITN_1(IE2,ES4)) : (BITN_0(IE2,ES4))
#define L0_uart4_IntRI() (S4CON & S4RI)//BITN_G(SCON,U0RI)
#define L0_uart4_IntTI() (S4CON & S4TI)//BITN_G(SCON,U0TI)
#define L0_uart4_IntRIClear(); BITN_0(S4CON,S4RI)
#define L0_uart4_IntTIClear(); BITN_0(S4CON,S4TI)
//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
void L0_uart4_buf_init(void);
void L0_uart4_sendArray(U8 * buf, U16 len);
#define L0_uart4_uc(X) L0_uartN_uc(uNum4,X)
#define L0_uart4_us(X) L0_uartN_us(uNum4,X)
#define L0_uart4_ul(X) L0_uartN_ul(uNum4,X)
#define L0_uart4_0d0a() L0_uartN_0d0a(0)
#define L0_uart4_uchex(X) L0_uartN_uchex(uNum4,X)
#define L0_uart4_ushex(X) L0_uartN_ushex(uNum4,X)
#define L0_uart4_ulhex(X) L0_uartN_ulhex(uNum4,X)
#define L0_uart4_sendstr(buf) L0_uartN_sendstr(uNum4,buf)
#define L1_uart4_uchexArray(buf) L1_uartN_uchexArray(uNum4,buf)
extern TP_Handler_X s_uart4_rec;
extern TS_PH3_ccmodbus s_uart4_ack;
#endif //#ifndef _uart4_H

209
source/msp/UARTN.C
View File

@ -0,0 +1,209 @@
//////////////////////////////////////////////////////////////////////////
/// COPYRIGHT NOTICE
/// Copyright (c) 2015, 传控科技
/// All rights reserved.
///
/// @file main.c
/// @brief main app
///
///（本文件实现的功能的详述）
///
/// @version 1.1 CCsens technology
/// @author CC
/// @date 20150102
///
///
/// 修订说明：最初版本
/// Modified by:
/// Modified date:
/// Version:
/// Descriptions:
// 20160413 CC-ACC-VH02
// 连接至 J22 RXD0 TXD0
//P5_DIR &= ~BITN1; //p5.1输出TXD
//P5_DIR |= BITN0; //p5.0输入RXD
//P5_SEL0 &= ~(BITN0 +BITN1); //设置P5.0 P5.1为UART0 RXD TXD
//P5_SEL1 |= BITN0 +BITN1;
/*****************************************************************************
update by cc @201700110
针对多串口 和 单一串口 有区别 每个串口是独立的还是分开的有讲究 程序是复杂的还是软件应用简单是
个需要平衡的事情.
clib/clib.c:
公用的函数 和硬件无关
放置串行模式(串口等其他通讯总线类的输出)输出的函数,
一些覆盖模式输出的(lcd等固屏输出的)的也可使用
void Lc_print(void (*L0pf_send_uc)(char ww), char *dat,...)
-----------------------------------------------------------------------------------------
uartcom/Uprotocol2app
协议到应用
为了适应不同的通讯协议需要不同的uart口来对应 和应用相关
typedef struct _ts_lcm_pro_; 应用协议包的定义? LCM的协议------------
L3_UARTcom0_exp_protocol 解析应用协议
-----------------------------------------------------------------------------------------
uartcom/urec2protocol: 接收到的数据放入到指向特定协议的缓存中，和协议的格式有关 一般分为 标头式或者标尾式
公用的串口通讯定义
struct _s_uart_rec_ 的公共协议包(关键的结构体)的声明------struct _s_uart_rec_
void L1_uart_2buf(struct _s_uart_rec_ *p)串行数据保存到指向特定协议的缓冲中
--------------------------------------------------------------------------------------------
msp/uartx.c 底层代码 和cpu相关 缓存发送也放在里面
L0_UART0_Init
UART0_IRQHandler
L0_Usend_uc------UserDef
-----------------------------------------------------------------------------------------
********************************************************************************/
#include "uartN.h"
TS_uart_reg idata ts_uart[SERIAL_MAX_NUM] = {0};
void L0_uartN_set(U8 uartx,U8 x) reentrant
{
switch(uartx)
{
case 0:SBUF = (x);break;
case 1:S2BUF = (x);break;
case 2:S3BUF = (x);break;
case 3:S4BUF = (x);break;
default:break;
}
}
U8 L0_uartN_get(U8 uartx)
{
U8 x = 0;
switch(uartx)
{
case 0:x = SBUF; break;
case 1:x = S2BUF;break;
case 2:x = S3BUF;break;
case 3:x = S4BUF;break;
default:break;
}
return x;
}
void L0_waitFree_uartN(U8 uartx)
{
ts_uart[uartx].p->over = 0;
while(ts_uart[uartx].p->ok != D_ready)
{
#if 0 //发送数据特别快时，某些情况下会导致数据发送出错
if(ts_uart[uartx].p->over ++ > 600000)
{
break;
}
#endif
}
}
void L0_uartN_sendArray(U8 uartx,void *buf,U16 len)
{
if(len > 0)
{
L0_waitFree_uartN(uartx);
ts_uart[uartx].p->ok = D_clear;
ts_uart[uartx].p->over = 0;
ts_uart[uartx].p->max = len;
ts_uart[uartx].p->now = 1;
if(len <= D_send_buf_max)
{
//将参数buf拷贝至内部buf
for(ts_uart[uartx].p->num = 0;ts_uart[uartx].p->num < len;ts_uart[uartx].p->num ++)
{
ts_uart[uartx].p->buf[ts_uart[uartx].p->num] = ((U8*)buf)[ts_uart[uartx].p->num];
}
ts_uart[uartx].p->p = ts_uart[uartx].p->buf;
}
else
{
//不使用内部buf,如果再发送完毕之前,参数buf被回收,发送会出错
ts_uart[uartx].p->p = (U8 *)buf;
}
L0_uartN_set(uartx,ts_uart[uartx].p->p[0]);
}
}
void L0_uartN_uc(U8 uartx,U8 ww)
{
L0_uartN_sendArray(uartx,&ww,1);
}
void L0_uartN_us(U8 uartx,vU16 ww)
{
U_U16 uStemp;
uStemp.word = ww;
ts_uart[uartx].p->buf3[0] = uStemp.BYTE2.h;
ts_uart[uartx].p->buf3[1] = uStemp.BYTE2.l;
L0_uartN_sendArray(uartx,ts_uart[uartx].p->buf3,2);
}
void L0_uartN_ul(U8 uartx,vU32 ww)
{
U_U32 uStemp;
uStemp.dWord = ww;
ts_uart[uartx].p->buf3[0] = uStemp.BYTE4.byte0;
ts_uart[uartx].p->buf3[1] = uStemp.BYTE4.byte1;
ts_uart[uartx].p->buf3[2] = uStemp.BYTE4.byte2;
ts_uart[uartx].p->buf3[3] = uStemp.BYTE4.byte3;
L0_uartN_sendArray(uartx,ts_uart[uartx].p->buf3,4);
}
void L0_uartN_0d0a(U8 uartx)
{
ts_uart[uartx].p->buf3[0] = 0x0d;
ts_uart[uartx].p->buf3[1] = 0x0a;
L0_uartN_sendArray(uartx,ts_uart[uartx].p->buf3,2);
}
void L0_uartN_uchex(U8 uartx,U8 ww)
{
ts_uart[uartx].p->buf3[0] = cguHex2Char[D_uc_high(ww)][1];
ts_uart[uartx].p->buf3[1] = cguHex2Char[D_uc_low (ww)][1];
L0_uartN_sendArray(uartx,ts_uart[uartx].p->buf3,2);
}
void L0_uartN_ushex(U8 uartx,vU16 ww)
{
U_F16 k;
k.us = ww;
ts_uart[uartx].p->buf3[0] = cguHex2Char[D_uc_high(k.BYTE2.H)][1];
ts_uart[uartx].p->buf3[1] = cguHex2Char[D_uc_low (k.BYTE2.H)][1];
ts_uart[uartx].p->buf3[2] = cguHex2Char[D_uc_high(k.BYTE2.L)][1];
ts_uart[uartx].p->buf3[3] = cguHex2Char[D_uc_low (k.BYTE2.L)][1];
L0_uartN_sendArray(uartx,ts_uart[uartx].p->buf3,4);
}
void L0_uartN_ulhex(U8 uartx,U32 ww)
{
U_U32 k;
k.dWord = ww;
ts_uart[uartx].p->buf3[0] = cguHex2Char[D_uc_high(k.BYTE4.byte0)][1];
ts_uart[uartx].p->buf3[1] = cguHex2Char[D_uc_low (k.BYTE4.byte0)][1];
ts_uart[uartx].p->buf3[2] = cguHex2Char[D_uc_high(k.BYTE4.byte1)][1];
ts_uart[uartx].p->buf3[3] = cguHex2Char[D_uc_low (k.BYTE4.byte1)][1];
ts_uart[uartx].p->buf3[4] = cguHex2Char[D_uc_high(k.BYTE4.byte2)][1];
ts_uart[uartx].p->buf3[5] = cguHex2Char[D_uc_low (k.BYTE4.byte2)][1];
ts_uart[uartx].p->buf3[6] = cguHex2Char[D_uc_high(k.BYTE4.byte3)][1];
ts_uart[uartx].p->buf3[7] = cguHex2Char[D_uc_low (k.BYTE4.byte3)][1];
L0_uartN_sendArray(uartx,ts_uart[uartx].p->buf3,8);
}
void L0_uartN_sendstr(U8 uartx,U8 *str)
{
L0_uartN_sendArray(uartx,str,libc_strlen(str));
}
void L0_uartN_uchexArray(U8 uartx,vU8 *buf,U16 n)
{
int i;
for(i=0;i<n;i++)
{
L0_uartN_uchex(uartx,buf[i]);
L0_uartN_uc(uartx,' ');
}
L0_uartN_0d0a(uartx);
}

114
source/msp/UARTN.h
View File

@ -0,0 +1,114 @@
//////////////////////////////////////////////////////////////////////////
/// COPYRIGHT NOTICE
/// Copyright (c) 2015, 传控科技
/// All rights reserved.
///
/// @file main.c
/// @brief main app
///
///（本文件实现的功能的详述）
///
/// @version 1.1 CCsens technology
/// @author CC
/// @date 20150102
///
///
/// 修订说明：最初版本
/// Modified by:
/// Modified date:
/// Version:
/// Descriptions:
//////////////////////////////////////////////////////////////////////////
/*****************************************************************************
update by cc @201700110
针对多串口 和 单一串口 有区别 每个串口是独立的还是分开的有讲究 程序是复杂的还是软件应用简单是
个需要平衡的事情.
clib/clib.c:
公用的函数 和硬件无关
放置串行模式(串口等其他通讯总线类的输出)输出的函数,
一些覆盖模式输出的(lcd等固屏输出的)的也可使用
void Lc_print(void (*L0pf_send_uc)(char ww), char *dat,...)
-----------------------------------------------------------------------------------------
uartcom/Uprotocol2app
协议到应用
为了适应不同的通讯协议需要不同的uart口来对应 和应用相关
typedef struct _ts_lcm_pro_; 应用协议包的定义? LCM的协议------------
L3_UARTcom0_exp_protocol 解析应用协议
-----------------------------------------------------------------------------------------
uartcom/urec2protocol: 接收到的数据放入到指向特定协议的缓存中，和协议的格式有关 一般分为 标头式或者标尾式
公用的串口通讯定义
struct _s_uart_rec_ 的公共协议包(关键的结构体)的声明------struct _s_uart_rec_
void L1_uart_2buf(struct _s_uart_rec_ *p)串行数据保存到指向特定协议的缓冲中
--------------------------------------------------------------------------------------------
msp/uartx.c 底层代码 和cpu相关 缓存发送也放在里面
L0_UART0_Init
UART0_IRQHandler
L0_Usend_uc------UserDef
-----------------------------------------------------------------------------------------
********************************************************************************/
#ifndef _uartN_H
#define _uartN_H
#include "../clib/Clib.h"
#include "../tpc/tpc_x.h"
#define D_uartN_free() (0 == ts_uart_send_shop[uartx].max)
#define D_uartN_busy() (0 != ts_uart_send_shop[uartx].max)
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
////fixme:和cpu的程序容量息息相关
#define D_send_buf_max 16 /// 9600bps = 10000bps = 1000 Bps = 1Byte/ms
/// 19200bps = 20000bps = 2000Bps = 2Byte/ms = 1Byte/0.5ms
/// 128Bytes = 128*0.5ms = 64ms
#define D_send_buf2_max 8 //此处改动会影响L0_uartN_ulhex函数
typedef struct _ts_uart0_send_buf_
{//8byte
vU8 num; //接收到的数目注意数据长度的范围
vU8 *p;
vU16 now; /// 当前buf所在的位置 0------(max-1)
vU16 max; /// 当前buf的最大值,也就是需要发送的长度
vU32 over; /// 结束等待标志，over累加到某个值时，结束等待
vU8 ok; /// 发送完成标志
vU8 buf[D_send_buf_max + 1];
/// U8 buf2[D_send_buf2_max];
vU8 buf3[D_send_buf2_max];
//// U8 buf4[D_send_buf_max];
/// U8 buf[D_send_buf_max + 1];//buffer 的第一位是 长度
}Ts_uart_send_buf;
typedef struct _TS_uart_reg
{
Ts_uart_send_buf idata *p;
//eUSCI_UART_Config *c;
//int sta;
//U8 heartbeat;
TP_Handler_X *t;
void (*tp_handler)(TP_Handler_X *); //reentrant;
U8 *ack; //ack
}TS_uart_reg;
//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
#define SERIAL_MAX_NUM 1
extern TS_uart_reg idata ts_uart[SERIAL_MAX_NUM];
extern void L0_uartN_init(U8 uartx);
extern void L0_uartN_set(U8 uartx,U8 x) reentrant;
extern U8 L0_uartN_get(U8 uartx);
extern void L0_uartN_sendArray(U8 uartx,void *buf,U16 len);
extern void L0_uartN_uc(U8 uartx,U8 ww);
extern void L0_uartN_us(U8 uartx,vU16 ww);
extern void L0_uartN_ul(U8 uartx,vU32 ww);
extern void L0_uartN_0d0a(U8 uartx);
extern void L0_uartN_uchex(U8 uartx, U8 ww);
extern void L0_uartN_ushex(U8 uartx, U16 ww);
extern void L0_uartN_ulhex(U8 uartx, U32 ww);
extern void L0_uartN_sendstr(U8 uartx,U8 *buf);
extern void L1_uartN_uchexArray(U8 uartx,vU8 *buf,U16 n);
#endif //#ifndef _uartN_H

355
source/msp/iic_sim.c
View File

@ -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） ，
常简记为NA。发送器发送LSB之后，应当释放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 = 0和no_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: uchar型1字节
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;i<n-1;i++) //读取字节数据
{
*(p + i) = L0_I2C_ReceiveData(); //读取数据
L0_I2C_Ack(); //__/```\__
}
*(p + n - 1) = L0_I2C_ReceiveData();
L0_I2C_NoAck();
L0_I2C_Stop();
}
///////////////////////////////
///写入一个reg 为后续的写命令或者读取服务
void L1_I2C_WriteReg(unsigned char sla,unsigned char reg)
{
L0_I2C_Start(); //启动I2C
L0_I2C_SendData(sla);//发送器件地址
L0_I2C_SendData(reg);
}
// sla.(reg)=cmd
void L2_I2C_WriteCmd(unsigned char sla,unsigned char reg,unsigned char cmd)
{
L1_I2C_WriteReg(sla,reg);
L0_I2C_SendData(cmd);
L0_I2C_Stop();
/*****************
if(gRccUs05 >0)///测试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

64
source/msp/iic_sim.h
View File

@ -0,0 +1,64 @@
//////////////////////////////////////////////////////////////////////////
/// COPYRIGHT NOTICE
/// Copyright (c) 2018, 传控科技
/// All rights reserved.
///
/// @file iic_sim
/// @brief iic 模拟io 版本， 和cpu无关，唯一需要修改的就是头函数中的管脚定义
/// @info 除了io配置 ,其他地方如无必要请勿修改
///（本文件实现的功能的详述）
///
/// @version 1.1 CCsens technology
/// @author CC
/// @date 20180102
//
//////////////////////////////////////////////////////////////////////////
#ifndef _IIC_SIM_H_
#define _IIC_SIM_H_
#include "../clib/type.h"
#include "../clib/clib.h"
#include "../ctask/tick.h"
///>>>端口位定义，可修改!!!!!!>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
#include "../bsp/bsp_config.h"
#if 0
//// for stc 11.0M
#define delay10us() NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();///Lc_delay_us(1) //根据cpu的速率进行相应的调整
#define L0_I2C_delay(x) NOP();NOP();///Lc_delay_us(x)
#else
///#define delay10us() NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();///Lc_delay_us(1) //根据cpu的速率进行相应的调整
///#define L0_I2C_delay(x) NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();///Lc_delay_us(x)
//#define delay10us() Lc_delay_us(3000) //根据cpu的速率进行相应的调整
//#define L0_I2C_delay(x) Lc_delay_us(10000)
///#define delay10us() Lc_delay_us(80) //20us
///#define L0_I2C_delay(x) Lc_delay_us(300) //25us
#define L0_slc_1_delay() Lc_delay_nop(4);
#define L0_slc_0_delay() Lc_delay_nop(1); // 4us
#define L0_I2C_delay(x) ///Lc_delay_us(80)
#endif
//<<<<端口位定义，可修改!!!!!!<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
extern void L2_I2C_ReadReg(unsigned char sla,unsigned char reg,unsigned char *r,unsigned char n);
extern void L2_I2C_WriteCmd(unsigned char sla,unsigned char reg,unsigned char cmd);
extern void L0_I2C_INIT(unsigned char v);
////extern void L2_tws_ReadReg(unsigned char sla,unsigned char reg,
//// unsigned char *v);
#define L2_tws_ReadReg(x,y,z) L2_I2C_ReadReg((x),(y),(z),1)
#endif// #ifndef _IIC_H_

0
source/msp/mcu support/.keep
View File

151
source/msp/msp_eeprom.c
View File

@ -0,0 +1,151 @@
////////////////////////////////////////////////////////////////////////////
///@copyright Copyright (c) 2018, 传控科技 All rights reserved.
///-------------------------------------------------------------------------
/// @file msp_eeprom.c
/// @brief msp @ driver config
///-------------------------------------------------------------------------
/// @version 1.0
/// @author CC
/// @date 20190106
/// @note cc_AS_stc02 由stc-isp v6.0860
//////////////////////////////////////////////////////////////////////////////
#include "msp_eeprom.h"
#define WT_30M 0x80
#define WT_24M 0x81
#define WT_20M 0x82
#define WT_12M 0x83
#define WT_6M 0x84
#define WT_3M 0x85
#define WT_2M 0x86
#define WT_1M 0x87
U_F16 uf_ee_add;
void L0_Iap_Idle()
{
IAP_CONTR = 0; //关闭IAP功能
IAP_CMD = 0; //清除命令寄存器
IAP_TRIG = 0; //清除触发寄存器
IAP_ADDRH = 0x80; //将地址设置到非IAP区域
IAP_ADDRL = 0;
}
char L0_Iap_Read(vU16 addr)
{
char dat;
IAP_CONTR = WT_12M; //使能IAP
IAP_CMD = 1; //设置IAP读命令
IAP_ADDRL = addr; //设置IAP低地址
IAP_ADDRH = addr >> 8; //设置IAP高地址
IAP_TRIG = 0x5a; //写触发命令(0x5a)
IAP_TRIG = 0xa5; //写触发命令(0xa5)
_nop_();
dat = IAP_DATA; //读IAP数据
L0_Iap_Idle(); //关闭IAP功能
return dat;
}
void L0_Iap_Program(vU16 addr, char dat)
{
IAP_CONTR = WT_12M; //使能IAP
IAP_CMD = 2; //设置IAP写命令
IAP_ADDRL = addr; //设置IAP低地址
IAP_ADDRH = addr >> 8; //设置IAP高地址
IAP_DATA = dat; //写IAP数据
IAP_TRIG = 0x5a; //写触发命令(0x5a)
IAP_TRIG = 0xa5; //写触发命令(0xa5)
_nop_();
L0_Iap_Idle(); //关闭IAP功能
}
///每个扇区512字节
///指定地址可以为当前扇区内的任意地址，都会完整擦除当前扇区
void L0_Iap_Erase(vU16 addr)
{
IAP_CONTR = WT_12M; //使能IAP
IAP_CMD = 3; //设置IAP擦除命令
IAP_ADDRL = addr; //设置IAP低地址
IAP_ADDRH = addr >> 8; //设置IAP高地址
IAP_TRIG = 0x5a; //写触发命令(0x5a)
IAP_TRIG = 0xa5; //写触发命令(0xa5)
_nop_(); //
L0_Iap_Idle(); //关闭IAP功能
}
void L0_Iap_Program_array(vU16 addr,U8 *buf,U8 len)
{
U8 i = 0;
for(i=0;i<len;i++)
{
L0_Iap_Program(addr + i,buf[i]);
}
}
void L0_Iap_Read_array(vU16 addr,U8 *buf,U8 len)
{
U8 i = 0;
for(i=0;i<len;i++)
{
buf[i] = L0_Iap_Read(addr + i);
}
}
#if 0
void L1_Iap_main(void)
{
int i;
U16 addr = 0x00;
U8 buf[10];
L0_Iap_Erase(addr);
L0_Iap_Program_array(addr,"abcdefg",7);
L0_Iap_Read_array(addr,buf,10);
for(i=0;i<10;i++)
{
Lc_delay_ms(2);
L0_uart0_uc(buf[i]);
}
L0_Iap_Erase(addr + 0x200);
L0_Iap_Program_array(addr + 0x200,"ABCDEFG",7);
L0_Iap_Read_array(addr + 0x200,buf,10);
for(i=0;i<10;i++)
{
Lc_delay_ms(2);
L0_uart0_uc(buf[i]);
}
#if 0
for(i=0; i<0x1000; i++)
{
L0_Iap_Program(i,0);
}
for(i = 0;i < 0x1010; i++)
{
//L0_uart0_uchex(i%256);
L0_uart0_uchex(L0_Iap_Read(addr + i));
if(i==0x1000-1)
{
Lc_delay_ms(100);
L0_uart0_uchex(i>>8 & 0xFF);
L0_uart0_uchex(i>>0 & 0xFF);
}
}
#endif
Lc_delay_ms(100);
L0_uart0_uc('%');
while(1);
}
#endif

43
source/msp/msp_eeprom.h
View File

@ -0,0 +1,43 @@
//////////////////////////////////////////////////////////////////////////
/// COPYRIGHT NOTICE
/// Copyright (c) 2018, 传控科技
/// All rights reserved.
///
/// @file msp_eeprom
/// @brief msp_eeprom
/// @info
///（本文件实现的功能的详述）
///
/// @version 1.1 CCsens technology
/// @author CC
/// @date 20190106
//
//////////////////////////////////////////////////////////////////////////
#ifndef _msp_eeprom_H_
#define _msp_eeprom_H_
#include "../clib/type.h"
#include "../clib/clib.h"
#include "../ctask/tick.h"
///>>>端口位定义，可修改!!!!!!>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
#include "../bsp/bsp_config.h"
#include "uart0.h"
extern void L3_eeprom_fun(U8 *pPara);
///每个扇区512字节
extern void L0_Iap_Erase(vU16 addr);
extern void L0_Iap_Program(vU16 addr, char dat);
extern char L0_Iap_Read(vU16 addr);
extern void L0_Iap_Program_array(vU16 addr,U8 *buf,U8 len);
extern void L0_Iap_Read_array(vU16 addr,U8 *buf,U8 len);
extern void L1_Iap_main(void);
#endif// #ifndef _msp_eeprom_H_

52
source/msp/msp_id.c
View File

@ -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<MSP_ID_LEN;i++)
{
id[i] = ID[i];
}
}
void L0_id_get_rom(U8 *id)
{
U8 i = 0;
char *ID = (char code *)0x3ff9;
for(i=0;i<MSP_ID_LEN;i++)
{
id[i] = ID[i];
}
}
#if 1
void L0_id_main(void)
{
U8 i,id[MSP_ID_LEN];
L0_id_get_rom(id);
for(i=0;i<MSP_ID_LEN;i++)
{
L0_uart0_uchex(id[i]);
}
while(1);
}
#endif

40
source/msp/msp_id.h
View File

@ -0,0 +1,40 @@
//////////////////////////////////////////////////////////////////////////
/// 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_id_H_
#define _msp_id_H_
#include "../clib/type.h"
#include "../clib/clib.h"
#include "../ctask/tick.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_

205
source/msp/time.c
View File

@ -0,0 +1,205 @@
#include "Time.h"
/*************初始化定时器0由 stc-isp v6.86L定时器计算器生成******************/
#if(MainFre_5M == D_sys_MainFre)
#elif(MainFre_27M == D_sys_MainFre)
#elif(MainFre_22M == D_sys_MainFre)
void L0_timer0_Init(void) //25毫秒@22.1184MHz
{
AUXR &= 0x7F; //定时器时钟12T模式
TMOD &= 0xF0; //设置定时器模式
TL0 = 0x00; //设置定时初值
TH0 = 0x4C; //设置定时初值
TF0 = 0; //清除TF0标志
TR0 = 1; //定时器0开始计时
ET0 = 1; //add by cc
}
/********************************************
void L0_timer0_Init(void) //10毫秒@22.1184MHz
{
AUXR &= 0x7F; //定时器时钟12T模式
TMOD &= 0xF0; //设置定时器模式
TL0 = 0x00; //设置定时初值
TH0 = 0xB8; //设置定时初值
TF0 = 0; //清除TF0标志
TR0 = 1; //定时器0开始计时
ET0 = 1; //add by cc
}
void L0_timer0_Init_32k(void) //4fen@32kHz
{
AUXR &= 0x7F; //定时器时钟12T模式
TMOD &= 0xF0; //设置定时器模式
#if 0
TL0 = 0x00; //设置定时初值
TH0 = 0xB8; //设置定时初值/// 4m20s 71
#else
TL0 = 0x00; //设置定时初值
TH0 = 0xcc; //设置定时初值// ff 4s
#endif
TF0 = 0; //清除TF0标志
TR0 = 1; //定时器0开始计时
ET0 = 1; //add by cc
BITN_0(DR_who_wakeup, DRB_who_wakeup_timer0); /// 标志中断类型: 定时器
}
****************************************************/
#else ///MainFre_11M
void L0_timer0_Init(void) //10毫秒@11.0592MHz
{
AUXR &= 0x7F; //定时器时钟12T模式
TMOD &= 0xF0; //设置定时器模式
TL0 = 0x00; //设置定时初值
TH0 = 0xDC; //设置定时初值
TF0 = 0; //清除TF0标志
TR0 = 1; //定时器0开始计时
ET0 = 1; //add by cc
}
/********************************************
void L0_timer0_Init(void) //25毫秒@11.0592MHz
{
AUXR &= 0x7F; //定时器时钟12T模式
TMOD &= 0xF0; //设置定时器模式
TL0 = 0x00; //设置定时初值
TH0 = 0xA6; //设置定时初值
TF0 = 0; //清除TF0标志
TR0 = 1; //定时器0开始计时
ET0 = 1; //add by cc
}
****************************************************/
#endif//D_sys_MainFre)
//10---87 10s
/********************** Timer0中断函数************************/
/// 和 L0_timer0_Init 关联,需要配置 bsp_config.h中的 D_sys_MainFre
/// 默认10ms 作为TTSS系统的定时引擎
void timer0_isrHanddle (void) D_SERVE_TIMER0
{//
NOP(); NOP(); NOP();
TF0 = 0;
#if 0
/// 65535*65535 /3600/24/365=139nian/s=1.39nian/10ms
///相当于1.39年后t_10ms 溢出，对于电池供电的系统而言 完全可以满足
// 4,294,836,225 = 65535*65535 ;3600*24*60*60 = 31,536,000秒/年
s_nos_tick.t_10ms ++;//D_led_D1_REV(); 20160522 验证
#else
L1_tick_tick(); ///系统中的1sflag 和以10ms为颗粒的延时使用 为tdelay服务
#endif
/// BITN_1(DR_who_wakeup, DRB_who_wakeup_timer0);
NOP(); NOP(); NOP();
}
#if(MainFre_5M == D_sys_MainFre)
#elif(MainFre_27M == D_sys_MainFre)
#elif(MainFre_22M == D_sys_MainFre)
/******************************
void L0_Timer1_Init(void) //35毫秒@22.1184MHz
{///自动重载
AUXR &= 0xFB; //定时器时钟12T模式
T2L = 0x00; //设置定时初值
T2H = 0x04; //设置定时初值
AUXR |= 0x10; //定时器2开始计时
BITN_1(IE2, ET2);// IE2 = ET2; //使能定时器中断
}
**********************************/
#else ///MainFre_11M
void L0_timer1_Init_7ms(void) //7毫秒@11.0592MHz
{
AUXR &= 0xBF; //定时器时钟12T模式
TMOD &= 0x0F; //设置定时器模式
TL1 = 0xCD; //设置定时初值
TH1 = 0xE6; //设置定时初值
TF1 = 0; //清除TF1标志
TR1 = 1; //定时器1开始计时
ET1 = 1; //add by cc
}
void L0_timer1_Init_5ms(void) //5毫秒@11.0592MHz
{//0x7F示波器测试大约40ms，led闪烁 肉眼可见
AUXR &= 0xBF; //定时器时钟12T模式
TMOD &= 0x0F; //设置定时器模式
TL1 = 0x00; //设置定时初值
TH1 = 0xEE; //设置定时初值
TF1 = 0; //清除TF1标志
TR1 = 1; //定时器1开始计时
ET1 = 1; //add by cc
}
void L0_timer1_Init_1ms(void) //1毫秒@11.0592MHz
{
AUXR |= 0x40; //定时器时钟1T模式
TMOD &= 0x0F; //设置定时器模式
TL1 = 0xCD; //设置定时初值
TH1 = 0xD4; //设置定时初值
TF1 = 0; //清除TF1标志
TR1 = 1; //定时器1开始计时
ET1 = 1; //add by cc
}
void L0_timer1_Init(void) //600微秒@11.0592MHz
{
AUXR |= 0x40; //定时器时钟1T模式
TMOD &= 0x0F; //设置定时器模式
TL1 = 0x14; //设置定时初值
TH1 = 0xE6; //设置定时初值
TF1 = 0; //清除TF1标志
TR1 = 1; //定时器1开始计时
ET1 = 1; //add by cc
}
//0x7F示波器测试大约40ms，led闪烁 肉眼可见
void L0_timer1_reset(void)
{
TR1 = 0;
TL1 = 0x14; //设置定时初值
TH1 = 0xE6; //设置定时初值
TR1 = 1;
TF1 = 0;
}
#endif//D_sys_MainFre)
void L0_timer1_start(U16 v) //600微秒@11.0592MHz
{
AUXR |= 0x40; //定时器时钟1T模式
TMOD &= 0x0F; //设置定时器模式
TL1 = 0x14; //设置定时初值
TH1 = 0xE6; //设置定时初值
TF1 = 0; //清除TF1标志
TR1 = 1; //定时器1开始计时
ET1 = 1; //add by cc
}
void L0_timer1_stop(void)
{
TR1 = 0;
TF1 = 0;
}
/******************************END*********************************/

Some files were not shown because too many files changed in this diff

Write Preview
Loading…
Cancel
Save