SHARE
TWEET

Auto fara insurubare functional /manual functional 1/6/2020

Zaganu Jun 1st, 2020 780 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.  
  33. int so1 = 0;
  34.  
  35. int sw_val = 0;
  36.  
  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.         }
  301.         break;
  302.  
  303.       }
  304.     case 3:
  305.       {
  306.         delay(1000);
  307.         pump_on();
  308.         delay(500);
  309.         pump_off();
  310.         delay(500);
  311.         current_state = 4;
  312.         break;
  313.       }
  314.     case 4:
  315.       {
  316.         if (digitalRead(ls0in) == 1) {
  317.           conveyor_on();
  318.         }
  319.         else {
  320.           conveyor_off();
  321.           current_state = 5;
  322.         }
  323.         break;
  324.       }
  325.     case 5:
  326.       {
  327.        
  328.         if (counter >= 4000) {
  329.           current_state = 6;
  330.           counter = 0;
  331.         }
  332.         else {
  333.           move_motor(stepPin2, dirPin2, LOW, 1000);
  334.           counter++;
  335.         }
  336.         break;
  337.       }
  338.       case 6:
  339.       {
  340.          if (counter >= 17850) {
  341.           current_state = 7;
  342.           counter = 0;
  343.         }
  344.         else {
  345.           move_motor(stepPin3, dirPin3, LOW, 100);
  346.           counter++;
  347.         }
  348.         break;
  349.       }
  350.       case 7:
  351.       {
  352.          if (counter >= 2800) {
  353.           current_state = 8;
  354.           counter = 0;
  355.         }
  356.         else {
  357.           move_motor(stepPin, dirPin, LOW, 130);
  358.           counter++;
  359.         }
  360.       }
  361.  
  362.  
  363.   }
  364. }
  365. ////////////////////////////// states///////////////////////////
  366.  
  367. void initialize()
  368. {
  369.   pump_off();
  370.   conveyor_off();
  371.   motor_stop();
  372.  
  373.   if (digitalRead(ls1in) == 1) {
  374.     move_motor(stepPin3, dirPin3, HIGH, 100);
  375.   }
  376.   else
  377.   {
  378.     if (digitalRead(ls2in) == 1) {
  379.       move_motor(stepPin2, dirPin2, HIGH, 1000);
  380.     }
  381.     else
  382.     {
  383.       if (digitalRead(ls3in) == 1) {
  384.         move_motor(stepPin, dirPin, HIGH, 130);
  385.       }
  386.     }
  387.   }
  388.   if (digitalRead(ls1in) == 0 && digitalRead(ls2in) == 0 && digitalRead(ls3in) == 0)
  389.   {
  390.     current_state = 1;
  391.   }
  392.  
  393. }
  394.  
  395.  
  396.  
  397. //////////////////////////////// helper functions/////////////////
  398.  
  399. void conveyor_on() //miscare banda pornita
  400. {
  401.   digitalWrite(relay1, LOW);
  402. }
  403.  
  404. void conveyor_off() //miscare banda oprita
  405. {
  406.   digitalWrite(relay1, HIGH);
  407. }
  408.  
  409. void motor_cw() //motor infiletare sens orar
  410. {
  411.   digitalWrite(relay4, LOW);
  412. }
  413.  
  414. void motor_ccw() // motor infiletare sens trigonometric
  415. {
  416.   digitalWrite(relay3, LOW);
  417. }
  418.  
  419. void motor_stop() //motor infiletare este oprit
  420. {
  421.   digitalWrite(relay3, HIGH);
  422.   digitalWrite(relay4, HIGH);
  423. }
  424.  
  425. void pump_on()
  426. {
  427.   digitalWrite(relay2, LOW);
  428. }
  429.  
  430. void pump_off()
  431. {
  432.   digitalWrite(relay2, HIGH);
  433. }
  434.  
  435. void reset_opposite_key()
  436. {
  437.   opposite_key = NULL;
  438. }
  439.  
  440.  
  441. void cw()
  442. {
  443.   if (digitalRead(chA) > digitalRead(chB))
  444.   {
  445.     encoder_value++ ;
  446.   }
  447. }
  448.  
  449. void ccw()
  450. {
  451.   if (digitalRead(chA) > digitalRead(chB))
  452.   {
  453.     encoder_value-- ;
  454.  
  455.   }
  456. }
  457.  
  458. // functie pentru steppere
  459. void move_motor(int motor_pin, int dir_pin, int direction, int delay) {
  460.   digitalWrite(dir_pin, direction);
  461.   digitalWrite(motor_pin, HIGH);
  462.   digitalWrite(motor_pin, LOW);
  463.   delayMicroseconds(delay);
  464.   //ST1-SW123-011, comutator 111100;  delay micro 130
  465.   //ST2-SW123-010, comutator 111011;  delay micro 1000
  466.   //ST2-SW123--010, comutator 001100; delay micro 100
  467. }
  468.  
  469. void alarm() {
  470.   motor_stop();
  471.   pump_off();
  472.   conveyor_off();
  473.   flag_alarm = true;
  474.  
  475. }
  476.  
  477. void reset_alarm() {
  478.   flag_alarm = false;
  479.   current_state = 0;
  480. }
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