欧美极品高清xxxxhd,国产日产欧美最新,无码AV国产东京热AV无码,国产精品人与动性XXX,国产传媒亚洲综合一区二区,四库影院永久国产精品,毛片免费免费高清视频,福利所导航夜趣136

 找回密碼
 立即注冊

QQ登錄

只需一步，快速開始

搜索
查看: 4563|回復: 3
打印 上一主題 下一主題
收起左側

單片機循跡小車完整資料 包括注釋詳細的程序和硬件設計

  [復制鏈接]
跳轉到指定樓層
樓主
資料大家看吧！截圖截得不全。


單片機源程序如下:
  1. /***************************************************/
  2. /*                                        尋跡小車 FollowMe 項目                                                                 */
  3. /*          —— 主控程序軌跡控制模塊                                                                 */
  4. /*              之程序部分                                                                                            */
  5. /*                                            20060905                           */
  6. /*              By DingQi                          */
  7. /***************************************************/
  8. // 注：以下文檔的 TAB 為 2 個字符！

  10. /*------------------------------------------------------------------------
  11. 此程序為"尋跡小車FollowMe"項目中單板控制模式的走軌跡控制部分，附帶相關調試功能。
  12. 要實現：

  14.         1)接收各種調試命令，并解析；
  15.         2)通過串口反饋所需的調試信息；
  16.         3)獲取軌跡采樣部分處理后的信息，產生對策，發給電機驅動部分實施。
  17.        
  18.         根據上述要實現的功能，通訊部分歸此模塊管理。
  19.        
  20.         第一步先將原來的電機驅動功能整合到一個MCU中，將原來的通訊功能從電機驅動模塊中分解出來。

  22.        
  23. 目前的電機控制由串口實現，通訊協議定義如下：
  24. 1、幀格式：
  25.         幀頭（2字節）  幀長（1字節） 命令字（1字節） 數據區（N字節）校驗和（1字節）

  27. 其中：
  28.         幀頭 —— 0x55  0xAA       
  29.         幀長 ——  命令字 + 數據區的長度
  30.         命令字 ——         0x01 ：電機轉動控制參數，開環模式，電機的PWM值、轉動持續脈沖數；
  31.                                                    0x02 ：電機轉動控制參數，閉環模式，電機的轉速、轉動持續脈沖數；
  32.                                                          0x03 ：電機工作參數，PWM頻率、PID參數
  33.         數據區 —— 命令01：電機1數據（2字節PWM值，2字節轉動持續脈沖數）電機2數據（2字節PWM值，2字節轉動持續脈沖數），共 8字節；
  34.                                                 命令02：電機1數據（2字節轉速值，2字節轉動持續脈沖數）電機2數據（2字節轉速值，2字節轉動持續脈沖數），共 8字節；
  35.                                                 命令03：2字節PWM頻率，2字節比例系數，2字節積分系數，2字節微分系數，2字節PID系數的分母， 共10字節，兩個電機驅動器相同；
  36.         校驗和 —— 從命令字開始到數據區結束所有字節的算術和的反碼，取低字節。

  38. 上述數據中，PWM值，速度值、PWM頻率、PID系數等定義如下：
  39.         PWM值 ——         2字節有符號數，正對應正轉，負對應反轉，數值為占空比的百分數，
  40.                                                 取值范圍：- 1000 ——  +1000， 對應 0.1% ~ 100%；1001為電機“惰行”，1002為“剎車”；
  41.        
  42.         轉動持續脈沖數 ——  2字節無符號數，0 表示連續轉動；
  43.        
  44.         轉速值 —— 2字節有符號數，正對應正轉，負對應反轉，單位為：0.1轉/每分鐘；
  45.                                                 取值范圍：- 10000~ +10000，10001為電機“惰行”，10002為“剎車”；
  46.        
  47.         PWM頻率 —— 2字節整數，單位Hz，取值范圍：200 – 2000；
  48.        
  49.         PID系數 —— 均為 2字節無符號數；
  50.         PID系數分母 ——  2字節無符號數，為避免使用浮點數而增加了此參數，實際作用的PID系數為上述值除此值；
  51.                                                                         如：比例系數為190 ，PID分母為200，實際比例系數為0.95。

  53. 以上所有2字節的數據均為先低后高。
  54. 暫時不設計應答幀，因為一幀命令包含了兩個電機的驅動數據。

  56. 通訊數據格式為：19200  8  N  1。
  57. 此時，一幀數據約占 7ms。

  59. 為了調試，添加轉速讀取命令 0x04 ,原來的讀轉速命令是分開實現的：
  60.         0x55  0xAA  0x02（幀長） 0x04 (讀轉速命令)  電機序號（1字節）校驗和（1字節）
  61.        
  62.         對應的返回幀為：
  63.         0xAA 0x55  0x04（幀長） 0x84 (轉速值返回) 電機序號（1字節）轉速（2字節）校驗和（1字節）
  64.        

  66. 因為合并到一個MCU中了，所以對應將協議改為：
  67.         0x55  0xAA  0x01（幀長） 0x04 (讀轉速命令) 校驗和（1字節）
  68.        
  69.         對應的返回幀為：
  70.         0xAA 0x55  0x05（幀長） 0x84 (轉速值返回) 電機1轉速（2字節）電機2轉速（2字節）校驗和（1字節）


  73. 因為集成了走軌跡控制功能，所以要添加一個控制命令，使小車啟動，進入到走軌跡狀態或結束走軌跡的狀態。
  74.         走軌跡控制命令： 0x05 .   命令參數 ——  1 啟動走軌跡， 2 ——  啟動走直線 ，0 停止,
  75.         命令幀為：
  76.         0x55 0xAA 0x02 0x05 0x01 CS        ——  啟動走軌跡命令
  77.         0x55 0xAA 0x02 0x05 0x02 CS        ——  啟動直線走命令
  78.         0x55 0xAA 0x02 0x05 0x00 CS        ——  停止命令

  80. 為了調試方便，增加一個內存數據讀取命令：
  81.         內存數據讀取命令：0x06
  82.         命令幀為：
  83.         0x55 0xAA 0x04 0x06 讀數據低地址 讀數據高地址 讀數據長度 CS
  84.         返回幀為：
  85.         0x55 0xAA 幀長 0x86 讀數據低地址 讀數據高地址 讀數據長度 數據N字節 CS

  87. ------------------------------------------------------------------------
  88.         因為用雙輪驅動的小車由于電機等驅動元素的差異，導致走直線成為問題，故在此嘗試
  89. 用這兩個簡易的碼盤來實現直線行走。               

  91.         因為碼盤的分辨率太低，所以直接用脈沖計數方式控制似乎有些不夠精確，所以考慮用
  92. 兩路脈沖的觸發時間差別來控制。
  93.         實質上這是一種周期測量的變換，因為不能保證每個脈沖周期是真實的（即由于干擾會
  94. 導致某個周期變大或變�。杂美塾嫷姆绞较�。

  96.         具體的方式如下：
  97.         設立兩個 4 字節的計數器，2字節紀錄PCA的溢出值，2字節紀錄 PCA 的計時器值，這樣
  98. 構成了一個對PCA計數脈沖（Fosc/2)的長整形計數器，可紀錄約 388秒（2^32/11.0592M)，
  99. 這個值一般可以應付大部分比賽項目中的需要。

  101.         將這個時間計數器作為兩個輪子采樣脈沖（只取下降沿）的時標，根據兩者的差值確定兩輪
  102. 的驅動差。也就是要保證兩個輪子對應脈沖到達的時間相同，這樣，如果沒有漏計或打滑，兩
  103. 個輪子行走的距離應當是一樣的，軌跡也應當是直線！

  105.         這個控制也可以考慮使用PID控制，其控制的量為兩個計數器的差值，定值為“0”。
  106.        
  107. ------------------------------------------------------------------------*/

  109. #pragma PR
  110. #pragma OT(5,size)

  112. #pragma Listinclude
  113. #pragma code

  115. #include <E:\dingqi\keilc51\inc\math.h>

  117. #include <STC12C5410AD.h>                                /* STC12C5410AD 的頭文件*/

  119. #include <Port_Def.H>

  121. #include <ComConst.H>

  123. #include <LC_Const.H>

  125. #include <LC_Var.H>

  127. void init_SIO(unsigned char baud);                                                // 初始化串口
  128. void rcvdata_proc(void);                                                                                        // 接收數據幀
  129. void getCommandData(void);                                                                                // 從數據幀中取出命令數據
  130. unsigned int calStopCntValue(unsigned int uiRun_Num,unsigned char No); // 根據命令中的行走脈沖數計算出停止點
  131. char setMotorStat(int iRunValue);                                                        // 根據命令中的PWM值或轉速設置電機狀態
  132. void followLineControl(void);                                                                        // 走軌跡控制
  133. void straightRun(void);                                                                                                // 走直線控制

  135. /******************************** 外部調用函數 *********************************/

  137. // 以下函數為公共函數，需要在調用的模塊中聲明。

  139. /********************************************/
  140. /* 名稱：init_LineCtrl_Hardware                                                        */
  141. /* 用途：初始化串口等, 以保證相應硬件工作                */
  142. /********************************************/

  144. void init_LineCtrl_Hardware(void)
  145. {
  146.         //初始化串口
  147.         init_SIO(B_19200);
  148.        
  149.         // 初始化相關中斷
  150.         IE = IE|EnUART_C;                                                                                // 允許 UART 中斷
  151. }

  153. /********************************************/
  154. /* 名稱：init_LineCtrl_Var                                                                        */
  155. /* 用途：初始化自身工作變量                                                                        */
  156. /********************************************/

  158. void init_LineCtrl_Var(void)
  159. {
  160.         unsigned char j;
  161.        
  162.         // 接收數據變量初始化
  163.         gi_ucSavePtr=0;
  164.         gi_ucGetPtr=0;
  165.        
  166.         gb_NewData = FALSE;
  167.         gb_StartRcv = FALSE;
  168.         gb_DataOK = FALSE;
  169.        
  170.         // 命令數據存放單元初始化
  171.         for(j=0;j<2;j++)
  172.         {
  173.                 ga_iPWM_Value[j] = FLOAT_PWM;
  174.                 ga_iRotateSpeed[j] = FLOAT_SPEED;
  175.                
  176.                 ga_uiRotateNum[j] = 0;
  177.         }
  178.        
  179.         g_uiPWM_Freq = INIT_PWM_FREQ;                                                        // 初始化時，將PWM的頻率置為 200Hz
  180.        
  181.         gb_M1CalOutValue = TRUE;                                                                        // 上電計算一次輸出，以保證電機的正常工作狀態
  182.         gb_M2CalOutValue = TRUE;                                                                        // 上電計算一次輸出，以保證電機的正常工作狀態
  183.                        
  184.         // PID 控制初始化
  185.         g_uiKp = DEFAULT_KP;                                                                                        // 加載默認系數
  186.         g_uiTi = DEFAULT_TI;
  187.         g_uiTd = DEFAULT_TD;
  188.         g_uiPID_Ratio = DEFAULT_PID_RATIO;
  189.        
  190.         g_fKp = ((float)g_uiKp)/g_uiPID_Ratio;                        // 在此處計算好，減少每次 PID 的運算量
  191.         g_fTi = ((float)g_uiTi)/g_uiPID_Ratio;
  192.         g_fTd = ((float)g_uiTd)/g_uiPID_Ratio;

  194.         gb_EnablePID = FALSE;                                                                                        // 禁止調速 PID 功能
  195.        
  196.         gb_StartLineFollow = FALSE;
  197.         gb_StartStraightRun = FALSE;
  198.         g_ucDownSampCnt = 0;                                                                                        // 初始化時將脈沖采樣計數清為“0”       

  200. }

  202. /********************************************/
  203. /* 名稱：lineCtrl_proc                                                                                        */
  204. /* 用途：軌跡控制部分處理入口函數，根據帶入        */
  205. /*       的消息作相應處理。                                                                        */
  206. /*入口參數：要處理的消息                                                                                */
  207. /********************************************/

  209. void lineCtrl_proc(unsigned char ucMessage)
  210. {
  211.         switch(ucMessage)
  212.         {
  213.                 case NEW_RCV_DATA:
  214.                 {
  215.                         rcvdata_proc();                                                                                        // 處理接收緩沖區數據                        

  217.                         if(gb_DataOK)
  218.                         {
  219.                                 gb_DataOK = FALSE;
  220.                                 getCommandData();                                                                        // 從數據幀中提取命令數據
  221.                         }                               
  222.                         break;
  223.                 }
  224.                
  225.                 case NEW_SAMP_DATA:
  226.                 {
  227.                         followLineControl();
  228.                         break;
  229.                 }
  230.                
  231.                 case         SAMPLE_DOWN_PULS:
  232.                 {
  233.                         straightRun();
  234.                         break;
  235.                 }
  236.                
  237.                 default:         break;
  238.                
  239.         }
  240. }



  244. /***************************** 模塊自用函數 *******************************/

  246. // 以下函數只由模塊自身使用，別的模塊不用聲明。

  248. /********************************************/
  249. /* 名稱：init_SIO                                                                                                                */
  250. /* 用途：初始化串口,                                                                                                 */
  251. /* 參數: 波特率 , 模式固定為:1                                                         */
  252. /*                 1 START 8 DATA 1 STOP                                                                 */
  253. /********************************************/

  255. void init_SIO(unsigned char baud)
  256. {
  257.         // 波特率表
  258.         unsigned char        code        TH_Baud[5]={B4800_C,B9600_C,B19200_C,B38400_C,B57600_C};
  259.        
  260.         AUXR = AUXR|SET_T1X12_C;
  261.         TH1 = TH_Baud[baud];
  262.         TL1 = TH_Baud[baud];
  263.         TR1 = TRUE;
  264.        
  265.         SCON        =        UART_MODE1_C|EN_RCV_C;        // 8 位模式( MODE 1)
  266. }

  268. /********************************************/
  269. /*名稱:        rcvdata_proc                                                                                                */
  270. /*用途: 檢測接收緩沖區數據，                                                     */
  271. /*說明:        如果收到正確的數據幀則建立標志                        */
  272. /********************************************/

  274. void rcvdata_proc(void)
  275. {
  276.         unsigned char i,j,k;
  277.        
  278.        
  279.         if(gb_StartRcv == FALSE)
  280.         {
  281.                 /*  檢測幀頭 0x55 0xAA LEN */
  282.                
  283.                 i=(gi_ucGetPtr-2)&(MaxRcvByte_C-1);                // 指向0x55
  284.                 j=(gi_ucGetPtr-1)&(MaxRcvByte_C-1);                // 指向0xAA
  285.                
  286.                 if((ga_ucRcvBuf[i]==0x55)&&(ga_ucRcvBuf[j]==0xAA))
  287.                 {
  288.                         i=gi_ucGetPtr;
  289.                                                
  290.                         if(ga_ucRcvBuf[i]<= (MaxRcvByte_C-1));
  291.                         {
  292.                                 //幀頭正確，啟動數據區接收
  293.                                 gb_StartRcv=TRUE;       
  294.                                 gc_ucDataLen=ga_ucRcvBuf[i];
  295.                                 gi_ucStartPtr=(gi_ucGetPtr+1)&(MaxRcvByte_C-1);
  296.                                 gi_ucEndPtr= (gi_ucGetPtr + gc_ucDataLen+1)&(MaxRcvByte_C-1);
  297.                         }
  298.                 }
  299.                 gi_ucGetPtr=(gi_ucGetPtr+1)&(MaxRcvByte_C-1);
  300.         }
  301.         else
  302.         {
  303.                 //開始接收數據處理
  304.                 if(gi_ucGetPtr==gi_ucEndPtr)
  305.                 {
  306.                         /* 數據幀接收完 */
  307.                         gb_StartRcv=FALSE;
  308.                        
  309.                         j=gi_ucStartPtr;       
  310.                         k= 0;
  311.                         for(i=0;i<gc_ucDataLen;i++)
  312.                         {
  313.                                 // 計算CS
  314.                                 k +=ga_ucRcvBuf[j];               
  315.                                 j=(j+1)&(MaxRcvByte_C-1);
  316.                         }
  317.                        
  318.                         // 取校驗和
  319.                         k +=ga_ucRcvBuf[j];                       
  320.                         if( k == 0xFF)
  321.                         {
  322.                                 // 數據校驗正確
  323.                                 gb_DataOK=TRUE;
  324.                         }
  325.                 }
  326.                 gi_ucGetPtr=(gi_ucGetPtr+1)&(MaxRcvByte_C-1);
  327.         }                       
  328. }

  330. /********************************************/
  331. /*名稱:        getCommandData                                                                                        */
  332. /*用途: 從接收緩沖區中取出數據，                                                 */
  333. /*說明:        建立對應標志，通知相應的處理                          */
  334. /********************************************/

  336. void getCommandData(void)
  337. {
  338.         union
  339.         {
  340.                 unsigned int all;
  341.                 unsigned char b[2];
  342.         }uitemp;
  343.        
  344.         union
  345.         {
  346.                 int        all;
  347.                 unsigned char b[2];
  348.         }itemp;
  349.        
  350.         unsigned char ucCommand,i,j,sum,n;
  351.         unsigned char idata *ucI_Ptr;
  352.         unsigned char xdata *ucX_Ptr;
  353.        
  354.         ucCommand = ga_ucRcvBuf[gi_ucStartPtr];                                // 取出數據幀中的命令字
  355.        
  356.         switch (ucCommand)
  357.         {
  358.                 case PWM_MODE:
  359.                 {
  360.                         // 處理PWM開環控制命令
  361.                         i = (gi_ucStartPtr + 1)&(MaxRcvByte_C - 1);                        // 指向電機 1 數據區
  362.                        
  363.                         for(j=0;j<2;j++)                                                                                                                                // 循環 2 次完成兩個電機的數據提取
  364.                         {
  365.                                 itemp.b[1] = ga_ucRcvBuf[i];                                                                                // 注意，在C51中，整形等多字節數據在內存中是先高后低存放！
  366.                                 i =(i+1)&(MaxRcvByte_C-1);
  367.                                 itemp.b[0] = ga_ucRcvBuf[i];                               
  368.                                
  369.                                 if(itemp.all < (-1000))                                                                                                // PWM值合法性處理
  370.                                 {
  371.                                         itemp.all = -1000;
  372.                                 }
  373.                                 if(itemp.all > 1002)
  374.                                 {
  375.                                         itemp.all = 1000;
  376.                                 }                               
  377.                                 ga_iPWM_Value[j] = itemp.all;                                                                        // 得到 PWM 值

  379.                                 // 行走脈沖計數數據處理
  380.                                 i =(i+1)&(MaxRcvByte_C-1);
  381.                                 uitemp.b[1] = ga_ucRcvBuf[i];
  382.                                 i =(i+1)&(MaxRcvByte_C-1);
  383.                                 uitemp.b[0] = ga_ucRcvBuf[i];
  384.                                 ga_uiRotateNum[j] = uitemp.all;                                                                                                        // 得到轉動脈沖計數值
  385.                                
  386.                                 ga_uiStopCnt[j] = calStopCntValue(ga_uiRotateNum[j],j);        // 計算出停止計數值
  387.                                
  388.                                 ga_cMotorStat[j] = setMotorStat(ga_iPWM_Value[j]);                // 根據命令設置電機運轉標志
  389.                                
  390.                                 i = (gi_ucStartPtr + 1+4)&(MaxRcvByte_C - 1);                                        // 指向電機 2 數據區
  391.                         }
  392.                        
  393.                         gb_EnablePID = FALSE;                                                                                                                                                // 收到PWM控制命令后，禁止 PID 控制
  394.                                                        
  395.                         gb_M1CalOutValue =TRUE;                                                                                                                                        // 建立計算電機控制輸出值標志，因為PWM數據變化
  396.                         gb_M2CalOutValue =TRUE;       
  397.                        
  398.                         break;
  399.                 }
  400.                
  401.                 case SPEED_MODE:
  402.                 {
  403.                         // 處理轉速閉環控制命令
  404.                         i = (gi_ucStartPtr + 1 )&(MaxRcvByte_C-1);                                                        // 指向電機 1 數據區
  405.                        
  406.                         for(j=0;j<2;j++)                                                                                                                                                                // 循環 2 次完成兩個電機的數據提取
  407.                         {
  408.                                 itemp.b[1] = ga_ucRcvBuf[i];                                                                // 注意，在C51中，整形等多字節數據在內存中是先高后低存放！
  409.                                 i =(i+1)&(MaxRcvByte_C-1);
  410.                                 itemp.b[0] = ga_ucRcvBuf[i];                               

  412.                                 if(itemp.all < (-10000))                                                                                // 轉速數據合法性處理
  413.                                 {
  414.                                         itemp.all = -10000;
  415.                                 }
  416.                                 if(itemp.all > 10002)
  417.                                 {
  418.                                         itemp.all = 10000;
  419.                                 }
  420.                                 ga_iRotateSpeed[j] = itemp.all;                                                                // 得到轉速

  422.                                 // 行走脈沖數據處理       
  423.                                 i =(i+1)&(MaxRcvByte_C-1);
  424.                                 uitemp.b[1] = ga_ucRcvBuf[i];
  425.                                 i =(i+1)&(MaxRcvByte_C-1);
  426.                                 uitemp.b[0] = ga_ucRcvBuf[i];
  427.                                 ga_uiRotateNum[j] = uitemp.all;                                                                                                                // 得到轉動脈沖計數值
  428.                                
  429.                                 ga_uiStopCnt[j] = calStopCntValue(ga_uiRotateNum[j],j);        // 計算出停止計數值
  430.        
  431.                                 ga_cMotorStat[j] = setMotorStat(ga_iRotateSpeed[j]);                // 根據命令設置電機運轉標志
  432.                        
  433.                                 i = (gi_ucStartPtr + 1 + 4)&(MaxRcvByte_C-1);                                                // 指向電機 2 數據區
  434.                         }
  435.                        
  436.                         if(gb_EnablePID)
  437.                         {
  438.                                 // 已啟動PID控制       
  439.                         }
  440.                         else
  441.                         {
  442.                                 // 啟動 PID 控制
  443.                                 gb_EnablePID = TRUE;
  444.                                 gac_ucGetSpeedCnt[MOTOR1] = 3;                                                                // 電機 1 采集3次速度數據后才允許計算PID
  445.                                 gac_ucGetSpeedCnt[MOTOR2] = 3;                                                                // 電機 2 采集3次速度數據后才允許計算PID
  446.                                 ga_iPWM_Value[MOTOR1] = INI_PWM_VALUE;                                // 電機 1 輸出PWM初值，啟動電機
  447.                                 ga_iPWM_Value[MOTOR2] = INI_PWM_VALUE;                                // 電機 2 輸出PWM初值，啟動電機
  448.                                 gb_M1CalOutValue = TRUE;                                                                                        // 通知輸出計算
  449.                                 gb_M2CalOutValue = TRUE;
  450.                         }
  451.                                                
  452.                         break;
  453.                 }
  454.                
  455.                 case SET_PARA:
  456.                 {
  457.                         // 處理參數設置命令
  458.                         i = (gi_ucStartPtr + 1)&(MaxRcvByte_C-1);               
  459.                         uitemp.b[1] = ga_ucRcvBuf[i];                                                                // 注意，在C51中，整形等多字節數據在內存中是先高后低存放！
  460.                         i =(i+1)&(MaxRcvByte_C-1);
  461.                         uitemp.b[0] = ga_ucRcvBuf[i];
  462.                         g_uiPWM_Freq = uitemp.all;
  463.                         if(g_uiPWM_Freq <200)                                                // 數據合法性處理
  464.                         {
  465.                                 g_uiPWM_Freq = 200;
  466.                         }
  467.                         if(g_uiPWM_Freq >2000)
  468.                         {
  469.                                 g_uiPWM_Freq = 2000;
  470.                         }
  471.                         gb_M1CalOutValue =TRUE;                                        // 建立計算電機控制輸出值標志，因為PWM的頻率變了。
  472.                         gb_M2CalOutValue =TRUE;
  473.                        
  474.                         // 取 PID 參數
  475.                         i =(i+1)&(MaxRcvByte_C-1);
  476.                         uitemp.b[1] = ga_ucRcvBuf[i];
  477.                         i =(i+1)&(MaxRcvByte_C-1);
  478.                         uitemp.b[0] = ga_ucRcvBuf[i];
  479.                         g_uiKp = uitemp.all;
  480.                        
  481.                         i =(i+1)&(MaxRcvByte_C-1);
  482.                         uitemp.b[1] = ga_ucRcvBuf[i];
  483.                         i =(i+1)&(MaxRcvByte_C-1);
  484.                         uitemp.b[0] = ga_ucRcvBuf[i];
  485.                         g_uiTi = uitemp.all;

  487.                         i =(i+1)&(MaxRcvByte_C-1);
  488.                         uitemp.b[1] = ga_ucRcvBuf[i];
  489.                         i =(i+1)&(MaxRcvByte_C-1);
  490.                         uitemp.b[0] = ga_ucRcvBuf[i];                       
  491.                         g_uiTd = uitemp.all;
  492.                        
  493.                         i =(i+1)&(MaxRcvByte_C-1);
  494.                         uitemp.b[1] = ga_ucRcvBuf[i];
  495.                         i =(i+1)&(MaxRcvByte_C-1);
  496.                         uitemp.b[0] = ga_ucRcvBuf[i];
  497.                         if(uitemp.all >0)
  498.                         {
  499.                                 g_uiPID_Ratio = uitemp.all;
  500.                         }
  501.                        
  502.                         g_fKp = ((float)g_uiKp)/g_uiPID_Ratio;                        // 在此處計算好，減少每次 PID 的運算量
  503.                         g_fTi = ((float)g_uiTi)/g_uiPID_Ratio;
  504.                         g_fTd = ((float)g_uiTd)/g_uiPID_Ratio;
  505.                                                
  506.                         break;
  507.                 }
  508.                
  509.                 case READ_SPEED:
  510.                 {
  511.                         // 讀取轉速命令處理
  512.                         ga_ucTxdBuf[0] = 0xAA;
  513.                         ga_ucTxdBuf[1] = 0x55;                                                // 幀頭
  514.                         ga_ucTxdBuf[2] = 0x05;                                                // 幀長
  515.                         ga_ucTxdBuf[3] = 0x80+READ_SPEED;        // 返回命令
  516.                         sum = ga_ucTxdBuf[3];
  517.                         i=4;
  518.                         for(j=0;j<2;j++)                                                                        // 循環 2 次，返回 2 個電機的轉速
  519.                         {                                                               
  520.                                 itemp.all = ga_iCurSpeed[j];
  521.                                 ga_ucTxdBuf[i] = itemp.b[1];                // 返回轉速值，先低后高
  522.                                 sum += ga_ucTxdBuf[i];
  523.                                 i++;
  524.                                 ga_ucTxdBuf[i] = itemp.b[0];
  525.                                 sum += ga_ucTxdBuf[i];
  526.                                 i++;
  527.                         }
  528.                        
  529.                         ga_ucTxdBuf[i] = ~sum;                                                // 校驗和
  530.                                
  531.                         gc_ucTxdCnt = 9;                                                                        // 發送字節計數
  532.                         gi_ucTxdPtr = 0;                                                                        // 發送指針
  533.                         SBUF = ga_ucTxdBuf[0];                                                // 啟動發送
  534.                        
  535.                         break;
  536.                 }
  537.                
  538.                 case FOLLOW_LINE_CTRL:
  539.                 {
  540.                         i = (gi_ucStartPtr + 1)&(MaxRcvByte_C-1);
  541.                         switch (ga_ucRcvBuf[i])
  542.                         {
  543.                                 case FOLLOW_LINE:
  544.                                 {
  545.                                         break;
  546.                                 }
  547.                                
  548.                                 case STRAIGHT_RUN:
  549.                                 {
  550.                                         gb_StartStraightRun =  TRUE;
  551.                                        
  552.                                         gc_uiPCA_OverCnt = 0;
  553.                                         g_ucDownSampCnt = 0;
  554.                                                                                
  555.                                         //gb_EnSpeed_Hi_Low = TRUE;                                // 啟動速度上下限控制
  556.                                        
  557.                                         g_iInit_PWM = INI_PWM_VALUE;                 // 啟動電機
  558.                                         ga_iPWM_Value[MOTOR1] = g_iInit_PWM;
  559.                                         ga_cMotorStat[MOTOR1] = setMotorStat(ga_iPWM_Value[MOTOR1]);                // 設置電機運轉標志
  560.                                         ga_iPWM_Value[MOTOR2] = g_iInit_PWM;
  561.                                         ga_cMotorStat[MOTOR2] = setMotorStat(ga_iPWM_Value[MOTOR2]);                // 設置電機運轉標志
  562.                                        
  563.                                         m_iDiffPWM = 0;                                       

  565.                                         gb_M1CalOutValue =TRUE;                                        // 建立計算電機控制輸出值標志，
  566.                                         gb_M2CalOutValue =TRUE;       
  567.                                                                                
  568.                                         m_iError_Int = 0;                                                                // 初始化PID計算數據
  569.                                         m_iErrorOld = 0;
  570.                                        
  571.                                         break;
  572.                                 }
  573.                                
  574.                                 case STOP_RUN:
  575.                                 {
  576.                                         ga_iPWM_Value[MOTOR1] = BRAKE_PWM;
  577.                                         ga_cMotorStat[MOTOR1] = setMotorStat(ga_iPWM_Value[MOTOR1]);                // 設置電機運轉標志
  578.                                         ga_iPWM_Value[MOTOR2] = BRAKE_PWM;
  579.                                         ga_cMotorStat[MOTOR2] = setMotorStat(ga_iPWM_Value[MOTOR2]);                // 設置電機運轉標志

  581.                                         gb_EnSpeed_Hi_Low = FALSE;
  582.                                         gb_StartStraightRun = FALSE;
  583.                                         gb_StartLineFollow = FALSE;

  585.                                         gb_M1CalOutValue =TRUE;                                        // 建立計算電機控制輸出值標志，
  586.                                         gb_M2CalOutValue =TRUE;       
  587.                                         break;
  588.                                 }
  589.                                
  590.                                 default: break;
  591.                         }
  592.                        
  593.                         break;
  594.                 }
  595.                
  596.                 case READ_MEMORY:
  597.                 {
  598.                         // 讀內存數據處理
  599.                         i = (gi_ucStartPtr + 1)&(MaxRcvByte_C-1);               
  600.                         uitemp.b[1] = ga_ucRcvBuf[i];                                                                // 取讀數據地址
  601.                         i =(i+1)&(MaxRcvByte_C-1);
  602.                         uitemp.b[0] = ga_ucRcvBuf[i];
  603.                         i =(i+1)&(MaxRcvByte_C-1);
  604.                         n = ga_ucRcvBuf[i];                                                                                                        // 取讀數據長度
  605.                         if(n>(MaxTxdByte_C - 4))
  606.                         {
  607.                                 n = (MaxTxdByte_C - 4);                                                                                // 受發送緩沖區限制，減 4 個字節對應： 命令 地址 長度
  608.                         }
  609.                        
  610.                         ga_ucTxdBuf[0] = 0xAA;
  611.                         ga_ucTxdBuf[1] = 0x55;                                                                                        // 幀頭
  612.                         ga_ucTxdBuf[2] = n + 4;                                                                                        // 幀長
  613.                         ga_ucTxdBuf[3] = 0x80+READ_MEMORY;                                        // 返回命令
  614.                         ga_ucTxdBuf[4] = uitemp.b[1];                                                                // 將要讀數據的地址和長度返回
  615.                         ga_ucTxdBuf[5] = uitemp.b[0];
  616.                         ga_ucTxdBuf[6] = n;
  617.                         sum = ga_ucTxdBuf[3]+ga_ucTxdBuf[4]+ga_ucTxdBuf[5]+ga_ucTxdBuf[6];

  619.                         i = 7;                                                                                                                                                        // 數據區起始指針
  620.                        
  621.                         if(uitemp.b[0] == 0)
  622.                         {
  623.                                 ucI_Ptr = uitemp.b[1];                                                                                // 如果高地址為 0 ，則讀IDATA內容
  624.                                 for(j=0;j<n;j++)
  625.                                 {
  626.                                         ga_ucTxdBuf[i] = *ucI_Ptr;
  627.                                         i++;
  628.                                         ucI_Ptr++;
  629.                                 }
  630.                         }
  631.                         else
  632.                         {
  633.                                 ucX_Ptr = uitemp.b[1];                                                                                // 如果高地址不為“0”，則讀XDATA內容，因為只有256字節的XDATA，所以只取低字節。
  634.                                 for(j=0;j<n;j++)
  635.                                 {
  636.                                         ga_ucTxdBuf[i] = *ucX_Ptr;
  637.                                         i++;
  638.                                         ucX_Ptr++;
  639.                                 }
  640.                         }

  642.                         ga_ucTxdBuf[i] = ~sum;                                                // 校驗和
  643.                                
  644.                         gc_ucTxdCnt = i+1;                                                                // 發送字節計數
  645.                         gi_ucTxdPtr = 0;                                                                        // 發送指針
  646.                         SBUF = ga_ucTxdBuf[0];                                                // 啟動發送
  647.                        
  648.                         break;
  649.                 }
  650.                
  651.                 default:
  652.                 {
  653.                         break;
  654.                 }
  655.         }
  656. }

  658. /********************************************/
  659. /*名稱:        calStopCntValue                                                                                        */
  660. /*用途: 根據得到的行走脈沖數計算出停止點          */
  661. /********************************************/

  663. unsigned int calStopCntValue(unsigned int uiRun_Num,unsigned char No)
  664. {
  665.         unsigned int cnt1;
  666.        
  667.         if(uiRun_Num !=0)
  668.         {
  669.                 cnt1 = gac_uiPulsCnt[No];
  670.                 while(cnt1 != gac_uiPulsCnt[No])
  671.                 {
  672.                         cnt1 = gac_uiPulsCnt[No];                                                                        // 防護處理，避免正好在PCA中斷時取數
  673.                 }
  674.                
  675.                 cnt1 = cnt1 + uiRun_Num;                                                                                // 得到停止的判斷點
  676.         }
  677.         else
  678.         {
  679.                 cnt1 = 65535;                                                                                                                                // g_uiRotateNum =0；設置為最大值，永不停止
  680.         }       

  682.         return(cnt1);
  683. }

  685. /*********************************************/
  686. /*名稱:        setMotorStat                                                                                                 */
  687. /*用途: 根據命令中的PWM值或轉速值設置電機狀態*/
  688. /*********************************************/
  689. char setMotorStat(int iRunValue)
  690. {
  691.         char stat;
  692.        
  693.         switch (iRunValue)
  694.         {
  695.                 case 0:
  696.                 {
  697.                         stat = IN_STOP;
  698.                         break;
  699.                 }
  700.                
  701.                 case FLOAT_PWM:
  702.                 {
  703.                         stat = IN_STOP;
  704.                         break;
  705.                 }
  706.                
  707.                 case BRAKE_PWM:
  708.                 {
  709.                         stat = IN_STOP;
  710.                         break;
  711.                 }
  712.                
  713.                 case FLOAT_SPEED:
  714.                 {
  715.                         stat = IN_STOP;
  716.                         break;
  717.                 }
  718.                
  719.                 case BRAKE_SPEED:
  720.                 {
  721.                         stat = IN_STOP;
  722.                         break;
  723.                 }
  724.                
  725.                 default:
  726.                 {
  727.                         if(iRunValue >0)
  728.                         {
  729.                                 stat = IN_FORWARD;
  730.                         }
  731.                         else
  732.                         {
  733.                                 stat = IN_BACKWARD;
  734.                         }
  735.                         break;
  736.                 }               
  737.         }
  738.         return(stat);
  739. }

  741. /*********************************************/
  742. /*名稱:        followLineControl                                                                                 */
  743. /*用途: 根據采樣輸出值g_cSampleOut 控制尋跡         */
  744. /*********************************************/

  746. ……………………

  748. …………限于本文篇幅 余下代碼請從51黑下載附件…………
復制代碼

所有資料51hei提供下載:
循跡小車詳細資料包括電路圖、軟件編程.rar (238.93 KB, 下載次數: 150)


評分

參與人數 1黑幣 +50 收起 理由
admin + 50 共享資料的黑幣獎勵！

查看全部評分

分享到:  QQ好友和群QQ好友和群 QQ空間QQ空間 騰訊微博騰訊微博 騰訊朋友騰訊朋友
收藏收藏8 分享淘帖 頂頂2 踩踩
回復

使用道具 舉報

無效樓層，該帖已經被刪除
板凳
ID:539016 發表于 2020-4-28 00:14 | 只看該作者
好東西，值得學習
回復

使用道具 舉報

地板
ID:539016 發表于 2020-4-28 00:14 | 只看該作者
好東西，值得學習
回復

使用道具 舉報

5#
ID:958455 發表于 2021-9-7 20:35 | 只看該作者
最近學校也在組織循跡小車的比賽，頂
回復

使用道具 舉報

6#
無效樓層，該帖已經被刪除
您需要登錄后才可以回帖 登錄 | 立即注冊

本版積分規則

小黑屋|51黑電子論壇 |51黑電子論壇6群 QQ 管理員QQ:125739409;技術交流QQ群281945664

Powered by 單片機教程網

快速回復 返回頂部 返回列表