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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 电子技术分类讨论区 › 资料共享 › 电脑鼠代码（可以参考，不建议使用）
返回列表 发新帖
查看: 4541|回复: 2
收起左侧

电脑鼠代码（可以参考，不建议使用）

[复制链接]
ID:419622 发表于 2018-11-2 13:20 | 显示全部楼层 |阅读模式
不建议使用，可以参考

单片机源程序如下:
  1. #include "Maze.h"

  3. /*********************************************************************************************************
  4.   全局变量定义
  5. *********************************************************************************************************/
  6. static uint8    GucXStart                           = 0;                /*  起点横坐标                  */
  7. static uint8    GucYStart                           = 0;                /*  起点纵坐标                  */

  9. static uint8    GucXGoal0                           = XDST0;            /*  终点X坐标，有两个值         */
  10. static uint8    GucXGoal1                           = XDST1;
  11. static uint8    GucYGoal0                           = YDST0;            /*  终点Y坐标，有两个值         */
  12. static uint8    GucYGoal1                           = YDST1;

  14. static uint8    GucMouseTask                        = WAIT;             /*  状态机，初始状态为等待      */

  16. static uint8    GucMapStep[MAZETYPE][MAZETYPE]      = {0xff};           /*  保存各坐标的等高值          */

  18. static MAZECOOR GmcStack[MAZETYPE * MAZETYPE]       = {0};              /* 在mapStepEdit()中作堆栈使用 */
  19. static MAZECOOR GmcCrossway[MAZETYPE * MAZETYPE]    = {0};              /* Main()中暂存未走过支路坐标() */
  20. //用户自定义变量

  22. /*********************************************************************************************************
  23. ** Function name:       Delay
  24. ** Descriptions:        延时函数
  25. ** input parameters:    uiD :延时参数，值越大，延时越久
  26. ** output parameters:   无
  27. ** Returned value:      无
  28. *********************************************************************************************************/
  29. void delay (uint32 uiD)
  30. {
  31.     for (; uiD; uiD--);
  32. }

  34. /*********************************************************************************************************
  35. ** Function name:       mapStepEdit
  36. ** Descriptions:        制作以目标点为起点的等高图
  37. ** input parameters:    uiX:    目的地横坐标
  38. **                      uiY:    目的地纵坐标
  39. ** output parameters:   GucMapStep[][]:  各坐标上的等高值
  40. ** Returned value:      无
  41. *********************************************************************************************************/
  42. void mapStepEdit (int8  cX, int8  cY)
  43. {
  44.     uint8 n         = 0;                                                /*  GmcStack[]下标              */
  45.     uint8 ucStep    = 1;                                                /*  等高值                      */
  46.     uint8 ucStat    = 0;                                                /*  统计可前进的方向数          */
  47.     uint8 i,j;
  48.    
  49.     GmcStack[n].cX  = cX;                                               /*  起点X值入栈                 */
  50.     GmcStack[n].cY  = cY;                                               /*  起点Y值入栈                 */
  51.     n++;
  52.     /*
  53.      *  初始化各坐标等高值
  54.      */
  55.     for (i = 0; i < MAZETYPE; i++) {
  56.         for (j = 0; j < MAZETYPE; j++) {
  57.             GucMapStep[i][j] = 0xff;
  58.         }
  59.     }
  60.     /*
  61.      *  制作等高图，直到堆栈中所有数据处理完毕
  62.      */
  63.     while (n) {
  64.         GucMapStep[cX][cY] = ucStep++;                                  /*  填入等高值                  */

  66.         /*
  67.          *  对当前坐标格里可前进的方向统计
  68.          */
  69.         ucStat = 0;
  70.         if ((GucMapBlock[cX][cY] & 0x01) &&                             /*  前方有路                    */
  71.             (GucMapStep[cX][cY + 1] > (ucStep))) {                      /*  前方等高值大于计划设定值    */
  72.             ucStat++;                                                   /*  可前进方向数加1             */
  73.         }
  74.         if ((GucMapBlock[cX][cY] & 0x02) &&                             /*  右方有路                    */
  75.             (GucMapStep[cX + 1][cY] > (ucStep))) {                      /*  右方等高值大于计划设定值    */
  76.             ucStat++;                                                   /*  可前进方向数加1             */
  77.         }
  78.         if ((GucMapBlock[cX][cY] & 0x04) &&
  79.             (GucMapStep[cX][cY - 1] > (ucStep))) {
  80.             ucStat++;                                                   /*  可前进方向数加1             */
  81.         }
  82.         if ((GucMapBlock[cX][cY] & 0x08) &&
  83.             (GucMapStep[cX - 1][cY] > (ucStep))) {
  84.             ucStat++;                                                   /*  可前进方向数加1             */
  85.         }
  86.         /*
  87.          *  没有可前进的方向，则跳转到最近保存的分支点
  88.          *  否则任选一可前进方向前进
  89.          */
  90.         if (ucStat == 0) {
  91.             n--;
  92.             cX = GmcStack[n].cX;
  93.             cY = GmcStack[n].cY;
  94.             ucStep = GucMapStep[cX][cY];
  95.         } else {
  96.             if (ucStat > 1) {                                           /*  有多个可前进方向，保存坐标  */
  97.                 GmcStack[n].cX = cX;                                    /*  横坐标X值入栈               */
  98.                 GmcStack[n].cY = cY;                                    /*  纵坐标Y值入栈               */
  99.                 n++;
  100.             }
  101.             /*
  102.              *  任意选择一条可前进的方向前进
  103.              */
  104.             if ((GucMapBlock[cX][cY] & 0x01) &&                         /*  上方有路                    */
  105.                 (GucMapStep[cX][cY + 1] > (ucStep))) {                  /*  上方等高值大于计划设定值    */
  106.                 cY++;                                                   /*  修改坐标                    */
  107.                 continue;
  108.             }
  109.             if ((GucMapBlock[cX][cY] & 0x02) &&                         /*  右方有路                    */
  110.                 (GucMapStep[cX + 1][cY] > (ucStep))) {                  /*  右方等高值大于计划设定值    */
  111.                 cX++;                                                   /*  修改坐标                    */
  112.                 continue;
  113.             }
  114.             if ((GucMapBlock[cX][cY] & 0x04) &&                         /*  下方有路                    */
  115.                 (GucMapStep[cX][cY - 1] > (ucStep))) {                  /*  下方等高值大于计划设定值    */
  116.                 cY--;                                                   /*  修改坐标                    */
  117.                 continue;
  118.             }
  119.             if ((GucMapBlock[cX][cY] & 0x08) &&                         /*  左方有路                    */
  120.                 (GucMapStep[cX - 1][cY] > (ucStep))) {                  /*  左方等高值大于计划设定值    */
  121.                 cX--;                                                   /*  修改坐标                    */
  122.                 continue;
  123.             }
  124.         }
  125.     }
  126. }
  127. /*********************************************************************************************************
  128. ** Function name:       mouseSpurt
  129. ** Descriptions:        电脑鼠从起点以最短路径跑向终点
  130. ** input parameters:    无
  131. ** output parameters:  无
  132. ** Returned value:      无
  133. *********************************************************************************************************/
  134. void mouseSpurt (void)
  135. {
  136.     uint8 ucTemp = 0xff;
  137.     int8    cXdst = 0,    cYdst = 0;
  138.     /*
  139.      *  对终点的四个坐标分别制作等高图
  140.      *  取离起点最近的一个点作为目标点
  141.      */
  142.     if (GucMapBlock[GucXGoal0][GucYGoal0] & 0x0c) {                     /*  判断该终点坐标是否有出口    */
  143.         mapStepEdit(GucXGoal0,GucYGoal0);                               /*  制作等高图                  */
  144.         if (ucTemp > GucMapStep[GucXStart][GucYStart]) {                /*  保存离起点最近的坐标        */
  145.             cXdst  = GucXGoal0;
  146.             cYdst  = GucYGoal0;
  147.             ucTemp = GucMapStep[GucXStart][GucYStart];
  148.         }
  149.     }
  150.     if (GucMapBlock[GucXGoal0][GucYGoal1] & 0x09) {                     /*  判断该终点坐标是否有出口    */
  151.         mapStepEdit(GucXGoal0,GucYGoal1);                               /*  制作等高图                  */
  152.         if (ucTemp > GucMapStep[GucXStart][GucYStart]) {                /*  保存离起点最近的坐标        */
  153.             cXdst  = GucXGoal0;
  154.             cYdst  = GucYGoal1;
  155.             ucTemp = GucMapStep[GucXStart][GucYStart];
  156.         }
  157.     }
  158.     if (GucMapBlock[GucXGoal1][GucYGoal0] & 0x06) {                     /*  判断该终点坐标是否有出口    */
  159.         mapStepEdit(GucXGoal1,GucYGoal0);                               /*  制作等高图                  */
  160.         if (ucTemp > GucMapStep[GucXStart][GucYStart]) {                /*  保存离起点最近的坐标        */
  161.             cXdst  = GucXGoal1;
  162.             cYdst  = GucYGoal0;
  163.             ucTemp = GucMapStep[GucXStart][GucYStart];
  164.         }
  165.     }
  166.     if (GucMapBlock[GucXGoal1][GucYGoal1] & 0x03) {                     /*  判断该终点坐标是否有出口    */
  167.         mapStepEdit(GucXGoal1,GucYGoal1);                               /*  制作等高图                  */
  168.         if (ucTemp > GucMapStep[GucXStart][GucYStart]) {                /*  保存离起点最近的坐标        */
  169.             cXdst  = GucXGoal1;
  170.             cYdst  = GucYGoal1;
  171.             ucTemp = GucMapStep[GucXStart][GucYStart];
  172.         }
  173.     }
  174.     zlg7289Download(1, 0, 1, 1);
  175.     zlg7289Download(1, 1, 1, 1);
  176.     zlg7289Download(1, 2, 1, 2);
  177.     zlg7289Download(1, 3, 1, 3);   
  178.     zlg7289Download(1, 4, 1, 4);   

  180.     objectGoTo(cXdst,cYdst);                                            /*  运行到指定目标点            */
  181. }
  182. /*********************************************************************************************************
  183. ** Function name:       objectGoTo
  184. ** Descriptions:        使电脑鼠运动到指定坐标
  185. ** input parameters:    cXdst: 目的地的横坐标
  186. **                      cYdst: 目的地的纵坐标
  187. ** output parameters:   无
  188. ** Returned value:      无
  189. *********************************************************************************************************/
  190. void objectGoTo (int8  x, int8  y)
  191. {
  192.     uint8 ucStep = 1;
  193.     int8  cNBlock = 0, cDirTemp;
  194.     int8 cX,cY;
  195.     cX = GmcMouse.cX;
  196.     cY = GmcMouse.cY;
  197.     mapStepEdit(x,y);                                           /*  制作等高图                  */
  198.     /*
  199.      *  根据等高值向目标点运动，直到达到目的地
  200.      */
  201.     while ((cX != x) || (cY != y)) {
  202.         ucStep = GucMapStep[cX][cY];
  203.         /*
  204.          *  任选一个等高值比当前自身等高值小的方向前进
  205.          */
  206.         if ((GucMapBlock[cX][cY] & 0x01) &&                             /*  上方有路                    */
  207.             (GucMapStep[cX][cY + 1] < ucStep)) {                        /*  上方等高值较小              */
  208.             cDirTemp = UP;                                              /*  记录方向                    */
  209.             if (cDirTemp == GucMouseDir) {                              /*  优先选择不需要转弯的方向    */
  210.                 cNBlock++;                                              /*  前进一个方格                */
  211.                 cY++;
  212.                 continue;                                               /*  跳过本次循环                */
  213.             }
  214.         }
  215.         if ((GucMapBlock[cX][cY] & 0x02) &&                             /*  右方有路                    */
  216.             (GucMapStep[cX + 1][cY] < ucStep)) {                        /*  右方等高值较小              */
  217.             cDirTemp = RIGHT;                                           /*  记录方向                    */
  218.             if (cDirTemp == GucMouseDir) {                              /*  优先选择不需要转弯的方向    */
  219.                 cNBlock++;                                              /*  前进一个方格                */
  220.                 cX++;
  221.                 continue;                                               /*  跳过本次循环                */
  222.             }
  223.         }
  224.         if ((GucMapBlock[cX][cY] & 0x04) &&                             /*  下方有路                    */
  225.             (GucMapStep[cX][cY - 1] < ucStep)) {                        /*  下方等高值较小              */
  226.             cDirTemp = DOWN;                                            /*  记录方向                    */
  227.             if (cDirTemp == GucMouseDir) {                              /*  优先选择不需要转弯的方向    */
  228.                 cNBlock++;                                              /*  前进一个方格                */
  229.                 cY--;
  230.                 continue;                                               /*  跳过本次循环                */
  231.             }
  232.         }
  233.         if ((GucMapBlock[cX][cY] & 0x08) &&                             /*  左方有路                    */
  234.             (GucMapStep[cX - 1][cY] < ucStep)) {                        /*  左方等高值较小              */
  235.             cDirTemp = LEFT;                                            /*  记录方向                    */
  236.             if (cDirTemp == GucMouseDir) {                              /*  优先选择不需要转弯的方向    */
  237.                 cNBlock++;                                              /*  前进一个方格                */
  238.                 cX--;
  239.                 continue;                                               /*  跳过本次循环                */
  240.             }
  241.         }
  242.         cDirTemp = (cDirTemp + 4 - GucMouseDir)%4;                      /*  计算方向偏移量              */
  243.         
  244.         if (cNBlock) {
  245.             mouseGoahead(cNBlock);                                      /*  前进cNBlock步               */
  246.         }        
  247.         cNBlock = 0;                                                    /*  任务清零                    */
  248.         
  249.         /*
  250.          *  控制电脑鼠转弯
  251.          */
  252.         switch (cDirTemp) {

  254.         case 1:
  255.             mouseTurnright();
  256.             break;

  258.         case 2:
  259.             mouseTurnback();
  260.             break;

  262.         case 3:
  263.             mouseTurnleft();
  264.             break;

  266.         default:
  267.             break;
  268.         }
  269.     }
  270.     /*
  271.      *  判断任务是否完成，否则继续前进
  272.      */
  273.     if (cNBlock) {
  274.         mouseGoahead(cNBlock);
  275.     }
  276. }
  277. /*********************************************************************************************************
  278. ** Function name:       mazeBlockDataGet
  279. ** Descriptions:        根据电脑鼠的相对方向，取出该方向上迷宫格的墙壁资料
  280. ** input parameters:    ucDir: 电脑鼠的相对方向
  281. ** output parameters:   无
  282. ** Returned value:      GucMapBlock[cX][cY] : 墙壁资料
  283. *********************************************************************************************************/
  284. uint8 mazeBlockDataGet (uint8  ucDirTemp)
  285. {
  286.     int8 cX = 0,cY = 0;
  287.    
  288.     /*
  289.      *  把电脑鼠的相对方向转换为绝对方向
  290.      */
  291.     switch (ucDirTemp) {

  293.     case MOUSEFRONT:
  294.         ucDirTemp = GucMouseDir;
  295.         break;

  297.     case MOUSELEFT:
  298.         ucDirTemp = (GucMouseDir + 3) % 4;
  299.         break;

  301.     case MOUSERIGHT:
  302.         ucDirTemp = (GucMouseDir + 1) % 4;
  303.         break;

  305.     default:
  306.         break;
  307.     }
  308.    
  309.     /*
  310.      *  根据绝对方向计算该方向上相邻格的坐标
  311.      */
  312.     switch (ucDirTemp) {

  314.     case 0:
  315.         cX = GmcMouse.cX;
  316.         cY = GmcMouse.cY + 1;
  317.         break;
  318.         
  319.     case 1:
  320.         cX = GmcMouse.cX + 1;
  321.         cY = GmcMouse.cY;
  322.         break;
  323.         
  324.     case 2:
  325.         cX = GmcMouse.cX;
  326.         cY = GmcMouse.cY - 1;
  327.         break;
  328.         
  329.     case 3:
  330.         cX = GmcMouse.cX - 1;
  331.         cY = GmcMouse.cY;
  332.         break;
  333.         
  334.     default:
  335.         break;
  336.     }
  337.    
  338.     return(GucMapBlock[cX][cY]);                                        /*  返回迷宫格上的资料          */
  339. }
  340. /*********************************************************************************************************
  341. ** Function name:       rightMethod
  342. ** Descriptions:        右手法则，优先向右前进
  343. ** input parameters:    无
  344. ** output parameters:   无
  345. ** Returned value:      无
  346. *********************************************************************************************************/
  347. void rightMethod (void)
  348. {
  349.     if ((GucMapBlock[GmcMouse.cX][GmcMouse.cY] & MOUSEWAY_R) &&         /*  电脑鼠的右边有路            */
  350.         (mazeBlockDataGet(MOUSERIGHT) == 0x00)) {                       /*  电脑鼠的右边没有走过        */
  351.         //delay(20000);
  352.        // delay(10000);
  353.         mouseTurnright();                                               /*  电脑鼠右转                  */
  354.         return;
  355.     }
  356.     if ((GucMapBlock[GmcMouse.cX][GmcMouse.cY] & MOUSEWAY_F) &&         /*  电脑鼠的前方有路            */
  357.         (mazeBlockDataGet(MOUSEFRONT) == 0x00)) {                       /*  电脑鼠的前方没有走过        */
  358.         return;                                                         /*  电脑鼠不用转弯              */
  359.     }
  360.     if ((GucMapBlock[GmcMouse.cX][GmcMouse.cY] & MOUSEWAY_L) &&         /*  电脑鼠的左边有路            */
  361.         (mazeBlockDataGet(MOUSELEFT ) == 0x00)) {                       /*  电脑鼠的左边没有走过        */
  362.        // delay(20000);
  363.        // delay(10000);
  364.         mouseTurnleft();                                                /*  电脑鼠左转                  */
  365.         return;
  366.     }
  367. }
  368. /*********************************************************************************************************
  369. ** Function name:       leftMethod
  370. ** Descriptions:        左手法则，优先向左运动
  371. ** input parameters:    无
  372. ** output parameters:   无
  373. ** Returned value:      无
  374. *********************************************************************************************************/
  375. void leftMethod (void)
  376. {
  377.     if ((GucMapBlock[GmcMouse.cX][GmcMouse.cY] & MOUSEWAY_L) &&         /*  电脑鼠的左边有路            */
  378.         (mazeBlockDataGet(MOUSELEFT ) == 0x00)) {                       /*  电脑鼠的左边没有走过        */
  379.         //delay(20000);
  380.        // delay(10000);
  381.         mouseTurnleft();                                                /*  电脑鼠左转                  */
  382.         return;
  383.     }
  384.     if ((GucMapBlock[GmcMouse.cX][GmcMouse.cY] & MOUSEWAY_F) &&         /*  电脑鼠的前方有路            */
  385.         (mazeBlockDataGet(MOUSEFRONT) == 0x00)) {                       /*  电脑鼠的前方没有走过        */
  386.         return;                                                         /*  电脑鼠不用转弯              */
  387.     }
  388.     if ((GucMapBlock[GmcMouse.cX][GmcMouse.cY] & MOUSEWAY_R) &&         /*  电脑鼠的右边有路            */
  389.         (mazeBlockDataGet(MOUSERIGHT) == 0x00)) {                       /*  电脑鼠的右边没有走过        */
  390.         //delay(20000);
  391.        // delay(10000);
  392.         mouseTurnright();                                               /*  电脑鼠右转                  */
  393.         return;
  394.     }
  395. }
  396. /*********************************************************************************************************
  397. ** Function name:       frontRightMethod
  398. ** Descriptions:        中右法则，优先向前运行，其次向右
  399. ** input parameters:    无
  400. ** output parameters:   无
  401. ** Returned value:      无
  402. *********************************************************************************************************/
  403. void frontRightMethod (void)
  404. {
  405.     if ((GucMapBlock[GmcMouse.cX][GmcMouse.cY] & MOUSEWAY_F) &&         /*  电脑鼠的前方有路            */
  406.         (mazeBlockDataGet(MOUSEFRONT) == 0x00)) {                       /*  电脑鼠的前方没有走过        */
  407.         return;                                                         /*  电脑鼠不用转弯              */
  408.     }
  409.     if ((GucMapBlock[GmcMouse.cX][GmcMouse.cY] & MOUSEWAY_R) &&         /*  电脑鼠的右边有路            */
  410.         (mazeBlockDataGet(MOUSERIGHT) == 0x00)) {                       /*  电脑鼠的右边没有走过        */
  411.         //delay(20000);
  412.         //delay(10000);
  413.         mouseTurnright();                                               /*  电脑鼠右转                  */
  414.         return;
  415.     }
  416.     if ((GucMapBlock[GmcMouse.cX][GmcMouse.cY] & MOUSEWAY_L) &&         /*  电脑鼠的左边有路            */
  417.         (mazeBlockDataGet(MOUSELEFT ) == 0x00)) {                       /*  电脑鼠的左边没有走过        */
  418.         //delay(20000);
  419.        // delay(10000);
  420.         mouseTurnleft();                                                /*  电脑鼠左转                  */
  421.         return;
  422.     }
  423. }
  424. /*********************************************************************************************************
  425. ** Function name:       frontLeftMethod
  426. ** Descriptions:        中左法则，优先向前运行，其次向左
  427. ** input parameters:    无
  428. ** output parameters:   无
  429. ** Returned value:      无
  430. *********************************************************************************************************/
  431. void frontLeftMethod (void)
  432. {
  433.     if ((GucMapBlock[GmcMouse.cX][GmcMouse.cY] & MOUSEWAY_F) &&         /*  电脑鼠的前方有路            */
  434.         (mazeBlockDataGet(MOUSEFRONT) == 0x00)) {                       /*  电脑鼠的前方没有走过        */
  435.         return;                                                         /*  电脑鼠不用转弯              */
  436.     }
  437.     if ((GucMapBlock[GmcMouse.cX][GmcMouse.cY] & MOUSEWAY_L) &&         /*  电脑鼠的左边有路            */
  438.         (mazeBlockDataGet(MOUSELEFT ) == 0x00)) {                       /*  电脑鼠的左边没有走过        */
  439.         //delay(20000);
  440.        // delay(10000);
  441.         mouseTurnleft();                                                /*  电脑鼠左转                  */
  442.         return;
  443.     }
  444.     if ((GucMapBlock[GmcMouse.cX][GmcMouse.cY] & MOUSEWAY_R) &&         /*  电脑鼠的右边有路            */
  445.         (mazeBlockDataGet(MOUSERIGHT) == 0x00)) {                       /*  电脑鼠的右边没有走过        */
  446.         //delay(20000);
  447.        // delay(10000);
  448.         mouseTurnright();                                               /*  电脑鼠右转                  */
  449.         return;
  450.     }
  451. }
  452. /*********************************************************************************************************
  453. ** Function name:       centralMethod
  454. ** Descriptions:        中心法则，根据电脑鼠目前在迷宫中所处的位置觉定使用何种搜索法则
  455. ** input parameters:    无
  456. ** output parameters:   无
  457. ** Returned value:      无
  458. *********************************************************************************************************/
  459. void centralMethod (void)
  460. {
  461.     if (!(GmcMouse.cX & 0x08)) {
  462.         if (!(GmcMouse.cY & 0x08)) {
  463.          
  464.             /*
  465.              *  此时电脑鼠在迷宫的左下角
  466.              */   
  467.             switch (GucMouseDir) {
  468.                
  469.             case UP:                                                    /*  当前电脑鼠向上              */
  470.             //    delay(20000);  
  471.                 frontRightMethod();                                     /*  中右法则                    */
  472.                 break;

  474.             case RIGHT:                                                 /*  当前电脑鼠向右              */
  475.             //    delay(20000);
  476.                 frontLeftMethod();                                      /*  中左法则                    */
  477.                 break;

  479.             case DOWN:                                                  /*  当前电脑鼠向下              */
  480.             //    delay(20000);
  481.                 leftMethod();                                           /*  左手法则                    */
  482.                 break;

  484.             case LEFT:                                                  /*  当前电脑鼠向左              */
  485.             //    delay(20000);
  486.                 rightMethod();                                          /*  右手法则                    */
  487.                 break;

  489.             default:
  490.                 break;
  491.             }

  493.         } else {
  494.          
  495.             /*
  496.              *  此时电脑鼠在迷宫的左上角
  497.              */   
  498.             switch (GucMouseDir) {
  499.                
  500.             case UP:                                                    /*  当前电脑鼠向上              */
  501.             //    delay(20000);
  502.                 rightMethod();                                          /*  右手法则                    */
  503.                 break;

  505.             case RIGHT:                                                 /*  当前电脑鼠向右              */
  506.             //    delay(20000);
  507.                 frontRightMethod();                                     /*  中右法则                    */
  508.                 break;

  510.             case DOWN:                                                  /*  当前电脑鼠向下              */
  511.             //    delay(20000);
  512.                 frontLeftMethod();                                      /*  中左法则                    */
  513.                 break;

  515.             case LEFT:                                                  /*  当前电脑鼠向左              */
  516.             //    delay(20000);
  517.                 leftMethod();                                           /*  左手法则                    */
  518.                 break;

  520.             default:
  521.                 break;
  522.             }
  523.         }
  524.     } else {
  525.         if (!(GmcMouse.cY & 0x08)) {
  526.          
  527.             /*
  528.              *  此时电脑鼠在迷宫的右下角
  529.              */   
  530.             switch (GucMouseDir) {
  531.                
  532.             case UP:                                                    /*  当前电脑鼠向上              */
  533.             //    delay(20000);
  534.                 frontLeftMethod();                                      /*  中左法则                    */
  535.                 break;

  537.             case RIGHT:                                                 /*  当前电脑鼠向右              */
  538.             //    delay(20000);
  539.                 leftMethod();                                           /*  左手法则                    */
  540.                 break;

  542.             case DOWN:                                                  /*  当前电脑鼠向下              */
  543.             //    delay(20000);
  544.                 rightMethod();                                          /*  右手法则                    */
  545.                 break;

  547.             case LEFT:                                                  /*  当前电脑鼠向左              */
  548.            //     delay(20000);
  549.                 frontRightMethod();                                     /*  中右法则                    */
  550.                 break;

  552.             default:
  553.                 break;
  554.             }
  555.             
  556.         } else {

  558.             /*
  559.              *  此时电脑鼠在迷宫的右上角
  560.              */
  561.             switch (GucMouseDir) {
  562.                
  563.             case UP:                                                    /*  当前电脑鼠向上              */
  564.            //     delay(20000);
  565.                 leftMethod();                                           /*  左手法则                    */
  566.                 break;

  568.             case RIGHT:                                                 /*  当前电脑鼠向右              */
  569.            //     delay(20000);
  570.                 rightMethod();                                          /*  右手法则                    */
  571.                 break;

  573.             case DOWN:                                                  /*  当前电脑鼠向下              */
  574.            //     delay(20000);
  575.                 frontRightMethod();                                     /*  中右法则                    */
  576.                 break;

  578.             case LEFT:                                                  /*  当前电脑鼠向左              */
  579.             //    delay(20000);
  580.                 frontLeftMethod();                                      /*  中左法则                    */
  581.                 break;

  583.             default:
  584.                 break;
  585.             }            
  586.         }
  587.     }
  588. }

  590. //搜索返回的法则
  591. void mazeBackChoice()
  592. {
  593.     if (!(GmcMouse.cX & 0x08)) {
  594.         if (!(GmcMouse.cY & 0x08)) {
  595.          
  596.             /*
  597.              *  此时电脑鼠在迷宫的左下角
  598.              */   
  599.             switch (GucMouseDir) {
  600.                
  601.             case UP:                                                    /*  当前电脑鼠向上              */
  602.             //    delay(20000);  
  603.                 frontRightMethod();                                     /*  中右法则                    */
  604.                 break;

  606.             case RIGHT:                                                 /*  当前电脑鼠向右              */
  607.             //    delay(20000);
  608.                 frontLeftMethod();                                      /*  中左法则                    */
  609.                 break;

  611.             case DOWN:                                                  /*  当前电脑鼠向下              */
  612.             //    delay(20000);
  613.                 leftMethod();                                           /*  左手法则                    */
  614.                 break;

  616.             case LEFT:                                                  /*  当前电脑鼠向左              */
  617.             //    delay(20000);
  618.                 rightMethod();                                          /*  右手法则                    */
  619.                 break;

  621.             default:
  622.                 break;
  623.             }

  625.         } else {
  626.          
  627.             /*
  628.              *  此时电脑鼠在迷宫的左上角
  629.              */   
  630.             switch (GucMouseDir) {
  631.                
  632.             case UP:                                                    /*  当前电脑鼠向上              */
  633.             //    delay(20000);
  634.                 rightMethod();                                          /*  右手法则                    */
  635.                 break;

  637.             case RIGHT:                                                 /*  当前电脑鼠向右              */
  638.             //    delay(20000);
  639.                 frontRightMethod();                                     /*  中右法则                    */
  640.                 break;

  642.             case DOWN:                                                  /*  当前电脑鼠向下              */
  643.             //    delay(20000);
  644.                 frontLeftMethod();                                      /*  中左法则                    */
  645.                 break;

  647.             case LEFT:                                                  /*  当前电脑鼠向左              */
  648.             //    delay(20000);
  649.                 leftMethod();                                           /*  左手法则                    */
  650.                 break;

  652.             default:
  653.                 break;
  654.             }
  655.         }
  656.     } else {
  657.         if (!(GmcMouse.cY & 0x08)) {
  658.          
  659.             /*
  660.              *  此时电脑鼠在迷宫的右下角
  661.              */   
  662.             switch (GucMouseDir) {
  663.                
  664.             case UP:                                                    /*  当前电脑鼠向上              */
  665.             //    delay(20000);
  666.                 frontLeftMethod();                                      /*  中左法则                    */
  667.                 break;

  669.             case RIGHT:                                                 /*  当前电脑鼠向右              */
  670.             //    delay(20000);
  671.                 leftMethod();                                           /*  左手法则                    */
  672.                 break;

  674.             case DOWN:                                                  /*  当前电脑鼠向下              */
  675.             //    delay(20000);
  676.                 rightMethod();                                          /*  右手法则                    */
  677.                 break;

  679.             case LEFT:                                                  /*  当前电脑鼠向左              */
  680.            //     delay(20000);
  681.                 frontRightMethod();                                     /*  中右法则                    */
  682.                 break;

  684.             default:
  685.                 break;
  686.             }
  687.             
  688.         } else {

  690.             /*
  691.              *  此时电脑鼠在迷宫的右上角
  692.              */
  693.             switch (GucMouseDir) {
  694.                
  695.             case UP:                                                    /*  当前电脑鼠向上              */
  696.            //     delay(20000);
  697.                 leftMethod();                                           /*  左手法则                    */
  698.                 break;

  700.             case RIGHT:                                                 /*  当前电脑鼠向右              */
  701.            //     delay(20000);
  702.                 rightMethod();                                          /*  右手法则                    */
  703.                 break;

  705.             case DOWN:                                                  /*  当前电脑鼠向下              */
  706.            //     delay(20000);
  707.                 frontRightMethod();                                     /*  中右法则                    */
  708.                 break;

  710.             case LEFT:                                                  /*  当前电脑鼠向左              */
  711.             //    delay(20000);
  712.                 frontLeftMethod();                                      /*  中左法则                    */
  713.                 break;

  715.             default:
  716.                 break;
  717.             }            
  718.         }
  719.     }
  720. }
  721. /*********************************************************************************************************
  722. ** Function name:       crosswayCheck
  723. ** Descriptions:        统计某坐标存在还未走过的支路数
  724. ** input parameters:    ucX，需要检测点的横坐标
  725. **                      ucY，需要检测点的纵坐标
  726. ** output parameters:   无
  727. ** Returned value:      ucCt，未走过的支路数
  728. *********************************************************************************************************/
  729. uint8 crosswayCheck (int8  cX, int8  cY)
  730. {
  731.     uint8 ucCt = 0;
  732.     if ((GucMapBlock[cX][cY] & 0x01) &&                                 /*  绝对方向，迷宫上方有路      */
  733.         (GucMapBlock[cX][cY + 1]) == 0x00) {                            /*  绝对方向，迷宫上方未走过    */
  734.         ucCt++;                                                         /*  可前进方向数加1             */
  735.     }
  736.     if ((GucMapBlock[cX][cY] & 0x02) &&                                 /*  绝对方向，迷宫右方有路      */
  737.         (GucMapBlock[cX + 1][cY]) == 0x00) {                            /*  绝对方向，迷宫右方没有走过  */
  738.         ucCt++;                                                         /*  可前进方向数加1             */
  739.     }
  740.     if ((GucMapBlock[cX][cY] & 0x04) &&                                 /*  绝对方向，迷宫下方有路      */
  741.         (GucMapBlock[cX][cY - 1]) == 0x00) {                            /*  绝对方向，迷宫下方未走过    */
  742.         ucCt++;                                                         /*  可前进方向数加1             */
  743.     }
  744.     if ((GucMapBlock[cX][cY] & 0x08) &&                                 /*  绝对方向，迷宫左方有路      */
  745.         (GucMapBlock[cX - 1][cY]) == 0x00) {                            /*  绝对方向，迷宫左方未走过    */
  746.         ucCt++;                                                         /*  可前进方向数加1             */
  747.     }
  748.     return ucCt;
  749. }
  750. /*********************************************************************************************************
  751. ** Function name:       crosswayChoice
  752. ** Descriptions:        选择一条支路作为前进方向
  753. ** input parameters:    无
  754. ** output parameters:   无
  755. ** Returned value:      无
  756. *********************************************************************************************************/
  757. void crosswayChoice (void)
  758. {
  759.     switch (SEARCHMETHOD) {
  760.         
  761.     case RIGHTMETHOD:
  762.         rightMethod();
  763.         break;
  764.    
  765.     case LEFTMETHOD:
  766.         leftMethod();
  767.         break;
  768.    
  769.     case CENTRALMETHOD:
  770.         centralMethod();
  771.         break;

  773.     case FRONTRIGHTMETHOD:
  774.         frontRightMethod();
  775.         break;

  777.     case FRONTLEFTMETHOD:
  778.         frontLeftMethod();
  779.         break;

  781.     default:
  782.         break;
  783.     }
  784. }
  785. /*********************************************************************************************************
  786. ** Function name:      StopMazeSearch
  787. ** Descriptions:      停止向前搜索的函数   
  788. ** input parameters:    当前的坐标
  789. ** output parameters:     无
  790. ** Returned value:      0代表结束，1代表继续
  791. *********************************************************************************************************/
  792. int8 StopMazeSearch(int8 cX,int8 cY)
  793. {
  794.     if(cX==7 && cY==7)
  795.         return 1;
  796.     if(cX==8 && cY==7)
  797.         return 1;
  798.     if(cX==7 && cY==8)
  799.         return 1;
  800.     if(cX==8 && cY==8)
  801.         return 1;
  802.     return 0;
  803. }
  804. /*********************************************************************************************************
  805. ** Function name:      FastOperating
  806. ** Descriptions:     对特殊格子处理的函数  
  807. ** input parameters:    当前的坐标
  808. ** output parameters:     无
  809. ** Returned value:      1表示前方，2表示右方，3表示后方，4表示左方
  810. *********************************************************************************************************/
  811. int8 FastOperating(int8 cX,int8 cY)
  812. {
  813.   if(cX==5 && cY==7){
  814.       if(GucMapBlock[cX][cY] & 0x02)
  815.         return 2;
  816.   }
  817.   if(cX==5 && cY==8){
  818.       if(GucMapBlock[cX][cY] & 0x02)
  819.         return 2;
  820.   }
  821.   
  822.   if(cX==6 && cY==7){
  823.       if(GucMapBlock[cX][cY] & 0x02)
  824.         return 2;
  825.   }
  826.   if(cX==6 && cY==8){
  827.       if(GucMapBlock[cX][cY] & 0x02)
  828.         return 2;
  829.   }
  830.   
  831.   if(cX==7 && cY==5){
  832.       if(GucMapBlock[cX][cY] & 0x01)
  833.         return 1;
  834.   }
  835.   if(cX==8 && cY==5){
  836.       if(GucMapBlock[cX][cY] & 0x01)
  837.         return 1;
  838.   }
  839.   if(cX==7 && cY==6){
  840.       if(GucMapBlock[cX][cY] & 0x01)
  841.         return 1;
  842.   }
  843.   if(cX==8 && cY==6){
  844.       if(GucMapBlock[cX][cY] & 0x01)
  845.         return 1;
  846.   }
  847.   
  848.   if(cX==10 && cY==7){
  849.       if(GucMapBlock[cX][cY] & 0x08)
  850.         return 4;
  851.   }
  852.   if(cX==10 && cY==8){
  853.       if(GucMapBlock[cX][cY] & 0x08)
  854.         return 4;
  855.   }
  856.   if(cX==9 && cY==7){
  857.       if(GucMapBlock[cX][cY] & 0x08)
  858.         return 4;
  859.   }
  860.   if(cX==9 && cY==8){
  861.       if(GucMapBlock[cX][cY] & 0x08)
  862.         return 4;
  863.   }
  864.   
  865.   if(cX==8 && cY==10){
  866.       if(GucMapBlock[cX][cY] & 0x04)
  867.         return 3;
  868.   }
  869.   if(cX==7 && cY==10){
  870.       if(GucMapBlock[cX][cY] & 0x04)
  871.         return 3;
  872.   }
  873.   if(cX==8 && cY==9){
  874.       if(GucMapBlock[cX][cY] & 0x04)
  875.         return 3;
  876.   }
  877.   if(cX==7 && cY==9){
  878.       if(GucMapBlock[cX][cY] & 0x04)
  879.         return 3;
  880.   }
  881.   return 0;
  882. }
  883. /*********************************************************************************************************
  884. ** Function name:       piontMethod
  885. ** Descriptions:        向点法则，电脑鼠从终点找起点
  886. ** input parameters:    无
  887. ** output parameters:   无
  888. ** Returned value:      无
  889. *********************************************************************************************************/
  890. void piontMethod(void)
  891. {
  892.     switch(GucMouseDir)
  893.     {
  894.     case UP:
  895.       leftMethod();
  896.       break;
  897.     case RIGHT:
  898.       rightMethod();
  899.       break;
  900.     case DOWN:
  901.       frontRightMethod();
  902.       break;
  903.     case LEFT:
  904.       frontLeftMethod();
  905.       break;
  906.     default:
  907.       break;
  908.     }
  909. }
  910. /*********************************************************************************************************
  911. ** Function name:      StopMazeSearch
  912. ** Descriptions:      停止向前搜索的函数   
  913. ** input parameters:    当前的坐标
  914. ** output parameters:     无
  915. ** Returned value:      0代表结束，1代表继续
  916. *********************************************************************************************************/
  917. int8 StopSearch(int8 cX,int8 cY,int8 n)
  918. {
  919.    int8 i;
  920.    for(i=0;i<n;i++){
  921.       if(GmcCrossway[i].cX == cX && GmcCrossway[i].cY == cY){
  922.           return 1;
  923.       }
  924.    }
  925.    if(cX==7 && cY==7)
  926.        return 1;
  927.    if(cX==8 && cY==7)
  928.        return 1;
  929.    if(cX==7 && cY==8)
  930.        return 1;
  931.    if(cX==8 && cY==8)
  932.        return 1;
  933.     return 0;
  934. }
  935. /*********************************************************************************************************
  936. ** Function name:       main
  937. ** Descriptions:      主函数
  938. ** input parameters:    无
  939. ** output parameters:   无
  940. ** Returned value:      无
  941. *********************************************************************************************************/
  942. main (void)
  943. {
  944.     uint8 n          = 0;                                               /*  GmcCrossway[]下标           */  
  945.     uint8 ucRoadStat = 0;                                               /*  统计某一坐标可前进的支路数  */
  946.     uint8 ucTemp     = 0;                                               /*  用于START状态中坐标转换     */
  947.    
  948.     //用户自定义变量
  949.     int8    cXdst = 0,    cYdst = 0;
  950.    
  951.     mouseInit();                                                        /*  底层驱动的初始化            */
  952.     zlg7289Init();                                                      /*  显示模块初始化              */

  954.     while (1) {
  955.         switch (GucMouseTask) {                                         /*  状态机处理                  */
  956.             
  957.         case WAIT:
  958.             sensorDebug();
  959.             voltageDetect();
  960.             delay(100000);
  961.             if (keyCheck() == true) {                                   /*  检测按键等待启动            */
  962.                 zlg7289Reset();                                         /*  复位ZLG7289                 */
  963.                 GucMouseTask = START;
  964.             }
  965.             break;
  966.             
  967.         case START:                                                     /*  判断电脑鼠起点的横坐标      */
  968.             mazeSearch();                                               /*  向前搜索                    */
  969.             if (GucMapBlock[GmcMouse.cX][GmcMouse.cY] & 0x08) {         /*  判断电老鼠左边是否存在出口  */
  970.                 if (MAZETYPE == 8) {                                    /*  修改四分之一迷宫的终点坐标  */
  971.                     GucXGoal0 = 1;
  972.                     GucXGoal1 = 0;
  973.                 }
  974.                 GucXStart   = MAZETYPE - 1;                             /*  修改电脑鼠起点的横坐标      */
  975.                 GmcMouse.cX = MAZETYPE - 1;                             /*  修改电脑鼠当前位置的横坐标  */   
  976.                 /*
  977.                  *  由于默认的起点为(0,0)，现在需要把已记录的墙壁资料转换过来
  978.                  */
  979.                 ucTemp = GmcMouse.cY;
  980.                 do {
  981.                     GucMapBlock[MAZETYPE - 1][ucTemp] = GucMapBlock[0][ucTemp];
  982.                     GucMapBlock[0 ][ucTemp] = 0;
  983.                 }while (ucTemp--);
  984.                 /*
  985.                  *  在OFFSHOOT[0]中保存起点坐标
  986.                  */
  987.                 GmcCrossway[n].cX = MAZETYPE - 1;
  988.                 GmcCrossway[n].cY = 0;
  989.                 n++;
  990.                 GucMouseTask = MAZESEARCH;                              /*  状态转换为搜寻状态          */
  991.             }
  992.             if (GucMapBlock[GmcMouse.cX][GmcMouse.cY] & 0x02) {         /*  判断电老鼠右边是否存在出口  */
  993.                 /*
  994.                  *  在OFFSHOOT[0]中保存起点坐标
  995.                  */
  996.                 GmcCrossway[n].cX = 0;
  997.                 GmcCrossway[n].cY = 0;
  998.                 n++;
  999.                 GucMouseTask = MAZESEARCH;                              /*  状态转换为搜寻状态          */
  1000.             }
  1001.             break;
  1002.             
  1003.         case MAZESEARCH:
  1004.               //从起点搜索找终点
  1005.               if(StopMazeSearch(GmcMouse.cX,GmcMouse.cY)==1){
  1006.                     cXdst=GmcMouse.cX,cYdst=GmcMouse.cY;
  1007.                     mouseTurnback();
  1008.                     GucMouseTask = BACKSEARCH;
  1009.                     n--;
  1010.                     objectGoTo(GmcCrossway[n].cX,GmcCrossway[n].cY);
  1011.                     break;
  1012.                }
  1013.                ucRoadStat = crosswayCheck(GmcMouse.cX,GmcMouse.cY);
  1014.                if (ucRoadStat) {                                           /*  有可前进方向                */                  
  1015.                     if (ucRoadStat > 1) {                                   /*  有多条可前进方向，保存坐标  */
  1016.                         GmcCrossway[n].cX = GmcMouse.cX;
  1017.                         GmcCrossway[n].cY = GmcMouse.cY;
  1018.                         n++;                                       
  1019.                     }
  1020.                     switch(FastOperating(GmcMouse.cX,GmcMouse.cY)){
  1021.                         case 0:
  1022.                             centralMethod();
  1023.                             mazeSearch();
  1024.                             break;
  1025.                         case 1:
  1026.                            objectGoTo(GmcMouse.cX,GmcMouse.cY+1);
  1027.                            //  mazeSearch();
  1028.                             break;
  1029.                         case 2:
  1030.                           objectGoTo(GmcMouse.cX+1,GmcMouse.cY);
  1031.                           //    mazeSearch();
  1032.                             break;
  1033.                         case 3:
  1034.                            objectGoTo(GmcMouse.cX,GmcMouse.cY-1);
  1035.                           //   mazeSearch();
  1036.                             break;
  1037.                         case 4:
  1038.                            objectGoTo(GmcMouse.cX-1,GmcMouse.cY);
  1039.                            //  mazeSearch();
  1040.                             break;
  1041.                        default:
  1042.                             break;
  1043.                     }
  1044.                }else{                    /*  没有可前进方向，回到最近支路*/
  1045.                     while (--n) {
  1046.                           ucRoadStat = crosswayCheck(GmcCrossway[n].cX,GmcCrossway[n].cY);
  1047.                           if (ucRoadStat) {
  1048.                               objectGoTo(GmcCrossway[n].cX,GmcCrossway[n].cY);
  1049.                               if (ucRoadStat > 1) {
  1050.                                   n++;
  1051.                               }
  1052.                               centralMethod();
  1053.                               mazeSearch();
  1054.                               break;
  1055.                           }
  1056.                     
  1057.                      }
  1058.                    if (n == 0){                                           /*  走完了所有的支路，回到起点  */
  1059.                         objectGoTo(GmcCrossway[0].cX, GmcCrossway[0].cY);
  1060.                         mouseTurnback();
  1061.                            //异常处理那种死迷宫(即根本走不出去的迷宫)
  1062.                         if(GmcMouse.cX==GucXStart && GmcMouse.cY==GucYStart){
  1063.                             while(1){
  1064.                                 if(keyCheck()==true){
  1065.                                     break;
  1066.                                 }
  1067.                                 sensorDebug();
  1068.                                 delay(20000);
  1069.                             }
  1070.                         }
  1071.                     }
  1072.                 }
  1073.                 break;
  1074.          case BACKSEARCH:
  1075.              //从终点搜索找起点
  1076.              /*  while(1){
  1077.                     if(keyCheck()==true){
  1078.                          break;
  1079.                     }
  1080.                     sensorDebug();
  1081.                     delay(20000);
  1082.                 }*/
  1083.                 ucRoadStat = crosswayCheck(GmcMouse.cX,GmcMouse.cY);               
  1084.                 if (ucRoadStat) {                                           /*  有可前进方向                */
  1085.                     if (ucRoadStat > 1) {                                   /*  有多条可前进方向，保存坐标  */
  1086.                         GmcCrossway[n].cX = GmcMouse.cX;
  1087.                         GmcCrossway[n].cY = GmcMouse.cY;
  1088.                         n++;                                       
  1089.                     }
  1090.                     piontMethod();       //设定为向点法则                                
  1091.                     mazeSearch();          // 前进一格               
  1092.                     }else{                    /*  没有可前进方向，回到最近支路*/
  1093.                         while (--n) {
  1094.                             if(GmcMouse.cX==0 && GmcMouse.cY==0){
  1095.                                 mouseTurnback();
  1096.                                 GucMouseTask=SPURT;
  1097.                                 break;
  1098.                             }
  1099.                             ucRoadStat = crosswayCheck(GmcCrossway[n].cX,GmcCrossway[n].cY);
  1100.                             if(ucRoadStat) {
  1101.                                 objectGoTo(GmcCrossway[n].cX,GmcCrossway[n].cY);
  1102.                                 if (ucRoadStat > 1) {
  1103.                                     n++;
  1104.                                 }
  1105.                                 piontMethod();
  1106.                                 mazeSearch();
  1107.                                 break;
  1108.                            }
  1109.                            if(n==0){
  1110.                              GucMouseTask=SPURT;
  1111.                              break;
  1112.                         }
  1113.                     }
  1114.                 }
  1115.                 break;
  1116.         case SPURT:
  1117.           //  mouseSpurt ();
  1118.             objectGoTo(cXdst,cYdst);
  1119.             n--;
  1120.             objectGoTo(GmcCrossway[n].cX, GmcCrossway[n].cY);
  1121.             GucMouseTask = BACKSEARCH;
  1122.             break;
  1123.         default:
  1124.             break;
  1125.         }
  1126.     }
  1127. }


  1130. /*********************************************************************************************************
  1131.   END FILE
  1132. *********************************************************************************************************/





  1138. /*********************************************************************************************************
  1139. ** Function name:       piontMethod
  1140. ** Descriptions:        向点法则，电脑鼠从终点找起点
  1141. ** input parameters:    无
  1142. ** output parameters:   GmcMouse.cX,GmcMouse.cY
  1143. ** Returned value:      无
  1144. *********************************************************************************************************/

  1146. void piontMethod(int8 cX,int8 cY)
  1147. {
  1148.         if (!(GmcMouse.cX & 0x08))
  1149.         {
  1150.         if (!(GmcMouse.cY & 0x08))
  1151.                 {
  1152.                                 /*
  1153.                                  *  此时电脑鼠在迷宫的左下角
  1154.                                  */  
  1155.                                 switch (GucMouseDir)
  1156.                                 {
  1157.                         
  1158.                                 case UP:                                                    /*  当前电脑鼠向上              */
  1159.                                         LeftMethod();                                                                                        /*  左手法则                    */
  1160.                                         break;

  1162.                                 case RIGHT:                                                 /*  当前电脑鼠向右              */
  1163.                                         RightMethod();                                          /*  右手法则                    */
  1164.                                         break;

  1166.                                 case DOWN:                                                  /*  当前电脑鼠向下              */
  1167.                                         frontRightMethod();                                     /*  中右手法则                    */
  1168.                                         break;

  1170.                                 case LEFT:                                                  /*  当前电脑鼠向左              */
  1171.                                         frontLeftMethod();                                      /*  中左手法则                    */
  1172.                                         break;

  1174.                                 default:
  1175.                                         break;
  1176.                         ｝
  1177.                 }
  1178.     }
  1179.         else
  1180.         {
  1181.         
  1182.             frontLeftMethod();                                      /*  中左法则                    */


  1185.     if ((GucMapBlock[GmcMouse.cX][GmcMouse.cY] & MOUSEWAY_F) &&         /*  电脑鼠的前方有路            */
  1186.         (mazeBlockDataGet(MOUSEFRONT) == 0x00)) {                       /*  电脑鼠的前方没有走过        */
  1187.         return;                                                         /*  电脑鼠不用转弯              */
  1188.     }
  1189.     if ((GucMapBlock[GmcMouse.cX][GmcMouse.cY] & MOUSEWAY_L) &&         /*  电脑鼠的左边有路            */
  1190.         (mazeBlockDataGet(MOUSELEFT ) == 0x00)) {                       /*  电脑鼠的左边没有走过        */
  1191.         //delay(20000);
  1192.        // delay(10000);
  1193.         mouseTurnleft();                                                /*  电脑鼠左转                  */
  1194.         return;
  1195.     }
  1196.     if ((GucMapBlock[GmcMouse.cX][GmcMouse.cY] & MOUSEWAY_R) &&         /*  电脑鼠的右边有路            */
  1197.         (mazeBlockDataGet(MOUSERIGHT) == 0x00)) {                       /*  电脑鼠的右边没有走过        */
  1198.         //delay(20000);
  1199.        // delay(10000);
  1200.         mouseTurnright();                                               /*  电脑鼠右转                  */
  1201.         return;
  1202.     }
  1203.     }
  1204. }
复制代码

所有资料51hei提供下载:
.rar (198.73 KB, 下载次数: 18)



回复

使用道具 举报

ID:687193 发表于 2020-1-18 17:24 | 显示全部楼层
有这个代码的头文件吗
回复

使用道具 举报

ID:687193 发表于 2020-1-18 17:25 | 显示全部楼层
有这个代码的头文件吗
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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