SHARE
TWEET

4.6.2020. working

Zaganu Jun 4th, 2020 1,444 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  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. }
RAW Paste Data
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
Top