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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 24小时必答区 › 关于Arduino驱动步进电机驱动器控制步进电机导致电机跑 ...
返回列表 发新帖
查看: 609|回复: 8
收起左侧

关于Arduino驱动步进电机驱动器控制步进电机导致电机跑飞问题

[复制链接]
ID:486153 发表于 2024-8-11 12:52 | 显示全部楼层 |阅读模式
最近在做一个项目，主要内容是，通过Arduino Mega2560控制3个步进电机驱动器，进而控制步进电机实现带目标物进行移动。代码中使用了定时器中断，1KHZ的频率访问定时器，再通过串口，发送指令，控制步进电机进行移动。在几乎快调试完成后，发现一个重大问题，在有时候突然发送指令时，步进电机会不受控制的跑飞，除非再次发送指令，不然步进电机会一直按照某种异常的速度不停移动。

步进电机是通过驱动器进行控制的，所以只需要DIR和PUL两个脚控制即可，PUL脉冲波形的频率在正常情况下，我只给到了400HZ,50%占空比。在异常情况下，频率会突然飚的很高，达到了几KHZ,但是程序中没有代码让他按照此种频率运行。

而且该问题出现的时机是偶然的，都在串口发送完指令，Arduino接受解析完指令，再控制步进电机是出现，概率很高。

不知道有没有大佬遇到类似情况，给小弟指条明路，由于是第一次使用Arduino 开发项目，代码还是参考网上的。

定时器中断部分代码
timer.png
串口接收数据 部分代码
uart.png
回复

使用道具 举报

ID:161164 发表于 2024-8-12 10:20 | 显示全部楼层
UART_RX_DATA_SIZE没加限制吗？
回复

使用道具 举报

ID:486153 发表于 2024-8-12 15:43 | 显示全部楼层
lkc8210 发表于 2024-8-12 10:20
UART_RX_DATA_SIZE没加限制吗？

没有加限制，但是会在函数最后结束的时候 把它清零
回复

使用道具 举报

ID:844772 发表于 2024-8-12 15:45 | 显示全部楼层
应该是冲突造成的，看发出来的又没啥问题，需要相对完整的程序和电路图。
回复

使用道具 举报

ID:486153 发表于 2024-8-12 15:52 | 显示全部楼层
glinfei 发表于 2024-8-12 15:45
应该是冲突造成的，看发出来的又没啥问题，需要相对完整的程序和电路图。
  1. void System_IO_Init()
  2. {
  3.   pinMode(DIR_pin,    OUTPUT);
  4.   pinMode(DIR2_pin,    OUTPUT);
  5.   pinMode(DIR3_pin,    OUTPUT);
  6.   pinMode(PUL_pin,    OUTPUT);
  7.   pinMode(PUL2_pin,    OUTPUT);
  8.   pinMode(PUL3_pin,    OUTPUT);
  9.   pinMode(ENA_pin,    OUTPUT);
  10.   pinMode(ENA2_pin,    OUTPUT);
  11.   pinMode(ENA3_pin,    OUTPUT);

  13.   pinMode(STOPPER_x_pin,    INPUT_PULLUP);
  14.   pinMode(STOPPER_x_2_pin,    INPUT_PULLUP);
  15.   pinMode(STOPPER_y_pin,    INPUT_PULLUP);
  16.   pinMode(STOPPER_y_2_pin,    INPUT_PULLUP);
  17.   pinMode(STOPPER_z_pin,    INPUT_PULLUP);
  18.   
  19.   digitalWrite( DIR_pin, HIGH);   //HIGH 左  x轴
  20.   digitalWrite( ENA_pin, LOW);

  22.   digitalWrite( DIR2_pin, HIGH);   //HIGH 左
  23.   digitalWrite( ENA2_pin, LOW);

  25.   digitalWrite( DIR3_pin, HIGH);   //HIGH 左
  26.   digitalWrite( ENA3_pin, LOW);
  27. }

  29. void Timer_Init()
  30. {
  31.   cli();////关闭全局中断

  33. //Timer 1
  34. //设置定时器1为1kHz
  35.   TCCR1A = 0;//将整个TCCR1A寄存器设置为0
  36.   TCCR1B = 0;//将整个TCCR1B寄存器设置为0
  37.   TCNT1  = 0;//将计数器值初始化为0
  38.   //设置计数器为10kHZ，即1ms
  39.   OCR1A = 19;// = (16*10^6)/(1000*8) - 1 (must be <65536)
  40.   TCCR1B |= (1 << WGM12);//打开CTC模式
  41.   TCCR1B |= (1 << CS11);//设置CS11位为1(8倍预分频)
  42.   TIMSK1 |= (1 << OCIE1A);

  44.   //Timer 3
  45. //设置定时器3为1kHz
  46.   TCCR3A = 0;//将整个TCCR1A寄存器设置为0
  47.   TCCR3B = 0;//将整个TCCR1B寄存器设置为0
  48.   TCNT3  = 0;//将计数器值初始化为0
  49.   //设置计数器为10kHZ，即1ms
  50.   OCR3A = 19;// = (16*10^6)/(1000*8) - 1 (must be <65536)
  51.   TCCR3B |= (1 << WGM32);//打开CTC模式
  52.   TCCR3B |= (1 << CS31);//设置CS11位为1(8倍预分频)
  53.   TIMSK3 |= (1 << OCIE3A);

  55.    sei();//打开全局中断
  56. }

  58. void return_weizhi()
  59. {
  60.   int test=1;
  61.   digitalWrite( DIR_pin, LOW);   //HIGH 左  LOW 右
  62.   digitalWrite( DIR2_pin, LOW);
  63.   while(test)
  64.   {
  65.     while(((PINH & (B00100000)) == 32)||((PING & (B00100000)) == 32))
  66.     {
  67.       if((PINH & (B00100000)) == 32)
  68.         y_flag=1;
  69.       else
  70.        y_flag=0;
  71.       if((PING & (B00100000)) == 32)
  72.         x_flag=1;
  73.       else
  74.         x_flag=0;
  75. //       Serial.println("555");
  76.       if(((PINH & (B00100000)) == 0)&&((PING & (B00100000)) == 0))
  77.       {
  78.         delay(100);
  79. //       Serial.println("444");
  80.         if(((PINH & (B00100000)) == 0)&&((PING & (B00100000)) == 0))
  81.         {
  82.           delay(100);
  83.           if(((PINH & (B00100000)) == 0)&&((PING & (B00100000)) == 0))
  84.           {
  85.             x_flag=0;
  86.             y_flag=0;
  87.             x_pos=0;
  88.             y_pos=0;
  89.             Serial.println("{X000000-Y000000}");
  90.             test=0;
  91.             break;
  92.           }
  93.         }
  94.       }
  95.     }
  96.     test=0;
  97.   }
  98. }

  100. void setup() { // put your setup code here, to run once:
  101.   System_IO_Init();
  102.   Timer_Init();
  103.   Serial.begin(115200);
  104.   return_weizhi();     //系统返回原点
  105. }

  107. void SET_MOTOR_rotation(long num,long speed_motor)   //设置固定转多少圈，用于测试
  108. {
  109.   for(i=0;i<num;i++)
  110.   {
  111.     digitalWrite( PUL_pin, HIGH);
  112.     delayMicroseconds(speed_motor);
  113.     digitalWrite( PUL_pin, LOW);
  114.     delayMicroseconds(speed_motor);
  115.   }
  116. }


  119. ISR(TIMER1_COMPA_vect)   //定时器1，用于触发x,y轴电机转动
  120. {
  121. //产生频率为1Hz / 2 = 0.5Hz的脉冲波（全波切换为两个周期，然后切换为低）
  122.   if(x_motor_en==1&&x_position<=11800)
  123.   {
  124.     if(time_pul1<x_position)
  125.     {
  126.       if(toggle1<15)
  127.         digitalWrite(PUL_pin,HIGH);
  128.       if(toggle1>=15)
  129.         digitalWrite(PUL_pin,LOW);
  130.         
  131.       toggle1 += 1;
  132.       if((motor1_time_set>motor1_time)&&time_pul1%16==1)  //加速
  133.         motor1_time_set-=1;

  135.       if(toggle1 > 15*2)  
  136.       {
  137.         toggle1 = 0;
  138.         if(x_fangxiang)
  139.           x_pos++;
  140.         else
  141.           x_pos--;
  142.         time_pul1++;
  143.       }
  144.     }
  145.     else
  146.     {
  147.       pinMode(PUL_pin,    INPUT_PULLUP);
  148.      
  149.       time_pul1=0;
  150.       x_motor_en=0;
  151.        sdsf++;
  152.        reback_weizhi_flag=1;
  153.       }
  154.   }

  156.   if(x_flag==1&&(digitalRead(STOPPER_y_pin) == 1))
  157.   {
  158.    
  159.       if(toggle1<30)
  160.         digitalWrite(PUL_pin,HIGH);
  161.       if(toggle1>=30)
  162.         digitalWrite(PUL_pin,LOW);
  163.       toggle1 += 1;
  164.       if(toggle1 > 30*2)
  165.       {
  166.         toggle1 = 0;
  167.       }
  168.   }
  169.   
  170.   if(y_motor_en==1&&y_position<=11000)
  171.   {
  172.     if(time_pul2<y_position)  //5.4cm 54mm
  173.     {
  174.       if(toggle2<15)
  175.         digitalWrite(PUL2_pin,HIGH);
  176.       if(toggle2>=15)
  177.         digitalWrite(PUL2_pin,LOW);
  178.       toggle2 += 1;

  180.       if((motor2_time_set>motor2_time)&&time_pul2%16==1)   //加速
  181.         motor2_time_set-=1;
  182.       
  183.       if(toggle2 > 15*2)
  184.       {
  185.         toggle2 = 0;
  186.         if(y_fangxiang)
  187.           y_pos++;
  188.         else
  189.           y_pos--;
  190.         time_pul2++;
  191.       }
  192.     }
  193.     else
  194.     {
  195.       pinMode(PUL2_pin,    INPUT_PULLUP);
  196.      
  197.       time_pul2=0;
  198.       y_motor_en=0;
  199.       sdsf++;
  200.       reback_weizhi_flag=1;
  201.     }
  202.   }

  204.   if(y_flag==1&&(digitalRead(STOPPER_x_pin) == 1))
  205.   {   
  206.       if(toggle2<30)
  207.         digitalWrite(PUL2_pin,HIGH);
  208.       if(toggle2>=30)
  209.         digitalWrite(PUL2_pin,LOW);
  210.       toggle2 += 1;
  211.       if(toggle2 > 30*2)
  212.       {
  213.         toggle2 = 0;
  214.       }
  215.   }
  216. }


  219. ISR(TIMER3_COMPA_vect)   //定时器3，用于触发z轴电机转动
  220. {
  221. // timer3中断1Hz切换引脚9
  222. //产生频率为1Hz / 2 = 0.5Hz的脉冲波（全波切换为两个周期，然后切换为低）
  223.   
  224.   if(z_motor_en==1&&z_position<=5000)
  225.   {
  226.     if(time_pul3<z_position)  //5.4cm 54mm
  227.     {
  228. //      if(toggle3<15)
  229. //        digitalWrite(PUL3_pin,HIGH);
  230. //      if(toggle3>=15)
  231. //        digitalWrite(PUL3_pin,LOW);
  232. //      toggle3 += 1;
  233. //
  234. //      if((motor2_time_set>motor2_time)&&time_pul3%16==1)   //加速
  235. //        motor2_time_set-=1;
  236. //      
  237. //      if(toggle3 > 15*2)
  238. //      {
  239. //        toggle3 = 0;
  240. //        if(z_fangxiang)
  241. //          z_pos++;
  242. //        else
  243. //          z_pos--;
  244. //        time_pul3++;
  245. //      }
  246.     }
  247.     else
  248.     {
  249. //      time_pul3=0;
  250. //      z_motor_en=0;
  251. //      sdsf++;
  252. //      reback_weizhi_flag=1;
  253.     }
  254.   }
  255. }




  260. void goto_setposition(long x_now,long y_now)
  261. {
  262.   /*
  263.   int x_position_pass=0;      //上一次的x轴位置坐标
  264. int y_position_pass=0;      //上一次的y轴位置坐标
  265. int x_position_now=0;       //当前的x轴位置坐标
  266. int y_position_now=0;       //当前的y轴位置坐标
  267. int x_position=10;           //x轴位置坐标
  268. int y_position=10;           //z轴位置坐标
  269.   */

  271.   
  272.   if(x_now!=0)
  273.   {
  274.     x_position_now=x_now;
  275.     if(x_position_pass-x_position_now>0)
  276.     {
  277.       digitalWrite(DIR_pin,LOW);   //设置方向
  278.       x_fangxiang=0;
  279.       x_position=x_position_pass-x_position_now;  //计算步距
  280.       return_x_position=x_position;
  281.       x_position_pass=x_position_now;
  282.       x_motor_en=1;
  283.     }
  284.     else
  285.     {
  286.       digitalWrite(DIR_pin,HIGH);   //设置方向
  287.       x_fangxiang=1;
  288.       x_position=x_position_now-x_position_pass;  //计算步距
  289.       x_position_pass=x_position_now;
  290.       x_motor_en=1;
  291.     }
  292.   }

  294.   if(y_now!=0)
  295.   {
  296.     y_position_now=y_now;
  297.     if(y_position_pass-y_position_now>0)
  298.     {
  299.       digitalWrite(DIR2_pin,LOW);   //设置方向
  300.       y_fangxiang=0;
  301.       y_position=y_position_pass-y_position_now;  //计算步距
  302.       y_position_pass=y_position_now;
  303.       y_motor_en=1;
  304.     }
  305.     else
  306.     {
  307.       digitalWrite(DIR2_pin,HIGH);   //设置方向
  308.       y_fangxiang=1;
  309.       y_position=y_position_now-y_position_pass;  //计算步距
  310.       y_position_pass=y_position_now;
  311.       y_motor_en=1;
  312.     }
  313.   }
  314. }

  316. void sys_auto_move()
  317. {
  318.   if(sdsf==2)
  319.   {

  321.     if(!switch_flag)
  322.     Location_label++;
  323.     else
  324.     Location_label--;
  325.    
  326.     if(Location_label>12)
  327.     {
  328.       Location_label=12;
  329.       switch_flag=!switch_flag;
  330.     }
  331.     if(Location_label<1)
  332.     {
  333.       Location_label=1;

  335. //////////////////////////////////////////
  336.       auto_manual_flag=0;
  337.       delay(1000);
  338.       delay(1000);
  339.       pinMode(PUL_pin,    OUTPUT);
  340.       pinMode(PUL2_pin,    OUTPUT);
  341.       return_weizhi();
  342.       x_position_now=0;
  343.       y_position_now=0;
  344.       x_position_pass=0;
  345.       y_position_pass=0;
  346.       x_pos=0;
  347.       y_pos=0;
  348.       Serial.print("{D0}\r\n");

  350.       delay(1000);
  351.       delay(1000);
  352.       delay(1000);
  353.       delay(1000);

  355.       auto_manual_flag=1;
  356.       auto_move_flag=1;
  357.       sdsf=0;
  358. ///////////////////////////////////////////////
  359.       
  360.       switch_flag=!switch_flag;
  361.       cishu_cishu++;
  362.     }
  363.     sdsf=0;
  364.     auto_move_flag=1;
  365.     delay(1000);
  366.     delay(1000);
  367.     delay(1000);
  368.     delay(1000);
  369.     delay(1000);
  370.   }

  372.   if(auto_move_flag==1)
  373.   {
  374.     pinMode(PUL_pin,    OUTPUT);
  375.     pinMode(PUL2_pin,    OUTPUT);
  376.     switch(Location_label)
  377.     {
  378.       case 1:  actual_weizhi=1;goto_setposition(1500,hang1);auto_move_flag=0; break;
  379.       case 2:  actual_weizhi=2;goto_setposition(1500+1500,hang1); auto_move_flag=0;break;
  380.       case 3:  actual_weizhi=3;goto_setposition(1500+1500*2,hang1); auto_move_flag=0;break;
  381.       case 4:  actual_weizhi=4;goto_setposition(1500+1500*3,hang1); auto_move_flag=0;break;
  382.       
  383.       case 8:  actual_weizhi=5;goto_setposition(1500,hang2);auto_move_flag=0; break;
  384.       case 7:  actual_weizhi=6;goto_setposition(1500+1500,hang2); auto_move_flag=0;break;
  385.       case 6:  actual_weizhi=7;goto_setposition(1500+1500*2,hang2); auto_move_flag=0;break;
  386.       case 5:  actual_weizhi=8;goto_setposition(1500+1500*3,hang2); auto_move_flag=0;break;
  387.      
  388.       case 9:  actual_weizhi=13;goto_setposition(1500,hang3);auto_move_flag=0; break;
  389.       case 10:  actual_weizhi=14;goto_setposition(1500+1500,hang3); auto_move_flag=0;break;
  390.       case 11:  actual_weizhi=15;goto_setposition(1500+1500*2,hang3); auto_move_flag=0;break;
  391.       case 12:  actual_weizhi=16;goto_setposition(1500+1500*3,hang3); auto_move_flag=0;break;
  392.     }
  393.   }
  394. }

  396. void data_pro()    //串口数据接受与处理
  397. {
  398.   if(Serial.available()>0)
  399.   {
  400.     receive_buf[UART_RX_DATA_SIZE]=Serial.read();
  401.     if(receive_buf[UART_RX_DATA_SIZE]=='}')
  402.     {
  403.       UAER_RX_FLAG=1;
  404.       i_uart=0;
  405.     }
  406.     UART_RX_DATA_SIZE++;
  407.    
  408.   }
  409.   else if(UAER_RX_FLAG)
  410.   {
  411.     UAER_RX_FLAG=0;
  412.     #if UART_DEBUG
  413.     Serial.println(receive_buf);
  414.     #endif
  415.     while(i_uart<UART_RX_DATA_SIZE)
  416.     {
  417.       if(receive_buf[i_uart]=='{')  //{A0}
  418.       {
  419.         if(receive_buf[i_uart+1]=='A'&&receive_buf[i_uart+3]=='}')   //收到上位机发送的HALLO指令
  420.         {
  421.             Serial.print("{B0}\r\n");
  422.             i_uart+=3;
  423.         }
  424.         else if(receive_buf[i_uart+1]=='C'&&receive_buf[i_uart+3]=='}')  //全部軸歸回原點
  425.         {
  426.           pinMode(PUL_pin,    OUTPUT);
  427.           pinMode(PUL2_pin,    OUTPUT);
  428.           return_weizhi();
  429.           x_position_now=0;
  430.           y_position_now=0;
  431.           x_position_pass=0;
  432.           y_position_pass=0;
  433.           x_pos=0;
  434.           y_pos=0;
  435.           Serial.print("{D0}\r\n");
  436.           i_uart+=3;
  437.         }
  438.         else if(receive_buf[i_uart+1]=='E'&&receive_buf[i_uart+13]=='}')  //{EX000400-010}
  439.         {
  440.           pinMode(PUL_pin,    OUTPUT);
  441.           pinMode(PUL2_pin,    OUTPUT);
  442.           if(receive_buf[i_uart+2]=='X')
  443.           {
  444.             x_position_uart=(receive_buf[i_uart+3]-'0')*100000+(receive_buf[i_uart+4]-'0')*10000+(receive_buf[i_uart+5]-'0')*1000+(receive_buf[i_uart+6]-'0')*100+(receive_buf[i_uart+7]-'0')*10+(receive_buf[i_uart+8]-'0');
  445.             #if UART_DEBUG
  446.               Serial.println(x_position_uart);
  447.             #endif
  448.             goto_setposition(x_position_uart,0);
  449.             Serial.print("{F0}\r\n");
  450.           }
  451.           else if(receive_buf[i_uart+2]=='Y')
  452.           {
  453.             y_position_uart=(receive_buf[i_uart+3]-'0')*100000+(receive_buf[i_uart+4]-'0')*10000+(receive_buf[i_uart+5]-'0')*1000+(receive_buf[i_uart+6]-'0')*100+(receive_buf[i_uart+7]-'0')*10+(receive_buf[i_uart+8]-'0');
  454.             #if UART_DEBUG
  455.               Serial.println(y_position_uart);
  456.             #endif
  457.             goto_setposition(0,y_position_uart);
  458.             Serial.print("{F0}\r\n");
  459.           }
  460.           i_uart+=13;
  461.          }
  462.          else if(receive_buf[i_uart+1]=='L'&&receive_buf[i_uart+4]=='}')  //{L01}
  463.          {
  464.           int num=(receive_buf[i_uart+2]-'0')*10+(receive_buf[i_uart+3]-'0');
  465.             pinMode(PUL_pin,    OUTPUT);
  466.             pinMode(PUL2_pin,    OUTPUT);
  467.             switch(num)
  468.             {
  469.               case 1:  actual_weizhi=1;goto_setposition(1500,hang1);auto_move_flag=0; break;
  470.               case 2:  actual_weizhi=2;goto_setposition(1500+1500,hang1); auto_move_flag=0;break;
  471.               case 3:  actual_weizhi=3;goto_setposition(1500+1500*2,hang1); auto_move_flag=0;break;
  472.               case 4:  actual_weizhi=4;goto_setposition(1500+1500*3,hang1); auto_move_flag=0;break;
  473.               
  474.               case 5:  actual_weizhi=5;goto_setposition(1500,hang2);auto_move_flag=0; break;
  475.               case 6:  actual_weizhi=6;goto_setposition(1500+1500,hang2); auto_move_flag=0;break;
  476.               case 7:  actual_weizhi=7;goto_setposition(1500+1500*2,hang2); auto_move_flag=0;break;
  477.               case 8:  actual_weizhi=8;goto_setposition(1500+1500*3,hang2); auto_move_flag=0;break;
  478.             
  479.               case 9:  actual_weizhi=13;goto_setposition(1500,hang3);auto_move_flag=0; break;
  480.               case 10:  actual_weizhi=14;goto_setposition(1500+1500,hang3); auto_move_flag=0;break;
  481.               case 11:  actual_weizhi=15;goto_setposition(1500+1500*2,hang3); auto_move_flag=0;break;
  482.               case 12:  actual_weizhi=16;goto_setposition(1500+1500*3,hang3); auto_move_flag=0;break;
  483.               
  484.             }
  485.             i_uart+=4;
  486.          }
  487.          else if(receive_buf[i_uart+1]=='M'&&receive_buf[i_uart+3]=='}')  //{M0}
  488.          {
  489.           if(receive_buf[i_uart+2]=='1')
  490.           {
  491.               auto_manual_flag=1;
  492.               auto_move_flag=1;
  493.               sdsf=0;
  494.               Serial.println("auto_mode");
  495.           }
  496.           else
  497.           {
  498.               auto_manual_flag=0;
  499.           }
  500.           i_uart+=3;
  501.          }
  502.          else if(receive_buf[i_uart+1]=='F'&&receive_buf[i_uart+8]=='}')  //{F0_2500}  设定相机焦距
  503.          {
  504.             //步进值 16位
  505.             //左右旋转标志位 Direction_flag
  506.             direction_flag=receive_buf[i_uart+2]-0x30;
  507.             Serial.println(direction_flag);
  508.             focal_step_value=(receive_buf[i_uart+4]-0x30)*1000+(receive_buf[i_uart+5]-0x30)*100+(receive_buf[i_uart+6]-0x30)*10+(receive_buf[i_uart+7]-0x30);
  509.             focal_step_value=focal_step_value/10;
  510.             Serial.println(focal_step_value);
  511.             z_motor_en=1;
  512.             
  513.               if(direction_flag==0)
  514.               {
  515.                 z_position=focal_step_value;
  516.                 digitalWrite(DIR3_pin,HIGH);
  517.                
  518.               }
  519.               else if(direction_flag==1)
  520.               {
  521.                 z_position=focal_step_value;
  522.                 digitalWrite(DIR3_pin,LOW);
  523.                
  524.               }
  525.              i_uart+=8;
  526.          }
  527.          
  528.         
  529.       }
  530.       i_uart++;
  531.     }
  532.     for(i=0;i<UART_RX_DATA_SIZE;i++)
  533.       receive_buf[i]=' ';
  534.     UART_RX_DATA_SIZE=0;
  535.   }
  536. }


  539. void loop()
  540. {
  541.   data_pro();

  543. //  if(digitalRead(STOPPER_x_pin)==1)
  544. //    Serial.println("111");
  545. //   else
  546. //    Serial.println("222");
  547.    
  548.   if(auto_manual_flag)
  549.   {
  550.     sys_auto_move();
  551.   }
  552.   if(reback_weizhi_flag)
  553.   {
  554.      sprintf(weizhi_data,"{X%06ld-Y%06ld-L%02d}",x_pos,y_pos,actual_weizhi);
  555.      Serial.println(weizhi_data);
  556.      reback_weizhi_flag=0;
  557.   }
  558.   delay(100);
  559. }
复制代码

这是所有程序了
回复

使用道具 举报

ID:486153 发表于 2024-8-12 15:54 | 显示全部楼层
glinfei 发表于 2024-8-12 15:45
应该是冲突造成的，看发出来的又没啥问题，需要相对完整的程序和电路图。

主要就是串口接收到指令，一些变量置1，然后定时器那边见到变量置1，开始发送脉冲，记录指定脉冲数后，自动置零，等待下次
回复

使用道具 举报

ID:1128898 发表于 2024-8-12 20:47 | 显示全部楼层
有些驱动厂家会有详细的手册 编程应对应驱动信号
回复

使用道具 举报

ID:161164 发表于 2024-8-13 10:24 | 显示全部楼层
小枫啊 发表于 2024-8-12 15:43
没有加限制，但是会在函数最后结束的时候 把它清零

但是你receive_buf的长度有多大？
UART_RX_DATA_SIZE会不会有机会大于receive_buf的长度引致地址溢出？
回复

使用道具 举报

ID:844772 发表于 2024-8-13 16:35 | 显示全部楼层
我觉得，如果arduino就按它的玩法，都用库函数解决，不要混用单片机的程序思路，特别是没研究底层结构，嵌入寄存器控制部分，经常有冲突。比如上边的时间中断，就不要使用寄存器控制，否则不如直接用32呢；还有明明有String 类型，定义成数组是留隐患呢。另外别在时间中断函数放那么多东西啊。
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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