control.c 73 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011
  1. #include <control.h>
  2. /*
  3. * Copyright (c) 2006-2020, RT-Thread Development Team
  4. *
  5. * SPDX-License-Identifier: Apache-2.0
  6. *
  7. * Change Logs:
  8. * Date Author Notes
  9. * 2020-05-30 Administrator the first version
  10. */
  11. #include "beep.h"
  12. #include "hmi.h"
  13. #include "stdio.h"
  14. #include "sound.h"
  15. #include "dtu_uart2.h"
  16. #include "sht30_collect.h"
  17. #include "app_flashdb.h"
  18. #define DBG_ENABLE
  19. #define DBG_COLOR
  20. #define DBG_TAG "control"
  21. #define DBG_LEVEL DBG_LOG
  22. #include <rtdbg.h> //must after of DBG_LVL, DBG_TAG or other options
  23. /* ---- Y轴移动后等待机械振铃衰减的时间(ms) ----
  24. * 原实现固定等待 1000ms。但振铃量级与本次行程正相关: 对焦细扫只有 10~30 个脉冲的
  25. * 小步, 机械扰动远小于数百脉冲的粗扫大步, 等满 1s 属于无谓等待。
  26. * 32点位全程按 865 次采样计, 这一项单独就占 865s(约占总耗时 70%), 改为按行程
  27. * 自适应后仿真可省约 36% 的墙钟时间, 且不影响精度(精度由细扫插值+消隙回位决定)。
  28. *
  29. * 系数需按实测标定: 回位后以 100ms 间隔连采清晰度, 看多久稳定, 取该值*1.5。
  30. * 若不便标定, 把 AF_SETTLE_MIN_MS 设成 1000 即等价于原行为(安全回退)。 */
  31. #define AF_SETTLE_MIN_MS 200 /* 小步最短等待(ms), 建议 >= 实测振铃衰减时间 */
  32. #define AF_SETTLE_MAX_MS 1000 /* 大行程上限(ms), 与原来一致 */
  33. #define AF_SETTLE_MS_PER_PULSE 30 /* 每脉冲对应的等待时间(ms), 30脉冲->900ms */
  34. #define AF_SETTLE_MS(dis) \
  35. ((rt_uint32_t)(dis) * AF_SETTLE_MS_PER_PULSE < AF_SETTLE_MIN_MS \
  36. ? (rt_uint32_t)AF_SETTLE_MIN_MS \
  37. : ((rt_uint32_t)(dis) * AF_SETTLE_MS_PER_PULSE > AF_SETTLE_MAX_MS \
  38. ? (rt_uint32_t)AF_SETTLE_MAX_MS \
  39. : (rt_uint32_t)(dis) * AF_SETTLE_MS_PER_PULSE))
  40. //工作检测
  41. #define WORK_CHECK_THREAD_PRIORITY 23 //线程优先级
  42. #define WORK_CHECK_THREAD_STACK_SIZE 2024 //栈大小
  43. #define WORK_CHECK_THREAD_TIMESLICE 5 //时间片
  44. //工作流程
  45. #define WORK_LOOP_THREAD_PRIORITY 12 //线程优先级
  46. #define WORK_LOOP_THREAD_STACK_SIZE 2048 //栈大小
  47. #define WORK_LOOP_THREAD_TIMESLICE 5 //时间片
  48. #define PWM_EN 1 //0关闭,1-打开
  49. //设备状态表结构体
  50. Device_Status_typedef device_status;
  51. Device_slide_typedef slide_para;
  52. Flashdb_typedef flashdb_value;
  53. static rt_thread_t tid_workloop = RT_NULL;
  54. static rt_thread_t tid_wkstc = RT_NULL;
  55. static rt_thread_t rt_slide = RT_NULL;
  56. static rt_thread_t tid_motor_task = RT_NULL; /* 卷带电机任务线程: 异步执行turnlimit, 避免阻塞串口解析线程 */
  57. static rt_sem_t motor_task_sem = RT_NULL; /* 卷带请求信号量 */
  58. static struct rt_mutex turnlimit_mutex; /* turnlimit执行互斥锁(多线程串行化) */
  59. /***************************************************************************/
  60. int thread_delete_workloop(void)
  61. {
  62. /* 2026-09-28 (P2): ① 删除后必须把句柄置 NULL —— 原实现保留着已释放线程的句柄,
  63. * 而本函数在升级 / 自清洁等路径会被多次调用, 第二次会删除同一个已释放线程(use-after-delete);
  64. * ② 检查返回值, 删除失败时保留句柄以便下次重试; ③ 原 result 赋值后从未使用(编译警告)。 */
  65. LOG_W("thread_delete_workloop.");
  66. if(tid_workloop!=RT_NULL)
  67. {
  68. if (rt_thread_delete(tid_workloop) == RT_EOK) tid_workloop = RT_NULL;
  69. }
  70. if(tid_wkstc!=RT_NULL)
  71. {
  72. if (rt_thread_delete(tid_wkstc) == RT_EOK) tid_wkstc = RT_NULL;
  73. }
  74. if(rt_slide!=RT_NULL)
  75. {
  76. if (rt_thread_delete(rt_slide) == RT_EOK) rt_slide = RT_NULL;
  77. }
  78. if(tid_motor_task!=RT_NULL)
  79. {
  80. if (rt_thread_delete(tid_motor_task) == RT_EOK) tid_motor_task = RT_NULL;
  81. }
  82. return 0;
  83. }
  84. int thread_restart_workloop(void)
  85. {
  86. rt_err_t result;
  87. result = Work_Loop_Task();
  88. return result;
  89. }
  90. void slidelock();
  91. //滑台垂直方向开关
  92. uint8_t ctr_swz(uint8_t status_swz)
  93. {
  94. rt_pin_mode(SHAKE_SW, PIN_MODE_OUTPUT);
  95. if(status_swz == ON){
  96. rt_pin_write(SHAKE_SW,ON);
  97. }
  98. else if(status_swz == OFF){
  99. rt_pin_write(SHAKE_SW,OFF);
  100. }
  101. return status_swz;
  102. }
  103. //限位开关判断函数
  104. void turnlimit(void)
  105. {
  106. if(device_status.temp_status==1) return;
  107. rt_mutex_take(&turnlimit_mutex, RT_WAITING_FOREVER); /* 多线程(电机任务/工作循环/一键自检)互斥执行 */
  108. //Motor_shake(ON,0);
  109. Motor_Qingsao_R_PWM(ON);
  110. static uint16_t turn_timeout = 0;
  111. rt_pin_mode(LIMIT_DOWN,PIN_MODE_INPUT);
  112. while(rt_pin_read(LIMIT_DOWN)==0)
  113. {
  114. rt_thread_delay(20);
  115. while(rt_pin_read(LIMIT_DOWN)==0)
  116. {
  117. //ctr_cangmen_down(CLOSE);
  118. rt_thread_delay(50);
  119. turn_timeout++;
  120. /* 2026-09-28: 原用 == 比较静态累加计数, 一旦计数被跳过(多路径递增/被改写)
  121. * 条件永不成立 -> 在持有 turnlimit_mutex(RT_WAITING_FOREVER) 的情况下长阻塞,
  122. * 后续所有卷带请求永久排队(卷带功能整体失效)。改为 >= 保证必然触顶退出。 */
  123. if(turn_timeout>=200){
  124. char *translate = makeJson_Warn("translate","limit timeout");
  125. DTU_Write("%s",translate);
  126. rt_free(translate);
  127. break;
  128. }
  129. }
  130. break;
  131. }
  132. while(rt_pin_read(LIMIT_DOWN)==1)
  133. {
  134. rt_thread_delay(10);
  135. while(rt_pin_read(LIMIT_DOWN)==1)
  136. {
  137. turn_timeout++;
  138. rt_thread_delay(5);
  139. if(turn_timeout>=2000){ /* 2026-09-28: 同 turn_timeout>=200, 用 >= 避免永不成立 */
  140. char *translate = makeJson_Warn("translate","limit timeout");
  141. DTU_Write("%s",translate);
  142. rt_free(translate);
  143. break;
  144. }
  145. }
  146. break;
  147. }
  148. while(rt_pin_read(LIMIT_DOWN)==0)
  149. {
  150. rt_thread_delay(20);
  151. if(rt_pin_read(LIMIT_DOWN)==0)
  152. {
  153. //Motor_shake(OFF,0);
  154. Motor_Qingsao_R_PWM(OFF);
  155. break;
  156. }
  157. else {
  158. break;
  159. }
  160. }
  161. flashdb_value.tape_used+=60;
  162. app_flashdb_save("tape_used", &flashdb_value.tape_used, sizeof(flashdb_value.tape_used));
  163. //Motor_shake(OFF,0);
  164. Motor_Qingsao_R_PWM(OFF);
  165. turn_timeout = 0;
  166. char *translate = makeJson_Warn("translate","done");
  167. DTU_Write("%s",translate);
  168. rt_free(translate);
  169. rt_mutex_release(&turnlimit_mutex);
  170. // rt_thread_delay(1000);
  171. }
  172. uint8_t Replace_Filter(void)
  173. {
  174. //释放推杆电机
  175. ctr_cangmen_up(OPEN);
  176. //持续5S
  177. for(uint32_t i=0;i<10;i++){
  178. rt_thread_delay(1000);
  179. }
  180. //滤网传送
  181. ctr_cangmen_down(OPEN);
  182. //读取光控ADC值超时3S
  183. for(uint32_t i=0;i<50;i++)
  184. {
  185. rt_thread_delay(50);
  186. #if 0
  187. int value = Read_Light_Voltage();
  188. if(value>=3000) break;
  189. #endif
  190. /* 2026-09-28 (P1-10): 原判据写成 i==99, 而循环上限是 49, 永远不成立
  191. * -> 超时分支是死代码, 滤网更换卡住时平台侧收不到任何提示。改为末次迭代触发。 */
  192. if(i==49)
  193. {
  194. char *translate = makeJson_Warn("Replace_Filter","filter timeout");
  195. if (translate != RT_NULL) { DTU_Write("%s", translate); rt_free(translate); }
  196. LOG_W("滤网更换: 等待超时(2.5s), 未检测到预期状态");
  197. break;
  198. }
  199. }
  200. ctr_cangmen_down(OFF);
  201. //关闭推杆电机
  202. ctr_cangmen_up(CLOSE);
  203. //持续10S
  204. for(uint32_t i=0;i<10;i++){
  205. rt_thread_delay(1000);
  206. }
  207. ctr_cangmen_up(OFF);
  208. flashdb_value.filter_used+=30;
  209. //保存到flashdb
  210. app_flashdb_save("filter_used", &flashdb_value.filter_used, sizeof(flashdb_value.filter_used));
  211. /* 2026-09-28: 函数声明为 uint8_t, 原来没有任何 return —— 调用方若使用返回值就是未定义行为 */
  212. return 0;
  213. }
  214. uint32_t mapSpeed(int a1) {
  215. const int a1Min = 0;
  216. const int a1Max = 100;
  217. const int a2Min = 50000; //20khz
  218. const int a2Max = 200000; //5khz
  219. // 确保 a1 在有效范围内
  220. if (a1 < a1Min) {
  221. a1 = a1Min;
  222. } else if (a1 > a1Max) {
  223. a1 = a1Max;
  224. }
  225. // 执行线性映射
  226. uint32_t a2 = a2Max - ((a2Max - a2Min) * a1) / (a1Max - a1Min);
  227. return a2;
  228. }
  229. void stop_move(void)
  230. {
  231. slide_para.stop_flag = 1;
  232. slidelock();
  233. rt_pin_mode(HK_IO, PIN_MODE_OUTPUT); //PB14 EN
  234. pwm_stop();
  235. rt_pin_write(HK_IO, ON);
  236. }
  237. //DIR_ 轴选择(0-X,1-Y,2-Z) dir 轴方向
  238. uint32_t ctr_move(uint8_t DIR_,uint8_t dir_,uint32_t dis_,uint32_t pulse)
  239. {
  240. uint32_t j;
  241. switch(DIR_){
  242. case X_:
  243. ctr_lamp(ON,1); //X轴开关:关
  244. ctr_swz(OFF); //Z轴开关:关
  245. ctr_Collect_Fan(OFF); //Y轴开关:关
  246. break;
  247. case Y_:
  248. ctr_swz(OFF); //Z轴开关:关
  249. ctr_lamp(OFF,1); //X轴开关:关
  250. ctr_Collect_Fan(ON); //Y轴开关:开
  251. break;
  252. case Z_:
  253. ctr_swz(ON); //Y轴开关:关
  254. ctr_lamp(OFF,1); //X轴开关:关
  255. ctr_Collect_Fan(OFF); //Y轴开关:关
  256. break;
  257. }
  258. //限位检测初始化
  259. rt_pin_mode(Limit_Motor_X, PIN_MODE_INPUT);
  260. rt_pin_mode(Limit_Motor_Y, PIN_MODE_INPUT);
  261. rt_pin_mode(Limit_Motor_Z, PIN_MODE_INPUT);
  262. //驱动器初始化
  263. rt_pin_mode(HK_IO, PIN_MODE_OUTPUT); //PB14 EN
  264. rt_pin_mode(CTR_RO_LIMIT, PIN_MODE_OUTPUT); //PB15 DIR
  265. //rt_pin_mode(CTR_RC_LIMIT, PIN_MODE_OUTPUT); //PC6 PWM
  266. // if(dis_ >=1000){
  267. // beep_set(500000, 250000); //PWM使能
  268. // }else{
  269. // beep_set(2000000, 1000000); //PWM使能
  270. // }
  271. //驱动使能
  272. rt_pin_write(HK_IO, ON);
  273. //方向选择
  274. if(dir_ == 1){
  275. rt_pin_write(CTR_RO_LIMIT, ON);
  276. }else{
  277. rt_pin_write(CTR_RO_LIMIT, OFF);
  278. }
  279. switch(DIR_){
  280. case X_:
  281. ctr_lamp(1, ON); //X轴电源开关:开
  282. rt_thread_delay(1000);
  283. //判断限位
  284. if(dir_== 0 && rt_pin_read(Limit_Motor_X)==1){
  285. for(int z =0;z < 3; z++){
  286. Beep_Tip(200);
  287. LOG_W("X:已在初始位置!");
  288. }
  289. return 0;
  290. }
  291. rt_pin_write(HK_IO, ON);
  292. rt_thread_delay(100);
  293. beep_set(pulse, pulse/3); //PWM使能
  294. for(j=0;j<dis_;j++){
  295. if(slide_para.stop_flag == 0){
  296. rt_thread_delay(10); //10ms
  297. if(dir_==0&&rt_pin_read(Limit_Motor_X)==1){
  298. rt_thread_delay(10); //10ms
  299. if(rt_pin_read(Limit_Motor_X)==1){
  300. j = dis_;
  301. }
  302. }
  303. }else{ //急停
  304. for(int z =0;z < 3; z++){
  305. Beep_Tip(200);
  306. }
  307. break;
  308. }
  309. }
  310. break;
  311. case Y_:
  312. ctr_Collect_Fan(ON); //Y轴电源开关:开
  313. //rt_thread_delay(100);
  314. //判断限位
  315. if(dir_== 0 && rt_pin_read(Limit_Motor_Y)==1){
  316. for(int z =0;z < 3; z++){
  317. Beep_Tip(200);
  318. LOG_W("Y:已在初始位置!");
  319. }
  320. return 0;
  321. }
  322. rt_pin_write(HK_IO, ON);
  323. beep_set(pulse, pulse/2); //PWM使能
  324. for(j=0;j<dis_;j++){
  325. if(slide_para.stop_flag == 0){
  326. if(dis_>=8000){rt_thread_delay(10);}else{rt_thread_delay(1);}
  327. if(dir_==0&&rt_pin_read(Limit_Motor_Y)==1){
  328. if(dis_>=8000){rt_thread_delay(10);}else{rt_thread_delay(1);}
  329. if(rt_pin_read(Limit_Motor_Y)==1){
  330. j = dis_;
  331. }
  332. }
  333. }else{ //急停
  334. for(int z =0;z < 3; z++){
  335. Beep_Tip(200);
  336. }
  337. break;
  338. }
  339. }
  340. break;
  341. case Z_:
  342. ctr_swz(ON); //Z轴电源开关:开
  343. rt_thread_delay(1000); //
  344. //判断限位
  345. if(dir_== 1 && rt_pin_read(Limit_Motor_Z)==1){
  346. for(int z =0;z < 3; z++){
  347. Beep_Tip(200);
  348. LOG_W("Z:已在初始位置!");
  349. }
  350. return 0;
  351. }
  352. //驱动使能
  353. rt_pin_write(HK_IO, ON);
  354. beep_set(pulse, pulse/3); //PWM使能
  355. for(j=0;j<dis_;j++){
  356. if(slide_para.stop_flag == 0){
  357. rt_thread_delay(10);
  358. if(dir_==1&&rt_pin_read(Limit_Motor_Z)==1){
  359. rt_thread_delay(10);
  360. if(rt_pin_read(Limit_Motor_Z)==1){
  361. j = dis_;
  362. }
  363. }
  364. }else{ //急停
  365. for(int z =0;z < 3; z++){
  366. Beep_Tip(200);
  367. }
  368. break;
  369. }
  370. }
  371. break;
  372. }
  373. pwm_stop();
  374. rt_pin_write(HK_IO, ON);
  375. return dis_;
  376. }
  377. void slidelock()
  378. {
  379. ctr_lamp(OFF,1); //X轴开关:关
  380. ctr_swz(OFF); //Z轴开关:关
  381. ctr_Collect_Fan(OFF); //Y轴开关:关
  382. }
  383. /**********************************************************************/
  384. /*光控*/
  385. uint8_t In_Light_status(void)
  386. {
  387. rt_pin_mode(LIGHT_PIN,PIN_MODE_INPUT);
  388. return rt_pin_read(LIGHT_PIN);
  389. }
  390. /*雨控*/
  391. uint8_t In_Rain_status(void)
  392. {
  393. rt_pin_mode(RAIN_PIN,PIN_MODE_INPUT);
  394. return rt_pin_read(RAIN_PIN);
  395. }
  396. /*加热*/
  397. uint8_t ctr_Heat(uint8_t status_heat)
  398. {
  399. device_status.heat_status = status_heat;
  400. rt_pin_mode(Heat_Pin, PIN_MODE_OUTPUT);
  401. rt_pin_write(Heat_Pin,status_heat);
  402. return status_heat;
  403. }
  404. /*制冷*/
  405. uint8_t ctr_Cold(uint8_t status_cold)
  406. {
  407. device_status.cold_status = status_cold;
  408. rt_pin_mode(Cold_Pin, PIN_MODE_OUTPUT);
  409. rt_pin_write(Cold_Pin,status_cold);
  410. return status_cold;
  411. }
  412. /*相机供电*/
  413. void ctr_photo(uint8_t status_photo)
  414. {
  415. rt_pin_mode(PHOTO,PIN_MODE_OUTPUT);
  416. rt_pin_write(PHOTO,status_photo);
  417. }
  418. /*************************************************
  419. Function: ctr_Cool_Fan
  420. Description: 散热风机的开关
  421. Calls:
  422. Table Accessed: // 被访问的表(此项仅对于牵扯到数据库操作的程序)
  423. Table Updated: // 被修改的表(此项仅对于牵扯到数据库操作的程序)
  424. Input: ON-开,OFF-关
  425. Output: NULL
  426. Return: ON-开,OFF-关
  427. Others: NULL
  428. *************************************************/
  429. uint8_t ctr_Cool_Fan(uint8_t status_cool)
  430. {
  431. device_status.cool_fan_status = status_cool;
  432. rt_pin_mode(Cool_Fan_L, PIN_MODE_OUTPUT);
  433. rt_pin_mode(Cool_Fan_R, PIN_MODE_OUTPUT);
  434. if(status_cool==OFF)
  435. {
  436. rt_pin_write(Cool_Fan_L,OFF);
  437. rt_pin_write(Cool_Fan_R,OFF);
  438. }
  439. if(status_cool==ON)
  440. {
  441. rt_pin_write(Cool_Fan_L,ON);
  442. rt_pin_write(Cool_Fan_R,OFF);
  443. }
  444. return device_status.cool_fan_status;
  445. }
  446. /*************************************************
  447. Function: ctr_Collect_Fan
  448. Description: 采集风机的开关
  449. Calls:
  450. Table Accessed: // 被访问的表(此项仅对于牵扯到数据库操作的程序)
  451. Table Updated: // 被修改的表(此项仅对于牵扯到数据库操作的程序)
  452. Input: ON-开,OFF-关
  453. Output: NULL
  454. Return: ON-开,OFF-关
  455. Others: NULL
  456. *************************************************/
  457. uint8_t ctr_Collect_Fan(uint8_t status_collect)
  458. {
  459. device_status.collect_fan_status = status_collect;
  460. rt_pin_mode(Collect_Fan, PIN_MODE_OUTPUT);
  461. if(status_collect==OFF)
  462. {
  463. rt_pin_write(Collect_Fan,OFF);
  464. }
  465. if(status_collect==ON)
  466. {
  467. rt_pin_write(Collect_Fan,ON);
  468. }
  469. return device_status.collect_fan_status;
  470. }
  471. /*上仓门*/
  472. uint8_t ctr_cangmen_up(uint8_t status_up)
  473. {
  474. rt_pin_mode(Collect_fan_R, PIN_MODE_OUTPUT);
  475. rt_pin_mode(Collect_fan_L, PIN_MODE_OUTPUT);
  476. if(status_up==OFF)
  477. {
  478. rt_pin_write(Collect_fan_R,ON);
  479. rt_pin_write(Collect_fan_L,ON);
  480. device_status.ctr_up_motor = 0;
  481. rt_thread_delay(1000);
  482. }
  483. if(status_up==OPEN)
  484. {
  485. device_status.up_status = 1;
  486. rt_pin_write(Collect_fan_R,OFF);
  487. rt_pin_write(Collect_fan_L,OFF);
  488. rt_pin_write(Collect_fan_R,ON);
  489. rt_pin_write(Collect_fan_L,OFF);
  490. }
  491. if(status_up==CLOSE)
  492. {
  493. device_status.up_status = 0;
  494. rt_pin_write(Collect_fan_R,OFF);
  495. rt_pin_write(Collect_fan_L,OFF);
  496. rt_pin_write(Collect_fan_R,OFF);
  497. rt_pin_write(Collect_fan_L,ON);
  498. }
  499. return device_status.up_status;
  500. }
  501. //下仓门
  502. uint8_t ctr_cangmen_down(uint8_t status_down)
  503. {
  504. rt_pin_mode(C_DOWN_R, PIN_MODE_OUTPUT);
  505. rt_pin_mode(C_DOWN_L, PIN_MODE_OUTPUT);
  506. if(status_down==OFF)
  507. {
  508. rt_pin_write(C_DOWN_R,ON);
  509. rt_pin_write(C_DOWN_L,ON);
  510. device_status.ctr_down_motor = 0;
  511. rt_thread_delay(1000);
  512. }
  513. if(status_down==OPEN)
  514. {
  515. device_status.down_status = 1;
  516. rt_pin_write(C_DOWN_R,OFF);
  517. rt_pin_write(C_DOWN_L,OFF);
  518. rt_pin_write(C_DOWN_R,ON);
  519. rt_pin_write(C_DOWN_L,OFF);
  520. }
  521. if(status_down==CLOSE)
  522. {
  523. device_status.down_status = 0;
  524. rt_pin_write(C_DOWN_R,OFF);
  525. rt_pin_write(C_DOWN_L,OFF);
  526. rt_pin_write(C_DOWN_R,OFF);
  527. rt_pin_write(C_DOWN_L,ON);
  528. }
  529. return device_status.down_status;
  530. }
  531. //镇流器
  532. uint8_t ctr_lamp(uint8_t status_lamp,uint8_t lamp_num)
  533. {
  534. rt_pin_mode(LAMP_SW, PIN_MODE_OUTPUT);
  535. rt_pin_mode(LAMP_1_SW, PIN_MODE_OUTPUT);
  536. rt_pin_mode(LAMP_2_SW, PIN_MODE_OUTPUT);
  537. if(status_lamp==ON)
  538. {
  539. switch(lamp_num){
  540. case 1:
  541. rt_pin_write(LAMP_SW,ON);
  542. device_status.lamp_status = status_lamp;
  543. break;
  544. case 2:
  545. rt_pin_write(LAMP_1_SW,ON);
  546. device_status.lamp_status = status_lamp;
  547. break;
  548. case 3:
  549. rt_pin_write(LAMP_2_SW,ON);
  550. device_status.lamp_status = status_lamp;
  551. break;
  552. default:
  553. break;
  554. }
  555. }
  556. else {
  557. switch(lamp_num){
  558. case 1:
  559. rt_pin_write(LAMP_SW,OFF);
  560. device_status.lamp_status = status_lamp;
  561. break;
  562. case 2:
  563. rt_pin_write(LAMP_1_SW,OFF);
  564. device_status.lamp1_status = status_lamp;
  565. break;
  566. case 3:
  567. rt_pin_write(LAMP_2_SW,OFF);
  568. device_status.lamp2_status = status_lamp;
  569. break;
  570. default:
  571. break;
  572. }
  573. }
  574. return device_status.lamp_status;
  575. }
  576. //补光
  577. uint8_t ctr_led(uint8_t status_led)
  578. {
  579. rt_pin_mode(LED_SW, PIN_MODE_OUTPUT);
  580. if(status_led==ON)
  581. {
  582. rt_pin_write(LED_SW,ON);
  583. }
  584. else if(status_led==OFF){
  585. rt_pin_write(LED_SW,OFF);
  586. }
  587. return status_led;
  588. }
  589. /*************************************************
  590. Function: ctr_Petroleum_jelly
  591. Description: 涂凡士林
  592. Calls:
  593. Table Accessed: // 被访问的表(此项仅对于牵扯到数据库操作的程序)
  594. Table Updated: // 被修改的表(此项仅对于牵扯到数据库操作的程序)
  595. Input: NULL
  596. Output: NULL
  597. Return: NULL
  598. Others: NULL
  599. *************************************************/
  600. void ctr_Petroleum_jelly(rt_uint32_t delay)
  601. {
  602. beep_init();
  603. pwm_on(2,50000);
  604. rt_thread_delay(delay*1000);
  605. pwm_off(2,0);
  606. rt_thread_delay(1000);
  607. pwm_on(3, 50000);
  608. rt_thread_delay(delay*1000);
  609. pwm_off(3,0);
  610. device_status.fsl_sw = 0;
  611. }
  612. //1.0转仓
  613. void turnzp(void)
  614. {
  615. static uint16_t turn_timeout = 0;
  616. // rt_pin_mode(CLEAR_R, PIN_MODE_OUTPUT);
  617. // rt_pin_mode(CLEAR_L, PIN_MODE_OUTPUT);
  618. rt_pin_mode(CLEAR_R_LIMIT,PIN_MODE_INPUT);
  619. // rt_pin_write(CLEAR_R,OFF);
  620. // rt_pin_write(CLEAR_L,OFF);
  621. while(rt_pin_read(CLEAR_R_LIMIT)==0)
  622. {
  623. rt_thread_delay(20);
  624. while(rt_pin_read(CLEAR_R_LIMIT)==0)
  625. {
  626. // rt_pin_write(CLEAR_R,ON);
  627. // rt_pin_write(CLEAR_L,OFF);
  628. Motor_Juandai(ON);
  629. rt_thread_delay(50);
  630. turn_timeout++;
  631. /* 2026-09-28: 与 turnlimit() 同一类问题, 用 == 比较累加计数;
  632. * 两个循环共用同一个 turn_timeout, 第一个循环一旦累加到 600,
  633. * 第二个循环会从 601 起步 —— ==600 永不成立, 该分支永远等不到超时停止。改为 >= */
  634. if(turn_timeout>=600)
  635. {
  636. LOG_E("检测不到限位,电机强制停止");
  637. char *ctr_zp_limit_warn =makeJson_Warn("电流不足/限位超时","转盘电机");
  638. if (ctr_zp_limit_warn != RT_NULL) { DTU_Write("%s", ctr_zp_limit_warn); rt_free(ctr_zp_limit_warn); }
  639. else { LOG_E("makeJson_Warn failed(转盘电机限位超时)"); }
  640. break;
  641. }
  642. }
  643. break;
  644. }
  645. while(rt_pin_read(CLEAR_R_LIMIT)==1)
  646. {
  647. rt_thread_delay(20);
  648. while(rt_pin_read(CLEAR_R_LIMIT)==1)
  649. {
  650. // rt_pin_write(CLEAR_R,ON);
  651. // rt_pin_write(CLEAR_L,OFF);
  652. Motor_Juandai(ON);
  653. rt_thread_delay(50);
  654. turn_timeout++;
  655. /* 2026-09-28: 与 turnlimit() 同一类问题, 用 == 比较累加计数;
  656. * 两个循环共用同一个 turn_timeout, 第一个循环一旦累加到 600,
  657. * 第二个循环会从 601 起步 —— ==600 永不成立, 该分支永远等不到超时停止。改为 >= */
  658. if(turn_timeout>=600)
  659. {
  660. LOG_E("检测不到离开限位,电机或者限位开关异常,电机强制停止");
  661. char *ctr_zp_limit_warn =makeJson_Warn("检测不到离开限位,电机未启动或者限位开关故障","转盘电机");
  662. if (ctr_zp_limit_warn != RT_NULL) { DTU_Write("%s", ctr_zp_limit_warn); rt_free(ctr_zp_limit_warn); }
  663. else { LOG_E("makeJson_Warn failed(转盘电机限位异常)"); }
  664. break;
  665. }
  666. }
  667. break;
  668. }
  669. while(rt_pin_read(CLEAR_R_LIMIT)==0)
  670. {
  671. rt_thread_delay(20);
  672. if(rt_pin_read(CLEAR_R_LIMIT)==0)
  673. {
  674. // rt_pin_write(CLEAR_R,OFF);
  675. // rt_pin_write(CLEAR_L,OFF);
  676. Motor_Juandai(OFF);
  677. break;
  678. }
  679. else {
  680. break;
  681. }
  682. }
  683. Motor_Juandai(OFF);
  684. // rt_pin_write(CLEAR_R,OFF);
  685. // rt_pin_write(CLEAR_L,OFF);
  686. turn_timeout = 0;
  687. rt_thread_delay(1000);
  688. }
  689. //路由器供电
  690. void ctr_router(uint8_t status_router)
  691. {
  692. rt_pin_mode(ROUTER, PIN_MODE_OUTPUT);
  693. //rt_pin_mode(POWER_CLEAR, PIN_MODE_OUTPUT);
  694. if(status_router==ON)
  695. {
  696. rt_pin_write(ROUTER,ON);
  697. }
  698. else {
  699. rt_pin_write(ROUTER,OFF);
  700. }
  701. }
  702. //清扫-推杆电机
  703. void ctr_TG_Clear(uint16_t clear_timeout)
  704. {
  705. #if 0
  706. int current_clear[200];
  707. int16_t Electric_current = atoi(device_status.power); //获取电机运动前的电流
  708. LOG_I("清扫电机待机:%d",Electric_current);
  709. #endif
  710. static uint16_t clear_count = 0;
  711. clear_count = clear_timeout;
  712. #if PWM_EN == 0
  713. rt_pin_mode(CLEAR_R, PIN_MODE_OUTPUT);
  714. rt_pin_mode(CLEAR_L, PIN_MODE_OUTPUT);
  715. #endif
  716. while(clear_count!=0)
  717. {
  718. #if PWM_EN == 0
  719. rt_pin_write(CLEAR_R,ON);
  720. rt_pin_write(CLEAR_L,OFF);
  721. #else
  722. Motor_Qingsao_R_PWM(ON);
  723. Motor_Qingsao_L_PWM(OFF);
  724. #endif
  725. clear_count--;
  726. rt_thread_delay(100);
  727. }
  728. #if PWM_EN == 0
  729. rt_pin_write(CLEAR_R,ON);
  730. rt_pin_write(CLEAR_L,ON);
  731. #else
  732. Motor_Qingsao_R_PWM(OFF);
  733. Motor_Qingsao_L_PWM(OFF);
  734. #endif
  735. rt_thread_delay(3000);
  736. clear_count = 0;
  737. while(clear_timeout!=clear_count)
  738. {
  739. #if PWM_EN == 0
  740. rt_pin_write(CLEAR_R,OFF);
  741. rt_pin_write(CLEAR_L,ON);
  742. #else
  743. Motor_Qingsao_R_PWM(OFF);
  744. Motor_Qingsao_L_PWM(ON);
  745. #endif
  746. // if(clear_count<200)
  747. // current_clear[clear_count] = atoi(device_status.power);
  748. clear_count++;
  749. rt_thread_delay(100);
  750. }
  751. #if PWM_EN == 0
  752. rt_pin_write(CLEAR_R,ON);
  753. rt_pin_write(CLEAR_L,ON);
  754. #else
  755. Motor_Qingsao_R_PWM(OFF);
  756. Motor_Qingsao_L_PWM(OFF);
  757. #endif
  758. #if 0
  759. bubblesort(current_clear,200);
  760. if(current_clear[199]-Electric_current <100&&device_status.work_status==1&&Electric_current!=0&&Electric_current<5000)
  761. {
  762. LOG_E("清扫电机电流不足:%d!",current_clear[199]);
  763. char *ctr_clear_warn = makeJson_Warn("电流不足","清扫电机");
  764. DTU_Write("%s",ctr_clear_warn);
  765. rt_free(ctr_clear_warn);
  766. }
  767. #endif
  768. rt_thread_delay(2000);
  769. device_status.clear_status = 0;
  770. }
  771. //DTU,RTU供电
  772. void ctr_RTU_DTU(uint8_t status_rtu)
  773. {
  774. rt_pin_mode(RTU_DTU, PIN_MODE_OUTPUT);
  775. if(status_rtu==ON)
  776. {
  777. rt_pin_write(RTU_DTU,ON);
  778. }
  779. else
  780. {
  781. LOG_W("RTU电源复位!!!");
  782. rt_pin_write(RTU_DTU,OFF);
  783. }
  784. }
  785. //海康拍照
  786. void Hk_Take_io(void)
  787. {
  788. rt_pin_mode(HK_TAKE, PIN_MODE_OUTPUT);
  789. rt_pin_mode(HK_IO, PIN_MODE_OUTPUT);
  790. rt_pin_write(HK_TAKE, 1);
  791. rt_pin_write(HK_IO, 0);
  792. if(device_status.dtype==3)
  793. Beep_Tip(1000);
  794. if(device_status.dtype==7)
  795. rt_thread_mdelay(1000);
  796. rt_pin_write(HK_TAKE, 0);
  797. rt_pin_write(HK_IO, 1);
  798. }
  799. //拍照
  800. void HK_TakePhoto(void)
  801. {
  802. //打开补光灯
  803. DTU_Write("takephoto.mp3");
  804. rt_thread_delay(10000);
  805. char *takephotojson = makeJson_takephoto();
  806. DTU_Write("%s",takephotojson);
  807. rt_free(takephotojson);
  808. //吸虫塔
  809. if(device_status.version_type!=6)
  810. {
  811. ctr_led(ON);
  812. if(device_status.version_type==48)
  813. {
  814. rt_thread_delay(1000*60);
  815. }
  816. else {
  817. rt_thread_delay(1000*15);
  818. }
  819. }
  820. //触发海康相机拍照
  821. Hk_Take_io();
  822. if(device_status.version_type!=6)
  823. {
  824. rt_thread_delay(1000*45);
  825. }
  826. else {
  827. ctr_led(ON);
  828. rt_thread_delay(1000*19);
  829. }
  830. ctr_led(OFF);
  831. }
  832. /*上电初始化*/
  833. void ResetInit(void)
  834. {
  835. //打开相机供电
  836. ctr_photo(ON);
  837. //开启 工控机供电
  838. #if BZYV13_EN == 0
  839. ctr_router(ON);
  840. #endif
  841. //关闭风机-2.0/2.1
  842. #if BZYV13_EN == 0
  843. ctr_Heat(OFF);
  844. #else
  845. ctr_Heat(ON); //工控机-1.3
  846. #endif
  847. //关闭制冷
  848. ctr_Cold(OFF);
  849. //关闭Y轴驱动电源
  850. ctr_Collect_Fan(OFF);
  851. //自清洁推杆打开
  852. ctr_cangmen_up(CLOSE);
  853. }
  854. //工作状态检测
  855. /*孢子仪多段定时功能函数
  856. * 循环判断定时的触发
  857. *
  858. */
  859. u_int8_t alarmCheck(u_int8_t starthour,u_int8_t endhour,u_int8_t startmin,u_int8_t endmin)
  860. {
  861. u_int8_t workflag = 0;
  862. if(starthour == endhour) return workflag;
  863. time_t now;
  864. time(&now);
  865. struct tm now_tm = *localtime(&now);
  866. rt_uint32_t curr_sec = now_tm.tm_hour*3600 + now_tm.tm_min*60 + now_tm.tm_sec;
  867. rt_uint32_t start_sec = starthour * 3600 + startmin * 60;
  868. rt_uint32_t end_sec = endhour * 3600 + endmin * 60;
  869. // 处理开始和结束时间相同的情况
  870. if (start_sec == end_sec) {
  871. workflag = 0;
  872. }
  873. // 修复跨天判断逻辑
  874. if (start_sec < end_sec)
  875. {
  876. // 不跨天模式
  877. workflag = (curr_sec >= start_sec && curr_sec < end_sec) ? 1 : 0;
  878. }
  879. else
  880. {
  881. // 跨天模式
  882. workflag = (curr_sec >= start_sec || curr_sec < end_sec) ? 1 : 0;
  883. }
  884. /* 2026-09-28: 检测周期由 31s 缩短到约 1s 后, 本函数每轮会被调用 3 次,
  885. * 继续用 LOG_I 会每秒刷 3 条日志(抢占串口控制台), 降为 LOG_D */
  886. LOG_D("时控模式:状态[%s] 当前时间:%02d:%02d:%02d 设置:%02d:%02d-%02d:%02d",
  887. workflag ? "工作" : "待机",
  888. now_tm.tm_hour, now_tm.tm_min, now_tm.tm_sec,
  889. starthour,startmin, endhour,endmin);
  890. /* 2026-09-28 (P1-8): 原实现在这里 rt_thread_delay(10000) —— 一个"查询函数"里藏了 10 秒阻塞。
  891. * 调用方每轮要调 3 次, 导致工作/待机状态判定周期长达 31 秒: 到点不进工作、到点不停
  892. * 都与它有关。改为纯查询, 周期由调用方的 rt_thread_delay 决定(现约 1 秒)。 */
  893. return workflag;
  894. }
  895. /* 采集段结束处理:卷带电机转一圈 + 发送自动对焦指令
  896. * 进入时先清零自锁,避免执行期间(turnlimit可能阻塞较久)新的采集段结束事件被覆盖丢失
  897. * work_done 由工作流程线程独占清零,消除与状态检测线程的双写竞态
  898. */
  899. static void exec_work_done(void)
  900. {
  901. device_status.work_done = 0;
  902. LOG_I("采集段结束, 执行转带+自动对焦");
  903. #if BZYV13_EN == 1
  904. turnlimit();
  905. rt_thread_delay(1000);
  906. turnlimit();
  907. rt_thread_delay(1000);
  908. turnlimit();
  909. //延迟30S等胶带稳定
  910. for(int i=0;i<30;i++){
  911. rt_thread_delay(1000);
  912. LOG_I("等待胶带稳定:%d",i);
  913. }
  914. #else
  915. turnlimit();
  916. rt_thread_delay(2000);
  917. #endif
  918. uint8_t retry_send = 0;
  919. while(1){
  920. char *take_start = makeJson_Warn("start", "autofocus");
  921. if(take_start != RT_NULL) {
  922. DTU_Write("%s",take_start);
  923. rt_free(take_start);
  924. } else {
  925. LOG_E("makeJson_Warn failed! retry:%d", retry_send);
  926. }
  927. rt_thread_delay(5000);
  928. retry_send++;
  929. if(retry_send==30||device_status.autotakepic>0){
  930. LOG_I("send start msg done, retry=%d, autotakepic=%d", retry_send, device_status.autotakepic);
  931. break;
  932. }
  933. }
  934. }
  935. void WorkTask_BZYV2(void)
  936. {
  937. if(device_status.ds==1&&device_status.temp_status==0){
  938. /* 等待设备进入工作窗口 */
  939. while(device_status.work_status ==0){
  940. /* 待机期间若有未处理的采集段结束动作,立即补做 */
  941. if(device_status.work_done==1){
  942. exec_work_done();
  943. }
  944. rt_thread_delay(1000);
  945. }
  946. /* 处于工作窗口:按对焦状态控制路由器供电 */
  947. while(device_status.work_status ==1){
  948. if(device_status.autotakepic==0){
  949. #if BZYV13_EN == 1
  950. ctr_router(ON);
  951. #else
  952. ctr_Heat(ON);
  953. #endif
  954. }else{
  955. #if BZYV13_EN == 1
  956. ctr_router(OFF);
  957. #else
  958. ctr_Heat(OFF);
  959. #endif
  960. }
  961. if(device_status.temp_status==1){
  962. device_status.work_status = 0;
  963. #if BZYV13_EN == 1
  964. ctr_router(OFF);
  965. #else
  966. ctr_Heat(OFF);
  967. #endif
  968. break;
  969. }
  970. /* 任一采集段窗口结束(下降沿置位 work_done)立即执行转带+对焦 */
  971. if(device_status.work_done==1){
  972. exec_work_done();
  973. }
  974. rt_thread_delay(1000);
  975. }
  976. #if BZYV13_EN == 1
  977. ctr_router(OFF);
  978. #else
  979. ctr_Heat(OFF);
  980. #endif
  981. /* 退出工作循环后若有未处理的结束动作(如温控异常跳出), 补做 */
  982. if(device_status.work_done==1){
  983. exec_work_done();
  984. }
  985. }else{
  986. LOG_W("==================!!!设备已待机!!!===================");
  987. }
  988. }
  989. /* 入口函数-工作状态检测 */
  990. static void Work_status_thread_entry(void *parameter)
  991. {
  992. /* 记录上一轮各采集段的窗口状态,用于检测窗口结束(ON->OFF下降沿) */
  993. u_int8_t last_seg_on[3] = {OFF, OFF, OFF};
  994. static uint32_t takephoto_cnt = 0;
  995. static uint8_t work_day_checked = 0; // 23点当天只检查一次,非23点复位
  996. while(1)
  997. {
  998. if(device_status.ds==0 || device_status.temp_status==1)
  999. {
  1000. device_status.work_status = 0;
  1001. /* 设备待机时复位上一轮窗口状态,避免恢复工作后误判下降沿 */
  1002. last_seg_on[0] = OFF;
  1003. last_seg_on[1] = OFF;
  1004. last_seg_on[2] = OFF;
  1005. rt_thread_delay(5000);
  1006. continue;
  1007. }
  1008. /* 依次判断3段采集窗口,任何一段处于窗口内即为工作状态 */
  1009. u_int8_t seg_on[3];
  1010. seg_on[0] = alarmCheck(device_status.collecting_sh1, device_status.collecting_eh1,
  1011. device_status.collt_min_sh1, device_status.collt_min_eh1);
  1012. seg_on[1] = alarmCheck(device_status.collecting_sh2, device_status.collecting_eh2,
  1013. device_status.collt_min_sh2, device_status.collt_min_eh2);
  1014. seg_on[2] = alarmCheck(device_status.collecting_sh3, device_status.collecting_eh3,
  1015. device_status.collt_min_sh3, device_status.collt_min_eh3);
  1016. device_status.work_status = (seg_on[0] || seg_on[1] || seg_on[2]) ? 1 : 0;
  1017. /* 每段窗口结束(ON->OFF)置位一次 work_done,保证每个采集段结束后只触发一次转带+对焦 */
  1018. u_int8_t i;
  1019. for(i = 0; i < 3; i++)
  1020. {
  1021. if(last_seg_on[i] == ON && seg_on[i] == OFF)
  1022. {
  1023. device_status.work_done = 1;
  1024. LOG_I("alarm%d 采集段结束, 触发转带+对焦", i+1);
  1025. }
  1026. last_seg_on[i] = seg_on[i];
  1027. }
  1028. /* 每天23点检查设定的采集时间段是否有效,且总采集时长超过1小时,满足条件则递增 worked_day */
  1029. time_t now;
  1030. time(&now);
  1031. struct tm now_tm = *localtime(&now);
  1032. if (now_tm.tm_hour == 23)
  1033. {
  1034. /* 整个23点整点区间只执行一次,避免每秒循环重复判断 */
  1035. if (!work_day_checked)
  1036. {
  1037. work_day_checked = 1;
  1038. /* 计算3段采集时段的累计有效时长(秒)。
  1039. * 有效性口径与 alarmCheck 保持一致:开始小时==结束小时视为无效时段 */
  1040. uint32_t total_sec = 0;
  1041. u_int8_t seg;
  1042. for (seg = 0; seg < 3; seg++)
  1043. {
  1044. u_int8_t sh, eh, sm, em;
  1045. if (seg == 0)
  1046. {
  1047. sh = device_status.collecting_sh1; eh = device_status.collecting_eh1;
  1048. sm = device_status.collt_min_sh1; em = device_status.collt_min_eh1;
  1049. }
  1050. else if (seg == 1)
  1051. {
  1052. sh = device_status.collecting_sh2; eh = device_status.collecting_eh2;
  1053. sm = device_status.collt_min_sh2; em = device_status.collt_min_eh2;
  1054. }
  1055. else
  1056. {
  1057. sh = device_status.collecting_sh3; eh = device_status.collecting_eh3;
  1058. sm = device_status.collt_min_sh3; em = device_status.collt_min_eh3;
  1059. }
  1060. if (sh != eh) /* 无效时段(开始结束小时相同)不参与累计 */
  1061. {
  1062. uint32_t start_sec = sh * 3600 + sm * 60;
  1063. uint32_t end_sec = eh * 3600 + em * 60;
  1064. if (start_sec < end_sec)
  1065. total_sec += end_sec - start_sec; /* 当天时段 */
  1066. else
  1067. total_sec += 24 * 3600 - start_sec + end_sec; /* 跨天时段 */
  1068. }
  1069. }
  1070. /* 总采集时长超过1小时则递增 worked_day */
  1071. if (total_sec > 3600)
  1072. {
  1073. flashdb_value.worked_day++;
  1074. /* worked_day 是 uint8_t, 必须显式传长度, 否则按指针宽度4字节读写会踩坏 tape_max */
  1075. app_flashdb_save("worked_day", &flashdb_value.worked_day, sizeof(flashdb_value.worked_day));
  1076. LOG_I("采集时段有效且总时长>1h, worked_day=%d", flashdb_value.worked_day);
  1077. if(flashdb_value.worked_day==flashdb_value.freq_filter){
  1078. //清零
  1079. flashdb_value.worked_day = 0;
  1080. app_flashdb_save("worked_day", &flashdb_value.worked_day, sizeof(flashdb_value.worked_day));
  1081. //执行更换
  1082. Replace_Filter();
  1083. //上报预警消息
  1084. }
  1085. }
  1086. }
  1087. }
  1088. else
  1089. {
  1090. work_day_checked = 0; /* 离开23点后复位,第二天可再次检查 */
  1091. }
  1092. rt_thread_delay(1000);
  1093. }
  1094. }
  1095. /*入口函数-工作流程*/
  1096. static void Work_Loop_thread_entry(void *parameter)
  1097. {
  1098. rt_thread_delay(1000);
  1099. ResetInit();
  1100. while(1)
  1101. {
  1102. WorkTask_BZYV2();
  1103. rt_thread_delay(1000);
  1104. }
  1105. }
  1106. /* ==================== 预对焦(Pre-Focus) ====================
  1107. * 背景 —— 为什么要改:
  1108. * 老策略: 复位后盲走到固定坐标 y_init_dis -> 发 takephoto_done -> 工控机开始录制
  1109. * -> MCU 让 Y 轴下行固定行程 -> 发 record_stop -> 由工控机在视频流里挑最清晰帧。
  1110. * Y 轴在整轮 32 个点位之间从不回限位, 每次录制都是"下行 + 回程"的相对往返:
  1111. * 下行由重力/弹簧助力, 回程要反向克服阻力, 开环步进的丢步逐级累加,
  1112. * 于是"走着走着就拍不到清晰位置了"(画面一路偏往 dir=1 一侧)。
  1113. * 为了让固定行程一定罩得住这段漂移, 老策略只能把行程留得很宽(7s 量级)。
  1114. *
  1115. * 新策略(PF_EN=1) —— 录制前先找"清晰度开始上升"的位置:
  1116. * 从当前位置起以 PF_STEP 为步长向下取样清晰度。一旦出现连续上升、且抬升明显超过
  1117. * 本轮底噪, 就认定踩到了焦区的上升沿; 随即往回退 PF_HEADROOM 作为录制起点。
  1118. * 这样随后的下行必然完整经过"上升 -> 峰值 -> 下降", 3 秒行程就够覆盖整个焦区,
  1119. * 而且每个点位都重新锚定一次焦面, 漂移不再跨点位累积。
  1120. * 注意这里只找"上升沿", 不找峰值本身 —— 采样量比完整自动对焦少一个数量级。
  1121. *
  1122. * 失败处理(阶段2, 双向搜索):
  1123. * 阶段1(向下搜索 PF_SEARCH_LIMIT)没找到, 有两种原因 ——
  1124. * a) 下行一开始"从未上升且连续下降": 方向反了, 焦区其实在起始位置上方;
  1125. * b) 走完整段行程才停: 回程丢步把整条轨迹往下带, 起点已越过峰值。
  1126. * 两种都先回退到最开始的位置(进入预对焦时的高度), 再反向(向上)搜索峰值:
  1127. * 上行时清晰度先升后降, 越过峰值后连续回落即确认, 随后上移 PF_HEADROOM 作为录制起点
  1128. * (录制方向是下行, 起点必须在焦区上方)。
  1129. * 反向也失败则再退回到最初位置, 按 slide_set_record_travel(0) 的加长兜底行程录制。
  1130. *
  1131. * 单位口径(改动前必读, 与 ctr_move 的实现强耦合):
  1132. * ctr_move(Y_,dir,dis_,period) 是"定时开PWM": for(j=0;j<dis_;j++){ delay },
  1133. * dis_>=8000 时每格延迟 10ms, dis_<8000 时每格延迟 1ms —— 同一个数值在门槛两侧
  1134. * 行程相差 10 倍。
  1135. * · 预对焦小步: dis_<8000 且 period=PF_PWM_PERIOD_NS(1kHz)
  1136. * => 1 格 = 1ms = 1 个脉冲, 故本段所有 PF_* 行程/步长的单位就是"脉冲"。
  1137. * · 绝对接近 y_init_dis: dis_>=8000 且 period=mapSpeed(50)=125us(8kHz)
  1138. * => 1 格 = 10ms = 80 个脉冲。PF_APPROACH_BACKOFF 用的是这个口径(见 control.h),
  1139. * 且扣减后仍必须 >=8000, 否则掉到 1ms/格档, 同样的数字行程只剩 1/10。
  1140. * ============================================================ */
  1141. #define PF_PWM_PERIOD_NS 1000000UL /* 预对焦PWM周期(ns): 1kHz -> 1 格 = 1 脉冲 */
  1142. #define PF_STEP 60 /* 扫描步长(脉冲): 必须 <= 焦区上升沿宽度的 1/2, 否则整步跨过上升沿漏检 */
  1143. #define PF_SEARCH_LIMIT 600 /* 阶段1: 向下搜索行程(脉冲) */
  1144. #define PF_PHASE2_UP 600 /* 阶段2 反向搜索的基准行程(脉冲), 用于换算 PF_UP_SEARCH_LIMIT */
  1145. #define PF_HEADROOM 60 /* 录制起点相对上升沿再上移的量(脉冲): 保证从上升沿之前起录, 同时吃掉反向间隙 */
  1146. #define PF_RISE_STEP_RATIO 1.05f /* 单步涨幅超过该比例才计一次上升(本机清晰度噪声实测 <1%) */
  1147. #define PF_RISE_CONFIRM 2 /* 连续上升该次数 -> 确认处于上升沿 */
  1148. #define PF_RISE_RATIO 1.30f /* 且当前清晰度须高于本轮底噪该倍数(排除噪声抖动; 用比值故与清晰度绝对量纲无关) */
  1149. #define PF_FALL_GIVEUP_CNT 3 /* 阶段1: 从未上升过且连续下降该次数 -> 判为已身处焦后下降段, 提前换向省时间 */
  1150. #define PF_UP_SEARCH_LIMIT (PF_SEARCH_LIMIT + PF_PHASE2_UP) /* 阶段2 反向(向上)搜索行程(脉冲) */
  1151. #define PF_PEAK_FALL_CNT 2 /* 上行搜索: 越过峰值后连续下降该次数 -> 认为已离开峰值区 */
  1152. #define PF_PEAK_DROP_RATIO 0.90f /* 且当前值较记录到的峰值回落该比例以下才确认(抗噪声) */
  1153. #define PF_FOCUS_TIMEOUT_MS 5000 /* 单次等待 focus 回传的超时(ms) */
  1154. #define PF_FOCUS_RETRY_MAX 3 /* 超时后补发 movy 的次数上限 */
  1155. #define PF_TOTAL_TIMEOUT_MS 120000 /* 预对焦总时间预算(ms): 超时整体判失败走兜底, 防止通信异常时长时间卡死 */
  1156. #define PF_RECORD_MS_OK 5000 /* 预对焦成功: 录制下行行程(ms)。起点已在上升沿前, 无需长行程 */
  1157. #define PF_RECORD_MS_FAIL 7500 /* 预对焦失败兜底: 加大覆盖范围的录制下行行程(ms) */
  1158. #define PF_PREROLL_MS_OK 500 /* 预对焦成功时的预启动行程(ms) */
  1159. #define PF_PREROLL_MS_FAIL 1500 /* 预对焦失败时的预启动行程(ms)(保持旧值) */
  1160. #define PF_RETURN_BIAS_MS 0 /* 回程额外补偿行程(ms): >0 表示回程再往限位方向多走一点。
  1161. * 用于吸收实测的固定单向偏差(如下比上丢步多); 未标定前保持 0 */
  1162. #define PF_MOVE_TIMEOUT_MS 60000 /* 单次 Y 移动派发的等待上限(ms): 兜底防死锁, 超时强制继续 */
  1163. /* 滑台线程句柄: 预对焦需要判断自己是不是在滑台线程里跑(见 pf_move 的注释) */
  1164. static rt_thread_t g_slide_thread = RT_NULL;
  1165. /* Y 轴单次移动(供 case 6 与预对焦共用)。
  1166. * 注意: 预对焦(pf_move)在滑台线程内执行时必须直接调本函数, 不能走"派发 en_slide=6 再等
  1167. * 它清零"的路子 —— 执行 case 6 的就是滑台线程自己, 派发后本线程卡在等待里, 没人去执行,
  1168. * 形成自死锁(现象: 收到 focus 之后整机再无任何输出)。 */
  1169. static uint32_t slide_y_step(uint8_t dir, uint32_t dis, uint32_t pulse)
  1170. {
  1171. uint32_t ret;
  1172. slide_para.ydir = dir;
  1173. slide_para.ydis = dis;
  1174. slide_para.pulse_period = pulse;
  1175. ret = ctr_move(Y_, dir, dis, pulse);
  1176. rt_kprintf("The slide's y movement was done ok\n");
  1177. /* 按本次行程自适应等待振铃衰减(原固定 1000ms)。行程很小(对焦细扫)时无需等满 1s */
  1178. {
  1179. rt_uint32_t settle = AF_SETTLE_MS(dis);
  1180. LOG_D("Y移动后等待 %d ms (行程 %d 脉冲)", settle, dis);
  1181. rt_thread_delay(rt_tick_from_millisecond(settle));
  1182. }
  1183. slide_para.ydis = 0;
  1184. return ret;
  1185. }
  1186. /* 本次录制的行程参数: 由 slide_set_record_travel() 依据预对焦结果设定, case 8 消费 */
  1187. static uint32_t g_record_dis_1 = PF_RECORD_MS_FAIL;
  1188. static uint32_t g_record_dis_0 = PF_RECORD_MS_FAIL;
  1189. static uint32_t g_record_preroll = PF_PREROLL_MS_FAIL;
  1190. /* 预对焦进行中标志: hmi.c 用它把这段时间回传的 focus 帧挡在旧的爬山/校准状态机之外
  1191. * (dtu_uart2.c 每收到一个 focus 就会把 autotakepic 置 2 并给控制线程发信号) */
  1192. volatile uint8_t g_pf_busy = 0;
  1193. /* 请求一次清晰度采样: 发 movy 并等待 focus 回传。
  1194. * 返回 1 = 收到有效清晰度(值在 device_status.focus_value); 0 = 连续超时, 判定通信异常 */
  1195. static uint8_t pf_request_focus(void)
  1196. {
  1197. int retry = 0;
  1198. char utos[8];
  1199. rt_sprintf(utos, "%d", (int)slide_para.ystep);
  1200. do {
  1201. char *photo = makeJson_Warn("movy", utos);
  1202. if (photo != RT_NULL) {
  1203. LOG_D("%s", photo);
  1204. focus_valid_flag = 0; /* 清零后再发送, 避免误用上次残留的 focus */
  1205. DTU_Write("%s", photo);
  1206. rt_free(photo);
  1207. }
  1208. rt_tick_t deadline = rt_tick_get() + rt_tick_from_millisecond(PF_FOCUS_TIMEOUT_MS);
  1209. while ((rt_int32_t)(rt_tick_get() - deadline) < 0) {
  1210. if (focus_valid_flag) {
  1211. focus_valid_flag = 0;
  1212. return 1;
  1213. }
  1214. rt_thread_delay(RT_TICK_PER_SECOND / 10); /* 100ms 轮询一次 */
  1215. }
  1216. retry++;
  1217. LOG_W("[预对焦] movy 未收到 focus 回传, 重传第 %d 次", retry);
  1218. } while (retry < PF_FOCUS_RETRY_MAX);
  1219. return 0;
  1220. }
  1221. /* 相对移动 pulse 个脉冲(dir=1下行 / 0上行)。
  1222. * ctr_move 内部会先切 Y 轴电源、结束后按行程自适应等待振铃衰减。 */
  1223. static void pf_move(uint8_t dir, uint32_t pulse)
  1224. {
  1225. slide_para.stop_flag = 0;
  1226. slide_para.pulse_period = PF_PWM_PERIOD_NS;
  1227. slide_para.ystep = pulse;
  1228. slide_para.ydir = dir;
  1229. slide_para.ydis = pulse;
  1230. /* 关键: 判断当前是不是在滑台线程里。
  1231. * 是(点位切换 case 1/case 2 内调用) -> 只能直接调底层, 派发 en_slide=6 再死等会自死锁;
  1232. * 否(hmi.c 的 Ctr_Mortor 线程在初始化时调用) -> 仍走派发, 保证所有滑台动作串行执行。 */
  1233. if (g_slide_thread != RT_NULL && rt_thread_self() == g_slide_thread) {
  1234. slide_y_step(dir, pulse, PF_PWM_PERIOD_NS);
  1235. return;
  1236. }
  1237. /* 若滑台线程正忙(例如上一次录制还没走完), 先等它空闲 —— en_slide 是单槽的,
  1238. * 直接写会覆盖掉正在执行的动作。 */
  1239. {
  1240. rt_tick_t busy_deadline = rt_tick_get() + rt_tick_from_millisecond(PF_MOVE_TIMEOUT_MS);
  1241. while (slide_para.en_slide != 0) {
  1242. if ((rt_int32_t)(rt_tick_get() - busy_deadline) > 0) {
  1243. LOG_E("[预对焦] 等待滑台空闲超时%dms, 强制改派", PF_MOVE_TIMEOUT_MS);
  1244. break;
  1245. }
  1246. rt_thread_delay(10);
  1247. }
  1248. }
  1249. slide_para.en_slide = 6;
  1250. {
  1251. rt_tick_t deadline = rt_tick_get() + rt_tick_from_millisecond(PF_MOVE_TIMEOUT_MS);
  1252. while (slide_para.en_slide != 0) {
  1253. if ((rt_int32_t)(rt_tick_get() - deadline) > 0) {
  1254. LOG_E("[预对焦] Y移动派发等待超时%dms, 强制继续(防整机卡死)", PF_MOVE_TIMEOUT_MS);
  1255. slide_para.en_slide = OFF;
  1256. break;
  1257. }
  1258. rt_thread_delay(10);
  1259. }
  1260. }
  1261. }
  1262. /* 移动一步并采样清晰度。返回 1 = 取到有效清晰度; 0 = focus 连续超时(通信异常) */
  1263. static uint8_t pf_move_sample(uint8_t dir, uint32_t pulse, float *out)
  1264. {
  1265. pf_move(dir, pulse);
  1266. if (!pf_request_focus()) {
  1267. return 0;
  1268. }
  1269. *out = (float)device_status.focus_value;
  1270. return 1;
  1271. }
  1272. /* 向下搜索"清晰度上升沿"。
  1273. * limit_pulse: 本趟最大搜索行程(脉冲); deadline: 总时间预算;
  1274. * traveled: 出参, 本趟实际下行的脉冲数;
  1275. * pre_rise: 出参, 上升沿之前那一点相对本趟起点的位移(脉冲);
  1276. * comm_ok: 出参, 0 表示 focus 通信链路断了(调用方不应再重试)。
  1277. * 返回 1 = 找到上升沿(Y 停在发现点); 0 = 未找到(Y 停在起点+traveled)。 */
  1278. static uint8_t pf_scan_down(uint32_t limit_pulse, rt_tick_t deadline,
  1279. int *traveled, int *pre_rise, uint8_t *comm_ok,
  1280. uint8_t *fall_giveup)
  1281. {
  1282. float prev = 0.0f, cur = 0.0f, base = 0.0f;
  1283. int pos = 0, rise_cnt = 0, fall_cnt = 0;
  1284. int ever_risen = 0, rise_from = 0;
  1285. *fall_giveup = 0;
  1286. /* 起点基准值: 未移动直接请求一次 */
  1287. if (!pf_request_focus()) {
  1288. *comm_ok = 0;
  1289. *traveled = 0;
  1290. return 0;
  1291. }
  1292. prev = base = (float)device_status.focus_value;
  1293. while ((pos + (int)PF_STEP) <= (int)limit_pulse) {
  1294. if (slide_para.stop_flag != 0) {
  1295. LOG_W("[预对焦] 收到急停, 中断搜索(已下行%d脉冲)", pos);
  1296. break;
  1297. }
  1298. if ((rt_int32_t)(rt_tick_get() - deadline) > 0) {
  1299. LOG_W("[预对焦] 超出总时间预算%dms, 中断搜索(已下行%d脉冲)",
  1300. PF_TOTAL_TIMEOUT_MS, pos);
  1301. break;
  1302. }
  1303. if (!pf_move_sample(1, PF_STEP, &cur)) {
  1304. *comm_ok = 0;
  1305. break;
  1306. }
  1307. pos += (int)PF_STEP;
  1308. if (cur < base) base = cur;
  1309. if (cur > prev * PF_RISE_STEP_RATIO) {
  1310. if (rise_cnt == 0) rise_from = pos - (int)PF_STEP; /* 开始上升之前的那个采样点 */
  1311. rise_cnt++;
  1312. ever_risen = 1;
  1313. fall_cnt = 0;
  1314. if (rise_cnt >= PF_RISE_CONFIRM && base > 0.0f &&
  1315. cur > base * PF_RISE_RATIO) {
  1316. *pre_rise = rise_from;
  1317. *traveled = pos;
  1318. LOG_I("[预对焦] 发现上升沿: 上升前位置=+%d脉冲 清晰度 %.2f->%.2f (底噪 %.2f)",
  1319. rise_from, prev, cur, base);
  1320. return 1;
  1321. }
  1322. } else {
  1323. rise_cnt = 0;
  1324. if (cur < prev) {
  1325. fall_cnt++;
  1326. if (!ever_risen && fall_cnt >= PF_FALL_GIVEUP_CNT) {
  1327. LOG_W("[预对焦] 起点已在焦后下降段(从未上升且连续下滑%d次), 提前结束本趟下行",
  1328. fall_cnt);
  1329. *fall_giveup = 1; /* 告诉调用方: 是"走错方向", 需要反向上搜 */
  1330. break;
  1331. }
  1332. } else {
  1333. fall_cnt = 0;
  1334. }
  1335. }
  1336. prev = cur;
  1337. }
  1338. *traveled = pos;
  1339. return 0;
  1340. }
  1341. /* 阶段2 反向(向上)搜索峰值: 判定"方向反了"时使用 —— 焦区在起始位置上方。
  1342. * 上行过程中清晰度先升后降, 越过峰值后连续回落 PF_PEAK_FALL_CNT 次且跌破峰值的
  1343. * PF_PEAK_DROP_RATIO, 即认为峰值已过; 此时 Y 在峰值上方一点点, 再由调用方上移
  1344. * PF_HEADROOM 作为录制起点(录制方向是下行, 起点必须在焦区上方)。
  1345. * 返回 1 = 找到峰值; 0 = 未找到(通信中断/急停/超时/一路升到行程上限仍不见回落)。
  1346. * *climb: 出参, 本趟实际上行的脉冲数(供失败时回原位);
  1347. * *peak_pos: 出参, 峰值位置(相对本趟起点的上行脉冲)。 */
  1348. static uint8_t pf_scan_up(uint32_t limit_pulse, rt_tick_t deadline,
  1349. int *climb, int *peak_pos, uint8_t *comm_ok)
  1350. {
  1351. float prev = 0.0f, cur = 0.0f, peak = 0.0f;
  1352. int pos = 0, peak_at = 0, fall_cnt = 0;
  1353. if (!pf_request_focus()) {
  1354. *comm_ok = 0;
  1355. *climb = 0;
  1356. *peak_pos = 0;
  1357. return 0;
  1358. }
  1359. peak = prev = (float)device_status.focus_value;
  1360. while ((pos + (int)PF_STEP) <= (int)limit_pulse) {
  1361. if (slide_para.stop_flag != 0) {
  1362. LOG_W("[预对焦] 上行搜索收到急停, 中断(已上行%d脉冲)", pos);
  1363. break;
  1364. }
  1365. if ((rt_int32_t)(rt_tick_get() - deadline) > 0) {
  1366. LOG_W("[预对焦] 上行搜索超出时间预算, 中断(已上行%d脉冲)", pos);
  1367. break;
  1368. }
  1369. if (!pf_move_sample(0, PF_STEP, &cur)) { /* dir=0 = 上行 */
  1370. *comm_ok = 0;
  1371. break;
  1372. }
  1373. pos += (int)PF_STEP;
  1374. if (cur > peak) {
  1375. peak = cur;
  1376. peak_at = pos;
  1377. fall_cnt = 0;
  1378. } else if (cur < prev && peak > 0.0f && cur < peak * PF_PEAK_DROP_RATIO) {
  1379. if (++fall_cnt >= PF_PEAK_FALL_CNT) {
  1380. *climb = pos;
  1381. *peak_pos = peak_at;
  1382. LOG_I("[预对焦] 上行搜索发现峰值: 峰值位置=+%d脉冲(清晰度%.2f), 当前已上行%d脉冲",
  1383. peak_at, peak, pos);
  1384. return 1;
  1385. }
  1386. } else {
  1387. fall_cnt = 0;
  1388. }
  1389. prev = cur;
  1390. }
  1391. *climb = pos;
  1392. *peak_pos = peak_at;
  1393. return 0;
  1394. }
  1395. /* 预对焦主流程: 找到"清晰度上升前"的位置, 并把 Y 轴回退到该位置上方 PF_HEADROOM 处待录。
  1396. * 返回 1 = 成功(Y 已在录制起点); 0 = 失败, 调用方应按 slide_set_record_travel(0) 的兜底行程录制 */
  1397. int slide_pre_focus(void)
  1398. {
  1399. rt_tick_t deadline;
  1400. int traveled = 0, pre_rise = 0;
  1401. int net = 0; /* 相对进入时位置的净下行量(脉冲) */
  1402. uint8_t comm_ok = 1, found = 0;
  1403. uint8_t fall_giveup = 0; /* 阶段1: 是否因"连续下降=方向反了"提前结束 */
  1404. uint32_t saved_period = slide_para.pulse_period; /* 预对焦用小步PWM, 退出时恢复,
  1405. * 否则会污染后续 X/Z 复位的速度档 */
  1406. if (!PF_EN) {
  1407. return 0;
  1408. }
  1409. g_pf_busy = 1;
  1410. deadline = rt_tick_get() + rt_tick_from_millisecond(PF_TOTAL_TIMEOUT_MS);
  1411. LOG_I("[预对焦] 开始: 步长=%d脉冲 阶段1搜索%d脉冲", PF_STEP, PF_SEARCH_LIMIT);
  1412. found = pf_scan_down(PF_SEARCH_LIMIT, deadline, &traveled, &pre_rise, &comm_ok,
  1413. &fall_giveup);
  1414. net += traveled;
  1415. /* 阶段2: 向下没找到 —— 回到最开始的位置, 再反向(向上)搜一次。
  1416. * 触发依据: ① 下行一开始就"从未上升且连续下降"(fall_giveup), 说明方向反了、焦区在起始位置上方;
  1417. * ② 走完整段行程才停(回程丢步把轨迹整体往下带), 也按同样方式回到原点重搜,
  1418. * 避免继续在已经跑偏的方向上白走。 */
  1419. if (!found && comm_ok && slide_para.stop_flag == 0 &&
  1420. (rt_int32_t)(rt_tick_get() - deadline) <= 0) {
  1421. int up_climb = 0, peak_pos = 0;
  1422. /* ① 回到最开始的位置(进入预对焦时的高度) */
  1423. if (net > 0) {
  1424. pf_move(0, (uint32_t)net);
  1425. LOG_W("[预对焦] 阶段1未找到上升沿(%s, 已下行%d脉冲), 回退到起始位置后反向搜索",
  1426. fall_giveup ? "方向反了" : "行程内未见上升", net);
  1427. net = 0;
  1428. }
  1429. /* ② 反向(向上)搜索峰值 */
  1430. LOG_I("[预对焦] 阶段2: 自起始位置向上搜索%d脉冲", PF_UP_SEARCH_LIMIT);
  1431. found = pf_scan_up(PF_UP_SEARCH_LIMIT, deadline, &up_climb, &peak_pos, &comm_ok);
  1432. net -= up_climb; /* 上行 = 净下行量减少 */
  1433. if (found) {
  1434. /* 录制方向是下行, 起点必须再往焦区上方让出 PF_HEADROOM;
  1435. 但不要超出本次上行搜索的行程上限, 免得顶到机械限位 */
  1436. if (PF_HEADROOM > 0 && slide_para.stop_flag == 0 &&
  1437. (up_climb + (int)PF_HEADROOM) <= (int)PF_UP_SEARCH_LIMIT) {
  1438. pf_move(0, PF_HEADROOM);
  1439. net -= (int)PF_HEADROOM;
  1440. }
  1441. LOG_I("[预对焦] 反向搜索成功: 峰值+%d脉冲, 停在峰值上方%d脉冲处等待录制",
  1442. peak_pos, -net);
  1443. slide_para.pulse_period = saved_period;
  1444. g_pf_busy = 0;
  1445. return 1;
  1446. }
  1447. }
  1448. if (!found) {
  1449. LOG_W("[预对焦] 失败(净下行%d脉冲, %s), 回原位后按加长行程兜底录制",
  1450. net, comm_ok ? "未搜到焦区(已双向搜索)" : "focus回传中断");
  1451. /* 关键: 必须退回进入预对焦时的高度再开始录。兜底行程是照着"到位就录"的老行为
  1452. * 标定的, 若不退回, 净下行(反向搜索后也可能是净上行)的部分会叠加在兜底行程上,
  1453. * 有可能超出机械下限。 */
  1454. if (comm_ok) {
  1455. if (net > 0) {
  1456. pf_move(0, (uint32_t)net); /* 曾在起始位置下方: 上行回原位 */
  1457. } else if (net < 0) {
  1458. pf_move(1, (uint32_t)(-net)); /* 曾在起始位置上方: 下行回原位 */
  1459. }
  1460. }
  1461. slide_para.pulse_period = saved_period;
  1462. g_pf_busy = 0;
  1463. return 0;
  1464. }
  1465. /* 回退到"上升沿之前 0"作为录制起点(dir=0 为上行/限位方向) */
  1466. {
  1467. int back = (traveled - pre_rise);
  1468. if (back > 0) {
  1469. pf_move(0, (uint32_t)back);
  1470. LOG_I("[预对焦] 成功: 上退%d脉冲, 停在上升沿前脉冲处等待录制", back);
  1471. }
  1472. }
  1473. slide_para.pulse_period = saved_period;
  1474. g_pf_busy = 0;
  1475. return 1;
  1476. }
  1477. /* 依据预对焦结果设定本次录制的行程 */
  1478. void slide_set_record_travel(uint8_t pf_ok)
  1479. {
  1480. if (pf_ok) {
  1481. g_record_dis_1 = PF_RECORD_MS_OK;
  1482. g_record_dis_0 = PF_RECORD_MS_OK;
  1483. g_record_preroll = PF_PREROLL_MS_OK;
  1484. } else {
  1485. g_record_dis_1 = PF_RECORD_MS_FAIL;
  1486. g_record_dis_0 = PF_RECORD_MS_FAIL;
  1487. g_record_preroll = PF_PREROLL_MS_FAIL;
  1488. }
  1489. LOG_I("[录制] 行程: 预对焦%s -> 预启动%ums 下行%ums 回程%ums",
  1490. pf_ok ? "成功" : "失败", g_record_preroll, g_record_dis_1, g_record_dis_0);
  1491. }
  1492. void slide_thread_entry(void *parameter)
  1493. {
  1494. g_slide_thread = rt_thread_self(); /* 供 pf_move 判断是否处于滑台线程内(避免自死锁) */
  1495. slide_para.pulse_period = 1; //默认滑台的脉宽为1ms
  1496. /* 向下丢步优化(3.7.26): 步率200Hz->133Hz, 物理行程≈1000脉冲不变 */
  1497. const uint32_t record_pulse = 7500000UL; /* 缓慢:低速PWM(周期ns) */
  1498. while(1)
  1499. {
  1500. rt_thread_delay(10);
  1501. switch(slide_para.en_slide){
  1502. case 1:{
  1503. uint8_t en_before = slide_para.en_slide; /* 供预对焦后判断是否被外部改派 */
  1504. ctr_move(X_,slide_para.xdir,slide_para.xdis,slide_para.pulse_period);
  1505. LOG_I("The slide's x movement was done ok");
  1506. #if FOCUS_STEP_EN == 1
  1507. if(slide_para.xdis==55||slide_para.xdis==80)
  1508. {
  1509. DTU_Write("{\"cmd\": \"takephoto\" }");
  1510. device_status.autotakepic = 4;
  1511. }else {
  1512. char *photo = makeJson_Warn("movx","done");
  1513. LOG_I("%s",photo);
  1514. DTU_Write("%s",photo);
  1515. rt_free(photo);
  1516. }
  1517. #else
  1518. if(slide_para.xdis==55||slide_para.xdis==80)
  1519. {
  1520. /* 点位切换(X轴走到新点位, 焦面会随之起伏): 通知工控机录制之前先做一次
  1521. * 轻量预对焦, 重新锚定"清晰度上升沿之前"的位置 —— 既让本次录制只需约
  1522. * 3 秒下行就罩住整个焦区, 也顺带把点位之间"下行+回程"累积的相对误差清零。 */
  1523. uint8_t pf_ok = 0;
  1524. ctr_swz(OFF); //Z轴开关:关
  1525. ctr_lamp(OFF,1); //X轴开关:关
  1526. ctr_Collect_Fan(ON); //Y轴电源开关:开
  1527. rt_thread_delay(200);
  1528. #if PF_EN
  1529. slide_para.stop_flag = 0;
  1530. pf_ok = slide_pre_focus();
  1531. #endif
  1532. slide_set_record_travel(pf_ok);
  1533. char *photo = makeJson_Warn("mov_init_y","takephoto_done");
  1534. DTU_Write("%s",photo);
  1535. rt_free(photo);
  1536. }
  1537. #endif
  1538. slide_para.stop_flag = 0;
  1539. if (slide_para.en_slide == en_before) {
  1540. slide_para.en_slide = OFF;
  1541. } else {
  1542. LOG_W("预对焦期间收到新的滑台派发(en_slide=%d), 保留不清除", slide_para.en_slide);
  1543. }
  1544. break;
  1545. }
  1546. case 2:{
  1547. uint8_t en_before = slide_para.en_slide; /* 供预对焦后判断是否被外部改派 */
  1548. ctr_move(Z_,slide_para.zdir,slide_para.zdis,slide_para.pulse_period);
  1549. LOG_I("The slide's z movement was done ok\n");
  1550. #if FOCUS_STEP_EN == 1
  1551. if(slide_para.zdis==55||slide_para.zdis==80)
  1552. {
  1553. DTU_Write("{\"cmd\": \"takephoto\" }");
  1554. device_status.autotakepic = 4;
  1555. }else {
  1556. char *photo = makeJson_Warn("movz","done");
  1557. LOG_I("%s",photo);
  1558. DTU_Write("%s",photo);
  1559. rt_free(photo);
  1560. }
  1561. #else
  1562. if(slide_para.zdis==55||slide_para.zdis==80)
  1563. {
  1564. /* 同 case 1: 点位切换(Z轴走到新点位)后录制前先预对焦一次 */
  1565. uint8_t pf_ok = 0;
  1566. ctr_swz(OFF); //Z轴开关:关
  1567. ctr_lamp(OFF,1); //X轴开关:关
  1568. ctr_Collect_Fan(ON); //Y轴电源开关:开
  1569. rt_thread_delay(200);
  1570. #if PF_EN
  1571. slide_para.stop_flag = 0;
  1572. pf_ok = slide_pre_focus();
  1573. #endif
  1574. slide_set_record_travel(pf_ok);
  1575. char *photo = makeJson_Warn("mov_init_y","takephoto_done");
  1576. DTU_Write("%s",photo);
  1577. rt_free(photo);
  1578. }
  1579. #endif
  1580. slide_para.zdir = 1;
  1581. slide_para.zdis = 0;
  1582. slide_para.stop_flag = 0;
  1583. if (slide_para.en_slide == en_before) {
  1584. slide_para.en_slide = OFF;
  1585. } else {
  1586. LOG_W("预对焦期间收到新的滑台派发(en_slide=%d), 保留不清除", slide_para.en_slide);
  1587. }
  1588. break;
  1589. }
  1590. case 3:{ //复位X
  1591. LOG_W("X轴复位!");
  1592. slide_para.xdir = 0;
  1593. slide_para.xdis = 8000;
  1594. ctr_move(X_,slide_para.xdir,slide_para.xdis,slide_para.pulse_period);
  1595. LOG_I("The slide's X movement was done ok");
  1596. slide_para.xdir = 0;
  1597. slide_para.xdis = 0;
  1598. slide_para.stop_flag = 0;
  1599. slide_para.en_slide = OFF;
  1600. break;
  1601. }
  1602. case 4:{
  1603. //复位Z
  1604. LOG_W("Z轴复位!");
  1605. slide_para.zdir = 1; //250717
  1606. slide_para.zdis = 5000;
  1607. ctr_move(Z_,slide_para.zdir,slide_para.zdis,slide_para.pulse_period);
  1608. LOG_I("The slide's Z movement was done ok");
  1609. slide_para.zdis = 0;
  1610. slide_para.stop_flag = 0;
  1611. slide_para.en_slide = OFF;
  1612. break;
  1613. }
  1614. case 6:{ //Y轴
  1615. slide_y_step(slide_para.ydir, slide_para.ydis, slide_para.pulse_period);
  1616. #if FOCUS_STEP_EN == 1
  1617. if(1){
  1618. /* 发送movy后等待相机回传focus, 5S超时未收到则重发, 最多重传3次, 避免对焦卡死 */
  1619. int focus_ok = 0;
  1620. int retry = 0;
  1621. do {
  1622. char utos[5];
  1623. rt_sprintf(utos,"%d",slide_para.ystep);
  1624. char *photo = makeJson_Warn("movy",utos);
  1625. LOG_I("%s",photo);
  1626. focus_valid_flag = 0; /* 清零后再发送, 避免误用上次残留的focus */
  1627. DTU_Write("%s",photo);
  1628. rt_free(photo);
  1629. /* 等待相机回传有效focus, 超时5S */
  1630. rt_uint32_t deadline = rt_tick_get() + 5 * RT_TICK_PER_SECOND;
  1631. while ((rt_int32_t)(rt_tick_get() - deadline) < 0) {
  1632. if (focus_valid_flag) {
  1633. focus_valid_flag = 0;
  1634. focus_ok = 1;
  1635. break;
  1636. }
  1637. rt_thread_delay(RT_TICK_PER_SECOND / 10); /* 100ms轮询一次 */
  1638. }
  1639. if (focus_ok) {
  1640. break;
  1641. }
  1642. retry++;
  1643. LOG_W("movy 未收到focus回传, 重传第%d次", retry);
  1644. } while (retry < 3);
  1645. if (!focus_ok) {
  1646. LOG_W("movy 连续4次未收到focus回传, 放弃重传");
  1647. }
  1648. }
  1649. #endif
  1650. slide_para.ydis = 0;
  1651. slide_para.stop_flag = 0;
  1652. slide_para.en_slide = OFF;
  1653. break;
  1654. }
  1655. case 7:{ //Y轴复位
  1656. LOG_W("Y轴复位!");
  1657. slide_para.ydir = 0;
  1658. slide_para.ydis = 8000;
  1659. ctr_move(Y_,slide_para.ydir,slide_para.ydis,slide_para.pulse_period);
  1660. LOG_I("The slide's Y movement was done ok");
  1661. /* Y轴复位后录制行程复位为兜底值; 随后 slide_set_record_travel()
  1662. * 会依据该点位的预对焦结果改写成短行程(成功)或保留加长行程(失败) */
  1663. g_record_dis_1 = PF_RECORD_MS_FAIL;
  1664. g_record_dis_0 = PF_RECORD_MS_FAIL;
  1665. g_record_preroll = PF_PREROLL_MS_FAIL;
  1666. slide_para.stop_flag = 0;
  1667. slide_para.en_slide = OFF;
  1668. break;
  1669. }
  1670. case 8:{ //录制:Y轴缓慢向下移动(行程由预对焦结果决定),完成后发送record_stop,再返回出发位置
  1671. /* 说明: 录制起点已由 slide_pre_focus() 锚定在"清晰度上升沿之前",
  1672. * 因此预对焦成功时只需约 3 秒下行即可完整经过 上升->峰值->下降;
  1673. * 预对焦失败时才退回加长行程盲录 —— 与工控机的录制开始/停止握手保持不变
  1674. * (takephoto_done -> 工控机开录 -> 下发 record_start -> 本分支 -> record_stop)。 */
  1675. // LOG_W("录制:Y轴缓慢向下移动%ums(预启动%ums)!",g_record_dis_1,g_record_preroll);
  1676. // ctr_move(Y_, 1, g_record_preroll, record_pulse); /* 预启动 */
  1677. rt_tick_t tick_down_start = rt_tick_get();
  1678. ctr_move(Y_, 1, g_record_dis_1, record_pulse); /* 缓慢向下移动 */
  1679. LOG_I("向下移动耗时:%u ms",
  1680. (unsigned int)((rt_tick_get() - tick_down_start) * 1000UL / RT_TICK_PER_SECOND));
  1681. /* 执行完成, 通知远端停止录制 */
  1682. char *c0 = makeJsonRpc2_0("record_stop", NULL, 0);
  1683. if(c0 != NULL)
  1684. {
  1685. DTU_Write("%s", c0);
  1686. rt_free(c0);
  1687. }
  1688. rt_thread_delay(500);
  1689. /* Y轴返回出发位置(方向0为初始/限位方向)
  1690. * 【重要修改】原实现这里硬编码 800 作为回程预启动, 而下行预启动是 1500 ——
  1691. * 两个方向不对称, 名义上每个点位净往下走 700 个单位(≈93个脉冲), 32 个点位
  1692. * 累计就是约 3000 个脉冲的单向爬行, 是"走着走着就拍不到清晰位置"的主要来源。
  1693. * 现改为回程与下行共用同一套行程参数, 名义净位移为 0(实际残留差靠预对焦吸收);
  1694. * 若实测仍有固定单向偏差, 用 PF_RETURN_BIAS_MS 做一次性补偿。 */
  1695. //ctr_move(Y_, 0, g_record_preroll, record_pulse);
  1696. if (PF_RETURN_BIAS_MS != 0) {
  1697. ctr_move(Y_, 0, (uint32_t)PF_RETURN_BIAS_MS, record_pulse);
  1698. }
  1699. rt_tick_t tick_up_start = rt_tick_get();
  1700. ctr_move(Y_, 0, g_record_dis_0, record_pulse);
  1701. LOG_I("向上移动耗时:%u ms",
  1702. (unsigned int)((rt_tick_get() - tick_up_start) * 1000UL / RT_TICK_PER_SECOND));
  1703. slide_para.stop_flag = 0;
  1704. slide_para.en_slide = OFF;
  1705. break;
  1706. }
  1707. case 9:{
  1708. //执行32次Y轴缓慢向下移动3S,完成后返回record_stop,再返回出发位置
  1709. int i = 0;
  1710. for(i = 0; i < 32; i++)
  1711. {
  1712. LOG_W("第%d次Y轴缓慢向下移动3S!",i+1);
  1713. /* 向下丢步优化(3.7.26): 步率200Hz->133Hz, 行程保持≈1000脉冲 */
  1714. uint32_t record_pulse = 7500000UL; /* 缓慢:低速PWM(周期ns) */
  1715. uint32_t record_dis = 7500; /* 行程约7.5秒 */
  1716. rt_tick_t tick_down_start = rt_tick_get();
  1717. ctr_move(Y_, 1, record_dis, record_pulse); /* 缓慢向下移动 */
  1718. LOG_I("第%d次 向下移动耗时:%u ms", i+1,
  1719. (unsigned int)((rt_tick_get() - tick_down_start) * 1000UL / RT_TICK_PER_SECOND));
  1720. rt_thread_delay(10000);
  1721. /* Y轴返回出发位置(方向0为初始/限位方向) */
  1722. rt_tick_t tick_up_start = rt_tick_get();
  1723. ctr_move(Y_, 0, record_dis, record_pulse);
  1724. LOG_I("第%d次 向上移动耗时:%u ms", i+1,
  1725. (unsigned int)((rt_tick_get() - tick_up_start) * 1000UL / RT_TICK_PER_SECOND));
  1726. }
  1727. slide_para.stop_flag = 0;
  1728. slide_para.en_slide = OFF;
  1729. break;
  1730. }
  1731. default:
  1732. {
  1733. slide_para.en_slide = OFF;
  1734. slide_para.stop_flag = 0;
  1735. break;
  1736. }
  1737. }
  1738. }
  1739. }
  1740. /* 创建线程 -工作状态检测*/
  1741. int Workstatus_check(void)
  1742. {
  1743. /* 创建线程*/
  1744. tid_wkstc = rt_thread_create("w_s_c_t",
  1745. Work_status_thread_entry, RT_NULL,
  1746. WORK_CHECK_THREAD_STACK_SIZE, //1024
  1747. WORK_CHECK_THREAD_PRIORITY, //23
  1748. WORK_CHECK_THREAD_TIMESLICE); //5
  1749. if(tid_wkstc!=RT_NULL)
  1750. {
  1751. rt_thread_startup(tid_wkstc);
  1752. }
  1753. return 0;
  1754. }
  1755. /*工作流程线程*/
  1756. int Work_Loop_Task(void)
  1757. {
  1758. rt_err_t result_loop;
  1759. /* 创建线程*/
  1760. tid_workloop = rt_thread_create("work_loop_thread",
  1761. Work_Loop_thread_entry, RT_NULL,
  1762. WORK_LOOP_THREAD_STACK_SIZE, //2048
  1763. WORK_LOOP_THREAD_PRIORITY, //12
  1764. WORK_LOOP_THREAD_TIMESLICE); //5
  1765. #if Color_EN == 0
  1766. if(tid_workloop!=RT_NULL)
  1767. {
  1768. result_loop = rt_thread_startup(tid_workloop);
  1769. }
  1770. #endif
  1771. return result_loop;
  1772. }
  1773. int slide_Fresh(void)
  1774. {
  1775. rt_err_t ret = RT_EOK;
  1776. rt_slide = rt_thread_create("rt_slide",
  1777. slide_thread_entry,
  1778. RT_NULL,
  1779. 1024,
  1780. 5,
  1781. 20);
  1782. if (rt_slide != RT_NULL)
  1783. {
  1784. rt_thread_startup(rt_slide);
  1785. rt_kprintf("the thread of rt_slide start ok\n");
  1786. }
  1787. else
  1788. {
  1789. ret = RT_ERROR;
  1790. }
  1791. return ret;
  1792. }
  1793. /* 卷带电机任务线程: turnlimit最长会阻塞约10s(限位轮询),
  1794. * 将其从串口解析线程(t_uart2)中剥离, 由本线程异步执行, 保证串口JSON解析不被电机动作卡死 */
  1795. static void Motor_task_thread_entry(void *parameter)
  1796. {
  1797. while (1)
  1798. {
  1799. rt_sem_take(motor_task_sem, RT_WAITING_FOREVER);
  1800. #if BZYV13_EN == 1
  1801. turnlimit();
  1802. rt_thread_delay(1000);
  1803. turnlimit();
  1804. rt_thread_delay(1000);
  1805. turnlimit();
  1806. rt_thread_delay(1000);
  1807. #else
  1808. turnlimit();
  1809. rt_thread_delay(1000);
  1810. #endif
  1811. }
  1812. }
  1813. /* 非阻塞请求: 卷带电机旋转一次(供串口解析线程等短线程调用, 立即返回) */
  1814. void motor_turnlimit_req(void)
  1815. {
  1816. if(motor_task_sem != RT_NULL)
  1817. {
  1818. rt_sem_release(motor_task_sem);
  1819. }
  1820. }
  1821. /* 创建卷带电机任务线程(优先级10, 低于串口解析线程6, 保证串口优先响应) */
  1822. int Motor_Task_Init(void)
  1823. {
  1824. motor_task_sem = rt_sem_create("motor_sem", 0, RT_IPC_FLAG_FIFO);
  1825. if(motor_task_sem == RT_NULL)
  1826. {
  1827. return -1;
  1828. }
  1829. rt_mutex_init(&turnlimit_mutex, "turn_mutex", RT_IPC_FLAG_PRIO);
  1830. tid_motor_task = rt_thread_create("motor_task",
  1831. Motor_task_thread_entry, RT_NULL,
  1832. 2048, 10, 10);
  1833. if(tid_motor_task != RT_NULL)
  1834. {
  1835. rt_thread_startup(tid_motor_task);
  1836. return 0;
  1837. }
  1838. return -1;
  1839. }
  1840. void reboot(void)
  1841. {
  1842. LOG_W("手动触发重启!");
  1843. rt_hw_cpu_reset();
  1844. }
  1845. // ------------------------------
  1846. // RT-Thread 控制台命令实现
  1847. // ------------------------------
  1848. void fan_cmd(int argc, char *argv[])
  1849. {
  1850. if (argc == 1)
  1851. {
  1852. // 只输入 fan → 打印当前状态
  1853. rt_kprintf("Collect Fan status: %s\n",
  1854. device_status.collect_fan_status ? "ON" : "OFF");
  1855. return;
  1856. }
  1857. if (argc == 2)
  1858. {
  1859. if (!rt_strcmp(argv[1], "on"))
  1860. {
  1861. ctr_Collect_Fan(ON);
  1862. rt_kprintf("[FAN] Turn ON\n");
  1863. }
  1864. else if (!rt_strcmp(argv[1], "off"))
  1865. {
  1866. ctr_Collect_Fan(OFF);
  1867. rt_kprintf("[FAN] Turn OFF\n");
  1868. }
  1869. else
  1870. {
  1871. rt_kprintf("Usage: fan [on|off]\n");
  1872. }
  1873. }
  1874. }
  1875. // 导出到控制台命令
  1876. MSH_CMD_EXPORT(fan_cmd, fan control: fan on | fan off | fan);
  1877. MSH_CMD_EXPORT(ctr_lamp,ctr_lamp<ON|OFF>);
  1878. MSH_CMD_EXPORT(ctr_led,sample:ctr_led <ON|OFF>);
  1879. MSH_CMD_EXPORT(reboot,reboot);
  1880. //INIT_APP_EXPORT(Control_heat);