找回密码
 立即注册

QQ登录

只需一步,快速开始

搜索
查看: 3192|回复: 5
打印 上一主题 下一主题
收起左侧

步进电机驱动 C#上位机和STM32下位机源程序 步数方向控制

  [复制链接]
跳转到指定楼层
楼主
C#的上位机和STM32F103C8T6的下位机,利用驱动器实现常见步进电机的驱动,可以实现任意步数(65535以内)、方向的控制


单片机源程序如下:
  1. #include "led.h"
  2. #include "delay.h"
  3. #include "sys.h"
  4. #include "usart.h"         
  5. #include "adc.h"
  6. #include "crc.h"
  7. #include "timer.h"
  8. #include "exti.h"
  9. #define TIMES 5 //0.5 进5次反转一次
  10. #define INIT_STEPS1 500
  11. #define INIT_STEPS2 500
  12. #define INIT_STEPS3 500
  13. #define INIT_STEPS4 500
  14. #define INIT_STEPS5 500
  15. u16 StepNum[5];   //走的步数
  16. u8 Move_Flag[5]; //走不走
  17. u8 Move_Dir_Flag[5]; //走的方向
  18. u8 receive[20];  //接收的数据
  19. u8 send[20];    //发送的数据
  20. u16 crc;
  21. u8 k =0;
  22. u16 Total_times;  //运行要走的来回数目;
  23. u8 Runing_flag;   //运行的标志位
  24. u16 Real_times;//运行真实走的次数;
  25. u8 Init_flag;  //初始化标志位
  26. u8 Init_motor_num = 0; //初始化时逐一初始化
  27. //初始值始终为0
  28. u8 i;                                //定时器标志位
  29. u8 j = 0;       //每个电机的循环
  30. u16 Real_Step[5];  //实际走的步数
  31. u8 Res;
  32. u8 p=0;
  33. int main(void)
  34. {         
  35.         delay_init();                     //延时函数初始化         
  36.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//设置中断优先级分组为组2:2位抢占优先级,2位响应优先级
  37.         uart_init(115200);                 //串口初始化为115200
  38.          LED_Init();                             //LED端口初始化
  39.   Key_Init();
  40.         send[0]=0x55;
  41.         send[1]=0x02;
  42.         ENA1 = 0;
  43.         ENA2 = 0;
  44.         ENA3 = 0;
  45.         ENA4 = 0;
  46.         ENA5 = 0;
  47.         PWM1 = 1;
  48.         PWM2 = 1;
  49.         PWM3 = 1;
  50.         PWM4 = 1;
  51.         PWM5 = 1;

  52.         EXTIX_Init();
  53.         TIM3_Int_Init(4,799);//0.5ms进一次定时器
  54.         
  55.         while(1)
  56.         {
  57.                 delay_ms(1000);
  58. //                PWM1=~PWM1;
  59. //                PWM5=~PWM5;
  60. //                PWM2=~PWM2;
  61. //                PWM3=~PWM3;
  62. //                PWM4=~PWM4;
  63.                 LED0=~LED0;
  64.         }
  65. }

  66. //定时器3中断服务程序

  67. void TIM3_IRQHandler(void)   //TIM3中断
  68. {
  69.         
  70.         if (TIM_GetITStatus(TIM3, TIM_IT_Update) != RESET)  //检查TIM3更新中断发生与否
  71.                 {
  72.                                 i++;
  73.                                 if(i>=TIMES)
  74.                                 {
  75.                                         i=0;
  76.                                         if(Init_flag !=0)
  77.                                         {
  78.                                                 if(Init_flag ==1 )
  79.                                                 {
  80.                                                         switch(Init_motor_num)
  81.                                                         {
  82.                                                                 case 1:
  83.                                                                         if(PWM1 == 1)
  84.                                                                         {
  85.                                                                                 PWM1=0;
  86.                                                                         }
  87.                                                                         else
  88.                                                                         {
  89.                                                                                 PWM1=1;
  90.                                                                         }
  91.                                                                         break;
  92.                                                                 case 2:
  93.                                                                         if(PWM2 == 1)
  94.                                                                         {
  95.                                                                                 PWM2=0;
  96.                                                                         }
  97.                                                                         else
  98.                                                                         {
  99.                                                                                 PWM2=1;
  100.                                                                         }
  101.                                                                         break;
  102.                                                                 case 3:
  103.                                                                         if(PWM3 == 1)
  104.                                                                         {
  105.                                                                                 PWM3=0;
  106.                                                                         }
  107.                                                                         else
  108.                                                                         {
  109.                                                                                 PWM3=1;
  110.                                                                         }
  111.                                                                         break;
  112.                                                                 case 4:
  113.                                                                         if(PWM4 == 1)
  114.                                                                         {
  115.                                                                                 PWM4=0;
  116.                                                                         }
  117.                                                                         else
  118.                                                                         {
  119.                                                                                 PWM4=1;
  120.                                                                         }
  121.                                                                         break;
  122.                                                                 case 5:
  123.                                                                         if(PWM5 == 1)
  124.                                                                         {
  125.                                                                                 PWM5=0;
  126.                                                                         }
  127.                                                                         else
  128.                                                                         {
  129.                                                                                 PWM5=1;
  130.                                                                         }
  131.                                                                         break;
  132.                                                         }
  133.                                                         
  134.                                                 }
  135.                                                 else
  136.                                                 {
  137.                                                         switch(Init_motor_num)
  138.                                                         {
  139.                                                                 case 1:
  140.                                                                         if(PWM1 == 1)
  141.                                                                         {
  142.                                                                                 PWM1=0;
  143.                                                                                 Real_Step[0]++;
  144.                                                                         }
  145.                                                                         else
  146.                                                                         {
  147.                                                                                 PWM1=1;
  148.                                                                                 if(Real_Step[0]>=INIT_STEPS1)  //走够了
  149.                                                                                 {
  150.                                                                                         ENA1 = 0;
  151.                                                                                         ENA2 = 1;
  152.                                                                                         Real_Step[0]=0;
  153.                                                                                         Init_motor_num++;
  154.                                                                                         Init_flag = 1;
  155.                                                                                 }
  156.                                                                         }
  157.                                                                         break;
  158.                                                                 case 2:
  159.                                                                         if(PWM2 == 1)
  160.                                                                         {
  161.                                                                                 PWM2=0;
  162.                                                                                 Real_Step[1]++;
  163.                                                                         }
  164.                                                                         else
  165.                                                                         {
  166.                                                                                 PWM2=1;
  167.                                                                                 if(Real_Step[1]>=INIT_STEPS2)  //走够了
  168.                                                                                 {
  169.                                                                                         ENA2 = 0;
  170.                                                                                         ENA3 = 1;
  171.                                                                                         Real_Step[1]=0;
  172.                                                                                         Init_motor_num++;
  173.                                                                                         Init_flag = 1;
  174.                                                                                 }
  175.                                                                         }
  176.                                                                         break;
  177.                                                                 case 3:
  178.                                                                         if(PWM3 == 1)
  179.                                                                         {
  180.                                                                                 PWM3=0;
  181.                                                                                 Real_Step[2]++;
  182.                                                                         }
  183.                                                                         else
  184.                                                                         {
  185.                                                                                 PWM3=1;
  186.                                                                                 if(Real_Step[2]>=INIT_STEPS3)  //走够了
  187.                                                                                 {
  188.                                                                                         ENA3 = 0;
  189.                                                                                         ENA4 = 1;
  190.                                                                                         Real_Step[2]=0;
  191.                                                                                         Init_motor_num++;
  192.                                                                                         Init_flag = 1;
  193.                                                                                 }
  194.                                                                         }
  195.                                                                         break;
  196.                                                                 case 4:
  197.                                                                         if(PWM4 == 1)
  198.                                                                         {
  199.                                                                                 PWM4=0;
  200.                                                                                 Real_Step[3]++;
  201.                                                                         }
  202.                                                                         else
  203.                                                                         {
  204.                                                                                 PWM4=1;
  205.                                                                                 if(Real_Step[3]>=INIT_STEPS4)  //走够了
  206.                                                                                 {
  207.                                                                                         ENA4 = 0;
  208.                                                                                         ENA5 = 1;
  209.                                                                                         Real_Step[3]=0;
  210.                                                                                         Init_motor_num++;
  211.                                                                                         Init_flag = 1;
  212.                                                                                 }
  213.                                                                         }
  214.                                                                         break;
  215.                                                                 case 5:
  216.                                                                         if(PWM5 == 1)
  217.                                                                         {
  218.                                                                                 PWM5=0;
  219.                                                                                 Real_Step[4]++;
  220.                                                                         }
  221.                                                                         else
  222.                                                                         {
  223.                                                                                 PWM5=1;
  224.                                                                                 if(Real_Step[4]>=INIT_STEPS5)  //走够了
  225.                                                                                 {
  226.                                                                                         ENA5 = 0;
  227.                                                                                         Real_Step[4]=0;
  228.                                                                                         Init_motor_num = 0;
  229.                                                                                         Init_flag = 0;
  230.                                                                                         send[2]=0x02;
  231.                                                                                         send[3]=0x02;        
  232.                                                                                         send[4] =  1;
  233.                                                                                         send[5] = 2;
  234.                                                                                         send[6] = 0xaa;
  235.                                                                                         send[7] = 0xbb;
  236.                                                                                         for(j=0;j<8;j++)   //发送步数
  237.                                                                                         {
  238.                                                                                                 USART_SendData(USART1, send[j]);//向串口1发送数据
  239.                                                                                                 while(USART_GetFlagStatus(USART1,USART_FLAG_TC)!=SET);//等待发送结束
  240.                                                                                         }                                                
  241.                                                                                 }
  242.                                                                         }
  243.                                                                         break;
  244.                                                         }
  245.                                                 }
  246.                                                         
  247.                                                 }
  248.                                         }
  249.                                         else
  250.                                         {
  251.                                         if(Runing_flag==1)    //运行
  252.                                         {
  253.                                                 if(Move_Dir_Flag[0]==0) //走的方向
  254.                                                                 DIR1 = 0;
  255.                                                         else
  256.                                                                 DIR1 = 1;
  257.                                                 if(PWM1 == 1)
  258.                                                 {
  259.                                                         PWM1=0;
  260.                                                         Real_Step[0]++;
  261.                                                 }
  262.                                                         else
  263.                                                         {
  264.                                                                 PWM1=1;
  265.                                                                 if(Real_Step[0]>=StepNum[0])  //走够了
  266.                                                                 {
  267.                                                                         Real_Step[0]=0;
  268.                                                                         if(Move_Dir_Flag[0]==1) //走的方向
  269.                                                                                 Move_Dir_Flag[0] = 0;
  270.                                                                         else
  271.                                                                         {
  272.                                                                                 Move_Dir_Flag[0] = 1;
  273.                                                                                 Real_times++;
  274.                                                                                 send[2]=0x01;
  275.                                                                                 send[3]=0x02;
  276.                                                                                 send[4] = Real_times/256;
  277.                                                                                 send[5] = Real_times%256;
  278.                                                                                 send[6] = 0xaa;
  279.                                                                                 send[7] = 0xbb;
  280.                                                                                 for(j=0;j<8;j++)   //发送步数
  281.                                                                                 {
  282.                                                                                         USART_SendData(USART1, send[j]);//向串口1发送数据
  283.                                                                                         while(USART_GetFlagStatus(USART1,USART_FLAG_TC)!=SET);//等待发送结束
  284.                                                                                 }
  285.                                                                                 if(Real_times>=Total_times)   //次数达到了
  286.                                                                                 {
  287.                                                                                         ENA1 = 0;
  288.                                                                                         Real_Step[0]=0;
  289.                                                                                         Runing_flag= 0;
  290.                                                                                         PWM1=1;  
  291.                                                                                 }
  292.                                                                         }
  293.                                                                 }
  294.                                                         }
  295.                                         }
  296.                                         else
  297.                                         {
  298.                                         if(Move_Flag[0]==1)   //1号电机要转
  299.                                         {
  300.                                                 if(Move_Dir_Flag[0]==0) //走的方向
  301.                                                                 DIR1 = 0;
  302.                                                         else
  303.                                                                 DIR1 = 1;
  304.                                                 if(PWM1 == 1)
  305.                                                 {
  306.                                                         PWM1=0;
  307.                                                         Real_Step[0]++;
  308.                                                 }
  309.                                                         else
  310.                                                         {
  311.                                                                 PWM1=1;
  312.                                                                 if(Real_Step[0]>=StepNum[0])  //走够了
  313.                                                                 {
  314.                                                                         ENA1 = 0;
  315.                                                                         Move_Flag[0] = 0;
  316.                                                                         Real_Step[0]=0;
  317.                                                                         StepNum[0] = 0;
  318.                                                                         
  319.                                                                 }
  320.                                                         }
  321.                                         }
  322.                                         if(Move_Flag[1]==1)   //1号电机要转
  323.                                         {
  324.                                                 if(Move_Dir_Flag[1]==0) //走的方向
  325.                                                                 DIR2 = 0;
  326.                                                         else
  327.                                                                 DIR2 = 1;
  328.                                                 if(PWM2 == 1)
  329.                                                 {
  330.                                                         PWM2=0;
  331.                                                         Real_Step[1]++;
  332.                                                 }
  333.                                                         else
  334.                                                         {
  335.                                                                 PWM2=1;
  336.                                                                 if(Real_Step[1]>=StepNum[1])  //走够了
  337.                                                                 {
  338.                                                                         ENA2 = 0;
  339.                                                                         Move_Flag[1] = 0;
  340.                                                                         Real_Step[1]=0;
  341.                                                                         StepNum[1] = 0;
  342.                                                                 }
  343.                                                         }
  344.                                         }
  345.                                         if(Move_Flag[2]==1)   //1号电机要转
  346.                                         {
  347.                                                 if(Move_Dir_Flag[2]==0) //走的方向
  348.                                                                 DIR3 = 0;
  349.                                                         else
  350.                                                                 DIR3 = 1;
  351.                                                 if(PWM3 == 1)
  352.                                                 {
  353.                                                         PWM3=0;
  354.                                                         Real_Step[2]++;
  355.                                                 }
  356.                                                         else
  357.                                                         {
  358.                                                                 PWM3=1;
  359.                                                                 if(Real_Step[2]>=StepNum[2])  //走够了
  360.                                                                 {
  361.                                                                         ENA3 = 0;
  362.                                                                         Move_Flag[2] = 0;
  363.                                                                         Real_Step[2]=0;
  364.                                                                         StepNum[2] = 0;
  365.                                                                 }
  366.                                                         }
  367.                                         }
  368.                                         if(Move_Flag[3]==1)   //1号电机要转
  369.                                         {
  370.                                                 if(Move_Dir_Flag[3]==0) //走的方向
  371.                                                                 DIR4 = 0;
  372.                                                         else
  373.                                                                 DIR4 = 1;
  374.                                                 if(PWM4 == 1)
  375.                                                 {
  376.                                                         PWM4=0;
  377.                                                         Real_Step[3]++;
  378.                                                 }
  379.                                                         else
  380.                                                         {
  381.                                                                 PWM4=1;
  382.                                                                 if(Real_Step[3]>=StepNum[3])  //走够了
  383.                                                                 {
  384.                                                                         ENA4 = 0;
  385.                                                                         Move_Flag[3] = 0;
  386.                                                                         Real_Step[3]=0;
  387.                                                                         StepNum[3] = 0;
  388.                                                                 }
  389.                                                         }
  390.                                         }
  391.                                         if(Move_Flag[4]==1)   //1号电机要转
  392.                                         {
  393.                                                 if(Move_Dir_Flag[4]==0) //走的方向
  394.                                                                 DIR5 = 0;
  395.                                                         else
  396.                                                                 DIR5 = 1;
  397.                                                 if(PWM5 == 1)
  398.                                                 {
  399.                                                         PWM5=0;
  400.                                                         Real_Step[4]++;
  401.                                                 }
  402.                                                         else
  403.                                                         {
  404.                                                                 PWM5=1;
  405.                                                                 if(Real_Step[4]>=StepNum[4])  //走够了
  406.                                                                 {
  407.                                                                         ENA5 = 0;
  408.                                                                         Move_Flag[4] = 0;
  409.                                                                         Real_Step[4]=0;
  410.                                                                         StepNum[4] = 0;
  411.                                                                 }
  412.                                                         }
  413.                                         }
  414.                                 }
  415.                         }
  416.                 }
  417.          TIM_ClearITPendingBit(TIM3, TIM_IT_Update);  //清除TIMx更新中断标志
  418. }
  419. void USART1_IRQHandler(void)                        //串口1中断服务程序
  420.         {
  421.         //1.缓冲数据
  422.                 if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)  //接收中断(接收到的数据必须是0x0d 0x0a结尾)
  423.                 {
  424.                         Res =USART_ReceiveData(USART1);//(USART1->DR);        //读取接收到的数据
  425.                 }
  426.         receive[p++]=Res;
  427.         //2.完整性判断
  428.         while(p>=6)                        //六个数据
  429.         {
  430.                 //2.1查找数据头
  431.                 if(receive[0]==0x55)
  432.                 {
  433.                         u8 len=receive[3];
  434.                         if(p<len+6)
  435.                         {
  436.                                 break;                //跳出接收函数后继续接收数据
  437.                         }
  438.                         if(receive[len+4]==GetCRC16(receive,len+4)/256&&receive[len+5]==GetCRC16(receive,len+4)%256)//校验成功
  439.                         {
  440.                                 p=0;
  441.                                 switch (receive[2])
  442.                                 {
  443.                                         case 0x01:   //一个电机要动
  444.                                         {
  445.                                                 Move_Flag[receive[4]-1] = 1; //走不走
  446.                                                 StepNum[receive[4]-1] = receive[5]*256+receive[6];   //走的步数
  447.                                                 Move_Dir_Flag[receive[4]-1]=receive[7]; //走的方向
  448.                                                 switch(receive[4])
  449.                                                 {
  450.                                                         case 1:
  451.                                                                 ENA1 = 1;
  452.                                                                 break;
  453.                                                         case 2:
  454.                                                                 ENA2 = 1;
  455.                                                                 break;
  456.                                                         case 3:
  457.                                                                 ENA3 = 1;
  458.                                                                 break;
  459.                                                         case 4:
  460.                                                                 ENA4 = 1;
  461.                                                                 break;
  462.                                                         case 5:
  463.                                                                 ENA5 = 1;
  464.                                                                 break;
  465.                                                 }
  466.                                                 break;
  467.                                         }
  468.                                         case 0x02:    //多个电机动
  469.                                         {
  470.                                                 for (j=0;j<5;j++)
  471.                                                 {
  472.                                                         Move_Flag[j] = 1; //走不走
  473.                                                         StepNum[j] = receive[3*j+4]*256+receive[3*j+5];
  474.                                                         Move_Dir_Flag[j] = receive[3*j+6]; //走的方向
  475.                                                         Real_Step[j] = 0;
  476.                                                 }
  477.                                                 ENA1 = 1;
  478.                                                 ENA2 = 1;
  479.                                                 ENA3 = 1;
  480.                                                 ENA4 = 1;
  481.                                                 ENA5 = 1;
  482.                                                 break;
  483.                                         }
  484.                                         case 0x03:   //运行
  485.                                         {
  486.                                                 StepNum[0] = receive[4]*256+receive[5];
  487.                                                 Total_times = receive[6]*256+receive[7];
  488.                                                 Move_Dir_Flag[0] = 1;
  489.                                                 Real_Step[0]=0;
  490.                                                 Runing_flag= 1;
  491.                                                 Real_times = 0;  
  492.                                                 ENA1 = 1;
  493.                                                 break;
  494.                                         }
  495.                                         case 0x04:  //初始化
  496.                                         {
  497.                                                 Init_flag = 1;  //初始化标志位置1
  498.                                                 DIR1 = 0;//先向右走
  499.                                                 DIR2=  0;
  500.                                                 DIR3=  0;
  501.                                                 DIR4=  0;
  502.                                                 DIR5=  0;
  503.                                                 ENA1 = 1;
  504.                                                 Init_motor_num = 1;
  505.                                                 break;
  506.                                         }
  507.                                         case 0x05:  //急停
  508.                                         {
  509.                                                 PWM1=  1;
  510.                                                 Move_Flag[0] = 0; //走不走
  511.                                           Real_Step[0] = 0;
  512.                                                 Runing_flag= 0;
  513.                                                 Real_times = 0;  
  514.                                                 Init_flag = 0;  //初始化标志位置1
  515.                                                 ENA1 = 0;
  516.                                                 ENA2 = 0;
  517.                                                 ENA3 = 0;
  518.                                                 ENA4 = 0;
  519.                                                 ENA5 = 0;
  520.                                                 break;
  521.                                         }
  522.                                        
  523.                                 }
  524.                         }
  525.                         else//校验失败
  526.                         {
  527.                                 p=0;
  528.                                 continue;
  529.                         }
  530.                         
  531.                 }
  532.                 else
  533.                 {
  534.                         //重新接收
  535.                         p=0;
  536.                 }

  537.                
  538.                
  539.         }
  540. }
  541. //外部中断2服务程序
  542. void EXTI2_IRQHandler(void)
  543. {
  544.         if(Init_flag==1)
  545.         {
  546.                 Init_flag = 2;
  547.                 switch(Init_motor_num)
  548.                 {
  549.                         case 1:
  550.                                 PWM1 = 1;
  551.                                 DIR1 = 1;
  552.                                 Real_Step[0]=0;
  553.                                 break;
  554.                         case 2:
  555.                                 PWM2 = 1;
  556.                                 DIR2 = 1;
  557.                                 Real_Step[1]=0;
  558.                                 break;
  559.                         case 3:
  560.                                 PWM3 = 1;
  561.                                 DIR3 = 1;
  562.                                 Real_Step[2]=0;
  563.                                 break;
  564.                         case 4:
  565.                                 PWM4 = 1;
  566.                                 DIR4 = 1;
  567.                                 Real_Step[3]=0;
  568.                                 break;
  569.                         case 5:
  570.                                 PWM5 = 1;
  571.                                 DIR5 = 1;
  572.                                 Real_Step[4]=0;
  573.                                 break;
  574.                 }
  575.         }
  576.         EXTI_ClearITPendingBit(EXTI_Line2);  //清除LINE2上的中断标志位  
  577. }        
复制代码


所有资料51hei附件下载,仅供参考,切勿照搬:
3.2.1.7z (491.04 KB, 下载次数: 124)

评分

参与人数 1黑币 +50 收起 理由
admin + 50 共享资料的黑币奖励!

查看全部评分

分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏9 分享淘帖 顶1 踩
回复

使用道具 举报

沙发
ID:276663 发表于 2022-3-6 22:31 | 只看该作者
不错,很多东西有个上位机调试是方便很多。
回复

使用道具 举报

板凳
ID:1027457 发表于 2022-5-18 00:18 | 只看该作者
居然可以看到c#的組合,很有趣
回复

使用道具 举报

地板
ID:250090 发表于 2022-11-4 13:47 | 只看该作者

居然可以看到c#的組合,很有趣
回复

使用道具 举报

5#
ID:1090668 发表于 2023-8-4 13:49 | 只看该作者
居然可以看到c#的組合,很有趣
回复

使用道具 举报

6#
ID:165291 发表于 2023-8-8 08:49 | 只看该作者
厉害,会2种语言的使用并组合!
回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

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

Powered by 单片机教程网

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