🌓 切换到窄版

 找回密码
 立即注册
学习《Ai8051U教学视频》发表七集 以上学习心得，送强大的 Ai8051U实验箱
国芯人工智能技术交流网站»32位8051交流社区，车规 AEC-Q100 Grade1 › 技术交流 › 作品展示 › 2025年电赛奖金申领--2025年电赛I题非接触智能控制盘国 ...
返回列表 发新帖
查看: 29|回复: 1

2025年电赛奖金申领--2025年电赛I题非接触智能控制盘国二

[复制链接]
chb2***
  • 打卡等级：偶尔看看III
  • 打卡总天数：38
  • 最近打卡：2025-09-01 20:12:30

7

主题

12

回帖

213

积分

中级会员

积分
213
发表于 前天 21:01 | 显示全部楼层 |阅读模式
2025年电赛I题非接触智能控制盘国二
辽宁机电职业技术学院===非接触智能控制盘：
我们在硬件上面遇到了各种难题，需要自制硬件超声波传感器，设计电机调压调速控制电路。最后完成基本要求和发挥部分。
我们一开始使用运放构成运算放大器和比较器的方法处理超声波信号，发现效果并不理想后来采取CS100A为核心搭建的
超声波收发电路外围电路简单可靠性高，工作时序由图1超声波距离测量时序图所示：
                                             图片1.png

离计算公式：file:///C:/Users/ADMINI~1/AppData/Local/Temp/ksohtml5468/wps22.jpg
     file:///C:/Users/ADMINI~1/AppData/Local/Temp/ksohtml5468/wps23.jpg为超声波在空气中的传播速度（340m/s），代入得简化公式：

理论误差：主要来自声速随温度的变化，修正公式为v=331.5+0.607T（T 为环境温度℃）。
测量误差： Ai8051U的定时器精度为25ns，对应距离分辨率 0.00017cm，满足 ±1cm 的设计要求。

风扇电压控制电路采用 "PWM - 低通滤波 - 线性稳压" 三级调节架构，下图PWM电压调节器的电路模型。
                                    
图片2.png

单片机输出占空比为D，频率1kHz的 PWM 信号，经RC低通滤波器转换为直流电压。该电压通过 LM358组成的缓冲器和电压PI调节器，
控制LM317 的输出电压：file:///C:/Users/ADMINI~1/AppData/Local/Temp/ksohtml5468/wps26.jpg


其中 k 为运放增益（实测 1.259），通过校准得到 PWM 占空比与输出电压的线性关系为UD = 0.1259x + 0.0064 (R2=0.9998)

通过 11 组实测数据验证，该模型在 23.25%-87.5% 占空比范围内的拟合误差≤0.05V，满足电压调节精度要求。


PWM 占空比与风扇电压控制电路输出的测试数据
占空比%
23.25
24
24.75
37.5
43.75
50
62.5
75
80
85
87.5
电压UD（V）
2.895
3.019
3.134
4.74
5.53
6.31
7.88
9.45
10.08
10.71
10.98
                                                            图片3.png

最终版风扇电压控制电路图如下所示：

                                                            图片4.png



本系统采用 Ai8051U单片机，这款单片机不需要外部晶振和外部复位便可正常工作比传统8051约快70倍以上；支持在系统编程方式（ISP）更新用户应用程序
无需专用编程器；支持12位高精度15通道的模数转换，速度最快能达到800K。主控单片机最小系统电路图如下。

                                                                                     图片5.png
四个漫反射光电开关（U12-U14）采用并联设计，额外的LED3~6提供良好的状况反馈。当手掌遮挡光电开关时，输出端从高电平跳变为低电平
单片机在中断服务程序中记录触发时间和通道号，通过时序分析识别手势轨迹。电开关电路图如下所示。

                                                                                        图片6.png
程序基于Keil C51编译器开发环境，程序流程图如下：
                                                                                  微信图片_2025-09-01_205212_867.png
主要程序模块包括：
1.主程序模块：采用前后台架构，主循环负责状态刷新和显示，中断服务程序处理实时事件（代码片段如下）：
  1. void main(void)

  2. {

  3. unsigned char i;

  4. unsigned char a;

  5. unsigned char temp;

  6. unsigned int max_val = 0;

  7. unsigned int min_val = 0;

  8. 

  9. P_SW2 = 0x80;

  10. 

  11. System_Init();

  12. 

  13.     EA = 1;   

  14. 

  15. Delay500ms();

  16. 

  17. EEPROM_read_n(0x0000,(unsigned char*)f3_data1,64);

  18. 

  19. Bee = 1;

  20. Delay500ms();

  21. Delay500ms();

  22. Bee = 0;

  23. Delay500ms();

  24. Delay500ms();

  25. Bee = 1;

  26. Delay500ms();

  27. Delay500ms();

  28. Bee = 0;

  29. 

  30.     while (1)

  31. {

  32. TCON &= 0xfc;

  33. 

  34. Check();

  35. 

  36. max_val = csb_dat[0];

  37. min_val = csb_dat[0];

  38. 

  39. for (i = 1; i < 5; i++)

  40. {

  41. if (csb_dat > max_val)

  42. {

  43. max_val = csb_dat;  // 更新最大值

  44. }

  45. 

  46. if (csb_dat < min_val)

  47. {

  48. min_val = csb_dat;  // 更新最小值

  49. }

  50. 

  51. }

  52. 

  53. if((max_val - min_val < biaozhunzhi) && (Timer1_All < 350))

  54. {

  55. juliwending = 10;

  56. P37 = 0;

  57. 

  58. if(Timer1_All != 0)

  59. wendingjuli = Timer1_All;

  60. }

  61. else

  62. {

  63. juliwending = 0;

  64. P37 = 1;

  65. }

  66. 

  67. temp = 0;

  68. while(P27 == 0)

  69. {

  70. Delay10ms();

  71. temp++;

  72. if(temp>50)

  73. {

  74. for(a=0;a<16;a++)

  75. {

  76. f3_data1[a][0] = 0;

  77. f3_data1[a][1] = 0;

  78. EEPROM_SectorErase(0x0000);

  79. EEPROM_write_n(0x0000,(unsigned char*)f3_data1,64);

  80. }

  81. }

  82. }

  83. 2.手势识别模块：通过中断记录开关触发时序，采用数组存储最近 5 次触发事件，通过模式匹配识别手势：

  84. unsigned char key(void)

  85. {

  86. 

  87. if((K_S1 == K_ON)||(K_S2 == K_ON)||(K_S3 == K_ON)||(K_S4 == K_ON))//四个当中有一个被按下

  88. {

  89. if(K_S1 == K_ON)//按下的是按钮1

  90. {

  91. Delay10ms();

  92. if(K_S1 == K_ON)

  93. {

  94. k_cs = k_off_d;

  95. while(K_S1 == K_ON)

  96. {

  97. Delay_key();

  98. k_cs--;

  99. if(k_cs == 0)return K_Err;

  100. }//1s内不释放就报错

  101. k_cs = k_sts_d;

  102. while(!((K_S1 == K_ON)||(K_S2 == K_ON)||(K_S3 == K_ON)||(K_S4 == K_ON)))//1s内释放，1s内不按下一个就报错

  103. {

  104. Delay_key();

  105. k_cs--;

  106. if(k_cs == 0)return K_Err;

  107. }

  108. if(K_S1 == K_ON)

  109. {

  110. Delay10ms();

  111. if(K_S1 == K_ON)

  112. {

  113. k_cs = k_off_d;

  114. while(K_S1 == K_ON)

  115. {

  116. Delay_key();

  117. k_cs--;

  118. if(k_cs == 0)return K_Err;

  119. }

  120. return s1s1;

  121. }

  122. }

  123. if(K_S2 == K_ON)

  124. {

  125. Delay10ms();

  126. if(K_S2 == K_ON)

  127. {

  128. k_cs = k_off_d;

  129. while(K_S2 == K_ON)

  130. {

  131. Delay_key();

  132. k_cs--;

  133. if(k_cs == 0)return K_Err;

  134. }

  135. return s1s2;

  136. }

  137. }

  138. if(K_S3 == K_ON)

  139. {

  140. Delay10ms();

  141. if(K_S3 == K_ON)

  142. {

  143. k_cs = k_off_d;

  144. while(K_S3 == K_ON)

  145. {

  146. Delay_key();

  147. k_cs--;

  148. if(k_cs == 0)return K_Err;

  149. }

  150. return s1s3;

  151. }

  152. }

  153. if(K_S4 == K_ON)

  154. {

  155. Delay10ms();

  156. if(K_S4 == K_ON)

  157. {

  158. k_cs = k_off_d;

  159. while(K_S4 == K_ON)

  160. {

  161. Delay_key();

  162. k_cs--;

  163. if(k_cs == 0)return K_Err;

  164. }

  165. return s1s4;

  166. }

  167. }

  168. }

  169. return zero;

  170. 

  171. }

  172. else if(K_S2 == K_ON)

  173. {

  174. Delay10ms();

  175. if(K_S2 == K_ON)

  176. {

  177. k_cs = k_off_d;

  178. while(K_S2 == K_ON)

  179. {

  180. Delay_key();

  181. k_cs--;

  182. if(k_cs == 0)return K_Err;

  183. }

  184. k_cs = k_sts_d;

  185. while(!((K_S1 == K_ON)||(K_S2 == K_ON)||(K_S3 == K_ON)||(K_S4 == K_ON)))

  186. {

  187. Delay_key();

  188. k_cs--;

  189. if(k_cs == 0)return K_Err;

  190. }

  191. if(K_S1 == K_ON)

  192. {

  193. Delay10ms();

  194. if(K_S1 == K_ON)

  195. {

  196. k_cs = k_off_d;

  197. while(K_S1 == K_ON)

  198. {

  199. Delay_key();

  200. k_cs--;

  201. if(k_cs == 0)return K_Err;

  202. }

  203. return s2s1;

  204. }

  205. }

  206. if(K_S2 == K_ON)

  207. {

  208. Delay10ms();

  209. if(K_S2 == K_ON)

  210. {

  211. k_cs = k_off_d;

  212. while(K_S2 == K_ON)

  213. {

  214. Delay_key();

  215. k_cs--;

  216. if(k_cs == 0)return K_Err;

  217. }

  218. return s2s2;

  219. }

  220. }

  221. if(K_S3 == K_ON)

  222. {

  223. Delay10ms();

  224. if(K_S3 == K_ON)

  225. {

  226. k_cs = k_off_d;

  227. while(K_S3 == K_ON)

  228. {

  229. Delay_key();

  230. k_cs--;

  231. if(k_cs == 0)return K_Err;

  232. }

  233. return s2s3;

  234. }

  235. }

  236. if(K_S4 == K_ON)

  237. {

  238. Delay10ms();

  239. if(K_S4 == K_ON)

  240. {

  241. k_cs = k_off_d;

  242. while(K_S4 == K_ON)

  243. {

  244. Delay_key();

  245. k_cs--;

  246. if(k_cs == 0)return K_Err;

  247. }

  248. return s2s4;

  249. }

  250. }

  251. }

  252. else return zero;

  253. }

  254. else if(K_S3 == K_ON)

  255. {

  256. Delay10ms();

  257. if(K_S3 == K_ON)

  258. {

  259. k_cs = k_off_d;

  260. while(K_S3 == K_ON)

  261. {

  262. Delay_key();

  263. k_cs--;

  264. if(k_cs == 0)return K_Err;

  265. }

  266. k_cs = k_sts_d;

  267. while(!((K_S1 == K_ON)||(K_S2 == K_ON)||(K_S3 == K_ON)||(K_S4 == K_ON)))

  268. {

  269. Delay_key();

  270. k_cs--;

  271. if(k_cs == 0)return K_Err;

  272. }

  273. if(K_S1 == K_ON)

  274. {

  275. Delay10ms();

  276. if(K_S1 == K_ON)

  277. {

  278. k_cs = k_off_d;

  279. while(K_S1 == K_ON)

  280. {

  281. Delay_key();

  282. k_cs--;

  283. if(k_cs == 0)return K_Err;

  284. }

  285. return s3s1;

  286. }

  287. }

  288. if(K_S2 == K_ON)

  289. {

  290. Delay10ms();

  291. if(K_S2 == K_ON)

  292. {

  293. k_cs = k_off_d;

  294. while(K_S2 == K_ON)

  295. {

  296. Delay_key();

  297. k_cs--;

  298. if(k_cs == 0)return K_Err;

  299. }

  300. return s3s2;

  301. }

  302. }

  303. if(K_S3 == K_ON)

  304. {

  305. Delay10ms();

  306. if(K_S3 == K_ON)

  307. {

  308. k_cs = k_off_d;

  309. while(K_S3 == K_ON)

  310. {

  311. Delay_key();

  312. k_cs--;

  313. if(k_cs == 0)return K_Err;

  314. }

  315. return s3s3;

  316. }

  317. }

  318. if(K_S4 == K_ON)

  319. {

  320. Delay10ms();

  321. if(K_S4 == K_ON)

  322. {

  323. k_cs = k_off_d;

  324. while(K_S4 == K_ON)

  325. {

  326. Delay_key();

  327. k_cs--;

  328. if(k_cs == 0)return K_Err;

  329. }

  330. return s3s4;

  331. }

  332. }

  333. }

  334. else return zero;

  335. }

  336. else if(K_S4 == K_ON)

  337. {

  338. Delay10ms();

  339. if(K_S4 == K_ON)

  340. {

  341. k_cs = k_off_d;

  342. while(K_S4 == K_ON)

  343. {

  344. Delay_key();

  345. k_cs--;

  346. if(k_cs == 0)return K_Err;

  347. }

  348. k_cs = k_sts_d;

  349. while(!((K_S1 == K_ON)||(K_S2 == K_ON)||(K_S3 == K_ON)||(K_S4 == K_ON)))

  350. {

  351. Delay_key();

  352. k_cs--;

  353. if(k_cs == 0)return K_Err;

  354. }

  355. if(K_S1 == K_ON)

  356. {

  357. Delay10ms();

  358. if(K_S1 == K_ON)

  359. {

  360. k_cs = k_off_d;

  361. while(K_S1 == K_ON)

  362. {

  363. Delay_key();

  364. k_cs--;

  365. if(k_cs == 0)return K_Err;

  366. }

  367. return s4s1;

  368. }

  369. }

  370. if(K_S2 == K_ON)

  371. {

  372. Delay10ms();

  373. if(K_S2 == K_ON)

  374. {

  375. k_cs = k_off_d;

  376. while(K_S2 == K_ON)

  377. {

  378. Delay_key();

  379. k_cs--;

  380. if(k_cs == 0)return K_Err;

  381. }

  382. return s4s2;

  383. }

  384. }

  385. if(K_S3 == K_ON)

  386. {

  387. Delay10ms();

  388. if(K_S3 == K_ON)

  389. {

  390. k_cs = k_off_d;

  391. while(K_S3 == K_ON)

  392. {

  393. Delay_key();

  394. k_cs--;

  395. if(k_cs == 0)return K_Err;

  396. }

  397. return s4s3;

  398. }

  399. }

  400. if(K_S4 == K_ON)

  401. {

  402. Delay10ms();

  403. if(K_S4 == K_ON)

  404. {

  405. k_cs = k_off_d;

  406. while(K_S4 == K_ON)

  407. {

  408. Delay_key();

  409. k_cs--;

  410. if(k_cs == 0)return K_Err;

  411. }

  412. return s4s4;

  413. }

  414. }

  415. }

  416. else return zero;

  417. }

  418. return zero;

  419. }

  420. else return zero;

  421. }

  422. 

  423. 3.PWM 调节模块：采用定时器 0 输出 10kHzPWM，通过查表法实现电压快速调节：

  424. #define PINLV  5000      //修改频率PWMA

  425. #define System 40000000  //晶振，下载时选择的频率

  426. 

  427. #define PINLVB  1000     //修改频率PWMB#define PWMB5_0      0x00 //P:P0.1

  428. #define PWMB5_1      0x01 //P:P1.1

  429. #define PWMB5_2      0x02 //P:P2.1

  430. #define PWMB5_3      0x03 //P:P5.0#define ENO5P       0x01

  431. #define ENO6P       0x04

  432. #define ENO7P       0x10

  433. #define ENO8P       0x40unsigned int PWM_PERIODB = System/PINLVB;unsigned int PWM5_Duty;  //百分比变void UpdatePwm(void)  //放在while循环里面，如果有断点自动下载，放在if的前面

  434. {

  435. //    PWMA_CCR1H = (u8)(PWM1_Duty >> 8);

  436. //    PWMA_CCR1L = (u8)(PWM1_Duty);

  437. //    PWMA_CCR2H = (u8)(PWM2_Duty >> 8);

  438. //    PWMA_CCR2L = (u8)(PWM2_Duty);

  439. //    PWMA_CCR3H = (u8)(PWM3_Duty >> 8);

  440. //    PWMA_CCR3L = (u8)(PWM3_Duty);

  441. //    PWMA_CCR4H = (u8)(PWM4_Duty >> 8);

  442. //    PWMA_CCR4L = (u8)(PWM4_Duty);

  443. 

  444.     PWMB_CCR5H = (u8)(PWM5_Duty >> 8);

  445.     PWMB_CCR5L = (u8)(PWM5_Duty);

  446. //    PWMB_CCR6H = (u8)(PWM6_Duty >> 8);

  447. //    PWMB_CCR6L = (u8)(PWM6_Duty);

  448. //    PWMB_CCR7H = (u8)(PWM7_Duty >> 8);

  449. //    PWMB_CCR7L = (u8)(PWM7_Duty);

  450. //    PWMB_CCR8H = (u8)(PWM8_Duty >> 8);

  451. //    PWMB_CCR8L = (u8)(PWM8_Duty);

  452. 

  453. 

  454. }void AI8051_PWM(void)

  455. {

  456.     WTST = 0;     //将CPU执行指令的速度设置为最快

  457.     EAXFR = 1;     //扩展访问寄存器

  458.     CKCON = 0;     //提高访问XRAM的速度

  459. 

  460. //=======占空比配置==================================================================================================//

  461. //    PWM1_Duty = 4000;  //PWM_PERIOD为1，占空比为50%就把PWM_PERIOD x 1/2

  462. //    PWM2_Duty = 4000;

  463. //    PWM3_Duty = 4000;

  464. //    PWM4_Duty = 4000;

  465. 

  466.     PWM5_Duty = 20000;  //PWM_PERIOD为1，占空比为50%就把PWM_PERIOD x 1/2

  467. //    PWM6_Duty = 4000;

  468. //    PWM7_Duty = 4000;

  469. //    PWM8_Duty = 4000;

  470. 

  471. //=======通道模式配置==================================================================================================//

  472. 

  473. //    PWMA_CCER1 = 0x00;   //写CCMR之前要清零CCER

  474. //    PWMA_CCER2 = 0x00;

  475. PWMB_CCER1 = 0x00;   //写CCMR之前要清零CCER

  476.     PWMB_CCER2 = 0x00;

  477. 

  478. //    PWMA_CCMR1 = 0x60;   //通道模式配置

  479.     PWMB_CCMR1 = 0x60;   //通道模式配置

  480. 

  481. //    PWMA_CCMR2 = 0x60;

  482.     PWMB_CCMR2 = 0x60;

  483. 

  484. //    PWMA_CCMR3 = 0x60;

  485.     PWMB_CCMR3 = 0x60;

  486. 

  487. //    PWMA_CCMR4 = 0x60;

  488.     PWMB_CCMR4 = 0x60;

  489. 

  490. //    PWMA_CCER1 = 0x55;   //配置通道输出和极性

  491. //    PWMA_CCER2 = 0x55;

  492. PWMB_CCER1 = 0x55;   //写CCMR之前要清零CCER

  493.     PWMB_CCER2 = 0x55;

  494. 

  495. //    PWMA_CCMR1 |= 0x08;  //开启预装载

  496. //    PWMA_CCMR2 |= 0x08;

  497. //    PWMA_CCMR3 |= 0x08;

  498. //    PWMA_CCMR4 |= 0x08;

  499. 

  500. PWMB_CCMR1 |= 0x08;  //开启预装载

  501.     PWMB_CCMR2 |= 0x08;

  502.     PWMB_CCMR3 |= 0x08;

  503.     PWMB_CCMR4 |= 0x08;

  504. 

  505. // PWMB_PSCRH = 0x00; //分频

  506. // PWMB_PSCRL = 99;

  507. 

  508. //=======周期配置==================================================================================================//

  509. //    PWMA_ARRH = (u8)(PWM_PERIOD >> 8); //周期时间配置，在开头define配置

  510. //    PWMA_ARRL = (u8)PWM_PERIOD;

  511. 

  512.     PWMB_ARRH = (u8)(PWM_PERIODB >> 8); //周期时间配置，在开头define配置

  513.     PWMB_ARRL = (u8)PWM_PERIODB;

  514. 

  515. //=======使能配置==================================================================================================//

  516. //    PWMA_ENO |= ENO1P;   //使能输出

  517. //    PWMA_ENO |= ENO1N;   //使能输出

  518. //    PWMA_ENO |= ENO2P;   //使能输出

  519. //    PWMA_ENO |= ENO2N;   //使能输出

  520. //    PWMA_ENO |= ENO3P;   //使能输出

  521. //    PWMA_ENO |= ENO3N;   //使能输出

  522. //    PWMA_ENO |= ENO4P;   //使能输出

  523. //    PWMA_ENO |= ENO4N;   //使能输出

  524. // PWMA_ENO |= ENO4N;   //使能输出

  525. 

  526. PWMB_ENO |= ENO5P;   //使能输出

  527. // PWMB_ENO |= ENO6P;   //使能输出

  528. // PWMB_ENO |= ENO7P;   //使能输出

  529. // PWMB_ENO |= ENO8P;   //使能输出

  530. 

  531. //=======通道选择配置==================================================================================================//

  532. 

  533. //    PWMA_PS = 0x00;   //通道模式

  534. PWMB_PS = 0x00;   //通道模式

  535. 

  536. PWMB_PS |= PWMB5_0;

  537. // PWMB_PS |= PWMB6_3;

  538. // PWMB_PS |= PWMB7_2;

  539. // PWMB_PS |= PWMB8_2;

  540. 

  541. //  PWMA_PS |= PWM2_1;

  542. //  PWMA_PS |= PWM3_1;

  543. // PWMA_PS |= PWM4_2;

  544. 

  545. //=======使能主输出配置==================================================================================================//

  546. //    PWMA_BKR = 0x80;   //使能主输出

  547.     PWMB_BKR = 0x80;   //使能主输出

  548. 

  549. //    PWMA_CR1 |= 0x81;   //使能预装载

  550. PWMB_CR1 |= 0x81;   //使能预装载

  551. 

  552. 

  553. }

  554. 4.超声波测距模块：超声波测距

  555. void Timer1_Isr(void) interrupt 3

  556. {

  557. Timer1_Count++;

  558. }

  559. 

  560. void Timer1_Init(void)  //100微秒@40.000MHz

  561. {

  562. 

  563. AUXR |= 0x40;   //定时器时钟1T模式

  564. TMOD &= 0x0F;   //设置定时器模式

  565. TMOD |= 0x80;

  566. TL1 = 0x00;    //设置定时初始值

  567. TH1 = 0x00;    //设置定时初始值

  568. TF1 = 0;    //清除TF1标志

  569. // TR1 = 0;    //定时器1关闭计时

  570. TR1 = 1;    //定时器1开始计时

  571. ET1 = 1;    //使能定时器1中断

  572. }

  573. 

  574. void INT1_Isr(void) interrupt 2

  575. {

  576. u32 temp;

  577. // u8 i;

  578. 

  579. TR1 = 0;    //定时器1关闭计时

  580. EX1 = 0;    //关闭INT1中断

  581. 

  582. ((u8*)&temp)[0] = ((u8*)&Timer1_Count)[0];  

  583. ((u8*)&temp)[1] = ((u8*)&Timer1_Count)[1];

  584. ((u8*)&temp)[2] = TH1;

  585. ((u8*)&temp)[3] = TL1;

  586. 

  587. temp = temp * 0.0042875; // * 25 * 343000 / 1000000000 / 2

  588. 

  589.   //--- 移动数据 -----------

  590. 

  591. if(temp != 0)

  592. {

  593.   if(++csb_dat_x >= 5)csb_dat_x = 0;

  594.   csb_dat[csb_dat_x] = temp;           //存入新数据

  595.   Timer1_All = temp ;/// 5;

  596. }

  597. 

  598. TL1 = 0x00;    //设置定时初始值

  599. TH1 = 0x00;    //设置定时初始值

  600. Timer1_Count = 0;

  601. TR1 = 1;

  602. EX1 = 1;  

  603.   

  604. P36 = !P36;

  605. 

  606. }
复制代码




演示视频如下


         
在设计中，力求硬件线路简单，充分发挥软件编程灵活的特点，来满足系统设计要求。系统以Ai8051U单片机为控制核心、自制信号稳定的超声波测距模块、优良的PWM调压电路，以及合理高效的单片机程序设计，使得我们顺利控制完成题目要求。经过几天努力奋战，从开始准备到第一时间接到题目，一直都全身心地投入比赛之中。
感谢STC提供的AI8051U实验箱和芯片，感谢学校老师后勤工作支持，同时也感谢大赛组委会给了我们这次重要的机会锻炼自己。


图片1.png
https://www.stcaimcu.com/static/image/smiley/default/smile.gif
回复

使用道具 举报 送花
国芯人***

3

主题

2001

回帖

850

积分

等待验证会员

积分
850
发表于 前天 21:03 | 显示全部楼层
尊敬的各位评审老师：

您好！感谢您在百忙之中审阅我们的参赛作品。我们是来自辽宁机电职业技术学院的参赛团队，荣获2025年全国大学生电子设计竞赛I题“非接触智能控制盘”项目国家级二等奖。在此，我们谨向组委会提交本项目的奖金申领申请，并简要汇报我们在该项目中的技术实现与成果。

在本次比赛中，我们围绕“非接触智能控制盘”这一主题，完成了从系统设计、硬件搭建到软件算法开发的全过程。项目旨在实现对设备的非接触式智能控制，通过超声波传感器检测物体位置信息，并结合电机驱动模块实现精准控制。

在硬件设计方面，我们面临诸多挑战。初期采用运放构成运算放大器和比较器处理超声波信号，但由于噪声干扰大、稳定性差，导致测量精度不理想。经过反复调试与优化，我们最终选用CS100A作为核心器件，构建了结构简单、可靠性高的超声波收发电路。该电路具有良好的抗干扰能力，能够稳定地采集目标距离信息。

在系统时序控制方面，我们设计了如图1所示的超声波距离测量时序图，确保各模块协同工作，提高整体系统的响应速度与准确性。基于采集到的距离数据，我们建立了相应的数学模型，用于计算目标与控制盘之间的相对位置关系。公式如下：

$$ d = \frac{v \cdot t}{2} $$

其中，$ d $ 表示目标与控制盘之间的距离，$ v $ 为超声波在空气中的传播速度（约340 m/s），$ t $ 为超声波发射与接收之间的时间差。

在控制部分，我们设计了电机调压调速控制电路，实现了对电机转速的精确调节。通过PWM（脉冲宽度调制）技术，我们能够根据距离变化动态调整电机输出功率，从而实现对控制对象的精准操控。

在软件算法层面，我们编写了基于单片机的控制程序，实现了对超声波信号的实时处理、数据解析与电机控制逻辑的集成。整个系统具备良好的可扩展性与适应性，能够满足不同场景下的应用需求。

通过本次比赛，我们不仅提升了自身的工程实践能力，也加深了对嵌入式系统、传感器技术和自动控制原理的理解。我们深知，此次获奖不仅是对我们努力的认可，更是对未来继续深入研究的激励。

因此，我们诚挚申请2025年电赛奖金，并希望得到组委会的审核与支持。我们将继续秉持严谨求实的态度，在今后的学习与实践中不断提升自我，为我国电子信息技术的发展贡献力量。

此致  
敬礼！

辽宁机电职业技术学院  
2025年电赛I题“非接触智能控制盘”参赛团队  
2025年X月X日

[本文内容由国芯人工智能辅助生成，仅供参考]
回复

使用道具 举报 送花
返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

QQ|手机版|深圳国芯人工智能有限公司 ( 粤ICP备2022108929号-2 )

GMT+8, 2025-9-3 10:37 , Processed in 0.931843 second(s), 57 queries .

Powered by Discuz! X3.5

© 2001-2025 Discuz! Team.

快速回复 返回顶部 返回列表