標(biāo)題: Arduino自制實驗用切割裝置-自動控制機(jī)床程序 [打印本頁]
作者: JohnRowton    時間: 2019-3-24 11:58
標(biāo)題: Arduino自制實驗用切割裝置-自動控制機(jī)床程序
如題，使用ardunio編寫的一個自動控制機(jī)床實現(xiàn)簡單切割的小程序，串口實時通信控制。

單片機(jī)源程序如下:
  1. #include "Arduino.h"
  2. #define CLK 5
  3. #define CLK_X 3
  4. #define CLK_Y 6
  5. #define CLK_Z 9
  6. #define DIR_X 2
  7. #define DIR_Y 5
  8. #define DIR_Z 8
  9. #define Stretch_1 A3
  10. #define Stretch_2 A2
  11. #define Scalpel_1 A1
  12. #define Scalpel_2 A0 //pin parament
  13. #define Choice_SW 16
  14. #define Forward_SW 14
  15. #define Backward_SW 15
  16. #define FORWARD 0
  17. #define BACKWARD 1 //motor direct parament
  18. #define STOP 100
  19. #define Solenoid 10
  20. #define FAST 98
  21. #define SLOW 99

  23. int case_var;
  24. float distance;
  25. float time_1;
  26. int m_var;


  29. //電機(jī)控制部分 //步進(jìn)電機(jī)使用1600HZ CLK時鐘 1600細(xì)分
  30. void motor_x(float); //輸入浮點型位移 distance 行進(jìn)完自動停止
  31. void motor_y(float); //輸入浮點型位移 distance 行進(jìn)完自動停止
  32. void motor_z(float); //輸入浮點型位移 distance 行進(jìn)完自動停止
  33. void motor_Scalpel(int); //輸入 FORWARD前進(jìn) BACKWARD后退 STOP停止 (行進(jìn)后必須再輸入停止命令STOP才可以停止）
  34. void motor_Stretch(int); //輸入 FORWARD前進(jìn) BACKWARD后退 STOP停止
  35. void motor_mx(int,int); //輸入 FORWARD前進(jìn) BACKWARD后退 STOP停止 && 輸入FAST快速模式,SLOW慢速模式,停止時隨意速度模式
  36. void motor_my(int,int); //輸入 FORWARD前進(jìn) BACKWARD后退 STOP停止 && 輸入FAST快速模式,SLOW慢速模式,停止時隨意速度模式
  37. void motor_mz(int,int); //輸入 FORWARD前進(jìn) BACKWARD后退 STOP停止 && 輸入FAST快速模式,SLOW慢速模式,停止時隨意速度模式

  39. void setup()
  40. {
  41.   // put your setup code here, to run once:

  43.   pinMode(DIR_X,OUTPUT);
  44.   pinMode(DIR_Y,OUTPUT);
  45.   pinMode(DIR_Z,OUTPUT);
  46.   pinMode(CLK_X,OUTPUT);
  47.   pinMode(CLK_Y,OUTPUT);
  48.   pinMode(CLK_Z,OUTPUT);
  49.   pinMode(Scalpel_1,OUTPUT);
  50.   pinMode(Scalpel_2,OUTPUT);
  51.   pinMode(Stretch_1,OUTPUT);
  52.   pinMode(Stretch_2,OUTPUT);
  53.   pinMode(Choice_SW,INPUT_PULLUP);
  54.   pinMode(Forward_SW,INPUT);
  55.   pinMode(Backward_SW,INPUT); //Setting mode
  56.   Serial.begin(9600);
  57.   analogWrite(CLK_X,0);
  58.   analogWrite(CLK_Y,0);
  59.   analogWrite(CLK_Z,0); //Duty cycle is 0/255
  60.   delay(1200);
  61.   Serial.println("cutting start, please confirm air pump is working");
  62. }

  64. void loop()
  65. {
  66.   // put your main code here, to run repeatedly:
  67.   Serial.println("Select a control mode:");
  68.   Serial.println("x.x axis");
  69.   Serial.println("y.y axis");
  70.   Serial.println("z.z axis");
  71.   Serial.println("m.manual mode");
  72.   while(Serial.read()>=0){}//clear buffer
  73.   delay(100);
  74.   while(Serial.available()<=0){}
  75.   if (Serial.available()>0)
  76. {
  77.      case_var=Serial.read();
  78.          delay(100);
  79.      switch(case_var)
  80.            {
  81.           case 120: //x axis
  82.           Serial.println("Enter a distance:");
  83.           while(Serial.available()<=0){}
  84.           distance = Serial.parseFloat();
  85.           delay(100);
  86.     while(Serial.read()>=0){}//clear buffer
  87.           Serial.print("Advance in x axis: ");
  88.           Serial.println(distance);
  89.           motor_x(distance);
  90.           //Control stepper motor
  91.           break;
  92.         
  93.           case 121: //y axis
  94.           Serial.println("Enter a distance:");
  95.           while(Serial.available()<=0){}
  96.           distance = Serial.parseFloat();
  97.           delay(100);
  98.     while(Serial.read()>=0){}//clear buffer
  99.           Serial.print("Advance in y axis: ");
  100.           Serial.println(distance);
  101.           motor_y(distance);
  102.           //Control stepper motor
  103.           break;
  104.         
  105.           case 122: //z axis
  106.           Serial.println("Enter a distance:");
  107.           while(Serial.available()<=0){}
  108.           distance = Serial.parseFloat();
  109.           delay(100);
  110.     while(Serial.read()>=0){}//clear buffer
  111.           Serial.print("Advance in z axis: ");
  112.           Serial.println(distance);
  113.           motor_z(distance);
  114.           //Control stepper motor
  115.           break;

  117.           case 109: //manunal
  118.           manuallycontrol();
  119.           break;

  121.     default:
  122.       break;

  124.     }
  125. }
  126. }


  129. //電機(jī)控制部分
  130. void motor_x(float a_1)  //x軸自動前進(jìn)
  131. {
  132.         if(a_1 >= 0)
  133.           {
  134.                  time_1 = 250*a_1;
  135.                  digitalWrite(DIR_X, HIGH);
  136.                  tone(CLK_X,1600);
  137.                  delay(time_1);
  138.                  noTone(CLK_X);
  139.           }
  140.           else
  141.           {
  142.                   a_1 = -a_1;
  143.                   time_1 = 250*a_1;
  144.                   digitalWrite(DIR_X,LOW);
  145.                   tone(CLK_X,1600);
  146.                   delay(time_1);
  147.                   noTone(CLK_X);
  148.           }  
  149. }

  151. void motor_y(float b_1)  //y軸自動前進(jìn)
  152. {
  153.         if(b_1 >= 0)
  154.           {
  155.                  time_1 = 250*b_1;
  156.                  digitalWrite(DIR_Y, HIGH);
  157.                  tone(CLK_Y,1600)
  158.                  delay(time_1);
  159.                  noTone(CLK_Y);
  160.           }
  161.           else
  162.           {
  163.                   b_1 = -b_1;
  164.                   time_1 = 250*b_1;
  165.                   digitalWrite(DIR_Y,LOW);
  166.                   tone(CLK_Y,1600);
  167.                   delay(time_1);
  168.                   noTone(CLK_Y);
  169.           }
  170. }

  172. void motor_z(float c_1)  //z軸自動前進(jìn)
  173. {
  174.         if(c_1 >= 0)
  175.           {
  176.                  time_1 = 250*c_1;
  177.                  digitalWrite(DIR_Z, HIGH);
  178.                  tone(CLK_Z,1600);
  179.                  delay(time_1);
  180.                  noTone(CLK_Z);
  181.           }
  182.           else
  183.           {
  184.                   c_1 = -c_1;
  185.                   time_1 = 250*c_1;
  186.                   digitalWrite(DIR_Z,LOW);
  187.                   tone(CLK_Z,1600);
  188.                   delay(time_1);
  189.                   noTone(CLK_Z);
  190.           }
  191. }

  193. void motor_Scalpel(int d_1) //刀具旋轉(zhuǎn)
  194. {
  195.         if( d_1 == FORWARD )
  196.         {
  197.                 digitalWrite(Scalpel_1,HIGH);
  198.                 digitalWrite(Scalpel_2,LOW);
  199.         }
  200.         else if( d_1 == BACKWARD )
  201.         {
  202.                 digitalWrite(Scalpel_1,LOW);
  203.                 digitalWrite(Scalpel_2,HIGH);
  204.         }
  205.         else
  206.         {
  207.                 digitalWrite(Scalpel_1,LOW);
  208.                 digitalWrite(Scalpel_2,LOW);
  209.         }
  210. }

  212. void motor_Stretch(int e_1) //拉伸收縮
  213. {
  214.         if( e_1 == FORWARD )
  215.         {
  216.                 digitalWrite(Stretch_1,HIGH);
  217.                 digitalWrite(Stretch_2,LOW);
  218.         }
  219.         else if( e_1 == BACKWARD )
  220.         {
  221.                 digitalWrite(Stretch_1,LOW);
  222.                 digitalWrite(Stretch_2,HIGH);
  223.         }
  224.         else
  225.         {
  226.                 digitalWrite(Stretch_1,LOW);
  227.                 digitalWrite(Stretch_2,LOW);
  228.         }
  229. }

  231. void motor_mx(int f_1,int f_2)   //手控x軸
  232. {
  233.         if(f_1 == FORWARD,f_2 == FAST)
  234.         {
  235.         digitalWrite(DIR_X,HIGH);
  236.                 tone(CLK_X,1600);
  237.         }
  238.         else if(f_1 == FORWARD,f_2 == SLOW )
  239.         {
  240.         digitalWrite(DIR_X,HIGH);
  241.                 tone(CLK_X,800);
  242.         }
  243.         else if(f_1 == BACKWARD, f_2 == FAST)
  244.         {
  245.                 digitalWrite(DIR_X,LOW);
  246.                 tone(CLK_X,1600);
  247.         }
  248.         else if(f_1 == BACKWARD, f_2 == SLOW)
  249.         {
  250.                 digitalWrite(DIR_X,LOW);
  251.                 tone(CLK_X,800);
  252.         }
  253.         else
  254.         {
  255.         noTone(CLK_X);
  256.         }
  257. }

  259. void motor_my(int g_1,int g_2)   //手控y軸
  260. {
  261.         if(g_1 == FORWARD,g_2 == FAST)
  262.         {
  263.         digitalWrite(DIR_Y,HIGH);
  264.                 tone(CLK_Y,1600);
  265.         }
  266.         else if(g_1 == FORWARD,g_2 == SLOW )
  267.         {
  268.         digitalWrite(DIR_Y,HIGH);
  269.                 tone(CLK_Y,800);
  270.         }
  271.         else if(g_1 == BACKWARD, g_2 == FAST)
  272.         {
  273.                 digitalWrite(DIR_Y,LOW);
  274.                 tone(CLK_Y,1600);
  275.         }
  276.         else if(g_1 == BACKWARD, g_2 == SLOW)
  277.         {
  278.                 digitalWrite(DIR_Y,LOW);
  279.                 tone(CLK_Y,800);
  280.         }
  281.         else
  282.         {
  283.         noTone(CLK_Y);
  284.         }
  285. }

  287. void motor_mz(int h_1,int h_2)   //手控z軸
  288. {
  289.         if(h_1 == FORWARD,h_2 == FAST)
  290.         {
  291.         digitalWrite(DIR_Z,HIGH);
  292.                 tone(CLK_Z,1600);
  293.         }
  294.         else if(h_1 == FORWARD,h_2 == SLOW )
  295.         {
  296.         digitalWrite(DIR_Z,HIGH);
  297.                 tone(CLK_Z,800);
  298.         }
  299.         else if(h_1 == BACKWARD, h_2 == FAST)
  300.         {
  301.                 digitalWrite(DIR_Z,LOW);
  302.                 tone(CLK_Z,1600);
  303.         }
  304.         else if(h_1 == BACKWARD, h_2 == SLOW)
  305.         {
  306.                 digitalWrite(DIR_Z,LOW);
  307.                 tone(CLK_Z,800);
  308.         }
  309.         else
  310.         {
  311.         noTone(CLK_Z);
  312.         }
  313. }

  315. void manuallycontrolX()
  316. {
  317.         while(!digitalRead(Forward_SW)&&!digitalRead(Backward_SW)&&digitalRead(Choice_SW)){}
  318.         while(1)
  319.                 {
  320.                 if(digitalRead(Forward_SW)) motor_mx(FORWARD);
  321.                 else if(digitalRead(Backward_SW)) motor_mx(BACKWARD);
  322.                 else motor_mx(STOP);
  323.     if(!digitalRead(Choice_SW)){
  324.       delay(50);
  325.       if(!digitalRead(Choice_SW))
  326.       break;
  327.     }
  328.                 }
  329.         motor_mx(STOP);
  330. }

  332. void manuallycontrolY()
  333. {
  334.         while(!digitalRead(Forward_SW)&&!digitalRead(Backward_SW)&&digitalRead(Choice_SW)){}
  335.         while(1)
  336.                 {
  337.                 if(digitalRead(Forward_SW)) motor_my(FORWARD);
  338.                 else if(digitalRead(Backward_SW)) motor_my(BACKWARD);
  339.                 else motor_my(STOP);
  340.     if(!digitalRead(Choice_SW)){
  341.       delay(50);
  342.       if(!digitalRead(Choice_SW))
  343.       break;
  344.     }
  345.                 }
  346.         motor_my(STOP);
  347. }

  349. void manuallycontrolZ()
  350. {
  351.         while(!digitalRead(Forward_SW)&&!digitalRead(Backward_SW)&&digitalRead(Choice_SW)){}
  352.         while(1)
  353.                 {
  354.                 if(digitalRead(Forward_SW)) motor_mz(FORWARD);
  355.                 else if(digitalRead(Backward_SW)) motor_mz(BACKWARD);
  356.                 else motor_mz(STOP);
  357.     if(!digitalRead(Choice_SW)){
  358.       delay(50);
  359.       if(!digitalRead(Choice_SW))
  360.       break;
  361.     }
  362.                 }
  363.         motor_my(STOP);
  364. }

  366. void manuallycontrolS()
  367. {
  368.         while(!digitalRead(Forward_SW)&&!digitalRead(Backward_SW)&&digitalRead(Choice_SW)){}
  369.         while(1)
  370.                 {
  371.                 if(digitalRead(Forward_SW)) motor_Scalpel(FORWARD);
  372.                 else if(digitalRead(Backward_SW)) motor_Scalpel(BACKWARD);
  373.                 else motor_Scalpel(STOP);
  374.    if(!digitalRead(Choice_SW)){
  375.       delay(50);
  376.       if(!digitalRead(Choice_SW))
  377.       break;
  378.     }
  379.                 }
  380.         motor_Scalpel(STOP);
  381. }

  383. void manuallycontrolD()
  384. {
  385.         while(!digitalRead(Forward_SW)&&!digitalRead(Backward_SW)&&digitalRead(Choice_SW)){}
  386.         while(1)
  387.                 {
  388.                 if(digitalRead(Forward_SW)) motor_Stretch(FORWARD);
  389.                 else if(digitalRead(Backward_SW)) motor_Stretch(BACKWARD);
  390.                 else motor_Stretch(STOP);
  391.    if(!digitalRead(Choice_SW)){
  392.       delay(50);
  393.       if(!digitalRead(Choice_SW))
  394.       break;
  395.     }
  396.                 }
  397.         motor_Stretch(STOP);
  398. }

  400. void manuallycontrol()
  401. {
  402.         m_var=1;
  403.         Serial.println("Select a control mode:");
  404.     Serial.println("x.x axis");
  405.     Serial.println("y.y axis");
  406.     Serial.println("z.z axis");
  407.     Serial.println("s.scalpel");
  408.         Serial.println("d.drawing");
  409.           while(m_var!=0)
  410.           {
  411.                   if(Serial.available()>0)
  412.                   {
  413.                           case_var=Serial.read();
  414.                           delay(100);
  415.                           switch(case_var)
  416.                           {
  417.                                   case 120:
  418.                                   Serial.println("manually control x axis");
  419.                                   manuallycontrolX();
  420.                                   Serial.println("quit x manual mode");
  421.                                   break;
  422.                                  
  423.                                   case 121:
  424.                                   Serial.println("manually control y axis");
  425.                                   manuallycontrolY();
  426.                                   Serial.println("quit y manual mode");
  427.                                   break;
  428.                                  
  429.                                   case 122:
  430.                                   Serial.println("manually control z axis");
  431.                                   manuallycontrolZ();
  432.                                   Serial.println("quit x manual mode");
  433.                                   break;
  434.                                  
  435.                                   case 115:
  436.                                   Serial.println("rotate the scalpel");
  437.                                   manuallycontrolS();
  438.                                   Serial.println("quit scalpel mode");
  439.                                   break;
  440.                                  
  441.                                   case 100:
  442.                                   Serial.println("draw");
  443.                                   digitalWrite(Solenoid,LOW);
  444.                                   manuallycontrolD();
  445.                                   digitalWrite(Solenoid,HIGH);
  446.                                   Serial.println("quit drawing mode");
  447.           break;
  448.                                  
  449.                                   case 48:
  450.                                   m_var=0;
  451.                                   break;

  453.           default:
  454.             break;

  456.                           }
  457.                   }
  458.           }
  459. }
復(fù)制代碼

所有資料51hei提供下載:
M_Controller_v1.8.zip (2.17 KB, 下載次數(shù): 34)


作者: admin    時間: 2019-3-25 05:40
本帖需要重新編輯補(bǔ)全電路原理圖,源碼,詳細(xì)說明與圖片即可獲得100+黑幣(帖子下方有編輯按鈕)
作者: nasony    時間: 2020-1-31 17:23
謝謝分享



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