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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 电子技术分类讨论区 › 资料共享 › 电脑鼠迷宫程序
返回列表 发新帖
查看: 1283|回复: 0
收起左侧

电脑鼠迷宫程序

[复制链接]
ID:714730 发表于 2020-10-25 00:06 | 显示全部楼层 |阅读模式
冠军完美版 能顺利运行
51hei.png

单片机源程序如下:
  1. #include "..\config.h"
  2. #include "Mouse_Drive.h"

  4. /*********************************************************************************************************
  5. *当小车进入时，以小车的前方为north,右方为east,下方为south,左方为west.作为迷宫的绝对方向
  6. *对应已经定义的绝对方向:     up,right,down,left.
  7. **********************************************************************************************************/
  8. #define NORTH      1
  9. #define EAST       2
  10. #define SOUTH      4
  11. #define WEST       8
  12. #define PASSED     16
  13. #define MARK       32
  14. #define SJUDGE     64
  15. #define SPECIAL    128

  17. //#define SEARCHSPEED        100                                //95,100

  19. /*********************************************************************************************************
  20.   定义全局变量
  21. *********************************************************************************************************/
  22. INT8U             GucMouseDir                     = UP;                 /*  保存电脑鼠当前方向          */
  23. MAZECOOR          GmcMouse                        = {0,0};              /*  保存电脑鼠当前位置坐标      */
  24. INT8U             GucMapBlock[MAZETYPE][MAZETYPE] = {0};                /*  GucMapBlock[x][y]           */

  26. static MOTOR   GmRight  = {MOTOR_STOP, MOTOR_GO_AHEAD, 0, 0, 0};        /*  定义并初始化右电机状态      */
  27. static MOTOR   GmLeft   = {MOTOR_STOP, MOTOR_GO_AHEAD, 0, 0, 0};        /*  定义并初始化左电机状态      */
  28.                                                                         
  29. static volatile INT8U GucMouseState = STOP;                             /*  保存电脑鼠当前运行状态      */
  30. static INT32U GulAccelTable[300]    = {0}; //300                             /*  电机加减速各阶段定时器值    */
  31. static INT32S GlMaxSpeed            = SEARCHSPEED;                               /*  保存允许运行的最大速度      */

  33. static volatile INT8U GucDistance[5]    = {0};                          /*  记录传感器状态              */

  35. INT8U  GWallMap[MAXSIZE];
  36. INT8U  GDistanceMap[MAXSIZE]={255};
  37. INT8U GStartChange =0;        
  38. static INT8U GLCoorflag =0;         /* 允许在转弯时，是否检测左边  */
  39. static INT8U GRCoorflag =0;         /* 允许在转弯时，是否检测右边  */
  40. INT8U BlankNum =0;

  42. INT8U GCurPosition  =LEFT_START_NUM;  
  43. static INT8U  GSetflag =0;
  44. static INT8U  zb=0,zs=0,zg=0;

  46. INT8U GEndNum =LEFT_END_NUM ;           /*终点坐标*/
  47. INT8U GStartNum=LEFT_START_NUM ;

  49. static INT8U  GConformflag =0;     /*  终点坐标确认标志  */

  51. INT8U Gmazetype = 8;

  53. static INT8U GoLong = 0;

  55. INT8U straigtOneflag = 0;
  56. INT8U PreTurnRflag = 0;
  57. INT8U PreTurnLflag = 0;
  58. INT8U PreTurnBflag = 0;
  59. INT8U TurnRLflag = 0;

  61. INT8U  GCountInfo[100]={0x87,0x81,0x41,0x81,0x41,0x81,0x41,0x81,0x41,0x81,
  62.                        0x82,0x41,0x81,0x84,0,0x41,0x81,0x41,0x83,0x81,0x02,0};

  64. INT8U turnback_first_step=0;
  65. INT8U turnback_secend_step=0;
  66. INT8U  first_step=0;
  67. INT8U Spurt_num_count =1;

  69. INT8U  left_flag=0;
  70. INT8U  right_flag=0;

  72. INT8U Lturnflag =0;
  73. INT8U Rturnflag =0;
  74. INT8U spurtflag=0;


  77. void SeveralStep(INT8U step);
  78. void updateCPostion(void);





  84. /*********************************************************************************************************
  85. ** Function name:       myDelay
  86. ** Descriptions:        软件延时
  87. ** input parameters:    延时时间，单位为us
  88. ** output parameters:   无
  89. ** Returned value:      无
  90. *********************************************************************************************************/
  91. void delayMs(INT32U ulTime)
  92. {
  93.     INT32U i;
  94.     while (ulTime--) {
  95.       for (i = 0; i < (FCCLK / 1000 / 3); i++);
  96.     }
  97. }
  98. /*********************************************************************************************************
  99. ** Function name:       lftMtCtrl
  100. ** Descriptions:        左步进电机驱动时序
  101. ** input parameters:    GmLeft.cDir :电机运行方向
  102. ** output parameters:   无
  103. ** Returned value:      无
  104. *********************************************************************************************************/
  105. void  lftMtCtrl (void)
  106. {
  107.     static INT8U ucRunStep = 0;                                         /*  保存电机当前位置            */
  108.    
  109.     switch (GmLeft.cDir) {
  110.     case MOTOR_GO_AHEAD:                                                /*  向前步进                    */
  111.         if (++ucRunStep >= 8) {
  112.             ucRunStep = 0;
  113.         }
  114.         break;
  115.     case MOTOR_GO_BACK:                                                 /*  向后步进                    */
  116.         if (--ucRunStep >= 8) {                                         /*  溢出                        */
  117.             ucRunStep = 7;
  118.         }
  119.         break;
  120.     case MOTORPAUSE:
  121.         break;
  122.     default:
  123.         break;
  124.     }
  125.    
  126.     switch (ucRunStep) {                                                /*  执行步进电机时序            */
  127.     case 0:
  128.         MT_LFT_STEP1_SET();
  129.         break;
  130.     case 1:
  131.         MT_LFT_STEP2_SET();
  132.         break;
  133.     case 2:
  134.         MT_LFT_STEP3_SET();
  135.         break;
  136.     case 3:
  137.         MT_LFT_STEP4_SET();
  138.         break;
  139.     case 4:
  140.         MT_LFT_STEP5_SET();
  141.         break;
  142.     case 5:
  143.         MT_LFT_STEP6_SET();
  144.         break;
  145.     case 6:
  146.         MT_LFT_STEP7_SET();
  147.         break;
  148.     case 7:
  149.         MT_LFT_STEP8_SET();
  150.         break;
  151.     default:
  152.         break;
  153.     }
  154. }


  157. /*********************************************************************************************************
  158. ** Function name:       rgtMtCtrl
  159. ** Descriptions:        右步进电机驱动时序
  160. ** input parameters:    无
  161. ** output parameters:   无
  162. ** Returned value:      无
  163. *********************************************************************************************************/
  164. void  rgtMtCtrl (void)
  165. {
  166.     static INT8U ucRunStep = 0;                                         /*  保存电机当前位置            */
  167.    
  168.     switch (GmRight.cDir) {
  169.     case MOTOR_GO_AHEAD:                                                /*  向前步进                    */
  170.         if (--ucRunStep >= 8) {                                         /*  溢出                        */
  171.             ucRunStep = 7;
  172.         }
  173.         break;
  174.     case MOTOR_GO_BACK:                                                 /*  向后步进                    */
  175.         if (++ucRunStep >= 8) {
  176.             ucRunStep = 0;
  177.         }
  178.         break;
  179.         case MOTORPAUSE:
  180.         break;
  181.     default:
  182.         break;
  183.     }
  184.    
  185.     switch (ucRunStep) {                                                /*  执行步进电机时序            */
  186.     case 0:
  187.         MT_RGT_STEP1_SET();
  188.         break;
  189.     case 1:
  190.         MT_RGT_STEP2_SET();
  191.         break;
  192.     case 2:
  193.         MT_RGT_STEP3_SET();
  194.         break;
  195.     case 3:
  196.         MT_RGT_STEP4_SET();
  197.         break;
  198.     case 4:
  199.         MT_RGT_STEP5_SET();
  200.         break;
  201.     case 5:
  202.         MT_RGT_STEP6_SET();
  203.         break;
  204.     case 6:
  205.         MT_RGT_STEP7_SET();
  206.         break;
  207.     case 7:
  208.         MT_RGT_STEP8_SET();
  209.         break;
  210.     default:
  211.         break;
  212.     }
  213. }


  216. /*********************************************************************************************************
  217. ** Function name:       lftMtSpeedCtrl
  218. ** Descriptions:        左电机速度调节
  219. ** input parameters:    无
  220. ** output parameters:   无
  221. ** Returned value:      无
  222. *********************************************************************************************************/
  223. void lftMtSpeedCtrl (void)
  224. {
  225.     INT32S lDownPusle;
  226.    
  227.     lDownPusle = GmLeft.ulPulse - GmLeft.ulPulseCtr;                    /*  统计电机还剩余的步数        */
  228.     if (lDownPusle <= GmLeft.lSpeed) {
  229.         GmLeft.lSpeed--;
  230.     } else {                                                            /*  非减速区间，则加速到最大值  */
  231.         if (GmLeft.lSpeed < GlMaxSpeed) {
  232.             GmLeft.lSpeed++;
  233.         }
  234.     }
  235.     if (GmLeft.lSpeed < 0) {                                            /*  设置速度下限                */
  236.         GmLeft.lSpeed = 0;
  237.     }
  238.    
  239.     TIMER0_LOAD_SET(GulAccelTable[GmLeft.lSpeed]);                     /*  设置定时时间                 */
  240. }

  242. /*********************************************************************************************************
  243. ** Function name:       rgtMtSpeedCtrl
  244. ** Descriptions:        右电机速度调节
  245. ** input parameters:    无
  246. ** output parameters:   无
  247. ** Returned value:      无
  248. *********************************************************************************************************/
  249. void rgtMtSpeedCtrl (void)
  250. {
  251.     INT32S lDownPusle;
  252.    
  253.     lDownPusle = GmRight.ulPulse - GmRight.ulPulseCtr;                  /*  统计电机还剩余的步数        */
  254.     if (lDownPusle <= GmRight.lSpeed) {
  255.         GmRight.lSpeed--;
  256.     } else {                                                            /*  非减速区间，则加速到最大值  */
  257.         if (GmRight.lSpeed < GlMaxSpeed) {
  258.             GmRight.lSpeed++;
  259.         }/* else {
  260.             GmRight.lSpeed--;
  261.         }*/
  262.     }
  263.     if (GmRight.lSpeed < 0) {                                           /*  设置速度下限                */
  264.         GmRight.lSpeed = 0;
  265.     }

  267.     TIMER1_LOAD_SET(GulAccelTable[GmRight.lSpeed]);                     /*  设置定时时间                */

  269. }
  270. /*********************************************************************************************************
  271. ** Function name:       __speedContrR
  272. ** Descriptions:        右电机速度调节
  273. ** input parameters:    无
  274. ** output parameters:   无
  275. ** Returned value:      无
  276. *********************************************************************************************************/
  277. void __speedContrR_C (void)
  278. {
  279.     INT32S iDPusle;
  280.     if(Lturnflag ||Rturnflag );
  281.      //   GmRight.iSpeed = 60;
  282.     else
  283.     {
  284.       iDPusle =  GmRight.ulPulse+30 -  GmRight.ulPulseCtr;                 /*  统计电机还剩余的步数        */
  285.       if (iDPusle <=  GmRight.lSpeed) {
  286.            GmRight.lSpeed--;
  287.       } else {                                                            /*  非减速区间，则加速到最大值  */
  288.           if ( GmRight.lSpeed <  GlMaxSpeed)
  289.           {
  290.                GmRight.lSpeed++;
  291.           }
  292.           else
  293.           {
  294.                GmRight.lSpeed--;
  295.           }       
  296.       }
  297.     }
  298.     if (  GmRight.lSpeed < 0) {                                         /*  设置速度下限                */
  299.           GmRight.lSpeed = 0;
  300.     }
  301.     //__GmRight.iSpeed = 50;////////////////////////////////调试添加/////////////////////
  302.     TIMER1_LOAD_SET(GulAccelTable[GmRight.lSpeed]);
  303. }
  304. /*********************************************************************************************************
  305. ** Function name:       __speedContrL
  306. ** Descriptions:        左电机速度调节
  307. ** input parameters:    无
  308. ** output parameters:   无
  309. ** Returned value:      无
  310. *********************************************************************************************************/
  311. void __speedContrL_C (void)
  312. {
  313.     INT32S iDPusle;
  314.     if(Lturnflag ||Rturnflag );           //??????
  315.     else
  316.     {
  317.       iDPusle =  GmLeft.ulPulse +30 -  GmLeft.ulPulseCtr;                   /*  统计电机还剩余的步数        */
  318.       if (iDPusle <=  GmLeft.lSpeed) {
  319.            GmLeft.lSpeed--;
  320.       } else {                                                            /*  非减速区间，则加速到最大值  */
  321.           if (  GmLeft.lSpeed < GlMaxSpeed) {
  322.                 GmLeft.lSpeed++;
  323.           }
  324.       }
  325.     }
  326.     if (  GmLeft.lSpeed < 0) {                                          /*  设置速度下限                */
  327.           GmLeft.lSpeed = 0;
  328.     }
  329.    
  330.     // GmLeft.iSpeed = 50;////////////////////////////////调试添加/////////////////////
  331.    TIMER0_LOAD_SET(GulAccelTable[GmLeft.lSpeed]); /*  设置定时时间                */
  332. }
  333. /*********************************************************************************************************
  334. ** Function name:       timer0Isr
  335. ** Descriptions:        Timer0中断服务函数
  336. ** input parameters:    GmLeft.cState :驱动步进电机的时序状态
  337. **                      GmLeft.cDir   :步进电机运动的方向
  338. ** output parameters:   无
  339. ** Returned value:      无
  340. *********************************************************************************************************/
  341. void timer0Isr(void)
  342. {
  343.     static INT8S ucCnt1 = 0, ucCnt2 = 0;                                /*  修正姿态计数变量            */
  344.     TIMER0_INT_CLR();                                                   /*  清除中断标志                */

  346.     switch (GmLeft.cState) {        
  347.     case MOTOR_STOP:                                                    /*  停止，同时清零速度和脉冲值  */
  348.         GmLeft.lSpeed     = 0;
  349.         GmLeft.ulPulse    = 0;
  350.         GmLeft.ulPulseCtr = 0;
  351.         break;        
  352.     case WAITONE_STEP:                                                  /*  暂停一步                    */
  353.         GmLeft.cState     = MOTOR_RUN;
  354.         break;
  355.     case MOTOR_RUN:                                                     /*  电机运行                    */
  356.         if (GucMouseState == GO_AHEAD) {                                /*  根据传感器状态微调电机位置  */
  357.             if (GucDistance[__FRONTR] &&                                 /*  前右方有挡板                */\
  358.                (GucDistance[__FRONTL]==0)) {                              /*  前左方无挡板                */
  359.                 if (ucCnt1 == 1) {
  360.                     GmLeft.cState = WAITONE_STEP;                       /*  使下一步暂停                */
  361.                 }
  362.                 if (++ucCnt1 > 3) {                                      // 3步暂停一步               
  363.                     ucCnt1 = 0;
  364.                 }
  365.                                
  366.                                
  367.                                
  368.             } else {
  369.                 ucCnt1 = 0;
  370.             }
  371.             if ((GucDistance[__LEFT] == 1) &&                             /*  左远方有挡板               */\
  372.                (GucDistance[__RIGHT] == 0)) {                             /*  右方无挡板                  */
  373.                 if(ucCnt2 == 3) {
  374.                     GmLeft.cState = WAITONE_STEP;                       /*  使下一步暂停                */
  375.                 }
  376.             if (++ucCnt2 > 6) {                                  // 6步暂停一步                 
  377.                     ucCnt2 = 0;
  378.                 }
  379.                                

  381.                                
  382.                                
  383.             } else {
  384.                 ucCnt2  = 0;
  385.             }
  386.         }
  387.         lftMtCtrl();                                                    /*  电机驱动程序                */
  388.         break;
  389.     default:
  390.         break;
  391.     }
  392.     /*
  393.      *  是否完成任务判断
  394.      */
  395.     if (GmLeft.cState != MOTOR_STOP) {
  396.         GmLeft.ulPulseCtr++;                                            /*  运行脉冲计数                */
  397.         if(spurtflag)
  398.            __speedContrL_C();                                                    /*  电机驱动程序                */
  399.                 else
  400.                         lftMtSpeedCtrl();                                               /*  速度调节                    */                                              /*  速度调节                    */
  401.         if (GmLeft.ulPulseCtr >= GmLeft.ulPulse) {
  402.             GmLeft.cState      = MOTOR_STOP;
  403.             GmLeft.ulPulseCtr  = 0;
  404.             GmLeft.ulPulse     = 0;
  405.             GmLeft.lSpeed      = 0;
  406.         }
  407.     }
  408. }


  411. /*********************************************************************************************************
  412. ** Function name:       timer1Isr
  413. ** Descriptions:        Timer1中断服务函数
  414. ** input parameters:    无
  415. ** output parameters:   无
  416. ** Returned value:      无
  417. *********************************************************************************************************/
  418. void timer1Isr(void)
  419. {
  420.     static INT8S ucCnt1 = 0, ucCnt2 = 0;                                /*  修正姿态计数变量            */
  421.     TIMER1_INT_CLR();                                                   /*  清除中断标志                */
  422.    
  423.     switch (GmRight.cState) {
  424.     case MOTOR_STOP:                                                     /*  停止，同时清零速度和脉冲值  */
  425.         GmRight.lSpeed     = 0;
  426.         GmRight.ulPulse    = 0;
  427.         GmRight.ulPulseCtr = 0;
  428.         break;

  430.     case WAITONE_STEP:                                                   /*  暂停一步                    */
  431.         GmRight.cState     = MOTOR_RUN;
  432.         break;
  433.     case MOTOR_RUN:                                                     /*  电机运行                    */
  434.         if (GucMouseState == GO_AHEAD) {                                /*  根据传感器状态微调电机位置  */
  435.             if (GucDistance[__FRONTL] &&                                 /*  前左方有挡板                */\
  436.                (GucDistance[__FRONTR]==0)) {                              /*  前右方无挡板                */
  437.                 if (ucCnt1 == 1) {
  438.                     GmRight.cState = WAITONE_STEP;                      /*  使下一步暂停                */
  439.                 }
  440.                 if (++ucCnt1 > 3) {                                 // 3步暂停一步            
  441.                     ucCnt1 = 0;
  442.                 }

  444.             } else {
  445.                 ucCnt1 = 0;
  446.             }
  447.             if ((GucDistance[__RIGHT] == 1) &&                           /*  右远方有挡板               */\
  448.                (GucDistance[__LEFT] == 0)) {                              /*  左方无挡板                  */
  449.                 if(ucCnt2 == 3) {
  450.                     GmRight.cState = WAITONE_STEP;                      /*  使下一步暂停                */
  451.                 }
  452.                 if (++ucCnt2 > 6) {                                     //6步暂停一步              
  453.                     ucCnt2 = 0;
  454.                 }
  455.             } else {
  456.                 ucCnt2  = 0;
  457.             }
  458.         }
  459.         rgtMtCtrl();                                                    /*  推动电机转动一步            */
  460.         break;

  462.     default:
  463.         break;
  464.     }
  465.     /*
  466.      *  是否完成任务判断
  467.      */
  468.     if (GmRight.cState != MOTOR_STOP) {
  469.         GmRight.ulPulseCtr++;                                           /*  运行脉冲计数                */
  470.         if(spurtflag)
  471.             __speedContrR_C();                  /*  速度调节                    */
  472.                 else
  473.                         rgtMtSpeedCtrl();                                               /*  速度调节                    */                                              /*  速度调节                    */
  474.         if (GmRight.ulPulseCtr >= GmRight.ulPulse) {
  475.             GmRight.cState      = MOTOR_STOP;
  476.             GmRight.ulPulseCtr  = 0;
  477.             GmRight.ulPulse     = 0;
  478.             GmRight.lSpeed      = 0;
  479.         }
  480.     }
  481. }
  482. /*********************************************************************************************************
  483. ** Function name:       irSend
  484. ** Descriptions:        红外发射启动函数
  485. ** input parameters:    ucIndex: 红外发射索引号
  486. **                      ulFreq : 红外载波频率
  487. ** output parameters:   无
  488. ** Returned value:      无
  489. *********************************************************************************************************/
  490. void  irSend (INT8U ucIndex, INT32U ulFreq)
  491. {
  492.     switch (ucIndex) {
  493.     case FRONT_SIDE_PWM_INDEX:
  494.         PWM_RESET();
  495.         PWM_FRQ_SET(ulFreq);
  496.         FRONTSIDE_PWM_PULSE_SET(FPCLK / ulFreq / 2);
  497.         PWM_START();
  498.         FRONTSIDE_PWM_EN();
  499.         break;
  500.     case DIG_PWM_INDEX:
  501.         PWM_RESET();
  502.         PWM_FRQ_SET(ulFreq);
  503.         DIG_PWM_PULSE_SET(FPCLK / ulFreq / 2);
  504.         PWM_START();
  505.         DIG_PWM_EN();
  506.         break;
  507.     default:
  508.         break;
  509.     }
  510. }
  511. /*********************************************************************************************************
  512. ** Function name:       irCheck
  513. ** Descriptions:        红外线传感器检测。
  514. ** input parameters:    无
  515. ** output parameters:   无
  516. ** Returned value:      无
  517. *********************************************************************************************************/
  518. void irCheck (void)
  519. {
  520.     static INT8U ucState = 0;
  521.     static INT32U ulIRCheck;
  522.    
  523.     switch (ucState) {
  524.     case 0:
  525.         irSend(FRONT_SIDE_PWM_INDEX, 32200);                            /*  探测左右两侧近距            */
  526.         irSend(DIG_PWM_INDEX, 35000); //35000                                  /*  驱动斜角上的传感器检测      */
  527.         break;
  528.     case 1:
  529.         ulIRCheck = IR_READ();                                          /*  读取传感器状态              */
  530.         FRONTSIDE_PWM_DIS();                                            /*  禁止PWM发生器2              */
  531.         DIG_PWM_DIS();                                                  /*  禁止PWM发生器1              */
  532.         
  533.         if (ulIRCheck & IR_SIDE_LFT) {
  534.             GucDistance[__LEFT]   &= 0xfd;
  535.         } else {
  536.             GucDistance[__LEFT]   |= 0x02;
  537.         }

  539.         if (ulIRCheck & IR_DIG_LFT) {
  540.             GucDistance[__FRONTL]  = 0x00;
  541.         } else {
  542.             GucDistance[__FRONTL]  = 0x01;
  543.         }
  544.         
  545.         if (ulIRCheck & IR_DIG_RGT) {
  546.             GucDistance[__FRONTR]  = 0x00;
  547.         } else {
  548.             GucDistance[__FRONTR]  = 0x01;
  549.         }
  550.         if (ulIRCheck & IR_SIDE_RGT) {
  551.             GucDistance[__RIGHT]  &= 0xfd;
  552.         } else {
  553.             GucDistance[__RIGHT]  |= 0x02;
  554.         }
  555.         break;
  556.     case 2:
  557.         irSend(FRONT_SIDE_PWM_INDEX, 36000);                            /*  驱动检测左前右三个方向远距  */
  558.         
  559.         break;
  560.     case 3:
  561.         ulIRCheck = IR_READ();                                          /*  读取传感器状态              */
  562.         FRONTSIDE_PWM_DIS();                                            /*  禁止PWM发生器2              */
  563.         break;
  564.     case 4:
  565.         irSend(FRONT_SIDE_PWM_INDEX, 36000);                            /*  重复检测左前右三个方向远距  */
  566.         break;
  567.     case 5:
  568.         ulIRCheck &= IR_READ();                                         /*  读取传感器状态              */
  569.         FRONTSIDE_PWM_DIS();                                            /*  禁止PWM发生器2              */

  571.         
  572.         if (ulIRCheck & IR_SIDE_LFT) {
  573.             GucDistance[__LEFT]  &= 0xfe;
  574.         } else {
  575.             GucDistance[__LEFT]  |= 0x01;
  576.         }
  577.         if (ulIRCheck & IR_FRONT) {
  578.             GucDistance[__FRONT] &= 0xfe;
  579.         } else {
  580.             GucDistance[__FRONT] |= 0x01;
  581.         }
  582.         if (ulIRCheck & IR_SIDE_RGT) {
  583.             GucDistance[__RIGHT] &= 0xfe;
  584.         } else {
  585.             GucDistance[__RIGHT] |= 0x01;
  586.         }
  587.         break;
  588.     default:
  589.         break;
  590.     }
  591.     if (++ucState >= 6) {
  592.         ucState = 0;
  593.     }
  594. }

  596. /*********************************************************************************************************
  597. ** Function name:       mouseTurnback_C
  598. ** Descriptions:        后转
  599. ** input parameters:    无
  600. ** output parameters:   无
  601. ** Returned value:      无
  602. *********************************************************************************************************/
  603. void mouseTurnback_C(void)
  604. {
  605.     while (GmLeft.cState  != MOTOR_STOP);
  606.     while (GmRight.cState != MOTOR_STOP);
  607.     delayMs(1);

  609.     GucMouseState   = TURN_BACK;
  610.     GmRight.cDir    = MOTOR_GO_BACK;
  611.     GmRight.ulPulse = 85;//162 * 10;

  613.    
  614.     GmLeft.cDir     = MOTOR_GO_AHEAD;
  615.     GmLeft.ulPulse  = 85;//162 * 10;

  617.     GmLeft.cState   = MOTOR_RUN;
  618.     GmRight.cState  = MOTOR_RUN;
  619.    
  620.     GucMouseDir = (GucMouseDir + 2) % 4;                                /*  方向标记                    */
  621.    
  622.     while (GmRight.cState != MOTOR_STOP);
  623.     while (GmLeft.cState  != MOTOR_STOP);
  624.     delayMs(2);

  626. }
  627. /*********************************************************************************************************
  628. ** Function name:       mazeSearch
  629. ** Descriptions:        迷宫搜索，若发现分支路或者前方有挡板则退出
  630. ** input parameters:    无  
  631. ** output parameters:   无
  632. ** Returned value:      无
  633. *********************************************************************************************************/
  634. void mazeSearch(void)
  635. {
  636.     INT8S cL = 0, cR = 0;
  637.         INT32U temp1 = 0;
  638.         INT8U num = 0;
  639.         INT8U Gonum = 0;
  640.         INT8U DelayFlag = 0;
  641.        
  642.     /*
  643.      *  设定运行任务
  644.      */

  646.        
  647.     GucMouseState   = GO_AHEAD;
  648.         GlMaxSpeed = SEARCHSPEED;
  649.     GmRight.cDir  = MOTOR_GO_AHEAD;
  650.     GmLeft.cDir   = MOTOR_GO_AHEAD;
  651.         GmLeft.ulPulseCtr = 0;
  652.         GmRight.ulPulseCtr = 0;
  653.     GmRight.ulPulse = MAZETYPE * ONEBLOCK;
  654.     GmLeft.ulPulse  = MAZETYPE * ONEBLOCK;
  655.     GmRight.cState  = MOTOR_RUN;
  656.     GmLeft.cState   = MOTOR_RUN;
  657.    
  658.        
  659.         if(GLCoorflag || GRCoorflag)   /* 有转弯  */
  660.     {
  661.           GLCoorflag =0;
  662.           GRCoorflag =0;
  663.           DelayFlag  =1;
  664.       GoLong = 0;
  665.           num=20;
  666.           Gonum = 0;
  667.     }
  668.    
  669.         else { // 没有转弯  
  670.          
  671.       if(GoLong == 1){             //如果上一次跳出过MazeSearch
  672.           GoLong = 0;
  673.           Gonum = 20;
  674.           num = 0;
  675.       }
  676.       else{                        //一直在该函数内，没有跳出过，直走
  677.           num = 0;
  678.           Gonum = 0;
  679.       }                       
  680.     }

  682.     while (GmLeft.cState != MOTOR_STOP)
  683.         {
  684.                 if ((GmLeft.ulPulseCtr+num) >= (ONEBLOCK + Gonum))                          // 判断是否走完一格      
  685.                 {
  686.                         GmLeft.ulPulse    -= (ONEBLOCK + Gonum);
  687.                         GmRight.ulPulse   -= (ONEBLOCK + Gonum);
  688.                         GmLeft.ulPulse    += num;
  689.                         GmRight.ulPulse   += num;

  691.                         updateCPostion();                                  //更新当前坐标            
  692.                         wallCheck();

  694.                         GmLeft.ulPulseCtr = 0;
  695.                         GmRight.ulPulseCtr = 0;
  696.                         GmRight.ulPulse = MAZETYPE * ONEBLOCK;
  697.                         GmLeft.ulPulse  = MAZETYPE * ONEBLOCK;
  698.                         num =0;                                                    // num 清零
  699.                         Gonum = 0;
  700.                 }
  701.                
  702.                                

  704.                
  705.         if (GucDistance[__FRONT]) {                                       /*  前方有墙                    */
  706.             /*
  707.              *  设置继续前进的步数，以实现能停止在单元格中心的目的
  708.              */
  709.             GmRight.ulPulse = GmRight.ulPulseCtr + 74;//70,80,83,76
  710.             GmLeft.ulPulse  = GmLeft.ulPulseCtr  + 74;
  711.             /*
  712.              *  反复检测前方传感器的状态，以消除误判
  713.              */
  714.                         //GmLeft.cState = GmRight.cState = MOTOR_STOP;
  715.                         //delayMs(5000);
  716.                        
  717.                         //tempF = 35;
  718.                         if(PreTurnBflag == 1){
  719.                                 PreTurnBflag = 0;
  720.                                 while(GucDistance[__FRONT]) {
  721.                                         if((GmLeft.ulPulseCtr + 40) > GmLeft.ulPulse) {                        //48
  722.                                                 goto End;                                           /*  跳出循环，跳到程序结束处    */
  723.                                         }
  724.                                 }
  725.                         }
  726.                        
  727.         /*                if(PreTurnLflag || PreTurnRflag){
  728.                                 PreTurnLflag = 0;
  729.                                 PreTurnRflag = 0;
  730.                                 while (GucDistance[__FRONT]) {
  731.                                         if((GmLeft.ulPulseCtr + 35) > GmLeft.ulPulse) {                        //48
  732.                                                 goto End;                                    
  733.                                         }
  734.                                 }
  735.                                
  736.                         }*/
  737.                        
  738.             while (GucDistance[__FRONT]) {
  739.                 if ((GmLeft.ulPulseCtr + 40) > GmLeft.ulPulse) {                        //48
  740.                     goto End;                                           /*  跳出循环，跳到程序结束处    */
  741.                 }
  742.             }
  743.             /*
  744.              *  程序执行到此步表明出现误判，则重新设定电机运行任务
  745.              */            

  747.             GmRight.ulPulse = MAZETYPE * ONEBLOCK;
  748.             GmLeft.ulPulse  = MAZETYPE * ONEBLOCK;
  749.         }
  750.        
  751.                 if(DelayFlag)
  752.                 {
  753.                         DelayFlag = 0;
  754.                         temp1= GmRight.ulPulseCtr;
  755.                         while(GmRight.ulPulseCtr <= (temp1 + 24));                        //                        if(GucDistance[__LEFT] == 0)
  756.                                 cL = 1;
  757.                         if(GucDistance[__RIGHT] == 0)
  758.                                 cR = 1;
  759.                 }
  760.                
  761.         if (cL) {                                                       /*  是否允许检测左边            */
  762.             if ((GucDistance[__LEFT] & 0x01) == 0){                      /*  左边有支路                  */
  763.                 /*
  764.                  *  设置继续前进的步数，以实现能停止在单元格中心的目的
  765.                  */
  766.                 GmRight.ulPulse = GmRight.ulPulseCtr + 74;//82
  767.                 GmLeft.ulPulse  = GmLeft.ulPulseCtr  + 74;
  768.                 /*
  769.                  *  反复检测前方传感器的状态，以消除误判
  770.                  */       
  771.                                 //tempL = 37;                       
  772.                                
  773.                 while ((GucDistance[__LEFT] & 0x01) == 0) {
  774.                     if ((GmLeft.ulPulseCtr + 40) > GmLeft.ulPulse) {                //53
  775.                         GoLong = 1;
  776.                                                 goto End;                                       /*  跳出循环，跳到程序结束处    */
  777.                     }
  778.                 }
  779.                 /*
  780.                  *  程序执行到此步表明出现误判，则重新设定电机运行任务
  781.                  */
  782.                 GmRight.ulPulse = MAZETYPE * ONEBLOCK;
  783.                 GmLeft.ulPulse  = MAZETYPE * ONEBLOCK;
  784.             }
  785.         } else {                                                        /*  左边有墙时开始允许检测左边  */
  786.             if ( GucDistance[__LEFT] & 0x01) {
  787.                 cL = 1;
  788.             }
  789.         }
  790.                
  791.                
  792.         if (cR) {                                                       /*  是否允许检测右边            */
  793.             if ((GucDistance[__RIGHT] & 0x01) == 0) {                     /*  右边有支路                  */
  794.                 /*
  795.                  *  设置继续前进的步数，以实现能停止在单元格中心的目的
  796.                  */
  797.                 GmRight.ulPulse = GmRight.ulPulseCtr + 74;
  798.                 GmLeft.ulPulse  = GmLeft.ulPulseCtr  + 74;
  799.                 /*
  800.                  *  反复检测前方传感器的状态，以消除误判
  801.                  */
  802.                                 //tempR = 37;
  803.                        
  804.                 while ((GucDistance[__RIGHT] & 0x01) == 0) {
  805.                     if ((GmLeft.ulPulseCtr + 40) > GmLeft.ulPulse) {                        //53
  806.                         GoLong = 1;
  807.                                                 goto End;                                       /*  跳出循环，跳到程序结束处    */
  808.                     }
  809.                 }
  810.                 /*
  811.                  *  程序执行到此步表明出现误判，则重新设定电机运行任务
  812.                  */
  813.                 GmRight.ulPulse = MAZETYPE * ONEBLOCK;
  814.                 GmLeft.ulPulse  = MAZETYPE * ONEBLOCK;
  815.             }
  816.         } else {
  817.             if ( GucDistance[__RIGHT] & 0x01) {                           /*  右边有墙时开始允许检测右边  */
  818.                 cR = 1;
  819.             }
  820.         }
  821.     }
  822. End:
  823.         PreTurnBflag = 0;
  824.         PreTurnLflag = 0;
  825.         PreTurnRflag = 0;
  826.         updateCPostion();
  827.         wallCheck();       
  828. }

  830. /*********************************************************************************************************
  831. ** Function name:       mouseTurnright
  832. ** Descriptions:        右转
  833. ** input parameters:    无
  834. ** output parameters:   无
  835. ** Returned value:      无
  836. *********************************************************************************************************/
  837. void mouseTurnright(void)
  838. {

  840.        
  841.     GRCoorflag = 1;                                                /*右转的标志*/
  842.         PreTurnBflag = 0;
  843.         PreTurnRflag = 1;
  844.         PreTurnLflag = 0;
  845.     GucMouseState  = TURN_RIGHT;                                 

  847.     GmLeft.lSpeed      = SEARCHSPEED;
  848.   
  849.     GmRight.cDir    = MOTORPAUSE;                                /*抱死状态*/
  850.    
  851.       
  852.     GmLeft.ulPulse = MAZETYPE * ONEBLOCK;
  853.     GmRight.ulPulse = MAZETYPE * ONEBLOCK;
  854.     GmLeft.ulPulseCtr = 0;
  855.     GmRight.ulPulseCtr  = 0;

  857.        
  858.     while(GmLeft.ulPulseCtr <= 78);                //88
  859.        

  861.     GmRight.cDir    = MOTOR_GO_AHEAD;  
  862.          // GmLeft.lSpeed = GmRight.lSpeed = 30;
  863.     GucMouseDir     = (GucMouseDir + 1) % 4;  /*  方向标记  */  
  864.    
  865.    

  867.     /*
  868.      *  设定运行任务
  869.      */
  870.     GucMouseState   = GO_AHEAD;
  871.     GlMaxSpeed      =  SEARCHSPEED/4;

  873.     GmRight.cDir    = MOTOR_GO_AHEAD;
  874.     GmLeft.cDir     = MOTOR_GO_AHEAD;
  875.     GmRight.ulPulseCtr  = 0;
  876.     GmLeft.ulPulseCtr   = 0;
  877.    
  878.     GmLeft.lSpeed = SEARCHSPEED/4 - 3;//40
  879.     GmRight.lSpeed = SEARCHSPEED/4 - 3;
  880.     GmLeft.ulPulse   =   ONEBLOCK;
  881.     GmRight.ulPulse  =   ONEBLOCK;
  882.     GmLeft.cState  = MOTOR_RUN;
  883.     GmRight.cState   = MOTOR_RUN;

  885.    //GmLeft.lSpeed =  GmRight.lSpeed;   

  887. }


  890. /*********************************************************************************************************
  891. ** Function name:       mouseTurnleft
  892. ** Descriptions:        左转
  893. ** input parameters:    无
  894. ** output parameters:   无
  895. ** Returned value:      无
  896. *********************************************************************************************************/
  897. void mouseTurnleft(void)
  898. {       
  899.     GLCoorflag  = 1;
  900.         PreTurnBflag = 0;
  901.         PreTurnRflag = 0;
  902.         PreTurnLflag = 1;
  903.        
  904.         GucMouseState    = TURN_LEFT;
  905.    
  906.         GmRight.lSpeed      = SEARCHSPEED;

  908.     GmLeft.cDir     = MOTORPAUSE;
  909.    
  910.       
  911.     GmRight.ulPulse =  MAZETYPE * ONEBLOCK;
  912.     GmLeft.ulPulse = MAZETYPE * ONEBLOCK;
  913.     GmRight.ulPulseCtr  = 0;
  914.     GmLeft.ulPulseCtr   = 0;
  915.    
  916.        
  917.     while(GmRight.ulPulseCtr<=78);                //88


  920.     GmLeft.cDir     = MOTOR_GO_AHEAD;
  921.         //GmLeft.lSpeed = GmRight.lSpeed = 30;
  922.         GucMouseDir     = (GucMouseDir + 3) % 4;  /*  方向标记   */  

  924.     /*
  925.      *  设定运行任务
  926.      */
  927.     GucMouseState   = GO_AHEAD;
  928.     GlMaxSpeed      =SEARCHSPEED / 4;
  929.     GmRight.cDir    = MOTOR_GO_AHEAD;
  930.     GmLeft.cDir     = MOTOR_GO_AHEAD;
  931.     GmLeft.ulPulseCtr  = 0;
  932.     GmRight.ulPulseCtr = 0;
  933.    
  934.     GmLeft.lSpeed = SEARCHSPEED/4-3;//40
  935.     GmRight.lSpeed =SEARCHSPEED/4-3;
  936.    
  937.     GmLeft.ulPulse   =  ONEBLOCK;
  938.     GmRight.ulPulse  =  ONEBLOCK;
  939.     GmRight.cState  = MOTOR_RUN;
  940.     GmLeft.cState   = MOTOR_RUN;
  941.    // GmRight.lSpeed = GmLeft.lSpeed;

  943. }


  946. /*********************************************************************************************************
  947. ** Function name:       mouseTurnback
  948. ** Descriptions:        后转
  949. ** input parameters:    无
  950. ** output parameters:   无
  951. ** Returned value:      无
  952. *********************************************************************************************************/
  953. void mouseTurnback(void)
  954. {
  955.         if((GucMouseTask == BACK) && (hy == 1)){
  956.                 //GmLeft.ulPulse = 40;
  957.                 //GmRight.ulPulse =40;
  958.                 GmLeft.ulPulseCtr = 0;
  959.                 GmRight.ulPulseCtr = 0;
  960.                 GmLeft.cState = MOTOR_RUN;
  961.                 GmRight.cState = MOTOR_RUN;
  962.                 GmLeft.cDir = MOTOR_GO_AHEAD;
  963.                 GmRight.cDir = MOTOR_GO_AHEAD;
  964.         }
  965.     /*
  966.      *  等待停止
  967.      */
  968.     while (GmLeft.cState  != MOTOR_STOP);
  969.     while (GmRight.cState != MOTOR_STOP);
  970.     delayMs(50);
  971.        
  972.     GucMouseState   = TURN_BACK;
  973.     /*
  974.      *  开始后转
  975.      */
  976.     GmRight.cDir    = MOTOR_GO_BACK;
  977.     GmRight.ulPulse = 85;//90
  978.    
  979.     GmLeft.cDir     = MOTOR_GO_AHEAD;
  980.     GmLeft.ulPulse  = 85;
  981.        
  982.         PreTurnBflag = 1;
  983.         PreTurnRflag = 0;
  984.         PreTurnLflag = 0;
  985.    
  986.     GmLeft.cState   = MOTOR_RUN;
  987.     GmRight.cState  = MOTOR_RUN;
  988.        
  989.         GucMouseDir = (GucMouseDir + 2) % 4;
  990.     /*
  991.      *  等待后转完成
  992.      */
  993.     while (GmLeft.cState  != MOTOR_STOP);
  994.     while (GmRight.cState != MOTOR_STOP);
  995.         delayMs(50);
  996.        
  997. /*        if(hy == 1){
  998.                 GmLeft.ulPulse = 20;
  999.                 GmRight.ulPulse = 20;
  1000.                 GmLeft.cState = MOTOR_RUN;
  1001.                 GmRight.cState = MOTOR_RUN;
  1002.                 GmLeft.cDir = MOTOR_GO_AHEAD;
  1003.                 GmRight.cDir = MOTOR_GO_AHEAD;
  1004.         }
  1005. */
  1006.        
  1007. }
  1008. /*********************************************************************************************************
  1009. ** Function name:       mouseTurnright_C
  1010. ** Descriptions:        右转
  1011. ** input parameters:    无
  1012. ** output parameters:   无
  1013. ** Returned value:      无
  1014. *********************************************************************************************************/
  1015. void mouseTurnright_C(void)
  1016. {
  1017.     INT8U tempnum=0;
  1018.         Rturnflag = 1;
  1019.        
  1020.         if(BlankNum!=0)
  1021.         {
  1022.                 if (BlankNum==1)
  1023.                 {
  1024.                         tempnum=125;  //125 ..//120
  1025.                 }
  1026.                 else tempnum=125;  //133
  1027.         }       
  1028.         else  tempnum=125;

  1030.     GucMouseState  = TURN_RIGHT;
  1031.         GmLeft.ulPulse  = GmLeft.ulPulseCtr  + tempnum;//133;  //140 ??
  1032.         GmLeft.lSpeed   = 80;//80;    //150
  1033.    
  1034.     GmRight.ulPulse = GmRight.ulPulseCtr + 21;//24;  //  30
  1035.     GmRight.lSpeed  = 12;//7;    //12
  1036.    
  1037.    
  1038.     GmRight.cDir    = MOTOR_GO_AHEAD;
  1039.     GmLeft.cDir     = MOTOR_GO_AHEAD;
  1040.    
  1041.     GmRight.cState  = MOTOR_RUN;
  1042.     GmLeft.cState   = MOTOR_RUN;
  1043.    
  1044.     //while (GmRight.cState  != __MOTORSTOP);
  1045.     while ( GmLeft.ulPulseCtr<=(GmLeft.ulPulse-30));  // 30
  1046.    
  1047.    
  1048.       GucMouseDir     = (GucMouseDir + 1) % 4;  /*  方向标记  */
  1049.     //while (GmLeft.cState  != __MOTORSTOP);
  1050.       GmRight.ulPulse = MAZETYPE * ONEBLOCK;
  1051.       GmLeft.ulPulse  = MAZETYPE * ONEBLOCK;  
  1052.    
  1053.    GmRight.ulPulseCtr = 0;
  1054.    GmLeft.ulPulseCtr  = 0;  
  1055.    GmRight.ulPulse = GmRight.ulPulseCtr + 10;

  1057.     GmRight.cState  = MOTOR_RUN;
  1058.     GmLeft.cState   = MOTOR_RUN;
  1059.     GmLeft.lSpeed = GmRight.lSpeed +10 ;
  1060.    

  1062.      Rturnflag = 0;
  1063.      

  1065.    
  1066.    if(turnback_secend_step==1)//转180度的第二个弯
  1067.        SeveralStep(12);
  1068.    else{
  1069.      if(turnback_first_step==1)   //转180度的第一个弯
  1070.        SeveralStep(55);//60
  1071.      else
  1072.        SeveralStep(34);
  1073.    }
  1074. }

  1076. /*********************************************************************************************************
  1077. ** Function name:      SeveralStep
  1078. ** Descriptions:      
  1079. ** input parameters:    执行几步
  1080. ** output parameters:   无
  1081. ** Returned value:      无
  1082. *********************************************************************************************************/
  1083. void SeveralStep(INT8U step)
  1084. {
  1085.       GucMouseState   = GO_AHEAD;
  1086.     GlMaxSpeed      =  53;
  1087.     GmRight.cDir    = MOTOR_GO_AHEAD;
  1088.     GmLeft.cDir     = MOTOR_GO_AHEAD;
  1089.    
  1090.    GmRight.ulPulseCtr = 0;
  1091.    GmLeft.ulPulseCtr  = 0;  
  1092.     GmRight.ulPulse = step+10;//__GmRight.uiPulse + cNBlock * ONEBLOCK - 6;
  1093.     GmLeft.ulPulse  = step+10;//__GmLeft.uiPulse  + cNBlock * ONEBLOCK - 6;
  1094.     GmRight.cState  = MOTOR_RUN;
  1095.     GmLeft.cState   = MOTOR_RUN;
  1096.    
  1097.    
  1098.     if((turnback_first_step==1)||(turnback_secend_step==1))
  1099.     {
  1100.       GmRight.lSpeed=40;
  1101.       GmLeft.lSpeed=40;  
  1102.     }
  1103.     else
  1104.     {
  1105.       GmRight.lSpeed=50;
  1106.       GmLeft.lSpeed=50;      
  1107.     }
  1108.     if (GucDistance[__FRONT]) {                                   /*  前方有墙，则跳出程序        */
  1109.           if((GmRight.ulPulse - GmRight.ulPulseCtr)<=10)
  1110.           {
  1111.             GmRight.ulPulse = GmRight.ulPulseCtr + 8;
  1112.             GmLeft.ulPulse  = GmLeft.ulPulseCtr  + 8;
  1113.           }
  1114.           else
  1115.           {
  1116.             GmRight.ulPulse = GmRight.ulPulseCtr + 18;
  1117.             GmLeft.ulPulse  = GmLeft.ulPulseCtr  + 18;
  1118.           }
  1119.           while (GucDistance[ __FRONT]) {
  1120.                 if ((GmLeft.ulPulseCtr + 10) > GmLeft.ulPulse) {
  1121.                     goto SeveralEnd;
  1122.                 }
  1123.                 else
  1124.                 {
  1125.                     GmRight.ulPulse = step+8;
  1126.                     GmLeft.ulPulse  = step+8;
  1127.                 }
  1128.                   
  1129.             }
  1130.         }   
  1131.    
  1132.     while(GmLeft.ulPulseCtr+10 < GmLeft.ulPulse);
  1133.     while(GmRight.ulPulseCtr+10 < GmRight.ulPulse);

  1135. SeveralEnd:;
  1136.    
  1137. }


  1140. /*********************************************************************************************************
  1141. ** Function name:       mouseTurnleft_C
  1142. ** Descriptions:        左转
  1143. ** input parameters:    无
  1144. ** output parameters:   无
  1145. ** Returned value:      无
  1146. *********************************************************************************************************/
  1147. void mouseTurnleft_C(void)
  1148. {

  1150.     INT8U tempnum=0;
  1151.         Lturnflag = 1;
  1152.        
  1153.         if(BlankNum!=0)
  1154.         {
  1155.                 if (BlankNum==1)
  1156.                 {
  1157.                         tempnum=125;   //125  ,120
  1158.                 }
  1159.                 else tempnum=125;   //133
  1160.         }       
  1161.         else  tempnum=125;   //131
  1162.    
  1163.     GucMouseState   = TURN_LEFT;
  1164.     GmRight.ulPulse  = GmRight.ulPulseCtr  + tempnum;//133;  //140
  1165.     GmRight.lSpeed   = 80;//80;//150;   
  1166.    
  1167.     GmLeft.ulPulse = GmLeft.ulPulseCtr + 21;//24;  // 30
  1168.     GmLeft.lSpeed  = 12;//7;//9;
  1169.    
  1170.    
  1171.     GmLeft.cDir    = MOTOR_GO_AHEAD;
  1172.     GmRight.cDir     = MOTOR_GO_AHEAD;
  1173.    
  1174.     GmRight.cState  = MOTOR_RUN;
  1175.     GmLeft.cState   = MOTOR_RUN;
  1176.    
  1177.     //while (GmRight.cState  != __MOTORSTOP);
  1178.     while ( GmRight.ulPulseCtr<=(GmRight.ulPulse-30));  // 30
  1179.     //while (GmLeft.cState  != __MOTORSTOP);
  1180.    
  1181.      GmRight.lSpeed  =  GmLeft.lSpeed + 10;
  1182.      

  1184.    GmRight.ulPulseCtr = 0;
  1185.    GmLeft.ulPulseCtr  = 0;  
  1186.    GmLeft.ulPulse = GmRight.ulPulseCtr + 10;

  1188.     GmRight.cState  = MOTOR_RUN;
  1189.     GmLeft.cState   = MOTOR_RUN;
  1190.     //while(keyCheck() == false);
  1191.     GucMouseDir     = (GucMouseDir + 3) % 4;  /*  方向标记                    */  
  1192.   
  1193.    GmRight.ulPulseCtr = 0;
  1194.    GmLeft.ulPulseCtr  = 0;  
  1195.    
  1196.    Lturnflag = 0;
  1197.   /*
  1198.    if(turnback_first_step==1)   //转180度的第一个弯
  1199.        SeveralStep(55);//60
  1200.     else if(turnback_secend_step==1)//转180度的第二个弯
  1201.        SeveralStep(10);

  1203.     else
  1204.        SeveralStep(30);
  1205. */
  1206.    if(turnback_secend_step==1)//转180度的第二个弯
  1207.        SeveralStep(12);
  1208.    else{
  1209.      if(turnback_first_step==1)   //转180度的第一个弯
  1210.        SeveralStep(55);//60
  1211.      else
  1212.        SeveralStep(34);
  1213.    }      
  1214. }
  1215. /*********************************************************************************************************
  1216. ** Function name:       冲刺时候用的mouseGoahead_C
  1217. ** Descriptions:        前进N格
  1218. ** input parameters:    iNblock: 前进的格数
  1219. ** output parameters:   无
  1220. ** Returned value:      无
  1221. *********************************************************************************************************/
  1222. void mouseGoahead_C (INT8S  nBlock)
  1223. {
  1224.     INT8U num=0;
  1225.     INT8U cNBlock=0,Block=0;
  1226.     INT8U coner=0;
  1227.     INT8U blacknum =0;
  1228.     INT8U first_step_Back =0;

  1230.     INT8S cL = 0, cR = 0,left_first_flag=1,right_first_flag=1;

  1232.     static INT8U step_count=0;      
  1233.    
  1234.     step_count++;
  1235.    
  1236.     if((coner==2)&&((GCountInfo[step_count]&0xc0)==0x80))//(GCountInfo[step_count]==0x81))
  1237.       turnback_first_step=1;
  1238.     if((coner==1)&&((GCountInfo[step_count]&0xc0)==0x40))//(GCountInfo[step_count]==0x41))
  1239.       turnback_first_step=1;
  1240.    
  1241.     if(first_step==1)
  1242.     {   first_step_Back =1;
  1243.             num=10;
  1244.         first_step=0;
  1245.     }
  1246.     else
  1247.         num=70;
  1248.     cNBlock=nBlock&0x0f;
  1249.     Block=cNBlock;
  1250.     coner=nBlock&0xc0;
  1251.     coner>>=6;
  1252.    
  1253.     blacknum = nBlock&0x30;
  1254.     blacknum >>=4;
  1255.    
  1256.     /*
  1257.      *  设定运行任务
  1258.      */
  1259.    
  1260.     GucMouseState   = GO_AHEAD;
  1261.     GmRight.cDir    = MOTOR_GO_AHEAD;
  1262.     GmLeft.cDir     = MOTOR_GO_AHEAD;
  1263.    
  1264.    
  1265.     if(Block>=4)
  1266.     {   
  1267.            
  1268.        if(Spurt_num_count  == 1)
  1269.           GlMaxSpeed   =  230;         //230
  1270.        if(Spurt_num_count  == 2)  
  1271.           GlMaxSpeed    =  250;        //250
  1272.     }
  1273.     if(Block==3)
  1274.     {
  1275.                 if (Spurt_num_count  == 1)
  1276.                         GlMaxSpeed    =  200;
  1277.                 if (Spurt_num_count  == 2)
  1278.                         GlMaxSpeed    =  240;
  1279.         }
  1280.     if(blacknum)
  1281.     {  if(Spurt_num_count  == 1)
  1282.          GlMaxSpeed     =  200;
  1283.        if(Spurt_num_count  == 2)
  1284.           GlMaxSpeed    =  230;
  1285.     }
  1286.     else{
  1287.    
  1288.        if(Spurt_num_count  == 1)
  1289.          GlMaxSpeed     =  MAXSPEED;
  1290.        if(Spurt_num_count  == 2)
  1291.           GlMaxSpeed    =  MAXSPEED2;
  1292.    
  1293.     }
  1294. //        GlMaxSpeed      =   MAXSPEED;  
  1295. //   GmRight.cDir    = MOTOR_GO_AHEAD;
  1296. //   GmLeft.cDir     = MOTOR_GO_AHEAD;
  1297.    GmRight.ulPulseCtr = 0;
  1298.    GmLeft.ulPulseCtr  = 0;  
  1299.     GmRight.ulPulse = cNBlock * ONEBLOCK-15 ;//GmRight.ulPulse + cNBlock * ONEBLOCK - 6;
  1300.     GmLeft.ulPulse  = cNBlock * ONEBLOCK-15 ;//GmLeft.ulPulse  + cNBlock * ONEBLOCK - 6;
  1301.     GmRight.cState  = MOTOR_RUN;
  1302.     GmLeft.cState   = MOTOR_RUN;
  1303.    
  1304.    GmLeft.lSpeed = GmRight.lSpeed;   /*********调试加***********/
  1305.     switch(coner)
  1306.     {
  1307.       case 0: left_flag=0;
  1308.               right_flag=0;
  1309.               break;
  1310.       case 1: left_flag=1;
  1311.               right_flag=0;
  1312.               break;
  1313.       case 2: left_flag=0;
  1314.              right_flag=1;
  1315.              break;
  1316.       default:
  1317.         break;
  1318.     }
  1319.    
  1320.         /*if(Block==3)
  1321.     {   
  1322.        if(Spurt_num_count  == 1)
  1323.           GlMaxSpeed    =  200;                        //200
  1324.        if(Spurt_num_count  == 2)
  1325.           GlMaxSpeed    =  240;          //240
  1326.       
  1327.     }
  1328.     if(Block>3)
  1329.     {   
  1330.            
  1331.        if(Spurt_num_count  == 1)
  1332.           GlMaxSpeed    =  250;                //250
  1333.        if(Spurt_num_count  == 2)
  1334.           GlMaxSpeed    =  280;     //280
  1335.     }*/
  1336.   
  1337.     if(cNBlock==1)
  1338.     {
  1339.       if(GucMouseTask == BACKTOSTART1  && first_step_Back == 1){
  1340.          if(GmLeft.ulPulse   <= 45 ||GmRight.ulPulse   <= 45 ){
  1341.             cR=1;
  1342.             cL=1;
  1343.             first_step_Back = 0;
  1344.          }
  1345.          else{
  1346.             cR=0;
  1347.             cL=0;
  1348.          }
  1349.        
  1350.       }
  1351.       else{
  1352.             cR=1;
  1353.             cL=1;
  1354.       }
  1355.     }
  1356.    
  1357.     if(coner==0)
  1358.     {
  1359.                 if(Block==1)
  1360.                 {
  1361.                         GmLeft.ulPulse  -= 55;  //45
  1362.                         GmRight.ulPulse -= 55;  //45
  1363.                 }
  1364.                 else
  1365.                 {
  1366.                         GmLeft.ulPulse  -= 68;//
  1367.                         GmRight.ulPulse -= 68;//60;
  1368.                 }
  1369.     }
  1370.    
  1371.     while (GmLeft.cState != MOTOR_STOP)
  1372.     {
  1373.         if(left_first_flag==1)
  1374.         {
  1375.           if ((GmLeft.ulPulseCtr+num) >= ONEBLOCK)
  1376.           {                          /*  判断是否走完一格            */
  1377.               GmLeft.ulPulse    -= ONEBLOCK;
  1378.               GmLeft.ulPulse    += num;
  1379.               GmLeft.ulPulseCtr -= ONEBLOCK;
  1380.               GmLeft.ulPulseCtr += num;
  1381.               cNBlock--;
  1382.               if(blacknum)
  1383.                      blacknum--;
  1384.               left_first_flag=0;
  1385.          }
  1386.         }
  1387.         else   if (GmLeft.ulPulseCtr >= ONEBLOCK)
  1388.           {                          /*  判断是否走完一格    */
  1389.               GmLeft.ulPulse    -= ONEBLOCK;
  1390.               GmLeft.ulPulseCtr -= ONEBLOCK;
  1391.               
  1392.               cNBlock--;
  1393.               if(blacknum)
  1394.                      blacknum--;
  1395.           }
  1396.         if(right_first_flag==1)
  1397.         {
  1398.           if ((GmRight.ulPulseCtr+num) >= ONEBLOCK) {                         /*  判断是否走完一格            */
  1399.               GmRight.ulPulse    -= ONEBLOCK;
  1400.               GmRight.ulPulse    += num;
  1401.               GmRight.ulPulseCtr -= ONEBLOCK;
  1402.               GmRight.ulPulseCtr += num;
  1403.               right_first_flag=0;
  1404.           }
  1405.         }
  1406.         else  if (GmRight.ulPulseCtr >= ONEBLOCK) {                         /*  判断是否走完一格            */
  1407.             GmRight.ulPulse    -= ONEBLOCK;
  1408.             GmRight.ulPulseCtr -= ONEBLOCK;

  1410.         }
  1411.         if (GucDistance[__FRONT]) {                                   /*  前方有墙，则跳出程序        */
  1412.             GmRight.ulPulse = GmRight.ulPulseCtr + 21;                                       
  1413.             GmLeft.ulPulse  = GmLeft.ulPulseCtr  + 21;                //30
  1414.             while (GucDistance[ __FRONT]) {
  1415.                 if ((GmLeft.ulPulseCtr + 10) > GmLeft.ulPulse) {               
  1416.                     goto End;
  1417.                 }
  1418.             }
  1419.         }
  1420.         if(Block==1)
  1421.         {   if(Spurt_num_count  == 1){
  1422.          
  1423.                         GmRight.lSpeed =  53;//70;//53;//33;
  1424.                         GmLeft.lSpeed  =  53;//70;//53;//33;
  1425.                         GlMaxSpeed     =  65;//80;//65;//40;
  1426.         }
  1427.         if(Spurt_num_count  == 2)
  1428.         {
  1429.                         GmRight.lSpeed   =  53;//60;//53;//33;
  1430.                         GmLeft.lSpeed    =  53;//60;//53;//33;
  1431.                         GlMaxSpeed       =  65;//70;//65;//40;
  1432.         }
  1433.         }
  1434.         if(Block >=2 && cNBlock<2)
  1435.         {
  1436.            if(Spurt_num_count  == 1){
  1437.          
  1438.             GmRight.lSpeed =  70;//70;//60; //70
  1439.             GmLeft.lSpeed  =  70;//70;//60;
  1440.             GlMaxSpeed     =  85;//85;//85;//70;           
  1441.            }
  1442.            if(Spurt_num_count  == 2){
  1443.                                 GmRight.lSpeed  =  80;//80;//70;//60; //70
  1444.                                 GmLeft.lSpeed   =  80;//80;//70;//60;
  1445.                                 GlMaxSpeed      =  85;//95;//85;//70;
  1446.             
  1447.            }
  1448.            
  1449.          
  1450.         }
  1451.         if (cNBlock <= 2) {
  1452.          
  1453.             if (cL&&left_flag) {                                                   /*  是否允许检测左边            */
  1454.             
  1455.                 if ((GucDistance[ __LEFT] & 0x01) == 0) {             /*  左边有支路，跳出程序        */
  1456.                     GmRight.ulPulse = GmRight.ulPulseCtr + 20;
  1457.                     GmLeft.ulPulse  = GmLeft.ulPulseCtr  + 20;
  1458.                     while ((GucDistance[ __LEFT] & 0x01) == 0) {
  1459.                         if ((GmLeft.ulPulseCtr + 8) > GmLeft.ulPulse)   //12
  1460.                                                 {                     
  1461.                             goto End;
  1462.                         }
  1463.                     }
  1464.                 }
  1465.             } else {                                                    /*  左边有墙时开始允许检测左边  */
  1466.                 if ( (GucDistance[ __LEFT] & 0x01)&&(cNBlock<2)) {
  1467.                     cL = 1;
  1468.                 }
  1469.             }
  1470.             if (cR&&right_flag) {                                                   /*  是否允许检测右边            */

  1472.                 if ((GucDistance[__RIGHT] & 0x01) == 0) {             /*  右边有支路，跳出程序        */
  1473.                     GmRight.ulPulse = GmRight.ulPulseCtr + 20;
  1474.                     GmLeft.ulPulse  = GmLeft.ulPulseCtr  + 20;
  1475.                     while ((GucDistance[ __RIGHT] & 0x01) == 0) {
  1476.                         if ((GmLeft.ulPulseCtr + 8) > GmLeft.ulPulse)   //12
  1477.                                                 {

  1479.                             goto End;
  1480.                         }
  1481.                     }
  1482.                 }
  1483.             } else {                  //修改过
  1484.                 if ( (GucDistance[__RIGHT] & 0x01)&&(cNBlock<2)) {                   /*  右边有墙时开始允许检测右边  */
  1485.                     cR = 1;
  1486.                 }
  1487.             }
  1488.         }
  1489.     }
  1490.     /*
  1491.      *  设定运行任务，让电脑鼠走到支路的中心位置
  1492.      */
  1493. End:   
  1494.   if(right_flag)
  1495.     mouseTurnright_C();
  1496.   if(left_flag)
  1497.     mouseTurnleft_C();
  1498.   left_flag=0;
  1499.   right_flag=0;
  1500.   turnback_first_step=0;
  1501.   turnback_secend_step=0;
  1502.   
  1503.   if((coner==2)&&(GCountInfo[step_count]==0x81))
  1504.       turnback_secend_step=1;   
  1505.   if((coner==1)&&(GCountInfo[step_count]==0x41))
  1506.       turnback_secend_step=1;
  1507.   
  1508.   BlankNum=(GCountInfo[step_count]&0x30)>>4;  //加的。。。计算
  1509.   
  1510. }
  1511. /*********************************************************************************************************
  1512. ** Function name:       keyCheck
  1513. ** Descriptions:        读取按键
  1514. ** input parameters:    无
  1515. ** output parameters:   无
  1516. ** Returned value:      true:  按键已按下
  1517. **                      false: 按键未按下
  1518. *********************************************************************************************************/
  1519. BOOLEAN keyCheck (void)
  1520. {
  1521.     if (KEY_PRESS()) {                                                  /*  按键按下                    */
  1522.         delayMs(10);                                                    /*  延时10ms消抖动              */
  1523.         if (KEY_PRESS()) {                                              /*  按键按下                    */
  1524.             delayMs(10);                                                /*  延时10ms消抖动              */
  1525.             while(!KEY_PRESS());                                        /*  等待按键释放                */
  1526.             return (true);
  1527.         }
  1528.     }
  1529.     return (false);
  1530. }

  1532. /*********************************************************************************************************
  1533. ** Function name:       keyCheck_C
  1534. ** Descriptions:        读取按键
  1535. ** input parameters:    无
  1536. ** output parameters:   无
  1537. ** Returned value:      true:  按键已按下
  1538. **                      false: 按键未按下
  1539. *********************************************************************************************************/
  1540. BOOLEAN keyCheck_C (void)
  1541. {
  1542.     if (ZLG7298_KEY_READ()){                                                  /*  按键按下                    */
  1543.         delayMs(10);                                                    /*  延时10ms消抖动              */
  1544.         if (ZLG7298_KEY_READ()) {                                              /*  按键按下                    */
  1545.             delayMs(10);                                                /*  延时10ms消抖动              */
  1546.             while(!ZLG7298_KEY_READ());                                        /*  等待按键释放                */
  1547.             return (true);
  1548.         }
  1549.     }
  1550.     return (false);
  1551. }

  1553. /*********************************************************************************************************
  1554. ** Function name:       sysTickIsr
  1555. ** Descriptions:        定时中断扫描。
  1556. ** input parameters:    无
  1557. ** output parameters:   无
  1558. ** Returned value:      无
  1559. *********************************************************************************************************/
  1560. void sysTickIsr(void)
  1561. {
  1562.     static INT32S lLft = 0, lRgt = 0;
  1563.    
  1564.     /*
  1565.      *  如果左电机长时间停止，则断电
  1566.      */
  1567.     if (GmLeft.cState == MOTOR_STOP) {
  1568.         lLft++;
  1569.     } else {
  1570.         lLft = 0;
  1571.     }
  1572.     if (lLft >= 500) {
  1573.         MT_LFT_OFF();
  1574.     }
  1575.     /*
  1576.      *  如果右电机长时间停止，则断电
  1577.      */
  1578.     if (GmRight.cState == MOTOR_STOP) {
  1579.         lRgt++;
  1580.     } else {
  1581.         lRgt = 0;
  1582.     }
  1583.     if (lRgt >= 500) {
  1584.         MT_RGT_OFF();
  1585.     }
  1586.     /*
  1587.      *  红外线检测
  1588.      */
  1589.     irCheck();
  1590. }


  1593. /*********************************************************************************************************
  1594. ** Function name:       __wallCheck
  1595. ** Descriptions:        根据传感器检测结果判断是否存在墙壁，并保存
  1596. ** input parameters:    无
  1597. ** output parameters:   无
  1598. ** Returned value:      无(已经调试)
  1599. ** atention:    ucMap低四位从右到左，依次对应迷宫的（前右下左)(即north=1,east=2,south=4,west=8)
  1600. *********************************************************************************************************/
  1601. void wallCheck (void)
  1602. {
  1603.     INT8U ucMap = 0;
  1604.    
  1605.     ucMap &= ~MOUSEWAY_B;                         /*    初始化为后方无Wall,有墙壁为1，无墙为0  */

  1607.     if (GucDistance[__LEFT]  & 0x01)            /*  __GucDistance[__LEFT]为1，说明左边传感器检测到有wall！(真)*/
  1608.      {         
  1609.          ucMap |=  MOUSEWAY_L;                     /*  将相对方向上的信息转化为绝对信息保存                      */
  1610.      }   
  1611.      if (GucDistance[__FRONT] & 0x01)
  1612.      {
  1613.          ucMap |=  MOUSEWAY_F;
  1614.      }
  1615.      if (GucDistance[__RIGHT] & 0x01)
  1616.      {
  1617.         ucMap |=  MOUSEWAY_R;
  1618.      }
  1619.       GWallMap[GCurPosition]  = ucMap;             /*   将墙壁信息保存    */
  1620.       
  1621.       GWallMap[GCurPosition] |= PASSED;           /*  经过的单元格标记  */
  1622.       
  1623.       if(ucMap==0x00)   /* 十字路口 */
  1624.       {
  1625.           GWallMap[GCurPosition] |= SPECIAL;   
  1626.       }
  1627.      if(ucMap)
  1628.      {
  1629.           if( ucMap & NORTH)   /*  该单元格上方有墙 ,上面一单元格下方有墙  */
  1630.           {
  1631.                   if((GCurPosition+1)%STEPNUM)    /*  上方单元格不能对north更新 */
  1632.                   {
  1633.                       GWallMap[GCurPosition + 1] |= SOUTH;
  1634.                   }   
  1635.           }
  1636.          
  1637.           if( ucMap & EAST)   /*  该单元格右方有墙 ,右面一单元格左方有墙  */
  1638.           {
  1639.                   if(GCurPosition<WALLNUM)      /*  右方单元格不能对east更新 */
  1640.                   GWallMap[GCurPosition + STEPNUM] |= WEST;   
  1641.           }
  1642.           if( ucMap & SOUTH)   /*  该单元格下方有墙 ,下面一单元格上方有墙  */
  1643.           {
  1644.                    if(GCurPosition%STEPNUM)        /*  下方单元格不能对south更新 */
  1645.                    GWallMap[GCurPosition - 1] |= NORTH;   
  1646.           }
  1647.           if( ucMap & WEST)   /*  该单元格左方有墙 ,左面一单元格右方有墙  */
  1648.           {
  1649.                   if(GCurPosition>(STEPNUM-1))          /*  左方单元格不能对West更新 */
  1650.                   GWallMap[GCurPosition -STEPNUM] |= EAST;   
  1651.           }
  1652.      }


  1655. }


  1658. /*********************************************************************************************************
  1659. ** Function name:       voltageDetect
  1660. ** Descriptions:        电压检测，检测结果在7289 EX BOARD 上显示出来
  1661. ** input parameters:    无
  1662. ** output parameters:   无
  1663. ** Returned value:      无
  1664. *********************************************************************************************************/
  1665. void volDetect (void)
  1666. {
  1667.     INT32U i;
  1668.     INT32U ulAdcData;

  1670.     ADC_SMP_ON();                                                       /* 立即转换                     */
  1671.     while (!ADC_DATA_READY_FLG());                                      /* 读取AD0STAT的通道5的Done     */

  1673.     ulAdcData = 0;                                                      /* 第一次转换结果丢弃           */
  1674.     for (i = 0; i < 8; i ++) {                                          /* 连续8次采样                  */
  1675.         ADC_SMP_ON();                                                   /* 立即转换                     */
  1676.         while (!ADC_DATA_READY_FLG());                                  /* 读取AD0STAT的通道5的Done     */
  1677.         ulAdcData += ADC_DATA_GET();

  1679.     }
  1680.     ulAdcData >>= 3;                                                    /* 外部电阻分压，相当于/8       */
  1681.     ulAdcData = ulAdcData * (3300 * 3) / ((1 << 12) - 1);               /*  计算电池电压值(mV)          */

  1683.     zlg7289Download(0,6,1,(ulAdcData / 1000));                          /*  显示电压值整数部分，单位V   */
  1684.     zlg7289Download(0,7,0,(ulAdcData % 1000 ) / 100);                   /*  显示电压值小数部分，单位V   */
  1685. }
  1686. /*********************************************************************************************************
  1687. ** Function name:       sensorInit
  1688. ** Descriptions:        传感器控制初始化
  1689. ** input parameters:    无
  1690. ** output parameters:   无
  1691. ** Returned value:      无
  1692. *********************************************************************************************************/
  1693. void  sensorInit (void)
  1694. {
  1695.     IR_PIN_MODE_IN();                                                   /* 红外检测引脚配置为输入引脚   */
  1696.    
  1697.     PWM1TCR  = 0x02;                                                    /* 复位PWM1定时器               */
  1698.     PWM1TC   = 0;                                                       /* 定时器设置为0                */
  1699.     PWM1PR   = 0;                                                       /* 时钟不分频                   */
  1700.     PWM1MCR  = 0x02;                                                    /* 设置PWMMR0匹配后复位PWMTC，  */
  1701.                                                                         /* 并产生中断标志               */
  1702.     PWM1MR0  = FPCLK / 38000;                                           /* 38KHz频率                    */
  1703.     PWM1MR1  = FPCLK / 38000 / 2;
  1704.     PWM1MR2  = FPCLK / 38000 / 2;

  1706.     PWM1PCR  &= ~((1 << 9) | (1 << 10));                                /* 禁止输出                     */
  1707.     PWM1TCR  = 0x05;                                                    /* 启动定时器                   */
  1708. }
  1709. /*********************************************************************************************************
  1710. ** Function name:       stepMotorIint
  1711. ** Descriptions:        步进电机控制初始化
  1712. ** input parameters:    无
  1713. ……………………

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

所有程序51hei提供下载:
电脑鼠迷宫程序（冠军组，完美版）.rar (488.92 KB, 下载次数: 23)
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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