control.c 33 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205
  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 "easyflash.h"
  14. #include "stdio.h"
  15. #include "sound.h"
  16. #include "dtu_uart2.h"
  17. #include "sht30_collect.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. //工作检测
  24. #define WORK_CHECK_THREAD_PRIORITY 23 //线程优先级
  25. #define WORK_CHECK_THREAD_STACK_SIZE 1024 //栈大小
  26. #define WORK_CHECK_THREAD_TIMESLICE 5 //时间片
  27. //工作流程
  28. #define WORK_LOOP_THREAD_PRIORITY 12 //线程优先级
  29. #define WORK_LOOP_THREAD_STACK_SIZE 2048 //栈大小
  30. #define WORK_LOOP_THREAD_TIMESLICE 5 //时间片
  31. #define PWM_EN 1 //0关闭,1-打开
  32. //设备状态表结构体
  33. Device_Status_typedef device_status;
  34. Device_slide_typedef slide_para;
  35. static rt_thread_t tid_workloop = RT_NULL;
  36. static rt_thread_t tid_wkstc = RT_NULL;
  37. static rt_thread_t rt_slide = RT_NULL;
  38. /***************************************************************************/
  39. int thread_delete_workloop(void)
  40. {
  41. LOG_W("thread_delete_workloop.");
  42. rt_err_t result;
  43. if(tid_workloop!=RT_NULL)
  44. {
  45. result = rt_thread_delete(tid_workloop);
  46. }
  47. if(tid_wkstc!=RT_NULL)
  48. {
  49. result = rt_thread_delete(tid_wkstc);
  50. }
  51. if(rt_slide!=RT_NULL)
  52. {
  53. result = rt_thread_delete(rt_slide);
  54. }
  55. return 0;
  56. }
  57. int thread_restart_workloop(void)
  58. {
  59. rt_err_t result;
  60. result = Work_Loop_Task();
  61. return result;
  62. }
  63. void slidelock();
  64. //滑台垂直方向开关
  65. uint8_t ctr_swz(uint8_t status_swz)
  66. {
  67. rt_pin_mode(SHAKE_SW, PIN_MODE_OUTPUT);
  68. if(status_swz == ON){
  69. rt_pin_write(SHAKE_SW,ON);
  70. }
  71. else if(status_swz == OFF){
  72. rt_pin_write(SHAKE_SW,OFF);
  73. }
  74. return status_swz;
  75. }
  76. //限位开关判断函数
  77. void turnlimit(void)
  78. {
  79. if(device_status.temp_status==1) return;
  80. //Motor_shake(ON,0);
  81. Motor_Qingsao_R_PWM(ON);
  82. static uint16_t turn_timeout = 0;
  83. rt_pin_mode(LIMIT_DOWN,PIN_MODE_INPUT);
  84. while(rt_pin_read(LIMIT_DOWN)==0)
  85. {
  86. rt_thread_delay(20);
  87. while(rt_pin_read(LIMIT_DOWN)==0)
  88. {
  89. //ctr_cangmen_down(CLOSE);
  90. rt_thread_delay(50);
  91. turn_timeout++;
  92. if(turn_timeout==200){
  93. char *translate = makeJson_Warn("translate","limit timeout");
  94. DTU_Write("%s",translate);
  95. rt_free(translate);
  96. break;
  97. }
  98. }
  99. break;
  100. }
  101. while(rt_pin_read(LIMIT_DOWN)==1)
  102. {
  103. rt_thread_delay(10);
  104. while(rt_pin_read(LIMIT_DOWN)==1)
  105. {
  106. turn_timeout++;
  107. rt_thread_delay(5);
  108. if(turn_timeout==2000){
  109. char *translate = makeJson_Warn("translate","limit timeout");
  110. DTU_Write("%s",translate);
  111. rt_free(translate);
  112. break;
  113. }
  114. }
  115. break;
  116. }
  117. while(rt_pin_read(LIMIT_DOWN)==0)
  118. {
  119. rt_thread_delay(20);
  120. if(rt_pin_read(LIMIT_DOWN)==0)
  121. {
  122. //Motor_shake(OFF,0);
  123. Motor_Qingsao_R_PWM(OFF);
  124. break;
  125. }
  126. else {
  127. break;
  128. }
  129. }
  130. //Motor_shake(OFF,0);
  131. Motor_Qingsao_R_PWM(OFF);
  132. turn_timeout = 0;
  133. char *translate = makeJson_Warn("translate","done");
  134. DTU_Write("%s",translate);
  135. rt_free(translate);
  136. // rt_thread_delay(1000);
  137. }
  138. uint32_t mapSpeed(int a1) {
  139. const int a1Min = 0;
  140. const int a1Max = 100;
  141. const int a2Min = 50000; //20khz
  142. const int a2Max = 200000; //5khz
  143. // 确保 a1 在有效范围内
  144. if (a1 < a1Min) {
  145. a1 = a1Min;
  146. } else if (a1 > a1Max) {
  147. a1 = a1Max;
  148. }
  149. // 执行线性映射
  150. uint32_t a2 = a2Max - ((a2Max - a2Min) * a1) / (a1Max - a1Min);
  151. return a2;
  152. }
  153. void stop_move(void)
  154. {
  155. slide_para.stop_flag = 1;
  156. slidelock();
  157. rt_pin_mode(HK_IO, PIN_MODE_OUTPUT); //PB14 EN
  158. pwm_stop();
  159. rt_pin_write(HK_IO, ON);
  160. }
  161. //DIR_ 轴选择(0-X,1-Y,2-Z) dir 轴方向
  162. uint32_t ctr_move(uint8_t DIR_,uint8_t dir_,uint32_t dis_,uint32_t pulse)
  163. {
  164. uint32_t j;
  165. switch(DIR_){
  166. case X_:
  167. ctr_lamp(ON,1); //X轴开关:关
  168. ctr_swz(OFF); //Z轴开关:关
  169. ctr_Collect_Fan(OFF); //Y轴开关:关
  170. break;
  171. case Y_:
  172. ctr_swz(OFF); //Z轴开关:关
  173. ctr_lamp(OFF,1); //X轴开关:关
  174. ctr_Collect_Fan(ON); //Y轴开关:开
  175. break;
  176. case Z_:
  177. ctr_swz(ON); //Y轴开关:关
  178. ctr_lamp(OFF,1); //X轴开关:关
  179. ctr_Collect_Fan(OFF); //Y轴开关:关
  180. break;
  181. }
  182. //限位检测初始化
  183. rt_pin_mode(Limit_Motor_X, PIN_MODE_INPUT);
  184. rt_pin_mode(Limit_Motor_Y, PIN_MODE_INPUT);
  185. rt_pin_mode(Limit_Motor_Z, PIN_MODE_INPUT);
  186. //驱动器初始化
  187. rt_pin_mode(HK_IO, PIN_MODE_OUTPUT); //PB14 EN
  188. rt_pin_mode(CTR_RO_LIMIT, PIN_MODE_OUTPUT); //PB15 DIR
  189. //rt_pin_mode(CTR_RC_LIMIT, PIN_MODE_OUTPUT); //PC6 PWM
  190. // if(dis_ >=1000){
  191. // beep_set(500000, 250000); //PWM使能
  192. // }else{
  193. // beep_set(2000000, 1000000); //PWM使能
  194. // }
  195. //驱动使能
  196. rt_pin_write(HK_IO, ON);
  197. //方向选择
  198. if(dir_ == 1){
  199. rt_pin_write(CTR_RO_LIMIT, ON);
  200. }else{
  201. rt_pin_write(CTR_RO_LIMIT, OFF);
  202. }
  203. switch(DIR_){
  204. case X_:
  205. ctr_lamp(1, ON); //X轴电源开关:开
  206. rt_thread_delay(1000);
  207. //判断限位
  208. if(dir_== 0 && rt_pin_read(Limit_Motor_X)==1){
  209. for(int z =0;z < 3; z++){
  210. Beep_Tip(200);
  211. LOG_W("X:已在初始位置!");
  212. }
  213. return 0;
  214. }
  215. rt_pin_write(HK_IO, ON);
  216. rt_thread_delay(100);
  217. beep_set(pulse, pulse/3); //PWM使能
  218. for(j=0;j<dis_;j++){
  219. if(slide_para.stop_flag == 0){
  220. rt_thread_delay(10); //10ms
  221. if(dir_==0&&rt_pin_read(Limit_Motor_X)==1){
  222. rt_thread_delay(10); //10ms
  223. if(rt_pin_read(Limit_Motor_X)==1){
  224. j = dis_;
  225. }
  226. }
  227. }else{ //急停
  228. for(int z =0;z < 3; z++){
  229. Beep_Tip(200);
  230. }
  231. break;
  232. }
  233. }
  234. break;
  235. case Y_:
  236. ctr_Collect_Fan(ON); //Y轴电源开关:开
  237. rt_thread_delay(100);
  238. //判断限位
  239. if(dir_== 0 && rt_pin_read(Limit_Motor_Y)==1){
  240. for(int z =0;z < 3; z++){
  241. Beep_Tip(200);
  242. LOG_W("Y:已在初始位置!");
  243. }
  244. return 0;
  245. }
  246. rt_pin_write(HK_IO, ON);
  247. beep_set(pulse, pulse/2); //PWM使能
  248. for(j=0;j<dis_;j++){
  249. if(slide_para.stop_flag == 0){
  250. if(dis_>=8000){rt_thread_delay(10);}else{rt_thread_delay(1);}
  251. if(dir_==0&&rt_pin_read(Limit_Motor_Y)==1){
  252. if(dis_>=8000){rt_thread_delay(10);}else{rt_thread_delay(1);}
  253. if(rt_pin_read(Limit_Motor_Y)==1){
  254. j = dis_;
  255. }
  256. }
  257. }else{ //急停
  258. for(int z =0;z < 3; z++){
  259. Beep_Tip(200);
  260. }
  261. break;
  262. }
  263. }
  264. break;
  265. case Z_:
  266. ctr_swz(ON); //Z轴电源开关:开
  267. rt_thread_delay(1000); //
  268. //判断限位
  269. if(dir_== 1 && rt_pin_read(Limit_Motor_Z)==1){
  270. for(int z =0;z < 3; z++){
  271. Beep_Tip(200);
  272. LOG_W("Z:已在初始位置!");
  273. }
  274. return 0;
  275. }
  276. //驱动使能
  277. rt_pin_write(HK_IO, ON);
  278. beep_set(pulse, pulse/3); //PWM使能
  279. for(j=0;j<dis_;j++){
  280. if(slide_para.stop_flag == 0){
  281. rt_thread_delay(10);
  282. if(dir_==1&&rt_pin_read(Limit_Motor_Z)==1){
  283. rt_thread_delay(10);
  284. if(rt_pin_read(Limit_Motor_Z)==1){
  285. j = dis_;
  286. }
  287. }
  288. }else{ //急停
  289. for(int z =0;z < 3; z++){
  290. Beep_Tip(200);
  291. }
  292. break;
  293. }
  294. }
  295. break;
  296. }
  297. pwm_stop();
  298. rt_pin_write(HK_IO, ON);
  299. return dis_;
  300. }
  301. void slidelock()
  302. {
  303. ctr_lamp(OFF,1); //X轴开关:关
  304. ctr_swz(OFF); //Z轴开关:关
  305. ctr_Collect_Fan(OFF); //Y轴开关:关
  306. }
  307. /**********************************************************************/
  308. /*光控*/
  309. uint8_t In_Light_status(void)
  310. {
  311. rt_pin_mode(LIGHT_PIN,PIN_MODE_INPUT);
  312. return rt_pin_read(LIGHT_PIN);
  313. }
  314. /*雨控*/
  315. uint8_t In_Rain_status(void)
  316. {
  317. rt_pin_mode(RAIN_PIN,PIN_MODE_INPUT);
  318. return rt_pin_read(RAIN_PIN);
  319. }
  320. /*加热*/
  321. uint8_t ctr_Heat(uint8_t status_heat)
  322. {
  323. device_status.heat_status = status_heat;
  324. rt_pin_mode(Heat_Pin, PIN_MODE_OUTPUT);
  325. rt_pin_write(Heat_Pin,status_heat);
  326. return status_heat;
  327. }
  328. /*制冷*/
  329. uint8_t ctr_Cold(uint8_t status_cold)
  330. {
  331. device_status.cold_status = status_cold;
  332. rt_pin_mode(Cold_Pin, PIN_MODE_OUTPUT);
  333. rt_pin_write(Cold_Pin,status_cold);
  334. return status_cold;
  335. }
  336. /*相机供电*/
  337. void ctr_photo(uint8_t status_photo)
  338. {
  339. rt_pin_mode(PHOTO,PIN_MODE_OUTPUT);
  340. rt_pin_write(PHOTO,status_photo);
  341. }
  342. /*************************************************
  343. Function: ctr_Cool_Fan
  344. Description: 散热风机的开关
  345. Calls:
  346. Table Accessed: // 被访问的表(此项仅对于牵扯到数据库操作的程序)
  347. Table Updated: // 被修改的表(此项仅对于牵扯到数据库操作的程序)
  348. Input: ON-开,OFF-关
  349. Output: NULL
  350. Return: ON-开,OFF-关
  351. Others: NULL
  352. *************************************************/
  353. uint8_t ctr_Cool_Fan(uint8_t status_cool)
  354. {
  355. device_status.cool_fan_status = status_cool;
  356. rt_pin_mode(Cool_Fan_L, PIN_MODE_OUTPUT);
  357. rt_pin_mode(Cool_Fan_R, PIN_MODE_OUTPUT);
  358. if(status_cool==OFF)
  359. {
  360. rt_pin_write(Cool_Fan_L,OFF);
  361. rt_pin_write(Cool_Fan_R,OFF);
  362. }
  363. if(status_cool==ON)
  364. {
  365. rt_pin_write(Cool_Fan_L,ON);
  366. rt_pin_write(Cool_Fan_R,OFF);
  367. }
  368. return device_status.cool_fan_status;
  369. }
  370. /*************************************************
  371. Function: ctr_Collect_Fan
  372. Description: 采集风机的开关
  373. Calls:
  374. Table Accessed: // 被访问的表(此项仅对于牵扯到数据库操作的程序)
  375. Table Updated: // 被修改的表(此项仅对于牵扯到数据库操作的程序)
  376. Input: ON-开,OFF-关
  377. Output: NULL
  378. Return: ON-开,OFF-关
  379. Others: NULL
  380. *************************************************/
  381. uint8_t ctr_Collect_Fan(uint8_t status_collect)
  382. {
  383. device_status.collect_fan_status = status_collect;
  384. rt_pin_mode(Collect_Fan, PIN_MODE_OUTPUT);
  385. if(status_collect==OFF)
  386. {
  387. rt_pin_write(Collect_Fan,OFF);
  388. }
  389. if(status_collect==ON)
  390. {
  391. rt_pin_write(Collect_Fan,ON);
  392. }
  393. return device_status.collect_fan_status;
  394. }
  395. /*上仓门*/
  396. uint8_t ctr_cangmen_up(uint8_t status_up)
  397. {
  398. rt_pin_mode(Collect_fan_R, PIN_MODE_OUTPUT);
  399. rt_pin_mode(Collect_fan_L, PIN_MODE_OUTPUT);
  400. if(status_up==OFF)
  401. {
  402. rt_pin_write(Collect_fan_R,ON);
  403. rt_pin_write(Collect_fan_L,ON);
  404. device_status.ctr_up_motor = 0;
  405. rt_thread_delay(1000);
  406. }
  407. if(status_up==OPEN)
  408. {
  409. device_status.up_status = 1;
  410. rt_pin_write(Collect_fan_R,OFF);
  411. rt_pin_write(Collect_fan_L,OFF);
  412. rt_pin_write(Collect_fan_R,ON);
  413. rt_pin_write(Collect_fan_L,OFF);
  414. }
  415. if(status_up==CLOSE)
  416. {
  417. device_status.up_status = 0;
  418. rt_pin_write(Collect_fan_R,OFF);
  419. rt_pin_write(Collect_fan_L,OFF);
  420. rt_pin_write(Collect_fan_R,OFF);
  421. rt_pin_write(Collect_fan_L,ON);
  422. }
  423. return device_status.up_status;
  424. }
  425. //下仓门
  426. uint8_t ctr_cangmen_down(uint8_t status_down)
  427. {
  428. rt_pin_mode(C_DOWN_R, PIN_MODE_OUTPUT);
  429. rt_pin_mode(C_DOWN_L, PIN_MODE_OUTPUT);
  430. if(status_down==OFF)
  431. {
  432. rt_pin_write(C_DOWN_R,ON);
  433. rt_pin_write(C_DOWN_L,ON);
  434. device_status.ctr_down_motor = 0;
  435. rt_thread_delay(1000);
  436. }
  437. if(status_down==OPEN)
  438. {
  439. device_status.down_status = 1;
  440. rt_pin_write(C_DOWN_R,OFF);
  441. rt_pin_write(C_DOWN_L,OFF);
  442. rt_pin_write(C_DOWN_R,ON);
  443. rt_pin_write(C_DOWN_L,OFF);
  444. }
  445. if(status_down==CLOSE)
  446. {
  447. device_status.down_status = 0;
  448. rt_pin_write(C_DOWN_R,OFF);
  449. rt_pin_write(C_DOWN_L,OFF);
  450. rt_pin_write(C_DOWN_R,OFF);
  451. rt_pin_write(C_DOWN_L,ON);
  452. }
  453. return device_status.down_status;
  454. }
  455. //镇流器
  456. uint8_t ctr_lamp(uint8_t status_lamp,uint8_t lamp_num)
  457. {
  458. rt_pin_mode(LAMP_SW, PIN_MODE_OUTPUT);
  459. rt_pin_mode(LAMP_1_SW, PIN_MODE_OUTPUT);
  460. rt_pin_mode(LAMP_2_SW, PIN_MODE_OUTPUT);
  461. if(status_lamp==ON)
  462. {
  463. switch(lamp_num){
  464. case 1:
  465. rt_pin_write(LAMP_SW,ON);
  466. device_status.lamp_status = status_lamp;
  467. break;
  468. case 2:
  469. rt_pin_write(LAMP_1_SW,ON);
  470. device_status.lamp_status = status_lamp;
  471. break;
  472. case 3:
  473. rt_pin_write(LAMP_2_SW,ON);
  474. device_status.lamp_status = status_lamp;
  475. break;
  476. default:
  477. break;
  478. }
  479. }
  480. else {
  481. switch(lamp_num){
  482. case 1:
  483. rt_pin_write(LAMP_SW,OFF);
  484. device_status.lamp_status = status_lamp;
  485. break;
  486. case 2:
  487. rt_pin_write(LAMP_1_SW,OFF);
  488. device_status.lamp1_status = status_lamp;
  489. break;
  490. case 3:
  491. rt_pin_write(LAMP_2_SW,OFF);
  492. device_status.lamp2_status = status_lamp;
  493. break;
  494. default:
  495. break;
  496. }
  497. }
  498. return device_status.lamp_status;
  499. }
  500. //震动电机
  501. uint8_t ctr_shake(uint8_t status_shake,uint16_t shake_sec)
  502. {
  503. static rt_uint16_t shake_i = 0;
  504. shake_i = atoi(device_status.power);
  505. LOG_I("震动电机待机电流:%d",shake_i);
  506. if(device_status.dtype==7&&shake_sec!=0)
  507. DTU_Write("drop");
  508. rt_pin_mode(SHAKE_SW, PIN_MODE_OUTPUT);
  509. #if 0
  510. rt_pin_write(SHAKE_SW,ON);
  511. return 0;
  512. #endif
  513. if(status_shake==ON&&device_status.shake_ws==1)
  514. {
  515. #if 0
  516. for(int8_t s = 0;s++;s<2)
  517. {
  518. rt_pin_write(SHAKE_SW,ON);
  519. rt_thread_delay(100);
  520. rt_pin_write(SHAKE_SW,OFF);
  521. rt_thread_delay(1000);
  522. }
  523. #endif
  524. rt_pin_write(SHAKE_SW,ON);
  525. if(device_status.dtype==3)
  526. {
  527. while(shake_sec--)
  528. {
  529. rt_thread_delay(100);
  530. if(shake_sec==20&&device_status.clear_status==0&&device_status.work_status==1&&atoi(device_status.power)-shake_i<100&&shake_i!=0&&shake_i<5000)
  531. {
  532. char * shake_warn = makeJson_Warn("电流不足", "震动电机");
  533. DTU_Write("%s",shake_warn);
  534. rt_free(shake_warn);
  535. }
  536. LOG_D("震动电机:%d",atoi(device_status.power));
  537. }
  538. }
  539. if(device_status.dtype==7) rt_thread_delay(shake_sec*1000);
  540. rt_pin_write(SHAKE_SW,OFF);
  541. }
  542. else
  543. {
  544. rt_pin_write(SHAKE_SW,OFF);
  545. }
  546. if(device_status.dtype==7)
  547. return status_shake;
  548. }
  549. //补光
  550. uint8_t ctr_led(uint8_t status_led)
  551. {
  552. rt_pin_mode(LED_SW, PIN_MODE_OUTPUT);
  553. if(status_led==ON)
  554. {
  555. rt_pin_write(LED_SW,ON);
  556. }
  557. else if(status_led==OFF){
  558. rt_pin_write(LED_SW,OFF);
  559. }
  560. return status_led;
  561. }
  562. /*************************************************
  563. Function: ctr_Petroleum_jelly
  564. Description: 涂凡士林
  565. Calls:
  566. Table Accessed: // 被访问的表(此项仅对于牵扯到数据库操作的程序)
  567. Table Updated: // 被修改的表(此项仅对于牵扯到数据库操作的程序)
  568. Input: NULL
  569. Output: NULL
  570. Return: NULL
  571. Others: NULL
  572. *************************************************/
  573. void ctr_Petroleum_jelly(rt_uint32_t delay)
  574. {
  575. beep_init();
  576. pwm_on(2,50000);
  577. rt_thread_delay(delay*1000);
  578. pwm_off(2,0);
  579. rt_thread_delay(1000);
  580. pwm_on(3, 50000);
  581. rt_thread_delay(delay*1000);
  582. pwm_off(3,0);
  583. device_status.fsl_sw = 0;
  584. }
  585. //1.0转仓
  586. void turnzp(void)
  587. {
  588. static uint16_t turn_timeout = 0;
  589. // rt_pin_mode(CLEAR_R, PIN_MODE_OUTPUT);
  590. // rt_pin_mode(CLEAR_L, PIN_MODE_OUTPUT);
  591. rt_pin_mode(CLEAR_R_LIMIT,PIN_MODE_INPUT);
  592. // rt_pin_write(CLEAR_R,OFF);
  593. // rt_pin_write(CLEAR_L,OFF);
  594. while(rt_pin_read(CLEAR_R_LIMIT)==0)
  595. {
  596. rt_thread_delay(20);
  597. while(rt_pin_read(CLEAR_R_LIMIT)==0)
  598. {
  599. // rt_pin_write(CLEAR_R,ON);
  600. // rt_pin_write(CLEAR_L,OFF);
  601. Motor_Juandai(ON);
  602. rt_thread_delay(50);
  603. turn_timeout++;
  604. if(turn_timeout==600)
  605. {
  606. LOG_E("检测不到限位,电机强制停止");
  607. char *ctr_zp_limit_warn =makeJson_Warn("电流不足/限位超时","转盘电机");
  608. DTU_Write("%s",ctr_zp_limit_warn);
  609. rt_free(ctr_zp_limit_warn);
  610. break;
  611. }
  612. }
  613. break;
  614. }
  615. while(rt_pin_read(CLEAR_R_LIMIT)==1)
  616. {
  617. rt_thread_delay(20);
  618. while(rt_pin_read(CLEAR_R_LIMIT)==1)
  619. {
  620. // rt_pin_write(CLEAR_R,ON);
  621. // rt_pin_write(CLEAR_L,OFF);
  622. Motor_Juandai(ON);
  623. rt_thread_delay(50);
  624. turn_timeout++;
  625. if(turn_timeout==600)
  626. {
  627. LOG_E("检测不到离开限位,电机或者限位开关异常,电机强制停止");
  628. char *ctr_zp_limit_warn =makeJson_Warn("检测不到离开限位,电机未启动或者限位开关故障","转盘电机");
  629. DTU_Write("%s",ctr_zp_limit_warn);
  630. rt_free(ctr_zp_limit_warn);
  631. break;
  632. }
  633. }
  634. break;
  635. }
  636. while(rt_pin_read(CLEAR_R_LIMIT)==0)
  637. {
  638. rt_thread_delay(20);
  639. if(rt_pin_read(CLEAR_R_LIMIT)==0)
  640. {
  641. // rt_pin_write(CLEAR_R,OFF);
  642. // rt_pin_write(CLEAR_L,OFF);
  643. Motor_Juandai(OFF);
  644. break;
  645. }
  646. else {
  647. break;
  648. }
  649. }
  650. Motor_Juandai(OFF);
  651. // rt_pin_write(CLEAR_R,OFF);
  652. // rt_pin_write(CLEAR_L,OFF);
  653. turn_timeout = 0;
  654. rt_thread_delay(1000);
  655. }
  656. //路由器供电
  657. void ctr_router(uint8_t status_router)
  658. {
  659. rt_pin_mode(ROUTER, PIN_MODE_OUTPUT);
  660. //rt_pin_mode(POWER_CLEAR, PIN_MODE_OUTPUT);
  661. if(status_router==ON)
  662. {
  663. rt_pin_write(ROUTER,ON);
  664. }
  665. else {
  666. rt_pin_write(ROUTER,OFF);
  667. }
  668. }
  669. //清扫-推杆电机
  670. void ctr_TG_Clear(uint16_t clear_timeout)
  671. {
  672. #if 0
  673. int current_clear[200];
  674. int16_t Electric_current = atoi(device_status.power); //获取电机运动前的电流
  675. LOG_I("清扫电机待机:%d",Electric_current);
  676. #endif
  677. static uint16_t clear_count = 0;
  678. clear_count = clear_timeout;
  679. #if PWM_EN == 0
  680. rt_pin_mode(CLEAR_R, PIN_MODE_OUTPUT);
  681. rt_pin_mode(CLEAR_L, PIN_MODE_OUTPUT);
  682. #endif
  683. while(clear_count!=0)
  684. {
  685. #if PWM_EN == 0
  686. rt_pin_write(CLEAR_R,ON);
  687. rt_pin_write(CLEAR_L,OFF);
  688. #else
  689. Motor_Qingsao_R_PWM(ON);
  690. Motor_Qingsao_L_PWM(OFF);
  691. #endif
  692. clear_count--;
  693. rt_thread_delay(100);
  694. }
  695. #if PWM_EN == 0
  696. rt_pin_write(CLEAR_R,ON);
  697. rt_pin_write(CLEAR_L,ON);
  698. #else
  699. Motor_Qingsao_R_PWM(OFF);
  700. Motor_Qingsao_L_PWM(OFF);
  701. #endif
  702. rt_thread_delay(3000);
  703. clear_count = 0;
  704. while(clear_timeout!=clear_count)
  705. {
  706. #if PWM_EN == 0
  707. rt_pin_write(CLEAR_R,OFF);
  708. rt_pin_write(CLEAR_L,ON);
  709. #else
  710. Motor_Qingsao_R_PWM(OFF);
  711. Motor_Qingsao_L_PWM(ON);
  712. #endif
  713. // if(clear_count<200)
  714. // current_clear[clear_count] = atoi(device_status.power);
  715. clear_count++;
  716. rt_thread_delay(100);
  717. }
  718. #if PWM_EN == 0
  719. rt_pin_write(CLEAR_R,ON);
  720. rt_pin_write(CLEAR_L,ON);
  721. #else
  722. Motor_Qingsao_R_PWM(OFF);
  723. Motor_Qingsao_L_PWM(OFF);
  724. #endif
  725. #if 0
  726. bubblesort(current_clear,200);
  727. if(current_clear[199]-Electric_current <100&&device_status.work_status==1&&Electric_current!=0&&Electric_current<5000)
  728. {
  729. LOG_E("清扫电机电流不足:%d!",current_clear[199]);
  730. char *ctr_clear_warn = makeJson_Warn("电流不足","清扫电机");
  731. DTU_Write("%s",ctr_clear_warn);
  732. rt_free(ctr_clear_warn);
  733. }
  734. #endif
  735. rt_thread_delay(2000);
  736. device_status.clear_status = 0;
  737. }
  738. //DTU,RTU供电
  739. void ctr_RTU_DTU(uint8_t status_rtu)
  740. {
  741. rt_pin_mode(RTU_DTU, PIN_MODE_OUTPUT);
  742. if(status_rtu==ON)
  743. {
  744. rt_pin_write(RTU_DTU,ON);
  745. }
  746. else
  747. {
  748. LOG_W("RTU电源复位!!!");
  749. rt_pin_write(RTU_DTU,OFF);
  750. }
  751. }
  752. //海康拍照
  753. void Hk_Take_io(void)
  754. {
  755. rt_pin_mode(HK_TAKE, PIN_MODE_OUTPUT);
  756. rt_pin_mode(HK_IO, PIN_MODE_OUTPUT);
  757. rt_pin_write(HK_TAKE, 1);
  758. rt_pin_write(HK_IO, 0);
  759. if(device_status.dtype==3)
  760. Beep_Tip(1000);
  761. if(device_status.dtype==7)
  762. rt_thread_mdelay(1000);
  763. rt_pin_write(HK_TAKE, 0);
  764. rt_pin_write(HK_IO, 1);
  765. }
  766. //拍照
  767. void HK_TakePhoto(void)
  768. {
  769. //打开补光灯
  770. DTU_Write("takephoto.mp3");
  771. rt_thread_delay(10000);
  772. char *takephotojson = makeJson_takephoto();
  773. DTU_Write("%s",takephotojson);
  774. rt_free(takephotojson);
  775. //吸虫塔
  776. if(device_status.version_type!=6)
  777. {
  778. ctr_led(ON);
  779. if(device_status.version_type==48)
  780. {
  781. rt_thread_delay(1000*60);
  782. }
  783. else {
  784. rt_thread_delay(1000*15);
  785. }
  786. }
  787. //触发海康相机拍照
  788. Hk_Take_io();
  789. if(device_status.version_type!=6)
  790. {
  791. rt_thread_delay(1000*45);
  792. }
  793. else {
  794. ctr_led(ON);
  795. rt_thread_delay(1000*19);
  796. }
  797. ctr_led(OFF);
  798. }
  799. /*上电初始化*/
  800. void ResetInit(void)
  801. {
  802. ctr_photo(ON);
  803. //关闭电磁阀
  804. ctr_shake(OFF, 0);
  805. //开启 工控机供电
  806. ctr_Heat(ON);
  807. //关闭制冷
  808. ctr_Cold(OFF);
  809. //关闭补光灯
  810. ctr_led(OFF);
  811. //关闭Y轴驱动电源
  812. ctr_Collect_Fan(OFF);
  813. //关闭X轴驱动电源
  814. }
  815. //工作状态检测
  816. /*孢子仪多段定时功能函数
  817. * 循环判断定时的触发
  818. *
  819. */
  820. u_int8_t alarmCheck(u_int8_t starthour,u_int8_t endhour,u_int8_t startmin,u_int8_t endmin)
  821. {
  822. u_int8_t workflag = 0;
  823. if(starthour == endhour) return workflag;
  824. time_t now;
  825. time(&now);
  826. struct tm now_tm = *localtime(&now);
  827. rt_uint32_t curr_sec = now_tm.tm_hour*3600 + now_tm.tm_min*60 + now_tm.tm_sec;
  828. rt_uint32_t start_sec = starthour * 3600 + startmin * 60;
  829. rt_uint32_t end_sec = endhour * 3600 + endmin * 60;
  830. // 处理开始和结束时间相同的情况
  831. if (start_sec == end_sec) {
  832. workflag = 0;
  833. }
  834. // 修复跨天判断逻辑
  835. if (start_sec < end_sec)
  836. {
  837. // 不跨天模式
  838. workflag = (curr_sec >= start_sec && curr_sec < end_sec) ? 1 : 0;
  839. }
  840. else
  841. {
  842. // 跨天模式
  843. workflag = (curr_sec >= start_sec || curr_sec < end_sec) ? 1 : 0;
  844. }
  845. LOG_I("时控模式:状态[%s] 当前时间:%02d:%02d:%02d 设置:%02d:%02d-%02d:%02d",
  846. workflag ? "工作" : "待机",
  847. now_tm.tm_hour, now_tm.tm_min, now_tm.tm_sec,
  848. starthour,startmin, endhour,endmin);
  849. rt_thread_delay(10000);
  850. return workflag;
  851. }
  852. void WorkTask_BZYV2(void)
  853. {
  854. if(device_status.ds==1&&device_status.temp_status==0){
  855. ctr_lamp(OFF,1); //镇流器关=X轴开关:开
  856. ctr_swz(OFF);
  857. ctr_Collect_Fan(OFF);
  858. while(device_status.work_status ==0){
  859. rt_thread_delay(10000);
  860. LOG_W("等待设备进入工作");
  861. }
  862. while(device_status.work_status ==1){
  863. if(device_status.autotakepic==0){
  864. ctr_router(ON);
  865. }else{
  866. ctr_router(OFF);
  867. }
  868. if(device_status.temp_status==1){
  869. device_status.work_status = 0;
  870. ctr_router(OFF);
  871. break;
  872. }
  873. rt_thread_delay(10000);
  874. }
  875. ctr_router(OFF);
  876. if(device_status.work_done==1){
  877. turnlimit(); //卷带电机转一圈
  878. rt_thread_delay(2000);
  879. uint8_t retry_send = 0;
  880. while(1){
  881. char *take_start = makeJson_Warn("start", "autofocus");
  882. DTU_Write(take_start);
  883. rt_free(take_start);
  884. rt_thread_delay(5000);
  885. retry_send++;
  886. if(retry_send==30||device_status.autotakepic>=0){
  887. break;
  888. }
  889. }
  890. device_status.work_done = 0;
  891. }
  892. }else{
  893. LOG_W("==================!!!设备已待机!!!===================");
  894. }
  895. }
  896. /* 入口函数-工作状态检测 */
  897. static void Work_status_thread_entry(void *parameter)
  898. {
  899. static uint32_t takephoto_cnt = 0;
  900. while(1)
  901. {
  902. if(device_status.ds==0||
  903. device_status.temp_status==1){
  904. device_status.work_status = 0;
  905. rt_thread_delay(5000);
  906. continue;
  907. }
  908. while(alarmCheck(device_status.collecting_sh1,device_status.collecting_eh1,device_status.collt_min_sh1,device_status.collt_min_eh1) == ON)
  909. {
  910. device_status.work_status = 1;
  911. LOG_I("the alarm1 workflag was ON");
  912. device_status.work_done=1;
  913. rt_thread_delay(1000);
  914. }
  915. //如果当前时间大于collecting_eh1,开始拍照
  916. while(alarmCheck(device_status.collecting_sh2,device_status.collecting_eh2,device_status.collt_min_sh2,device_status.collt_min_eh2) == ON)
  917. {
  918. device_status.work_status = 1;
  919. device_status.work_done=1;
  920. LOG_I("the alarm2 workflag was ON");
  921. rt_thread_delay(1000);
  922. }
  923. //如果当前时间大于collecting_eh2,开始拍照
  924. while(alarmCheck(device_status.collecting_sh3,device_status.collecting_eh3,device_status.collt_min_sh3,device_status.collt_min_eh3) == ON)
  925. {
  926. device_status.work_status = 1;
  927. device_status.work_done=1;
  928. LOG_I("the alarm3 workflag was ON");
  929. rt_thread_delay(1000);
  930. }
  931. device_status.work_status = 0;
  932. if(device_status.autotakepic==2){
  933. takephoto_cnt++;
  934. }else{
  935. takephoto_cnt=0;
  936. }
  937. if(takephoto_cnt==3600){
  938. device_status.autotakepic = 0;
  939. takephoto_cnt = 0;
  940. }
  941. //如果当前时间大于
  942. if(device_status.work_done!=0)
  943. {
  944. rt_thread_delay(1000*30);
  945. device_status.work_done = 0;
  946. }
  947. rt_thread_delay(1000);
  948. }
  949. }
  950. /*入口函数-工作流程*/
  951. static void Work_Loop_thread_entry(void *parameter)
  952. {
  953. rt_thread_delay(1000);
  954. ResetInit();
  955. while(1)
  956. {
  957. WorkTask_BZYV2();
  958. rt_thread_delay(1000);
  959. }
  960. }
  961. void slide_thread_entry(void *parameter)
  962. {
  963. slide_para.pulse_period = 1; //默认滑台的脉宽为1ms
  964. while(1)
  965. {
  966. rt_thread_delay(10);
  967. switch(slide_para.en_slide){
  968. case 1:{
  969. ctr_move(X_,slide_para.xdir,slide_para.xdis,slide_para.pulse_period);
  970. LOG_I("The slide's x movement was done ok");
  971. if(slide_para.xdis==55||slide_para.xdis==80)
  972. {
  973. DTU_Write("{\"cmd\": \"takephoto\" }");
  974. device_status.autotakepic = 4;
  975. }else {
  976. char *photo = makeJson_Warn("movx","done");
  977. LOG_I("%s",photo);
  978. DTU_Write("%s",photo);
  979. rt_free(photo);
  980. }
  981. slide_para.stop_flag = 0;
  982. slide_para.en_slide = OFF;
  983. break;
  984. }
  985. case 2:{
  986. ctr_move(Z_,slide_para.zdir,slide_para.zdis,slide_para.pulse_period);
  987. rt_kprintf("The slide's z movement was done ok\n");
  988. if(slide_para.zdis==55||slide_para.zdis==80)
  989. {
  990. DTU_Write("{\"cmd\": \"takephoto\" }");
  991. device_status.autotakepic = 4;
  992. }else {
  993. char *photo = makeJson_Warn("movz","done");
  994. LOG_I("%s",photo);
  995. DTU_Write("%s",photo);
  996. rt_free(photo);
  997. }
  998. slide_para.zdir = 1;
  999. slide_para.zdis = 0;
  1000. slide_para.stop_flag = 0;
  1001. slide_para.en_slide = OFF;
  1002. break;
  1003. }
  1004. case 3:{ //复位X
  1005. LOG_W("X轴复位!");
  1006. slide_para.xdir = 0;
  1007. slide_para.xdis = 8000;
  1008. ctr_move(X_,slide_para.xdir,slide_para.xdis,slide_para.pulse_period);
  1009. LOG_I("The slide's X movement was done ok");
  1010. slide_para.xdir = 0;
  1011. slide_para.xdis = 0;
  1012. slide_para.stop_flag = 0;
  1013. slide_para.en_slide = OFF;
  1014. break;
  1015. }
  1016. case 4:{
  1017. //复位Z
  1018. LOG_W("Z轴复位!");
  1019. slide_para.zdir = 1; //250717
  1020. slide_para.zdis = 5000;
  1021. ctr_move(Z_,slide_para.zdir,slide_para.zdis,slide_para.pulse_period);
  1022. LOG_I("The slide's Z movement was done ok");
  1023. slide_para.zdis = 0;
  1024. slide_para.stop_flag = 0;
  1025. slide_para.en_slide = OFF;
  1026. break;
  1027. }
  1028. case 6:{ //Y轴
  1029. ctr_move(Y_,slide_para.ydir,slide_para.ydis,slide_para.pulse_period);
  1030. rt_kprintf("The slide's y movement was done ok\n");
  1031. rt_thread_delay(1000);
  1032. if(1){
  1033. char utos[5];
  1034. rt_sprintf(utos,"%d",slide_para.ystep);
  1035. char *photo = makeJson_Warn("movy",utos);
  1036. LOG_I("%s",photo);
  1037. DTU_Write("%s",photo);
  1038. rt_free(photo);
  1039. }
  1040. slide_para.ydis = 0;
  1041. slide_para.stop_flag = 0;
  1042. slide_para.en_slide = OFF;
  1043. break;
  1044. }
  1045. case 7:{ //Y轴复位
  1046. LOG_W("Y轴复位!");
  1047. slide_para.ydir = 0;
  1048. slide_para.ydis = 8000;
  1049. ctr_move(Y_,slide_para.ydir,slide_para.ydis,slide_para.pulse_period);
  1050. LOG_I("The slide's Y movement was done ok");
  1051. slide_para.stop_flag = 0;
  1052. slide_para.en_slide = OFF;
  1053. break;
  1054. }
  1055. default:
  1056. {
  1057. slide_para.en_slide = OFF;
  1058. slide_para.stop_flag = 0;
  1059. break;
  1060. }
  1061. }
  1062. }
  1063. }
  1064. /* 创建线程 -工作状态检测*/
  1065. int Workstatus_check(void)
  1066. {
  1067. /* 创建线程*/
  1068. tid_wkstc = rt_thread_create("w_s_c_t",
  1069. Work_status_thread_entry, RT_NULL,
  1070. WORK_CHECK_THREAD_STACK_SIZE, //1024
  1071. WORK_CHECK_THREAD_PRIORITY, //23
  1072. WORK_CHECK_THREAD_TIMESLICE); //5
  1073. if(tid_wkstc!=RT_NULL)
  1074. {
  1075. rt_thread_startup(tid_wkstc);
  1076. }
  1077. return 0;
  1078. }
  1079. /*工作流程线程*/
  1080. int Work_Loop_Task(void)
  1081. {
  1082. rt_err_t result_loop;
  1083. /* 创建线程*/
  1084. tid_workloop = rt_thread_create("work_loop_thread",
  1085. Work_Loop_thread_entry, RT_NULL,
  1086. WORK_LOOP_THREAD_STACK_SIZE, //2048
  1087. WORK_LOOP_THREAD_PRIORITY, //12
  1088. WORK_LOOP_THREAD_TIMESLICE); //5
  1089. #if Color_EN == 0
  1090. if(tid_workloop!=RT_NULL)
  1091. {
  1092. result_loop = rt_thread_startup(tid_workloop);
  1093. }
  1094. #endif
  1095. return result_loop;
  1096. }
  1097. int slide_Fresh(void)
  1098. {
  1099. rt_err_t ret = RT_EOK;
  1100. rt_slide = rt_thread_create("rt_slide",
  1101. slide_thread_entry,
  1102. RT_NULL,
  1103. 1024,
  1104. 5,
  1105. 20);
  1106. if (rt_slide != RT_NULL)
  1107. {
  1108. rt_thread_startup(rt_slide);
  1109. rt_kprintf("the thread of rt_slide start ok\n");
  1110. }
  1111. else
  1112. {
  1113. ret = RT_ERROR;
  1114. }
  1115. return ret;
  1116. }
  1117. void reboot(void)
  1118. {
  1119. LOG_W("手动触发重启!");
  1120. rt_hw_cpu_reset();
  1121. }
  1122. MSH_CMD_EXPORT(ctr_lamp,ctr_lamp<ON|OFF>);
  1123. MSH_CMD_EXPORT(ctr_led,sample:ctr_led <ON|OFF>);
  1124. MSH_CMD_EXPORT(reboot,reboot);
  1125. //INIT_APP_EXPORT(Control_heat);