API tools faq
paste
Advertisement
Zaganu

licenta cod final automat+ manual working 100%

Zaganu
Jun 6th, 2020
1,189
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Arduino 13.64 KB | None | 0 0
raw download clone embed print report
  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.   }
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!