API tools faq
paste
Advertisement
Zaganu

6.3.2020

Zaganu
Jun 3rd, 2020
1,100
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Arduino 10.12 KB | None | 0 0
raw download clone embed print report
  1. // definirea pinului de pas, respectiv de directie pentru motorul pas cu pas miscare verticala
  2. #define stepPin 48
  3. #define dirPin 46
  4. #define ls3in 32
  5. #define ls4in 22
  6.  
  7. // definirea pinului de pas, respectiv de directie pentru motorul pas cu pas miscare orizontala lopata
  8. #define stepPin2 44
  9. #define dirPin2 42
  10. #define ls2in 34
  11.  
  12. // definirea pinului de pas, respectiv de directie pentru motorul pas cu pas miscare orizontala masa
  13. #define stepPin3 40
  14. #define dirPin3 38
  15. #define ls1in 36
  16.  
  17. //////////////// senzori///////////////
  18. #define ls0in 52
  19. #define so1in 50 //intrarea primului senzor de obstacole
  20.  
  21. //////////////relee/////////////////////////
  22. #define relay1 30
  23. #define relay2 28
  24. #define relay3 26
  25. #define relay4 24
  26.  
  27. ////// definim butoanele + switch
  28. #define swin 23  //switch
  29. #define start_button 20
  30. #define stop_button 21
  31.  
  32.  
  33. int so1 = 0;
  34.  
  35. int sw_val = 0;
  36. int time = 0;
  37. const byte ROWS = 4; // Four rows
  38. const byte COLS = 4; // Three columns
  39.  
  40.  
  41. char keys[ROWS][COLS] = { // Define the Keymap
  42.   {'1', '2', '3', 'A'},
  43.   {'4', '5', '6', 'B'},
  44.   {'7', '8', '9', 'C'},
  45.   {'*', '0', '#', 'D'}
  46. };
  47. char opposite_keys[ROWS][COLS] = { // Define the Keymap
  48.   {NULL, NULL, NULL, NULL},
  49.   {NULL, NULL, NULL, NULL},
  50.   {'^', '%', '$', NULL},
  51.   {NULL, '@', NULL, NULL}
  52. };
  53.  
  54. byte rowPins[ROWS] = { 2, 3, 4, 5 };// Connect keypad ROW0, ROW1, ROW2 and ROW3 to these Arduino pins.
  55.  
  56. byte colPins[COLS] = { 6, 7, 8 , 9}; // Connect keypad COL0, COL1 and COL2 to these Arduino pins.
  57.  
  58. int opposite_key = NULL;
  59. bool flag_alarm = true;
  60. int current_state = -1;
  61. int counter = 0;
  62.  
  63. byte chA = 18;
  64. byte chB = 19;
  65. int encoder_value = 0;
  66.  
  67. void setup()
  68. {
  69.   pinMode(stepPin, OUTPUT);
  70.   pinMode(dirPin, OUTPUT);
  71.   pinMode(ls3in, INPUT);
  72.   pinMode(ls4in, INPUT);
  73.  
  74.   pinMode(stepPin2, OUTPUT);
  75.   pinMode(dirPin2, OUTPUT);
  76.   pinMode(ls2in, INPUT);
  77.  
  78.   pinMode(stepPin3, OUTPUT);
  79.   pinMode(dirPin3, OUTPUT);
  80.   pinMode(ls1in, INPUT);
  81.  
  82.   pinMode(so1in, INPUT);
  83.   pinMode(ls0in, INPUT);
  84.  
  85.   pinMode(relay1, OUTPUT);
  86.   pinMode(relay2, OUTPUT);
  87.   pinMode(relay3, OUTPUT);
  88.   pinMode(relay4, OUTPUT);
  89.  
  90.   // pinmode pentru cele doua butoane si switch
  91.   pinMode(swin, INPUT_PULLUP);
  92.   pinMode(start_button, INPUT);
  93.   pinMode(stop_button, INPUT);
  94.  
  95.  
  96.  
  97.   // declararea pinilor de input respectiv output pentru tastatura 4x4
  98.   pinMode(6, INPUT);
  99.   pinMode(7, INPUT);
  100.   pinMode(8, INPUT);
  101.   pinMode(9, INPUT);
  102.   pinMode(2, OUTPUT);
  103.   pinMode(3, OUTPUT);
  104.   pinMode(4, OUTPUT);
  105.   pinMode(5, OUTPUT);
  106.   ///////////////////////////////
  107.   // setarea starii high pentru pinii asociati coloanelor
  108.  
  109.   digitalWrite(6, HIGH);
  110.   digitalWrite(7, HIGH);
  111.   digitalWrite(8, HIGH);
  112.   digitalWrite(9, HIGH);
  113.  
  114.   digitalWrite(relay1, HIGH);
  115.   digitalWrite(relay2, HIGH);
  116.   digitalWrite(relay3, HIGH);
  117.   digitalWrite(relay4, HIGH);
  118.  
  119.   ///// releul e COM_NC neenergizat, pe semnal LOW se conecteaza COM_NO iar pe semnal HIGH se conecteaza COM_NC.
  120.   Serial.begin(9600);
  121.  
  122.   attachInterrupt(digitalPinToInterrupt(stop_button), alarm, RISING);
  123.   attachInterrupt(digitalPinToInterrupt(start_button), reset_alarm, RISING);
  124.   // attachInterrupt(digitalPinToInterrupt(stop_button), cw, RISING);
  125.   // attachInterrupt(digitalPinToInterrupt(start_button), ccw, RISING);
  126. }
  127.  
  128. void loop() {
  129.   sw_val = digitalRead(swin);
  130.   if (sw_val == 0 && flag_alarm == false) {     // sw_val == 0 coincide cu modul AUTOMAT
  131.     automat();
  132.   }
  133.   else if (sw_val == 1) { //sw_val == 1 conincide cu modul MANUAL
  134.     current_state = -1;
  135.     manual();
  136.  
  137.   }
  138. }
  139.  
  140.  
  141. char read_keyboard()
  142. {
  143.   for ( uint8_t i = 2; i < 6; ++i) {
  144.     digitalWrite(i, LOW);
  145.     for ( uint8_t j = 6; j < 10; ++j) {
  146.       int key = digitalRead(j);
  147.       if (!key)
  148.       {
  149.         digitalWrite(i, HIGH);
  150.         opposite_key = (opposite_keys[i - 2][j - 6]);
  151.         return (keys[i - 2][j - 6]);
  152.       }
  153.     }
  154.     digitalWrite(i, HIGH);
  155.   }
  156.   return opposite_key;
  157. }
  158.  
  159.  
  160. void manual() {
  161.   char a = read_keyboard();
  162.   //Serial.println(a);
  163.   switch (a)
  164.   {
  165.  
  166.     case '0': //pompa pornita
  167.       {
  168.         if (digitalRead(so1in) == 0) {
  169.           pump_on();
  170.         }
  171.         break;
  172.       }
  173.     case '@': //pompa oprita
  174.       {
  175.         pump_off();
  176.         reset_opposite_key();     //opposite_character = NULL ;
  177.         break;
  178.       }
  179.     case '1': //stepper miscare sus
  180.       {
  181.  
  182.         if (digitalRead(ls3in) == 0) {
  183.           break;
  184.         }
  185.         else {
  186.           move_motor(stepPin, dirPin, HIGH, 130);
  187.           break;
  188.         }
  189.       }
  190.     case '4': //stepper miscare jos
  191.       {
  192.         if (digitalRead(ls4in) == 0) {
  193.           break;
  194.         }
  195.         else {
  196.           move_motor(stepPin, dirPin, LOW, 130);
  197.           break;
  198.         }
  199.       }
  200.     case '3': //stepper lopata miscare stanga
  201.       {
  202.  
  203.         if (digitalRead(ls2in) == 0) {
  204.           break;
  205.         }
  206.         else {
  207.           move_motor(stepPin2, dirPin2, HIGH, 1000);
  208.           break;
  209.         }
  210.       }
  211.     case '2': //stepper lopata miscare dreapta
  212.       {
  213.         move_motor(stepPin2, dirPin2, LOW, 1000);
  214.         break;
  215.  
  216.       }
  217.     case '6': //stepper masa miscare stanga
  218.       {
  219.  
  220.         if (digitalRead(ls1in) == 0) {
  221.           break;
  222.         }
  223.         else {
  224.           move_motor(stepPin3, dirPin3, HIGH, 100);
  225.           break;
  226.         }
  227.       }
  228.     case '5': //stepper masa miscare dreapta
  229.       {
  230.         move_motor(stepPin3, dirPin3, LOW, 100);
  231.         break;
  232.       }
  233.     case '9': // miscare banda
  234.       {
  235.         if (digitalRead(ls0in) == 0) { // trebuie modificat
  236.           conveyor_off();
  237.           break;
  238.         }
  239.         else
  240.         {
  241.           conveyor_on();
  242.           break;
  243.         }
  244.       }
  245.  
  246.     case '$' : // opposite 9
  247.       {
  248.         conveyor_off();
  249.         reset_opposite_key();   //opposite_character = NULL ;
  250.         break;
  251.       }
  252.     case '8': //invartire sens orar(privit de sus)
  253.       {
  254.         motor_cw();
  255.         break;
  256.       }
  257.     case '%':
  258.       {
  259.         motor_stop();
  260.         reset_opposite_key();    //opposite_character = NULL ;
  261.         break;
  262.       }
  263.     case '7': //invartire sens trigonometric(privit de sus)
  264.       {
  265.         motor_ccw();
  266.         break;
  267.       }
  268.     case '^':
  269.       {
  270.         motor_stop();
  271.         reset_opposite_key();   //opposite_character = NULL ;
  272.         break;
  273.       }
  274.  
  275.   }
  276. }
  277.  
  278. /////////////////////////////// automat /////////////////////////
  279. void automat() {
  280.  
  281.   switch (current_state)
  282.   {
  283.     case 0 :
  284.       {
  285.         initialize();
  286.         break;
  287.       }
  288.  
  289.     case 1 :
  290.       {
  291.         conveyor_on();
  292.         current_state = 2;
  293.         break;
  294.       }
  295.     case 2:
  296.       {
  297.         if (digitalRead(so1in) == 0) {
  298.           conveyor_off();
  299.           current_state = 3;
  300.           time = millis();  
  301.         }
  302.         break;
  303.       }
  304.     // waint 1 second
  305.     case 3:
  306.       {
  307.         if(millis() - time > 1000)
  308.         {
  309.           pump_on();
  310.           current_state = 4;
  311.           time = millis();
  312.         }
  313.         break;
  314.       }
  315.     case 4:
  316.     {
  317.       if(millis() - time > 2000)
  318.         {
  319.           pump_off();
  320.           current_state = 5;
  321.         }
  322.        break;
  323.     }
  324.     case 5:
  325.       {
  326.         if (digitalRead(ls0in) == 1) {
  327.           conveyor_on();
  328.         }
  329.         else {
  330.           conveyor_off();
  331.           current_state = 6;
  332.         }
  333.         break;
  334.       }
  335.     case 6:
  336.       {
  337.        
  338.         if (counter >= 4000) {
  339.           current_state = 7;
  340.           counter = 0;
  341.         }
  342.         else {
  343.           move_motor(stepPin2, dirPin2, LOW, 1000);
  344.           counter++;
  345.         }
  346.         break;
  347.       }
  348.       case 7:
  349.       {
  350.          if (counter >= 17850) {
  351.           current_state = 8;
  352.           counter = 0;
  353.         }
  354.         else {
  355.           move_motor(stepPin3, dirPin3, LOW, 100);
  356.           counter++;
  357.         }
  358.         break;
  359.       }
  360.       case 8:
  361.       {
  362.          if (counter >= 2800) {
  363.           current_state = 9;
  364.           counter = 0;
  365.         }
  366.         else {
  367.           move_motor(stepPin, dirPin, LOW, 130);
  368.           counter++;
  369.         }
  370.       }
  371.  
  372.  
  373.   }
  374. }
  375. ////////////////////////////// states///////////////////////////
  376.  
  377. void initialize()
  378. {
  379.   pump_off();
  380.   conveyor_off();
  381.   motor_stop();
  382.  
  383.   if (digitalRead(ls1in) == 1) {
  384.     move_motor(stepPin3, dirPin3, HIGH, 100);
  385.   }
  386.   else
  387.   {
  388.     if (digitalRead(ls2in) == 1) {
  389.       move_motor(stepPin2, dirPin2, HIGH, 1000);
  390.     }
  391.     else
  392.     {
  393.       if (digitalRead(ls3in) == 1) {
  394.         move_motor(stepPin, dirPin, HIGH, 130);
  395.       }
  396.     }
  397.   }
  398.   if (digitalRead(ls1in) == 0 && digitalRead(ls2in) == 0 && digitalRead(ls3in) == 0)
  399.   {
  400.     current_state = 1;
  401.   }
  402.  
  403. }
  404.  
  405.  
  406.  
  407. //////////////////////////////// helper functions/////////////////
  408.  
  409. void conveyor_on() //miscare banda pornita
  410. {
  411.   digitalWrite(relay1, LOW);
  412. }
  413.  
  414. void conveyor_off() //miscare banda oprita
  415. {
  416.   digitalWrite(relay1, HIGH);
  417. }
  418.  
  419. void motor_cw() //motor infiletare sens orar
  420. {
  421.   digitalWrite(relay4, LOW);
  422. }
  423.  
  424. void motor_ccw() // motor infiletare sens trigonometric
  425. {
  426.   digitalWrite(relay3, LOW);
  427. }
  428.  
  429. void motor_stop() //motor infiletare este oprit
  430. {
  431.   digitalWrite(relay3, HIGH);
  432.   digitalWrite(relay4, HIGH);
  433. }
  434.  
  435. void pump_on()
  436. {
  437.   digitalWrite(relay2, LOW);
  438. }
  439.  
  440. void pump_off()
  441. {
  442.   digitalWrite(relay2, HIGH);
  443. }
  444.  
  445. void reset_opposite_key()
  446. {
  447.   opposite_key = NULL;
  448. }
  449.  
  450.  
  451. void cw()
  452. {
  453.   if (digitalRead(chA) > digitalRead(chB))
  454.   {
  455.     encoder_value++ ;
  456.   }
  457. }
  458.  
  459. void ccw()
  460. {
  461.   if (digitalRead(chA) > digitalRead(chB))
  462.   {
  463.     encoder_value-- ;
  464.  
  465.   }
  466. }
  467.  
  468. // functie pentru steppere
  469. void move_motor(int motor_pin, int dir_pin, int direction, int delay) {
  470.   digitalWrite(dir_pin, direction);
  471.   digitalWrite(motor_pin, HIGH);
  472.   digitalWrite(motor_pin, LOW);
  473.   delayMicroseconds(delay);
  474.   //ST1-SW123-011, comutator 111100;  delay micro 130
  475.   //ST2-SW123-010, comutator 111011;  delay micro 1000
  476.   //ST2-SW123--010, comutator 001100; delay micro 100
  477. }
  478.  
  479. void alarm() {
  480.   motor_stop();
  481.   pump_off();
  482.   conveyor_off();
  483.   flag_alarm = true;
  484.  
  485. }
  486.  
  487. void reset_alarm() {
  488.   flag_alarm = false;
  489.   current_state = 0;
  490. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!