標題: 單片機步進電機控制實現(xiàn)直線插補的仿真與程序源碼 [打印本頁]
作者: 151431    時間: 2018-7-10 14:36
標題: 單片機步進電機控制實現(xiàn)直線插補的仿真與程序源碼
單片機控制步進電機實現(xiàn)直線插補仿真原理圖如下（proteus仿真工程文件可到本帖附件中下載）


單片機源程序如下:
  1. #include<reg51.h>
  2. #define uint unsigned int
  3. #define uchar unsigned char

  5. uchar code bux[]={0xf0,0xf1,0xf3,0xf2,0xf6,0xf4,0xfc,0xf8,0xf9};
  6. uchar code buy[]={0x00,0x10,0x30,0x20,0x60,0x40,0xc0,0x80,0x90};
  7. uchar code comx[]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90};
  8. uchar code comy[]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90};

  10. sbit SX=P3^4;
  11. sbit SY=P3^5;
  12. sbit ST=P3^6;

  14. uint countx=0;
  15. uint county=0;
  16. uint count,flag=0;
  17. uint x=0;
  18. uint y=0;
  19. uint a=0,b=0,k=0,m=0;
  20. uint st=0;
  21. char Fm[20];

  23. void Key_Scan(void);
  24. void Key_Action(void);
  25. void motor();
  26. void stepx();
  27. void stepy();
  28. void star();
  29. void time0(void);

  31. void delayms(uint t)
  32. {
  33. uint i,j;
  34. for(i=0;i<t;i++)
  35.   for(j=0;j<112;j++);
  36. }



  40. void main()
  41. {
  42.         while(1)
  43.         {
  44.                 Key_Scan();
  45.                 time0();
  46.                 while(!flag);
  47.                 flag=0;
  48.                 motor();
  49.                 if(1==st)
  50.                 {       
  51.                         star();
  52.                         st=0;
  53.                 }
  54.        
  55.         }
  56. }


  59. void Key_Scan(void)
  60. {
  61.         if(0==SX)
  62.         {
  63.                 delayms(10);
  64.                 if(0==SX)
  65.                 {
  66.                         countx++;
  67.                         while(!SX);       
  68.                 }       
  69.         }
  70.         if(0==SY)
  71.         {
  72.                 delayms(10);
  73.                 if(0==SY)
  74.                 {
  75.                         county++;
  76.                         while(!SY);       
  77.                 }       
  78.         }
  79.        
  80. }
  81. void time0(void)
  82. {
  83.         TMOD=0x01;
  84.         TH0=(65536-9216)/256;
  85.         TL0=(65536-9216)%256;
  86.         EA=1;
  87.         ET0=1;
  88.         TR0=1;
  89. }
  90. void TimeRS(void) interrupt 1
  91. {
  92.         TH0=(65536-9216)/256;
  93.         TL0=(65536-9216)%256;
  94.         count++;
  95.         if(count>=10)
  96.         {
  97.                 Key_Action();
  98.                 flag=1;       
  99.                 count=0;       
  100.         }


  103.        
  104. }
  105. void Key_Action(void)
  106. {
  107.         uint i,j;
  108.         if(countx>9)
  109.         {
  110.                 countx=0;
  111.         }
  112.         if(county>9)
  113.         {
  114.                 county=0;
  115.         }
  116.         P0=comx[countx];
  117.         //delayms(100);
  118.         P2=comy[county];
  119.         //delayms(100);
  120.        
  121.        
  122. }
  123. void motor()
  124. {
  125.         uint i,j;
  126.         if(0==ST)
  127.         {
  128.                 delayms(10);
  129.                 if(0==ST)
  130.                 {       
  131.                         st=1;
  132.                         while(!ST);       
  133.                 }       
  134.         }       
  135. }
  136. void star()
  137. {
  138.         a=countx;
  139.         b=county;
  140.         m=a+b;
  141.         Fm[k]=0;
  142.         while(m>0)
  143.         {
  144.                 if(Fm[k]>=0)
  145.                 {
  146.                         x++;
  147.                         m--;
  148.                         stepx();
  149.                         k++;
  150.                         Fm[k]=Fm[k-1]-b;

  152.                 }
  153.                 if(Fm[k]<0)
  154.                 {
  155.                         y++;
  156.                         m--;
  157.                         stepy();
  158.                         k++;
  159.                         Fm[k]=Fm[k-1]+a;
  160.        
  161.                 }
  162.         }
  163. }
  164. void stepx()
  165. {
  166.         P3=bux[x];
  167.         delayms(1000);
  168. }
  169. void stepy()
  170. {       
  171.         P1=bux[y];
  172.         delayms(1000);
  173. }

  175. #include<reg51.h>
  176. #define uint unsigned int
  177. #define uchar unsigned char

  179. uchar code bux[]={0xf0,0xf1,0xf3,0xf2,0xf6,0xf4,0xfc,0xf8,0xf9};
  180. uchar code buy[]={0x00,0x10,0x30,0x20,0x60,0x40,0xc0,0x80,0x90};
  181. uchar code comx[]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90};
  182. uchar code comy[]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90};

  184. sbit SX=P3^4;
  185. sbit SY=P3^5;
  186. sbit ST=P3^6;

  188. uint countx=0;
  189. uint county=0;
  190. uint count,flag=0;
  191. uint x=0;
  192. uint y=0;
  193. uint a=0,b=0,k=0,m=0;
  194. uint st=0;
  195. char Fm[20];

  197. void Key_Scan(void);
  198. void Key_Action(void);
  199. void motor();
  200. void stepx();
  201. void stepy();
  202. void star();
  203. void time0(void);

  205. void delayms(uint t)
  206. {
  207. uint i,j;
  208. for(i=0;i<t;i++)
  209.   for(j=0;j<112;j++);
  210. }



  214. void main()
  215. {
  216.         while(1)
  217.         {
  218.                 Key_Scan();
  219.                 time0();
  220.                 while(!flag);
  221.                 flag=0;
  222.                 motor();
  223.                 if(1==st)
  224.                 {       
  225.                         star();
  226.                         st=0;
  227.                 }
  228.        
  229.         }
  230. }


  233. void Key_Scan(void)
  234. {
  235.         if(0==SX)
  236.         {
  237.                 delayms(10);
  238.                 if(0==SX)
  239.                 {
  240.                         countx++;
  241.                         while(!SX);       
  242.                 }       
  243.         }
  244.         if(0==SY)
  245.         {
  246.                 delayms(10);
  247.                 if(0==SY)
  248.                 {
  249.                         county++;
  250.                         while(!SY);       
  251.                 }       
  252.         }
  253.        
  254. }
  255. void time0(void)
  256. {
  257.         TMOD=0x01;
  258.         TH0=(65536-9216)/256;
  259.         TL0=(65536-9216)%256;
  260.         EA=1;
  261.         ET0=1;
  262.         TR0=1;
  263. }
  264. void TimeRS(void) interrupt 1
  265. {
  266.         TH0=(65536-9216)/256;
  267.         TL0=(65536-9216)%256;
  268.         count++;
  269.         if(count>=10)
  270.         {
  271.                 Key_Action();
  272.                 flag=1;       
  273.                 count=0;       
  274.         }


  277.        
  278. }
  279. void Key_Action(void)
  280. {
  281.         uint i,j;
  282.         if(countx>9)
  283.         {
  284.                 countx=0;
  285.         }
  286.         if(county>9)
  287.         {
  288.                 county=0;
  289.         }
  290.         P0=comx[countx];
  291.         //delayms(100);
  292.         P2=comy[county];
  293.         //delayms(100);
  294.        
  295.        
  296. }
  297. void motor()
  298. {
  299.         uint i,j;
  300.         if(0==ST)
  301.         {
  302.                 delayms(10);
  303.                 if(0==ST)
  304.                 {       
  305.                         st=1;
  306.                         while(!ST);       
  307.                 }       
  308.         }       
  309. }
  310. void star()
  311. {
  312.         a=countx;
  313.         b=county;
  314.         m=a+b;
  315.         Fm[k]=0;
  316.         while(m>0)
  317.         {
  318.                 if(Fm[k]>=0)
  319.                 {
  320.                         x++;
  321.                         m--;
  322.                         stepx();
  323.                         k++;
  324.                         Fm[k]=Fm[k-1]-b;

  326.                 }
  327.                 if(Fm[k]<0)
  328.                 {
  329.                         y++;
  330.                         m--;
  331.                         stepy();
  332.                         k++;
  333.                         Fm[k]=Fm[k-1]+a;
  334.        
  335.                 }
  336.         }
  337. }
  338. void stepx()
  339. {
  340.         P3=bux[x];
  341.         delayms(1000);
  342. }
  343. void stepy()
  344. {       
  345.         P1=bux[y];
  346.         delayms(1000);
  347. }

復(fù)制代碼


所有資料51hei提供下載:
步進電機.rar (32.22 KB, 下載次數(shù): 81)



作者: 阿拉登666    時間: 2018-12-3 21:30
感謝分享 值得借鑒



歡迎光臨 (http://www.torrancerestoration.com/bbs/) Powered by Discuz! X3.1