设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › 功能很多的单片机智能小车源码(PS2手柄控制+舵机+W25Q64 ...
返回列表 发新帖
查看: 6696|回复: 2
收起左侧

功能很多的单片机智能小车源码(PS2手柄控制+舵机+W25Q64存储)

[复制链接]
ID:356227 发表于 2018-8-29 01:00 | 显示全部楼层 |阅读模式
手柄序号分布.png 0.png

单片机源程序如下:
  1. /*
  2.         1、串口1调试                  ok
  3.         2、串口2调试                  ok
  4.         3、定时器0调试                ok
  5.         4、定时器1调试                ok
  6.         5、PS2手柄调试                ok
  7.         6、4通道PWM调试                ok
  8.         7、舵机调试                          ok
  9.         8、W25Q64存储调试        ok
  10.         
  11.         调试的过程：
  12.         如上，一个一个模块调通，最后组合
  13.         左边的目录结构就是正队每一个模块调试好做成一个模块文件，便于移植
  14.         
  15.         看程序方法：
  16.         看程序的时候，从main文件的main函数看起
  17.         基本的程序思路是
  18.         主函数->各个模块初始化->大循环while(1)
  19.                                                   ->中断(串口、定时器等)
  20.         大家在深究本程序时，建议大家先去了解各个模块的原理，然后看懂文件结构和程序结构，最后再细究算法问题
  21.         
  22.         智能传感器版本增加内容：
  23.         所需硬件
  24.         循迹模块 2个
  25.         超声波模块 1个
  26.         颜色识别模块 1个
  27.         声音模块 1个
  28.         木块红、蓝、绿各一个
  29.         
  30.         IO口分布
  31.         循迹左         P0^6
  32.         循迹右         P0^7
  33.         超声波         P1^6
  34.         颜色          P1^2
  35.         声音          P1^0
  36.         
  37.         智能识别功能（手柄绿灯模式 左边 上下左右 和 右边 上下左右）
  38.         
  39.         功能0 循迹模式
  40.         功能1 声控夹取
  41.         功能2 自由避障
  42.         功能3 颜色识别
  43.         功能4 定距夹取
  44.         功能5 跟随功能
  45.         功能6 循迹避障
  46.         功能7 循迹识别
  47.         功能8 循迹定距
  48.         
  49.         手动遥控功能
  50.         1、手柄遥控
  51.         2、APP遥控
  52.         3、WIFI遥控

  54.         图形化编程功能
  55.         
  56.         功能切换：绿灯模式下通过左边上下左右键切换功能，通过蜂鸣器的声音的响声播报功能
  57.         
  58. */
  59. //头文件
  60. #include <stdio.h>
  61. #include <string.h>
  62. #include "z_stc15.h"
  63. #include "z_main.h"
  64. #include "z_uart.h"
  65. #include "z_delay.h"
  66. #include "z_gpio.h"
  67. #include "z_ps2.h"
  68. #include "z_pwm.h"
  69. #include "z_timer.h"
  70. #include "z_w25q64.h"
  71. #include "z_global.h"
  72. #include "z_adc.h"
  73. #include "z_sensor.h"
  74. //定义些变量，关于变量的作用，可以查找下是哪里用到了，具体看在那里是什么作用
  75. u16 adc7_value = 0, adc0_value = 0;
  76. u16 do_start_index, do_time, group_num_start, group_num_end, group_num_times;
  77. u8 i;
  78. u8 car_dw = 1;
  79. u32 bias_systick_ms_bak = 0;
  80. u8 djBiasSaveFlag = 0;
  81. u8 dbt_flag = 0;
  82. float vol_adc = 0;u32 save_addr_sector = 0, save_action_index_bak = 0;
  83. u8 psx_buf[9]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};         //存储手柄信息

  85. code const char *pre_cmd_set_red[PSX_BUTTON_NUM] = {
  86.         "<PS2_RED01:#005P0600T2000!^$DST!>",        //L2                                                  
  87.         "<PS2_RED02:#005P2400T2000!^$DST!>",        //R2                                                  
  88.         "<PS2_RED03:#004P0600T2000!^$DST!>",        //L1                                                  
  89.         "<PS2_RED04:#004P2400T2000!^$DST!>",        //R1                        
  90.         "<PS2_RED05:#002P2400T2000!^$DST!>",        //RU                                                  
  91.         "<PS2_RED06:#003P2400T2000!^$DST!>",        //RR                                                  
  92.         "<PS2_RED07:#002P0600T2000!^$DST!>",        //RD                                                  
  93.         "<PS2_RED08:#003P0600T2000!^$DST!>",        //RL                                
  94.         "<PS2_RED09:$!>",                                                           //SE                                      
  95.         "<PS2_RED10:$!>",                                                          //AL                                                   
  96.         "<PS2_RED11:$!>",                                                          //AR                                                  
  97.         "<PS2_RED12:$DJR!>",                                                //ST                        
  98.         "<PS2_RED13:#001P0600T2000!^$DST!>",        //LU                                                  
  99.         "<PS2_RED14:#000P0600T2000!^$DST!>",        //LR                                                                  
  100.         "<PS2_RED15:#001P2400T2000!^$DST!>",        //LD                                                  
  101.         "<PS2_RED16:#000P2400T2000!^$DST!>",        //LL                                                        
  102. };

  104. code const char *pre_cmd_set_grn[PSX_BUTTON_NUM] = {
  105.         "<PS2_GRN01:$!>",                                  //L2                                                  
  106.         "<PS2_GRN02:$!>",                                  //R2                                                  
  107.         "<PS2_GRN03:$!>",                                  //L1                                                  
  108.         "<PS2_GRN04:$!>",                                  //R1                        
  109.         "<PS2_GRN05:$SMODE5!>",                      //RU                                                  
  110.         "<PS2_GRN06:$SMODE8!>",                      //RR                                                  
  111.         "<PS2_GRN07:$SMODE6!>",                      //RD                                                  
  112.         "<PS2_GRN08:$SMODE7!>",                      //RL                                
  113.         "<PS2_GRN09:$SMODE0!>",                                              //SE                                             
  114.         "<PS2_GRN10:$!>",                                                          //AL                                          
  115.         "<PS2_GRN11:$!>",                                                          //AR                                          
  116.         "<PS2_GRN12:$DJR!>",                                                //ST                        
  117.         "<PS2_GRN13:$SMODE1!>",                      //LU                                                  
  118.         "<PS2_GRN14:$SMODE4!>",                      //LR                                                                  
  119.         "<PS2_GRN15:$SMODE2!>",                      //LD                                                  
  120.         "<PS2_GRN16:$SMODE3!>",                      //LL                                                  
  121. };


  124. code const char *action_pre_group[] = {
  125.     //动作生成数据为(可直接全选复制粘贴到程序中)：
  126.     //偏差调节组
  127.     "{G0000#000P1500T1000!#001P1500T1000!#002P1500T1000!#003P1500T1000!#004P1500T1000!#005P1500T1000!}",
  128.     //直立
  129.     "{G0001#000P1500T1500!#001P1500T1500!#002P1500T1500!#003P1500T1500!#004P1500T1500!#005P1500T0000!}",
  130.     //蜷缩
  131.     "{G0002#000P1500T1500!#001P2200T1500!#002P2500T1500!#003P2000T1500!#004P1500T1500!#005P1500T1500!}",
  132.     //大前抓右放 K0001(3-11)
  133.     "{G0003#000P1500T1000!#001P1500T1000!#002P1500T1000!#003P1500T1000!#004P1500T1000!#005P1000T1000!}",
  134.     "{G0004#000P1500T1000!#001P1100T1000!#002P1600T1000!#003P2100T1000!#004P1500T1000!#005P1000T0000!}",
  135.     "{G0005#000P1500T1500!#001P1050T1500!#002P1600T1000!#003P2100T1000!#004P1500T1000!#005P2000T0000!}",
  136.     "{G0006#000P1500T1000!#001P1800T1000!#002P1800T1000!#003P2100T1000!#004P1500T1000!#005P2000T0000!}",
  137.     "{G0007#000P0800T1000!#001P1500T1000!#002P1500T1000!#003P2100T1000!#004P1500T1000!#005P2000T0000!}",
  138.     "{G0008#000P0800T1000!#001P1300T1000!#002P1800T1000!#003P2100T1000!#004P1500T1000!#005P2000T0000!}",
  139.     "{G0009#000P0800T1000!#001P1300T1000!#002P1800T1000!#003P2100T1000!#004P1500T1000!#005P1000T0000!}",
  140.     "{G0010#000P0800T1000!#001P1600T1000!#002P1800T1000!#003P2100T1000!#004P1500T1000!#005P1000T0000!}",
  141.     "{G0011#000P1500T1500!#001P2200T1500!#002P2500T1500!#003P2000T1500!#004P1500T1500!#005P1500T1500!}",
  142.     //前爪前放 K0002(12-18)
  143.     "{G0012#000P1500T1000!#001P1500T1000!#002P1500T1000!#003P1500T1000!#004P1500T1000!#005P1500T1000!}",
  144.     "{G0013#000P1520T1000!#001P1100T2000!#002P1850T1000!#003P2100T1000!#004P1500T1000!#005P1000T0000!}",
  145.     "{G0014#000P1520T1000!#001P1100T2000!#002P1900T1000!#003P2100T1000!#004P1500T1000!#005P2000T0000!}",
  146.     "{G0015#000P1520T1000!#001P1800T2000!#002P2000T1000!#003P2000T1000!#004P1500T1000!#005P2000T1000!}",
  147.     "{G0016#000P1520T1000!#001P1100T2000!#002P1800T1000!#003P2000T1000!#004P1500T1000!#005P2000T1000!}",
  148.     "{G0017#000P1520T1000!#001P1100T2000!#002P1800T1000!#003P2000T1000!#004P1500T1000!#005P1000T0000!}",
  149.     "{G0018#000P1500T1500!#001P2200T1500!#002P2500T1500!#003P2000T1500!#004P1500T1500!#005P1500T1500!}",
  150.     //前爪左放 K0003(19-27)
  151.     "{G0019#000P1500T1000!#001P1500T1000!#002P1500T1000!#003P1500T1000!#004P1500T1000!#005P1500T1000!}",
  152.     "{G0020#000P1520T1000!#001P1100T2000!#002P1850T1000!#003P2100T1000!#004P1500T1000!#005P1000T0000!}",
  153.     "{G0021#000P1520T1000!#001P1100T2000!#002P1900T1000!#003P2100T1000!#004P1500T1000!#005P2000T0000!}",
  154.     "{G0022#000P1520T1000!#001P1800T2000!#002P2000T1000!#003P2000T1000!#004P1500T1000!#005P2000T1000!}",
  155.     "{G0023#000P2200T1000!#001P1800T2000!#002P2000T1000!#003P2000T1000!#004P1500T1000!#005P2000T1000!}",
  156.     "{G0024#000P2200T1000!#001P1200T2000!#002P2000T1000!#003P2000T1000!#004P1500T1000!#005P2000T1000!}",
  157.     "{G0025#000P2200T1000!#001P1200T2000!#002P2000T1000!#003P2000T1000!#004P1500T1000!#005P1000T0000!}",
  158.     "{G0026#000P2200T1000!#001P1800T2000!#002P2000T1000!#003P2000T1000!#004P1500T1000!#005P1000T1000!}",
  159.     "{G0027#000P1500T1500!#001P2200T1500!#002P2500T1500!#003P2000T1500!#004P1500T1500!#005P1500T1500!}",
  160.     //前爪右放 K0004(28-36)
  161.     "{G0028#000P1500T1000!#001P1500T1000!#002P1500T1000!#003P1500T1000!#004P1500T1000!#005P1500T1000!}",
  162.     "{G0029#000P1520T1000!#001P1100T2000!#002P1850T1000!#003P2100T1000!#004P1500T1000!#005P1000T0000!}",
  163.     "{G0030#000P1520T1000!#001P1100T2000!#002P1900T1000!#003P2100T1000!#004P1500T1000!#005P2000T0000!}",
  164.     "{G0031#000P1520T1000!#001P1800T2000!#002P2000T1000!#003P2000T1000!#004P1500T1000!#005P2000T1000!}",
  165.     "{G0032#000P0800T1000!#001P1800T2000!#002P2000T1000!#003P2000T1000!#004P1500T1000!#005P2000T1000!}",
  166.     "{G0033#000P0800T1000!#001P1200T2000!#002P2000T1000!#003P2000T1000!#004P1500T1000!#005P2000T1000!}",
  167.     "{G0034#000P0800T1000!#001P1200T2000!#002P2000T1000!#003P2000T1000!#004P1500T1000!#005P1000T0000!}",
  168.     "{G0035#000P0800T1000!#001P1800T2000!#002P2000T1000!#003P2000T1000!#004P1500T1000!#005P1000T1000!}",
  169.     "{G0036#000P1500T1500!#001P2200T1500!#002P2500T1500!#003P2000T1500!#004P1500T1500!#005P1500T1500!}",
  170. };

  172. /*
  173.         代码从main里开始执行
  174.         在进入大循环while(1)之前都为各个模块的初始化
  175.         最后在大循环处理持续执行的事情
  176.         另外注意uart中的串口中断，接收数据处理
  177.         timer中的定时器中断，舵机的脉冲收发就在那里
  178. */

  180. void main(void) {
  181.         setup_global();                        //初始化全局变量
  182.         setup_gpio();                          //初始化IO口
  183.         setup_nled();                          //初始化工作指示灯
  184.         setup_beep();                          //初始化定时器
  185.         setup_djio();                          //初始化舵机IO口
  186.         setup_sensor();                        //初始化传感器IO口
  187.         setup_w25q64();                        //初始化存储器W25Q64
  188.         setup_ps2();                          //初始化PS2手柄
  189.         setup_vol();                          //初始化电压采集
  190.         setup_car_pwm();                //初始化电机PWM定时
  191.         setup_uart1();                        //初始化串口1
  192.         setup_uart2();                        //初始化串口2
  193.         setup_uart4();                        //初始化串口4
  194.         setup_systick();                //初始化滴答时钟，1S增加一次systick_ms的值
  195.         setup_others();                        //初始化其他
  196.         
  197.         setup_dj_timer();                //初始化定时器2 处理舵机PWM输出
  198.         setup_interrupt();        //初始化总中断
  199.         
  200.         setup_start();                        //初始化启动信号
  201.     while (1) {
  202.                 loop_nled();                              //循环执行工作指示灯，500ms跳动一次
  203.                 loop_uart();                              //串口数据接收处理
  204.                 loop_action();                            //动作组批量执行
  205.                 loop_bt_once();                            //蓝牙修改波特率和名称
  206.                 loop_ps2_data();                    //循环读取PS2手柄数据
  207.                 loop_ps2_button();                  //处理手柄上的按钮
  208.                 loop_ps2_car_pwm();                  //处理小车电机摇杆控制
  209.                 loop_save_something();  //定时保存一些变量
  210. //    loop_smart_sensor();          //处理智能传感器功能
  211.                 smart_xunji();                                  //循迹模式
  212. //                smart_soundjiaqu();                  //声控夹取
  213. //                smart_ziyoubizhang();                //自由避障
  214. //                smart_yssbjiaqu();                        //颜色识别
  215. //                smart_csbjiaqu();                          //定距夹取
  216. //                smart_gensui();                                  //跟随功能
  217. //                smart_xunjibizhang();                //循迹避障
  218. //                smart_xunjiyanse();                        //循迹识别
  219. //                smart_xunjicsbjiaqu();        //循迹定距
  220.                 }
  221. }

  223. //--------------------------------------------------------------------------------
  224. /*
  225.         初始化函数实现
  226. */
  227. //初始化全局变量
  228. void setup_global(void) {
  229.         //全局变量初始化
  230.         global_init();
  231. }
  232. //初始化IO口
  233. void setup_gpio(void) {
  234.         //IO初始化
  235.         io_init();
  236. }
  237. //初始化工作指示灯 初始化已在io_init中初始化
  238. void setup_nled(void) {
  239.         nled_off();                        //工作指示灯关闭
  240. }
  241. //初始化蜂鸣器 初始化已在io_init中初始化
  242. void setup_beep(void) {
  243.         beep_off();                        //关闭蜂鸣器
  244. }                        
  245. //初始化舵机IO口
  246. void setup_djio(void) {
  247.         dj_io_init();                //舵机IO口初始化
  248. }        

  250. void setup_vol(void) {
  251.         adc_init(ADC_VOL);
  252. }

  254. //初始化存储器W25Q64
  255. void setup_w25q64(void) {
  256. //存储器初始化，读取ID进行校验，若错误则长鸣不往下执行
  257.         w25x_init();
  258.         while(w25x_readId()!= W25Q64)beep_on();
  259.         
  260.         w25x_read((u8 *)(&eeprom_info), W25Q64_INFO_ADDR_SAVE_STR, sizeof(eeprom_info_t));        //读取全局变量
  261.         if(eeprom_info.version != VERSION) {        //判断版本是否是当前版本
  262.                 eeprom_info.version = VERSION;                  //复制当前版本
  263.                 eeprom_info.dj_record_num = 0;                  //学习动作组变量赋值0
  264.                 rewrite_eeprom();                                                  //写入到存储器
  265.         }
  266.         
  267.         if(eeprom_info.dj_bias_pwm[DJ_NUM] != FLAG_VERIFY) {
  268.                 for(i=0;i<DJ_NUM;i++) {
  269.                         eeprom_info.dj_bias_pwm[i] = 0;
  270.                 }
  271.                 eeprom_info.dj_bias_pwm[DJ_NUM] = FLAG_VERIFY;
  272.         }
  273.         
  274.         
  275. }        

  277. //初始化PS2手柄
  278. void setup_ps2(void) {
  279.         //手柄初始化
  280.         psx_init();
  281. }
  282. //初始化定时器2 处理舵机PWM输出
  283. void setup_dj_timer(void) {
  284.         timer1_init();        //舵机 定时器初始化
  285. }
  286. //初始化电机PWM定时
  287. void setup_car_pwm(void) {
  288.         //小车 pwm 初始化
  289.         pwm_init(CYCLE);
  290.         car_pwm_set(0,0);        //设置小车的左右轮速度为0
  291. }        
  292. //初始化串口1
  293. void setup_uart1(void) {
  294.         //串口1初始化
  295.         uart1_init(115200);
  296.         //uart1_close();
  297.         uart1_open();
  298.         //串口发送测试字符
  299.         uart1_send_str((u8 *)"uart1 check ok!");
  300. }
  301. //初始化串口2
  302. void setup_uart2(void) {
  303.         //串口2初始化
  304.         uart2_init(115200);
  305.         //uart2_close();
  306.         uart2_open();
  307.         //串口发送测试字符
  308.         uart2_send_str((u8 *)"uart2 check ok!");
  309. }        
  310. //初始化串口4
  311. void setup_uart4(void) {
  312.         //串口4初始化
  313.         uart4_init(115200);
  314.         //uart4_close();
  315.         uart4_open();
  316.         
  317.         //串口发送测试字符
  318.         uart4_send_str((u8 *)"uart4 check ok!");
  319. }        
  320. //初始化滴答时钟，1S增加一次systick_ms的值
  321. void setup_systick(void) {
  322.         //系统滴答时钟初始化        
  323.         timer0_init();
  324. }        


  327. //初始化启动信号
  328. void setup_start(void) {
  329.         //蜂鸣器LED 名叫闪烁 示意系统启动
  330.         beep_on();nled_on();mdelay(100);beep_off();nled_off();mdelay(100);
  331.         beep_on();nled_on();mdelay(100);beep_off();nled_off();mdelay(100);
  332.         beep_on();nled_on();mdelay(100);beep_off();nled_off();mdelay(100);
  333. }        
  334. //初始化其他
  335. void setup_others(void) {        
  336.         //机械臂蜷缩 G0002组
  337.         memset(uart_receive_buf, 0, sizeof(uart_receive_buf));
  338.         if(ACTION_USE_ROM) {
  339.                 //使用存储在单片机内部rom中的动作组
  340.                 strcpy((char *)uart_receive_buf, action_pre_group[2]);
  341.         } else {
  342.                 //从存储芯片中读取第group_num个动作组
  343.                 w25x_read(uart_receive_buf, 2*ACTION_SIZE, ACTION_SIZE);        
  344.         }
  345.         //把读取出来的动作组传递到do_action执行
  346.         for(i=16;i<strlen((char *)uart_receive_buf);i+=15) {
  347.                 uart_receive_buf[i] = '0';
  348.                 uart_receive_buf[i+1] = '0';
  349.                 uart_receive_buf[i+2] = '0';
  350.                 uart_receive_buf[i+3] = '0';
  351.         }
  352.         do_action(uart_receive_buf);
  353.         //执行预存命令 {G0000#000P1500T1000!#000P1500T1000!}
  354.         if(eeprom_info.pre_cmd[PRE_CMD_SIZE] == FLAG_VERIFY) {
  355.                 strcpy((char *)uart_receive_buf, (char *)eeprom_info.pre_cmd);
  356.                 if(eeprom_info.pre_cmd[0] == '


  359. ) {
  360.                         parse_cmd(eeprom_info.pre_cmd);
  361.                 } else {
  362.                         for(i=16;i<strlen((char *)uart_receive_buf);i+=15) {
  363.                                 uart_receive_buf[i] = '0';
  364.                                 uart_receive_buf[i+1] = '0';
  365.                                 uart_receive_buf[i+2] = '0';
  366.                                 uart_receive_buf[i+3] = '0';
  367.                         }
  368.                         do_action(uart_receive_buf);
  369.                 }
  370.         }
  371.         
  372. }

  374. //初始化总中断
  375. void setup_interrupt(void) {
  376.         //串口1设为高优先级
  377.         IP = 0X10;
  378.         //IP2 = 0X01;
  379.         //总中断打开
  380.         EA = 1;
  381. }        
  382. //--------------------------------------------------------------------------------


  385. //--------------------------------------------------------------------------------
  386. /*
  387.         主循环函数实现
  388. */
  389. //循环执行工作指示灯，500ms跳动一次
  390. void loop_nled(void) {
  391.         static u32 systick_ms_bak = 0;
  392.         if(millis() - systick_ms_bak >= 500) {
  393.                 systick_ms_bak = millis();
  394.                 nled_switch();        
  395.         }
  396. }               
  397. //串口数据接收处理
  398. void loop_uart(void) {
  399.         static u8 do_once1 = 0, do_once2 = 0;
  400.         if(uart1_get_ok) {
  401.                 //测试发回去
  402.                 //uart1_send_str(uart_receive_buf);
  403.                 if(uart1_mode == 1) {                                //命令模式
  404.                         //uart1_send_str(">cmd");
  405.                         parse_cmd(uart_receive_buf);                        
  406.                 } else if(uart1_mode == 2) {                //单个舵机模式
  407.                         //uart1_send_str(">sig");
  408.                         do_action(uart_receive_buf);
  409.                 } else if(uart1_mode == 3) {                //多个舵机模式
  410.                         //uart1_send_str(">group:");
  411.                         do_action(uart_receive_buf);
  412.                 } else if(uart1_mode == 4) {                //保存模式
  413.                         //uart1_send_str(">save");
  414.                         //uart1_send_str(uart_receive_buf);
  415.                         action_save(uart_receive_buf);
  416.                 }
  417.                 uart1_mode = 0;
  418.                 uart1_get_ok = 0;
  419.                 //uart1_open();
  420.         }
  421.         

  423.         if(millis() - get_uart_timeout() > 100) {
  424.                 if(!do_once1) {
  425.                         timer1_open();
  426.                         do_once1 = 1;
  427.                         do_once2 = 0;
  428.                 }
  429.         } else {
  430.                 if(!do_once2) {
  431.                         timer1_close();
  432.                         do_once1 = 0;
  433.                         do_once2 = 1;
  434.                 }
  435.         }
  436.         
  437.         return;
  438. }        

  440. //定时保存一些变量
  441. void loop_save_something(void) {
  442.         static u32 saveTime = 3000;
  443.         if((djBiasSaveFlag == 1) && (millis() - bias_systick_ms_bak > saveTime)) {
  444.                 djBiasSaveFlag = 0;
  445.                 bias_systick_ms_bak = millis();
  446.                 rewrite_eeprom();
  447.         }        
  448.         return;
  449. }        


  452. void loop_ps2_data(void) {
  453.         static u32 systick_ms_bak = 0;
  454.         if(millis() - systick_ms_bak < 20) {
  455.                 return;
  456.         }
  457.         systick_ms_bak = millis();
  458.         psx_write_read(psx_buf);
  459. //#if 0        
  460. //        sprintf(cmd_return, "0x%02x,0x%02x,0x%02x,0x%02x,0x%02x,0x%02x,0x%02x,0x%02x,0x%02x\r\n",
  461. //        (int)psx_buf[0], (int)psx_buf[1], (int)psx_buf[2], (int)psx_buf[3],
  462. //        (int)psx_buf[4], (int)psx_buf[5], (int)psx_buf[6], (int)psx_buf[7], (int)psx_buf[8]);
  463. //        uart1_send_str(cmd_return);
  464. //#endif         
  465.         return;
  466. }
  467. //处理遥感数据，控制电机
  468. void loop_ps2_car_pwm(void) {
  469.         static int car_left_bak=0, car_right_bak=0;
  470.         int car_left, car_right;
  471.         
  472.         if(psx_buf[1] != PS2_LED_RED)return;
  473.         car_left = (127 - psx_buf[8]) * 8;
  474.         car_right = (127 - psx_buf[6]) * 8;
  475.         
  476.         if(car_left != car_left_bak || car_right != car_right_bak) {
  477.                 car_pwm_set(car_left, car_right);
  478.                 car_left_bak = car_left;
  479.                 car_right_bak = car_right;
  480.         }

  482. }


  485. //接收手柄按键数据
  486. void loop_ps2_button(void) {
  487.         static unsigned char psx_button_bak[2] = {0};
  488.         static unsigned char mode_bak;

  490.         //处理智能模式 红灯模式下 智能模式取消，此时为遥控模式
  491.         if(mode_bak != psx_buf[1]) {
  492.                 mode_bak = psx_buf[1];
  493.                 if(PS2_LED_RED == psx_buf[1]) {
  494.                         smart_mode = 255;
  495.                 }
  496.                 car_pwm_set(0,0);
  497.                 group_do_ok = 1;
  498.                 //beep_on_times(1, 500);
  499.         }

  501.         if((psx_button_bak[0] == psx_buf[3])
  502.         && (psx_button_bak[1] == psx_buf[4])) {                        
  503.         } else {
  504.                 parse_psx_buf(psx_buf+3, psx_buf[1]);
  505.                 psx_button_bak[0] = psx_buf[3];
  506.                 psx_button_bak[1] = psx_buf[4];
  507.         }
  508.         return;
  509. }

  511. //处理手柄接收到的数据
  512. void parse_psx_buf(unsigned char *buf, unsigned char mode) {
  513.         u8 i, pos = 0;
  514.         static u16 bak=0xffff, temp, temp2;
  515.         temp = (buf[0]<<8) + buf[1];
  516.         
  517.         if(bak != temp) {
  518.                 temp2 = temp;
  519.                 temp &= bak;
  520.                 for(i=0;i<16;i++) {
  521.                         if((1<<i) & temp) {
  522.                         } else {
  523.                                 if((1<<i) & bak) {        //press
  524.                                                                                                                         
  525.                                         memset(uart_receive_buf, 0, sizeof(uart_receive_buf));                                       
  526.                                         if(mode == PS2_LED_RED) {
  527.                                                 memcpy((char *)uart_receive_buf, (char *)pre_cmd_set_red[i], strlen(pre_cmd_set_red[i]));
  528.                                         } else if(mode == PS2_LED_GRN) {
  529.                                                 memcpy((char *)uart_receive_buf, (char *)pre_cmd_set_grn[i], strlen(pre_cmd_set_grn[i]));
  530.                                         } else continue;
  531.                                        
  532.                                         pos = str_contain_str(uart_receive_buf, "^");
  533.                                         if(pos) uart_receive_buf[pos-1] = '\0';
  534.                                         if(str_contain_str(uart_receive_buf, "[        DISCUZ_CODE_0        ]quot;)) {
  535.                                                 //uart1_close();
  536.                                                 //uart1_get_ok = 1;
  537.                                                 //uart1_mode = 1;
  538.                                                 strcpy(cmd_return, uart_receive_buf+11);
  539.                                                 strcpy(uart_receive_buf, cmd_return);
  540.                                                 parse_cmd(uart_receive_buf);
  541.                                         } else if(str_contain_str(uart_receive_buf, "#")) {
  542.                                                 //uart1_close();
  543.                                                 //uart1_get_ok = 1;
  544.                                                 //uart1_mode = 2;
  545.                                                 strcpy(cmd_return, uart_receive_buf+11);
  546.                                                 strcpy(uart_receive_buf, cmd_return);
  547.                                                 do_action(uart_receive_buf);
  548.                                         }
  549.                                        
  550.                                         //uart1_send_str(uart_receive_buf);
  551.                                         //zx_uart_send_str(uart_receive_buf);
  552.                                        
  553.                                         bak = 0xffff;
  554.                                 } else {//release
  555.                                                                                 
  556.                                         memset(uart_receive_buf, 0, sizeof(uart_receive_buf));                                       
  557.                                         if(mode == PS2_LED_RED) {
  558.                                                 memcpy((char *)uart_receive_buf, (char *)pre_cmd_set_red[i], strlen(pre_cmd_set_red[i]));
  559.                                         } else if(mode == PS2_LED_GRN) {
  560.                                                 memcpy((char *)uart_receive_buf, (char *)pre_cmd_set_grn[i], strlen(pre_cmd_set_grn[i]));
  561.                                         } else continue;        
  562.                                        
  563.                                         pos = str_contain_str(uart_receive_buf, "^");
  564.                                         if(pos) {
  565.                                                 if(str_contain_str(uart_receive_buf+pos, "[        DISCUZ_CODE_0        ]quot;)) {
  566.                                                         //uart1_close();
  567.                                                         //uart1_get_ok = 1;
  568.                                                         //uart1_mode = 1;
  569.                                                         strcpy(cmd_return, uart_receive_buf+pos);
  570.                                                         cmd_return[strlen(cmd_return) - 1] = '\0';
  571.                                                         strcpy(uart_receive_buf, cmd_return);
  572.                                                         parse_cmd(uart_receive_buf);
  573.                                                 } else if(str_contain_str(uart_receive_buf+pos, "#")) {
  574.                                                         //uart1_close();
  575.                                                         //uart1_get_ok = 1;
  576.                                                         //uart1_mode = 2;
  577.                                                         strcpy(cmd_return, uart_receive_buf+pos);
  578.                                                         cmd_return[strlen(cmd_return) - 1] = '\0';
  579.                                                         strcpy(uart_receive_buf, cmd_return);
  580.                                                         do_action(uart_receive_buf);
  581.                                                 }
  582.                                                 //uart1_send_str(uart_receive_buf);
  583.                                                 //zx_uart_send_str(uart_receive_buf);
  584.                                         }        
  585.                                 }
  586.                                 //测试执行指令
  587.                                 //uart1_send_str(uart_receive_buf);

  589.                         }
  590.                 }
  591.                 bak = temp2;
  592.                 beep_on();mdelay(50);beep_off();
  593.         }        
  594.         return;
  595. }

  597. //void handle_uart(void) {

  599. //        return;
  600. //}

  602. /*
  603. parse_cmd( )的作用是解析下列指令
  604.         $DST!
  605.         $DST:x!
  606.         $RST!
  607.         $CGP:%d-%d!
  608.         $DEG:%d-%d!
  609.         $DGS:x!
  610.         $DGT:%d-%d,%d!
  611.         $DCR:%d,%d!
  612.         $DWA!
  613.         $DWD!
  614.         $DJR!
  615.         $GETA!
  616. */
  617. void parse_cmd(u8 *cmd) {
  618.         //u32 uint1;
  619.         static u8 djrFlag=0;
  620.         u16 pos, i, index;
  621.         int int1, int2;
  622.         
  623.         uart1_send_str(cmd);
  624.         
  625.         if(pos = str_contain_str(cmd, "$DST!"), pos) {
  626.                 dbt_flag = 0;
  627.                 group_do_ok  = 1;
  628.                 for(i=0;i<DJ_NUM;i++) {
  629.                         duoji_doing[i].inc = 0;        
  630.                         duoji_doing[i].aim = duoji_doing[i].cur;
  631.                 }
  632.                 zx_uart_send_str("#255PDST!");
  633.         } else if(pos = str_contain_str(cmd, "$DST:"), pos) {
  634.                 if(sscanf(cmd, "$DST:%d!", &index)) {
  635.                         duoji_doing[index].inc = 0;        
  636.                         duoji_doing[index].aim = duoji_doing[index].cur;
  637.                         sprintf(cmd_return, "#%03dPDST!", (int)index);
  638.                         zx_uart_send_str(cmd_return);
  639.                 }
  640.                
  641.                
  642.         } else if(pos = str_contain_str(cmd, "$RST!"), pos) {               
  643.                 soft_reset();
  644.         } else if(pos = str_contain_str(cmd, "$CGP:"), pos) {               
  645.                 if(sscanf(cmd, "$CGP:%d-%d!", &int1, &int2)) {
  646.                         print_group(int1, int2);
  647.                 }
  648.         } else if(pos = str_contain_str(cmd, "$DEG:"), pos) {               
  649.                 if(sscanf(cmd, "$DEG:%d-%d!", &int1, &int2)) {
  650.                         erase_sector(int1, int2);
  651.                 }
  652.         } else if(pos = str_contain_str(cmd, "$DGS:"), pos) {               
  653.                 if(sscanf(cmd, "$DGS:%d!", &int1)) {
  654.                         do_group_once(int1);
  655.                         group_do_ok = 1;
  656.                 }
  657.         } else if(pos = str_contain_str(cmd, "$DGT:"), pos) {               
  658.                 if(sscanf((char *)cmd, "$DGT:%d-%d,%d!", &group_num_start, &group_num_end, &group_num_times)) {
  659.                         //uart1_send_str("111111");                        
  660.                         if(group_num_start != group_num_end) {
  661.                                 do_start_index = group_num_start;
  662.                                 do_time = group_num_times;
  663.                                 group_do_ok = 0;
  664.                                 //uart1_send_str("22222");
  665.                         } else {
  666.                                 group_do_ok = 1;
  667.                                 do_group_once(group_num_start);
  668.                                 //uart1_send_str("33333");
  669.                         }
  670.                 }
  671.         } else if(pos = str_contain_str(cmd, "$DCR:"), pos) {               
  672.                 if(sscanf(cmd, "$DCR:%d,%d!", &int1, &int2)) {
  673.                         car_pwm_set(int1, int2);
  674.                 }
  675.         } else if(pos = str_contain_str(cmd, "$DWA!"), pos) {               
  676.                 car_dw--;
  677.                 if(car_dw == 0)car_dw = 1;
  678.                 beep_on();mdelay(100);beep_off();
  679.         } else if(pos = str_contain_str(cmd, "$DWD!"), pos) {               
  680.                 car_dw++;
  681.                 if(car_dw == 4)car_dw = 3;
  682.                 beep_on();mdelay(100);beep_off();
  683.         } else if(pos = str_contain_str(cmd, "$CAR_FARWARD!"), pos) {               
  684.                 car_pwm_set(1000, 1000);
  685.         } else if(pos = str_contain_str(cmd, "$CAR_BACKWARD!"), pos) {               
  686.                 car_pwm_set(-1000, -1000);
  687.         } else if(pos = str_contain_str(cmd, "$CAR_LEFT!"), pos) {               
  688.                 car_pwm_set(-1000, 1000);
  689.         } else if(pos = str_contain_str(cmd, "$CAR_RIGHT!"), pos) {               
  690.                 car_pwm_set(1000, -1000);
  691.         } else if(pos = str_contain_str(cmd, "$DJR!"), pos) {        
  692.                 zx_uart_send_str("#255P1500T2000!");               
  693.                 for(i=0;i<DJ_NUM;i++) {
  694.                         duoji_doing[i].aim  = 1500;
  695.                         duoji_doing[i].time = 2000;
  696.                         duoji_doing[i].inc = (duoji_doing[i].aim -  duoji_doing[i].cur) / (duoji_doing[i].time/20.000);
  697.                 }
  698.                
  699.                 if(djrFlag) {
  700.                         do_group_once(1);
  701.                 } else {
  702.                         do_group_once(2);
  703.                 }
  704.                 djrFlag = !djrFlag;
  705.         } else if(pos = str_contain_str(cmd, "$GETA!"), pos) {               
  706.                 uart1_send_str("AAA");
  707.         } else if(pos = str_contain_str(cmd, "$GETS!"), pos) {               
  708.                 if(group_do_ok == 0) {
  709.                         uart1_send_str("group_do_ok=0");
  710.                 } else {
  711.                         uart1_send_str("group_do_ok=1");
  712.                 }
  713.         } else if(pos = str_contain_str(cmd, "$GETINC!"), pos) {               
  714.                 for(i=0;i<8;i++) {
  715.                         sprintf(cmd_return, "inc%d = %f \r\n", (int)i, duoji_doing[i].inc);
  716.                         uart1_send_str(cmd_return);
  717.                 }
  718.         }else if(pos = str_contain_str(uart_receive_buf, "$DBT:"), pos) {               
  719.                 if(sscanf(uart_receive_buf, "$DBT:%d,%d!", &int1, &int2)) {
  720.                         if(int1 == 1) {
  721.                                 group_num_start = 1;
  722.                                 group_num_end = 10;
  723.                                 group_num_times = int2;
  724.                         } else if(int1 == 2) {
  725.                                 group_num_start = 11;
  726.                                 group_num_end = 20;
  727.                                 group_num_times = int2;
  728.                         } else if(int1 == 3) {
  729.                                 group_num_start = 21;
  730.                                 group_num_end = 30;
  731.                                 group_num_times = int2;
  732.                         } else if(int1 == 4) {
  733.                                 group_num_start = 31;
  734.                                 group_num_end = 40;
  735.                                 group_num_times = int2;
  736.                         } else {
  737.                                 group_num_start = 0;
  738.                                 group_num_end = 0;
  739.                         }
  740.                         
  741.                         if(group_num_start != group_num_end) {
  742.                                 do_start_index = group_num_start;
  743.                                 do_time = group_num_times;
  744.                                 group_do_ok = 0;
  745.                                 dbt_flag = 1;
  746.                         } else {
  747.                                 do_group_once(group_num_start);
  748.                         }
  749.                         
  750.                 }
  751.         } else if(pos = str_contain_str(cmd, "$DRS!"), pos) {        
  752.                 uart1_send_str("51MCU-IAP15W4K61S4");
  753.         } else if(pos = str_contain_str(cmd, (u8 *)"$SMODE"), pos) {               
  754.                 if(sscanf((char *)cmd, "$SMODE%d!", &int1)) {
  755.                         if(int1 < 10) {
  756.                                 smart_mode = int1;
  757.                                 beep_on_times(1, 100);
  758.                                 car_pwm_set(0,0);
  759.                                 //uart1_send_str(cmd);
  760.                         }
  761.                 }
  762.         }
  763. }


  766. //预存指令处理
  767. void action_save(u8 *str) {
  768.         int action_index = 0;
  769.         //预存命令处理
  770.         if(str[1] == '

  772. && str[2] == '!') {
  773.                 eeprom_info.pre_cmd[PRE_CMD_SIZE] = 0;
  774.                 rewrite_eeprom();
  775.                 uart1_send_str((u8 *)"@CLEAR PRE_CMD OK!");
  776.                 return;
  777.         } else if(str[1] == '


  780. ) {
  781.                 if(sscanf((char *)str, "<$DGT:%d-%d,%d!>", &group_num_start, &group_num_end, &group_num_times)) {
  782.                         if(group_num_start == group_num_end) {
  783.                                 w25x_read(eeprom_info.pre_cmd, group_num_start*ACTION_SIZE, ACTION_SIZE);        
  784.                         } else {
  785.                                 memset(eeprom_info.pre_cmd, 0, sizeof(eeprom_info.pre_cmd));
  786.                                 strcpy((char *)eeprom_info.pre_cmd, (char *)str+1);
  787.                                 eeprom_info.pre_cmd[strlen((char *)str) - 2] = '\0';
  788.                         }
  789.                         eeprom_info.pre_cmd[PRE_CMD_SIZE] = FLAG_VERIFY;
  790.                         rewrite_eeprom();
  791.                         //uart1_send_str(eeprom_info.pre_cmd);
  792.                         uart1_send_str((u8 *)"@SET PRE_CMD OK!");
  793.                 }
  794.                 return;
  795.         }
  796.         
  797.         action_index = get_action_index(str);
  798.         //<G0001#001...>
  799.         if((action_index == -1) || str[6] != '#'){
  800.         //if( action_index == -1 ){
  801.                 uart1_send_str("E");
  802.                 return;
  803.         }
  804.         //save_action_index_bak++;
  805.         if(action_index*ACTION_SIZE % W25Q64_SECTOR_SIZE == 0)w25x_erase_sector(action_index*ACTION_SIZE/W25Q64_SECTOR_SIZE);
  806.         replace_char(str, '<', '{');
  807.         replace_char(str, '>', '}');
  808.         w25x_write(str, action_index*ACTION_SIZE, strlen(str) + 1);
  809.         //uart1_send_str(str);
  810.         uart1_send_str("A");
  811.         return;        
  812. }
  813. //获取指令中舵机ID号
  814. int get_action_index(u8 *str) {
  815.         int index = 0;
  816.         //uart_send_str(str);
  817.         while(*str) {
  818.                 if(*str == 'G') {
  819.                         str++;
  820.                         while((*str != '#') && (*str != '


  823. )) {
  824.                                 index = index*10 + *str-'0';
  825.                                 str++;        
  826.                         }
  827.                         return index;
  828.                 } else {
  829.                         str++;
  830.                 }
  831.         }
  832.         return -1;
  833. }
  834. //打印动作组到串口
  835. void print_group(int start, int end) {
  836.         if(start > end) {
  837.                 int_exchange(&start, &end);
  838.         }
  839.         for(;start<=end;start++) {
  840.                 memset(uart_receive_buf, 0, sizeof(uart_receive_buf));
  841.                 w25x_read(uart_receive_buf, start*ACTION_SIZE, ACTION_SIZE);
  842.                 uart1_send_str(uart_receive_buf);
  843.                 uart1_send_str("\r\n");
  844.         }
  845. }

  847. //交换两个变量
  848. void int_exchange(int *int1, int *int2) {
  849.         int int_temp;
  850.         int_temp = *int1;
  851.         *int1 = *int2;
  852.         *int2 = int_temp;
  853. }

  855. //擦除相应扇区
  856. void erase_sector(int start, int end) {
  857.         if(start > end) {
  858.                 int_exchange(&start, &end);
  859.         }
  860.         if(end >= 127)end = 127;
  861.         for(;start<=end;start++) {
  862.                 SpiFlashEraseSector(start);
  863.                 sprintf(cmd_return, "@Erase %d OK!", start);
  864.                 uart1_send_str(cmd_return);
  865.         }
  866.         save_action_index_bak = 0;
  867. }


  870. //执行动作一次
  871. void do_group_once(int group_num) {
  872.         memset(uart_receive_buf, 0, sizeof(uart_receive_buf));
  873.         if(ACTION_USE_ROM) {
  874.                 //使用存储在单片机内部rom中的动作组
  875.                 strcpy((char *)uart_receive_buf, action_pre_group[group_num]);
  876.         } else {
  877.                 //从存储芯片中读取第group_num个动作组
  878.                 w25x_read(uart_receive_buf, group_num*ACTION_SIZE, ACTION_SIZE);        
  879.         }
  880.         //把读取出来的动作组传递到do_action执行
  881.         do_action(uart_receive_buf);
  882.         sprintf((char *)cmd_return, "@DoGroup %d OK!\r\n", group_num);
  883.         uart1_send_str(cmd_return);
  884. }
  885. //取绝对值
  886. float abs_float(float value) {
  887.         if(value>0) {
  888.                 return value;
  889.         }
  890.         return (-value);
  891. }

  893. //舵机增量处理
  894. void duoji_inc_handle(u8 index) {        
  895.         int aim_temp;
  896.         
  897.         if(duoji_doing[index].inc != 0) {
  898.                
  899.                 aim_temp = duoji_doing[index].aim;
  900.                
  901.                 if(aim_temp > 2500){
  902.                         aim_temp = 2500;
  903.                 } else if(aim_temp < 500) {
  904.                         aim_temp = 500;
  905.                 }
  906.         
  907.                 if(abs_float(aim_temp - duoji_doing[index].cur) <= abs_float(duoji_doing[index].inc + duoji_doing[index].inc)) {
  908.                         duoji_doing[index].cur = aim_temp;
  909.                         duoji_doing[index].inc = 0;
  910.                 } else {
  911.                         duoji_doing[index].cur += duoji_doing[index].inc;
  912.                 }
  913.         }
  914. }

  916. //动作组批量执行
  917. void loop_action(void) {
  918.         
  919.         if(timer1_flag_dj) {
  920.                 duoji_inc_handle(duoji_index1);
  921.                 timer1_flag_dj = 0;
  922.         }
  923.         
  924.         if((check_dj_state() == 0) && (group_do_ok == 0)) {
  925.                 do_group_once(do_start_index);
  926.                
  927.                 if(group_num_start<group_num_end) {
  928.                         if(do_start_index == group_num_end) {
  929.                                 do_start_index = group_num_start;
  930.                                 if(group_num_times != 0) {
  931.                                         do_time--;
  932.                                         if(do_time == 0) {
  933.                                                 group_do_ok = 1;
  934.                                                 uart1_send_str((u8*)"@GroupDone!");
  935.                                         }
  936.                                 }
  937.                                 return;
  938.                         }
  939.                         do_start_index++;
  940.                 } else {
  941.                         if(do_start_index == group_num_end) {
  942.                                 do_start_index = group_num_start;
  943.                                 if(group_num_times != 0) {
  944.                                         do_time--;
  945.                                         if(do_time == 0) {
  946.                                                 group_do_ok = 1;
  947.                                                 uart1_send_str((u8*)"@GroupDone!");
  948.                                         }
  949.                                 }
  950.                                 return;
  951.                         }
  952.                         do_start_index--;
  953.                 }
  954.         }
  955.         
  956. }

  958. //舵机状态处理，有舵机处理动作返回1，否则返回0
  959. u8 check_dj_state(void) {
  960.         int i;
  961.         for(i=0;i<DJ_NUM;i++) {
  962.                 if(duoji_doing[i].inc) return 1;
  963.         }
  964.         return 0;
  965. }
  966. //单个动作处理
  967. void do_action(u8 *uart_receive_buf) {
  968.         u16 index,  time,i, lst_i, parse_ok;
  969.         int bias;
  970.         float pwm;
  971.         float aim_temp;
  972.         zx_uart_send_str(uart_receive_buf);
  973.         zx_uart_send_str("\r\n");
  974.         
  975.         if(uart_receive_buf[0] == '#' && uart_receive_buf[4] == 'P' && uart_receive_buf[5] == 'S' && uart_receive_buf[6] == 'C' && uart_receive_buf[7] == 'K' && uart_receive_buf[12] == '!') {
  976.                 index = (uart_receive_buf[1] - '0')*100 + (uart_receive_buf[2] - '0')*10 + (uart_receive_buf[3] - '0');
  977.                 bias = (uart_receive_buf[9] - '0')*100 + (uart_receive_buf[10] - '0')*10 + (uart_receive_buf[11] - '0');
  978.                 if((bias >= -500) && (bias <= 500) && (index < DJ_NUM)) {
  979.                         if(uart_receive_buf[8] == '+') {
  980.                         } else if(uart_receive_buf[8] == '-') {
  981.                                 bias = -bias;
  982.                         }
  983.                         aim_temp = duoji_doing[index].cur + 0.043198 - eeprom_info.dj_bias_pwm[index] + bias;
  984.                         eeprom_info.dj_bias_pwm[index] = bias;                        
  985.                         if(aim_temp > 2497){
  986.                                 aim_temp = 2497;
  987.                         } else if(aim_temp < 500) {
  988.                                 aim_temp = 500;
  989.                         }
  990.                         
  991.                         duoji_doing[index].aim = aim_temp;
  992.                         duoji_doing[index].cur = aim_temp;
  993.                         duoji_doing[index].inc = 0;
  994.                         bias_systick_ms_bak = millis();
  995.                         djBiasSaveFlag = 1;
  996.                 }
  997.                 return;
  998.         }
  999.         
  1000.                
  1001.         i = 0;parse_ok = 0;
  1002.         while(uart_receive_buf[i]) {
  1003.                 if(uart_receive_buf[i] == '#') {
  1004.                         lst_i = i;
  1005.                         index = 0;i++;
  1006.                         while(uart_receive_buf[i] && (uart_receive_buf[i] != 'P')) {
  1007.                                 index = index*10 + uart_receive_buf[i]-'0';i++;
  1008. ……………………

  1010. …………限于本文篇幅 余下代码请从51黑下载附件…………
复制代码

所有资料51hei提供下载:
01 循迹模式.rar (357.14 KB, 下载次数: 66)


回复

使用道具 举报

ID:1 发表于 2018-8-29 03:19 | 显示全部楼层
补全原理图与详细说明资料后即可获得100+黑币
回复

使用道具 举报

ID:704748 发表于 2020-3-8 20:02 | 显示全部楼层
请问楼主文中的eeprom_info.pre_cmd这个成员是什么意思呢？
回复

使用道具 举报

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

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

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