API tools faq
paste
Advertisement
Zaganu

4.6.2020. working

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