SHARE
TWEET

licenta cod final automat+ manual working 100%

Zaganu Jun 6th, 2020 826 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. ///// piesa de infiletare trebuie sa fie cu marcajul alb spre stanga. privit dinspre zona de alimentare cu peturi
  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.  
  34. byte flag_motor_done = 0;
  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.  
  65. //////////////////// timer///////////////////
  66. int time_counter = 0;
  67. int count = 0;
  68. byte init_done = false;
  69. byte done_count = false;
  70.  
  71.  
  72. void setup()
  73. {
  74.   pinMode(stepPin, OUTPUT);
  75.   pinMode(dirPin, OUTPUT);
  76.   pinMode(ls3in, INPUT);
  77.   pinMode(ls4in, INPUT);
  78.  
  79.   pinMode(stepPin2, OUTPUT);
  80.   pinMode(dirPin2, OUTPUT);
  81.   pinMode(ls2in, INPUT);
  82.  
  83.   pinMode(stepPin3, OUTPUT);
  84.   pinMode(dirPin3, OUTPUT);
  85.   pinMode(ls1in, INPUT);
  86.  
  87.   pinMode(so1in, INPUT);
  88.   pinMode(ls0in, INPUT);
  89.  
  90.   pinMode(relay1, OUTPUT);
  91.   pinMode(relay2, OUTPUT);
  92.   pinMode(relay3, OUTPUT);
  93.   pinMode(relay4, OUTPUT);
  94.  
  95.   // pinmode pentru cele doua butoane si switch
  96.   pinMode(swin, INPUT_PULLUP);
  97.   pinMode(start_button, INPUT);
  98.   pinMode(stop_button, INPUT);
  99.  
  100.  
  101.  
  102.   // declararea pinilor de input respectiv output pentru tastatura 4x4
  103.   pinMode(6, INPUT);
  104.   pinMode(7, INPUT);
  105.   pinMode(8, INPUT);
  106.   pinMode(9, INPUT);
  107.   pinMode(2, OUTPUT);
  108.   pinMode(3, OUTPUT);
  109.   pinMode(4, OUTPUT);
  110.   pinMode(5, OUTPUT);
  111.   ///////////////////////////////
  112.   // setarea starii high pentru pinii asociati coloanelor
  113.  
  114.   digitalWrite(6, HIGH);
  115.   digitalWrite(7, HIGH);
  116.   digitalWrite(8, HIGH);
  117.   digitalWrite(9, HIGH);
  118.  
  119.   digitalWrite(relay1, HIGH);
  120.   digitalWrite(relay2, HIGH);
  121.   digitalWrite(relay3, HIGH);
  122.   digitalWrite(relay4, HIGH);
  123.  
  124.   ///// releul e COM_NC neenergizat, pe semnal LOW se conecteaza COM_NO iar pe semnal HIGH se conecteaza COM_NC.
  125.   Serial.begin(9600);
  126.  
  127.   attachInterrupt(digitalPinToInterrupt(stop_button), alarm, RISING);
  128.   attachInterrupt(digitalPinToInterrupt(start_button), reset_alarm, RISING);
  129.  
  130.  
  131.  
  132.   ////////// timer////////
  133.  
  134.   TCCR1A = 0;// set entire TCCR1A register to 0
  135.   TCCR1B = 0;// same for TCCR1B
  136.   TCNT1  = 0;//initialize counter value to 0
  137.   // set compare match register for 1hz increments
  138.   OCR1A = 15;// = (16*10^6) / (1*1024) - 1 (must be <65536)
  139.   // turn on CTC mode
  140.   TCCR1B |= (1 << WGM12);
  141.   // Set CS10 and CS12 bits for 1024 prescaler
  142.   TCCR1B |= (1 << CS12) | (1 << CS10);
  143.   // enable timer compare interrupt
  144.   TIMSK1 |= (1 << OCIE1A);
  145.   sei();
  146.  
  147. }
  148.  
  149.   ISR(TIMER1_COMPA_vect) { //timer1 interrupt 1Hz toggles pin 13 (LED)
  150.     time_counter++;
  151.     if (time_counter == count)
  152.     {
  153.       stop_timer();
  154.       time_counter = 0;
  155.       count = 0;
  156.       done_count = true;
  157.       motor_stop();
  158.     }
  159.   }
  160.  
  161.   void loop() {
  162.     // Serial.println(encoder_pos);
  163.     sw_val = digitalRead(swin);
  164.     if (sw_val == 0 && flag_alarm == false) {     // sw_val == 0 coincide cu modul AUTOMAT
  165.       automat();
  166.     }
  167.     else if (sw_val == 1) { //sw_val == 1 conincide cu modul MANUAL
  168.       current_state = -1;
  169.       manual();
  170.       flag_alarm = true;
  171.  
  172.     }
  173.   }
  174.  
  175.  
  176.   char read_keyboard()
  177.   {
  178.     for ( uint8_t i = 2; i < 6; ++i) {
  179.       digitalWrite(i, LOW);
  180.       for ( uint8_t j = 6; j < 10; ++j) {
  181.         int key = digitalRead(j);
  182.         if (!key)
  183.         {
  184.           digitalWrite(i, HIGH);
  185.           opposite_key = (opposite_keys[i - 2][j - 6]);
  186.           return (keys[i - 2][j - 6]);
  187.         }
  188.       }
  189.       digitalWrite(i, HIGH);
  190.     }
  191.     return opposite_key;
  192.   }
  193.  
  194.  
  195.   void manual() {
  196.     char a = read_keyboard();
  197.     //Serial.println(a);
  198.     switch (a)
  199.     {
  200.  
  201.       case '0': //pompa pornita
  202.         {
  203.           if (digitalRead(so1in) == 0) {
  204.             pump_on();
  205.           }
  206.           break;
  207.         }
  208.       case '@': //pompa oprita
  209.         {
  210.           pump_off();
  211.           reset_opposite_key();     //opposite_character = NULL ;
  212.           break;
  213.         }
  214.       case '1': //stepper miscare sus
  215.         {
  216.  
  217.           if (digitalRead(ls3in) == 0) {
  218.             break;
  219.           }
  220.           else {
  221.             move_motor(stepPin, dirPin, HIGH, 130);
  222.             break;
  223.           }
  224.         }
  225.       case '4': //stepper miscare jos
  226.         {
  227.           if (digitalRead(ls4in) == 0) {
  228.             break;
  229.           }
  230.           else {
  231.             move_motor(stepPin, dirPin, LOW, 130);
  232.             break;
  233.           }
  234.         }
  235.       case '3': //stepper lopata miscare stanga
  236.         {
  237.  
  238.           if (digitalRead(ls2in) == 0) {
  239.             break;
  240.           }
  241.           else {
  242.             move_motor(stepPin2, dirPin2, HIGH, 1000);
  243.             break;
  244.           }
  245.         }
  246.       case '2': //stepper lopata miscare dreapta
  247.         {
  248.           move_motor(stepPin2, dirPin2, LOW, 1000);
  249.           break;
  250.  
  251.         }
  252.       case '6': //stepper masa miscare stanga
  253.         {
  254.  
  255.           if (digitalRead(ls1in) == 0) {
  256.             break;
  257.           }
  258.           else {
  259.             move_motor(stepPin3, dirPin3, HIGH, 100);
  260.             break;
  261.           }
  262.         }
  263.       case '5': //stepper masa miscare dreapta
  264.         {
  265.           move_motor(stepPin3, dirPin3, LOW, 100);
  266.           break;
  267.         }
  268.       case '9': // miscare banda
  269.         {
  270.           if (digitalRead(ls0in) == 0) { // trebuie modificat
  271.             conveyor_off();
  272.             break;
  273.           }
  274.           else
  275.           {
  276.             conveyor_on();
  277.             break;
  278.           }
  279.         }
  280.  
  281.       case '$' : // opposite 9
  282.         {
  283.           conveyor_off();
  284.           reset_opposite_key();   //opposite_character = NULL ;
  285.           break;
  286.         }
  287.       case '8': //invartire sens orar(privit de sus)
  288.         {
  289.           motor_cw();
  290.           break;
  291.         }
  292.       case '%':
  293.         {
  294.           motor_stop();
  295.           reset_opposite_key();    //opposite_character = NULL ;
  296.           break;
  297.         }
  298.       case '7': //invartire sens trigonometric(privit de sus)
  299.         {
  300.           motor_ccw();
  301.           break;
  302.         }
  303.       case '^':
  304.         {
  305.           motor_stop();
  306.           reset_opposite_key();   //opposite_character = NULL ;
  307.           break;
  308.         }
  309.  
  310.     }
  311.   }
  312.  
  313.   /////////////////////////////// automat /////////////////////////
  314.   void automat() {
  315.  
  316.     switch (current_state)
  317.     {
  318.       case 0 :
  319.         {
  320.           initialize();
  321.           break;
  322.         }
  323.  
  324.       case 1 :
  325.         {
  326.           //Serial.println("case 1");
  327.           conveyor_on();
  328.           current_state = 2;
  329.           break;
  330.         }
  331.       case 2:
  332.         {
  333.           // Serial.println("case 2");
  334.           if (digitalRead(so1in) == 0) {
  335.             conveyor_off();
  336.             current_state = 3;
  337.             reset_millis();
  338.             time = millis();
  339.           }
  340.           break;
  341.         }
  342.       // waint 1 second
  343.       case 3:
  344.         {
  345.           // Serial.println("case 3");
  346.           if (millis() - time > 1000)
  347.           {
  348.             pump_on();
  349.             current_state = 4;
  350.             reset_millis();
  351.             time = millis();
  352.           }
  353.           break;
  354.         }
  355.       case 4:
  356.         {
  357.           //Serial.println("case 4");
  358.           if (millis() - time > 11000)
  359.           {
  360.             pump_off();
  361.             current_state = 5;
  362.           }
  363.           break;
  364.         }
  365.       case 5:
  366.         {
  367.           //Serial.println("case 5");
  368.           if (digitalRead(ls0in) == 1) {
  369.             conveyor_on();
  370.           }
  371.           else {
  372.             conveyor_off();
  373.             current_state = 6;
  374.           }
  375.           break;
  376.         }
  377.       case 6:
  378.         {
  379.           if (counter >= 4000) {
  380.             current_state = 7;
  381.             counter = 0;
  382.           }
  383.           else {
  384.             move_motor(stepPin2, dirPin2, LOW, 1000);
  385.             counter++;
  386.           }
  387.           break;
  388.         }
  389.       case 7:
  390.         {
  391.           if (counter >= 17850) {
  392.             current_state = 8;
  393.             counter = 0;
  394.           }
  395.           else {
  396.             move_motor(stepPin3, dirPin3, LOW, 100);
  397.             counter++;
  398.           }
  399.           break;
  400.         }
  401.       case 8:
  402.         {
  403.           if (counter >= 3000) {
  404.             current_state = 9;
  405.             counter = 0;
  406.             motor_cw();
  407.             count = 150;
  408.             start_timer();
  409.           }
  410.           else {
  411.             move_motor(stepPin, dirPin, LOW, 130);
  412.             counter++;
  413.           }
  414.           break;
  415.         }
  416.  
  417.       case 9 :
  418.         {
  419.           //attachInterrupt(4, encoder, CHANGE);
  420.           if (done_count)
  421.           {
  422.             Serial.println("done");
  423.             done_count = false;
  424.             current_state = 10;
  425.           }
  426.           break;
  427.         }
  428.        
  429.       case 10 :
  430.         {
  431.           if (digitalRead(ls1in) == 1) {
  432.             move_motor(stepPin3, dirPin3, HIGH, 100);
  433.           }
  434.           else
  435.           {
  436.             if (digitalRead(ls2in) == 1) {
  437.               move_motor(stepPin2, dirPin2, HIGH, 1000);
  438.             }
  439.           }
  440.           if (digitalRead(ls1in) == 0 && digitalRead(ls2in) == 0)
  441.           {
  442.             current_state = 11;
  443.           }
  444.           break;
  445.         }
  446.        
  447.       case 11:
  448.         {
  449.           if (digitalRead(ls4in) == 1) {
  450.             move_motor(stepPin, dirPin, LOW, 130);
  451.           }
  452.           else
  453.           {
  454.             motor_cw();
  455.             count = 1300;
  456.             start_timer();
  457.             current_state = 12;
  458.            
  459.           }
  460.           break;
  461.         }
  462.  
  463.       case 12:
  464.         {
  465.           //Serial.println(encoder_pos);
  466.           if (done_count)
  467.           {
  468.             Serial.println("done");
  469.             current_state = 13;
  470.            
  471.             done_count = false;
  472.           }
  473.           break;
  474.         }
  475.       case 13:
  476.         {
  477.           if (counter <= 1500) {
  478.             move_motor(stepPin, dirPin, HIGH, 130);
  479.             counter++;
  480.           }
  481.           else
  482.           {
  483.             current_state = 14;
  484.           }
  485.         }
  486.        
  487.     }
  488.   }
  489.   ////////////////////////////// states///////////////////////////
  490.  
  491.   void initialize()
  492.   {
  493.     pump_off();
  494.     conveyor_off();
  495.     motor_stop();
  496.     stop_timer();
  497.     //  attachInterrupt(4, encoder, CHANGE);
  498.  
  499.     if (digitalRead(ls1in) == 1) {
  500.       move_motor(stepPin3, dirPin3, HIGH, 100);
  501.     }
  502.     else
  503.     {
  504.       if (digitalRead(ls2in) == 1) {
  505.         move_motor(stepPin2, dirPin2, HIGH, 1000);
  506.       }
  507.       else
  508.       {
  509.         if (digitalRead(ls3in) == 1) {
  510.           move_motor(stepPin, dirPin, HIGH, 130);
  511.         }
  512.       }
  513.     }
  514.     if (digitalRead(ls1in) == 0 && digitalRead(ls2in) == 0 && digitalRead(ls3in) == 0)
  515.     {
  516.       current_state = 1;
  517.     }
  518.  
  519.   }
  520.  
  521.  
  522.  
  523.   //////////////////////////////// helper functions/////////////////
  524.  
  525.   void conveyor_on() //miscare banda pornita
  526.   {
  527.     digitalWrite(relay1, LOW);
  528.   }
  529.  
  530.   void conveyor_off() //miscare banda oprita
  531.   {
  532.     digitalWrite(relay1, HIGH);
  533.   }
  534.  
  535.   void motor_cw() //motor infiletare sens orar
  536.   {
  537.     digitalWrite(relay4, LOW);
  538.   }
  539.  
  540.   void motor_ccw() // motor infiletare sens trigonometric
  541.   {
  542.     digitalWrite(relay3, LOW);
  543.   }
  544.  
  545.   void motor_stop() //motor infiletare este oprit
  546.   {
  547.     digitalWrite(relay3, HIGH);
  548.     digitalWrite(relay4, HIGH);
  549.   }
  550.  
  551.   void pump_on()
  552.   {
  553.     digitalWrite(relay2, LOW);
  554.   }
  555.  
  556.   void pump_off()
  557.   {
  558.     digitalWrite(relay2, HIGH);
  559.   }
  560.  
  561.   void reset_opposite_key()
  562.   {
  563.     opposite_key = NULL;
  564.   }
  565.  
  566.  
  567.  
  568.   // functie pentru steppere
  569.   void move_motor(int motor_pin, int dir_pin, int direction, int delay) {
  570.     digitalWrite(dir_pin, direction);
  571.     digitalWrite(motor_pin, HIGH);
  572.     digitalWrite(motor_pin, LOW);
  573.     delayMicroseconds(delay);
  574.     //ST1-SW123-011, comutator 111100;  delay micro 130
  575.     //ST2-SW123-010, comutator 111011;  delay micro 1000
  576.     //ST2-SW123--010, comutator 001100; delay micro 100
  577.   }
  578.  
  579.   void alarm() {
  580.     motor_stop();
  581.     pump_off();
  582.     conveyor_off();
  583.     flag_alarm = true;
  584.  
  585.   }
  586.  
  587.   void reset_alarm() {
  588.     if (flag_alarm)
  589.     {
  590.       flag_alarm = false;
  591.       current_state = 0;
  592.       // encoder_pos = 0;
  593.  
  594.     }
  595.   }
  596.  
  597.   void reset_millis() {
  598.     noInterrupts ();
  599.     timer0_millis = 0;
  600.     interrupts ();
  601.   }
  602.  
  603.   void start_timer()
  604.   {
  605.     TCCR1B |= (1 << CS12) | (1 << CS10);
  606.   }
  607.  
  608.   void stop_timer()
  609.   {
  610.     TCCR1B &= ~(1 << CS10);
  611.     TCCR1B &= ~(1 << CS11);
  612.     TCCR1B &= ~(1 << CS12);
  613.     TCNT1 = 0;
  614.     count = 0;
  615.     time_counter = 0;
  616.   }
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