elektronik97

Sterownik lewarow v1.3

Oct 23rd, 2021 (edited)
76
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. /*
  2.  * *******STEROWNIK**LEWAROW*******
  3.  *
  4.  * by MILKI
  5.  *
  6.  */
  7.  
  8. #define relay1_up 0
  9. #define relay1_down 1
  10. #define relay2_up 2
  11. #define relay2_down 3
  12. #define switchUp 8
  13. #define switchDown 9
  14. #define buzzer 7
  15.  
  16. float sensor1 = A0;    //pin czujnika 1
  17. float sensor2 = A1;    //pin czujnika 2
  18. float sens1;            //czujnik 1
  19. float sens2;            // czujnik 2
  20. float val1;             // wartosc obliczona na wolty z czujnika 1
  21. float val2;             // wartosc obliczona na wolty z czujnika 2
  22.  
  23.  
  24. bool permitUp = false;   //zezwolenie jazdy do góry
  25. bool permitDown = false;  //zezwolenie jazdy w dół
  26. //bool controlUp;
  27. //bool controlDown;
  28. bool checkingOutputsStatus;  //sprawdzanie stanu wyjsc
  29. bool autoLevelingPlus = false;    //roznica poza gorna tolerancja
  30. bool autoLevelingMinus = false;   //roznica poza dolna tolerancja
  31. bool directionUp;                 //jesli wartosc poza tolerancja pokazuje kierunek jazdy w gore
  32. bool directionDown;               //jesli wartosc poza tolerancja pokazuje kierunek jazdy w dol
  33. bool stopUp;                      //żądanie zatrzymania silnikow w gore
  34. bool stopDown;                    //żądanie zatrzymania silnikow w doł
  35. bool changeBuzzer;
  36.  
  37. float tolerancePlus = 0.10;    //tolerancja miedzy czunikami na plus
  38. float toleranceMinus = -0.10;  //tolerancja miedzy czujnikami na minus
  39. float aligmentLevelingPlus = 0.10;  //wartos o jaka ma sie wyrownac po osiagnieciu gornej tolerancji
  40. float aligmentLevelingMinus = -0.10; //wartosc o jaka ma sie wyrownac po osiagnieciu dolnej tolerancji
  41. float result;                  //roznica warotsci czujnikow
  42.  
  43. unsigned long newTime;
  44. unsigned long oldTime;
  45.  
  46.  
  47. void setup() {
  48.   Serial.begin(9600);
  49.   pinMode(relay1_up, OUTPUT);
  50.   pinMode(relay2_up, OUTPUT);
  51.   pinMode(relay1_down, OUTPUT);
  52.   pinMode(relay2_down, OUTPUT);
  53.   pinMode(switchUp, INPUT_PULLUP);
  54.   pinMode(switchDown, INPUT_PULLUP);
  55.   pinMode(sensor1, INPUT);
  56.   pinMode(sensor2, INPUT);
  57.   pinMode(relay1_up, HIGH);
  58.   pinMode(relay2_up, HIGH);
  59.   pinMode(relay1_down, HIGH);
  60.   pinMode(relay2_down, HIGH);
  61.  
  62. }
  63.  
  64. void loop() {
  65.  
  66.   checkingOutputs();           //sprawdzanie stanu wyjjsc
  67. /*  sens1 = analogRead(sensor1);
  68.   sens2 = analogRead(sensor2);
  69.   val1 = (sens1 / 204.6);
  70.   val2 = (sens2 / 204.6);
  71.   result = (val1 - val2);
  72.   Serial.print("sensor1 ");
  73.   Serial.print(val1);
  74.   Serial.print(" volt   ");
  75.   Serial.print("sensor2 ");
  76.   Serial.print(val2);
  77.   Serial.print(" volt  ");
  78.   Serial.print("roznica");
  79.   Serial.println(result);
  80. */
  81.   if ((digitalRead(switchUp) == LOW) && (checkingOutputsStatus == false)) {
  82.     delay(10);
  83.     stopUp = false;
  84.     permitUp = true;                         //jazda w gore
  85.     permitDown = false;
  86.     liftUp();
  87.     checkingOutputs();
  88.  
  89.   }
  90.  
  91.   else if ((digitalRead(switchDown) == LOW) && (checkingOutputsStatus == false)) {
  92.     delay(10);
  93.     stopDown = false;
  94.     permitUp = false;                 //jazda w dol
  95.     permitDown = true;
  96.     liftDown();
  97.     checkingOutputs();
  98.   }
  99.   else {
  100.     motorsStop();       //wylaczenie silnikow
  101.   }
  102. }
  103. void waringSoundAutoLeveling() {
  104.   newTime = millis();
  105.   if ((newTime - oldTime) >= 100) {
  106.     changeBuzzer = !changeBuzzer;
  107.     if (changeBuzzer == 1) {                 //ostrzezenie o autopoziomowaniu
  108.       tone(buzzer, 2700);
  109.     }
  110.     else {
  111.       noTone(buzzer);
  112.     }
  113.     oldTime = newTime;
  114.   }
  115. }
  116. void motorsStop() {
  117.   if (digitalRead(switchUp) == HIGH) {
  118.     digitalWrite(relay1_up, HIGH);
  119.     digitalWrite(relay2_up, HIGH);
  120.     autoLevelingPlus = false;
  121.     autoLevelingMinus = false;
  122.     directionUp = false;
  123.     directionDown = false;
  124.     stopUp = true;
  125.   }
  126.   if (digitalRead(switchDown) == HIGH) {
  127.     digitalWrite(relay1_down, HIGH);
  128.     digitalWrite(relay2_down, HIGH);
  129.     autoLevelingPlus = false;
  130.     autoLevelingMinus = false;
  131.     directionUp = false;
  132.     directionDown = false;
  133.     stopDown = true;
  134.   }
  135.  
  136. }
  137. int autoLeveling() {    //ta funkcja odpowiada za wyrownanie podnosikow w zaleznosci od kierunku jazdy i ktory podnosnik sie spoznia
  138.  
  139.   if (autoLevelingPlus == true) {
  140.     if (directionUp == true) {
  141.       while (stopUp == false) {
  142.         digitalWrite(relay1_up, HIGH);
  143.         digitalWrite(relay2_up, LOW);
  144.         motorsStop();
  145.         sensorReading();
  146.         waringSoundAutoLeveling();
  147.         if ((result + aligmentLevelingPlus) < tolerancePlus) {
  148.           directionUp = false;
  149.           return;
  150.         }
  151.       }
  152.     }
  153.     if (directionDown == true) {
  154.       while (stopDown == false) {
  155.         digitalWrite(relay1_down, LOW);
  156.         digitalWrite(relay2_down, HIGH);
  157.         motorsStop();
  158.         sensorReading();
  159.         waringSoundAutoLeveling();
  160.         if ((result + aligmentLevelingPlus) < tolerancePlus) {
  161.           directionDown = false;
  162.           return;
  163.         }
  164.       }
  165.     }
  166.   }
  167.   else if (autoLevelingMinus == true) {
  168.     if (directionUp == true) {
  169.       while (stopUp == false) {
  170.         digitalWrite(relay1_up, LOW);
  171.         digitalWrite(relay2_up, HIGH);
  172.         motorsStop();
  173.         sensorReading();
  174.         waringSoundAutoLeveling();
  175.         if ((result + aligmentLevelingMinus) > toleranceMinus) {
  176.           directionUp = false;
  177.           return;
  178.         }
  179.       }
  180.     }
  181.     else if (directionDown == true) {
  182.       while (stopDown == false) {
  183.         digitalWrite(relay1_down, HIGH);
  184.         digitalWrite(relay2_down, LOW);
  185.         motorsStop();
  186.         sensorReading();
  187.         waringSoundAutoLeveling();
  188.         if ((result + aligmentLevelingMinus) > toleranceMinus) {
  189.           directionDown = false;
  190.           return;
  191.         }
  192.       }
  193.     }
  194.  
  195.   }
  196.   autoLevelingPlus = false;
  197.   autoLevelingMinus = false;
  198.   return;
  199. }
  200. int liftUp() {        //funkcja podnoszenia
  201.  
  202.   while (permitUp == true) {
  203.     sensorReading();     //odczyt z czujnikow jesli bedzie poza tolerancja wywali blad
  204.     while ((autoLevelingPlus == true) || (autoLevelingMinus == true)) {
  205.       directionUp = true;
  206.       autoLeveling();    //wyrownanie
  207.     }
  208.     noTone(buzzer);
  209.     digitalWrite(relay1_up, LOW);
  210.     digitalWrite(relay2_up, LOW);
  211.  
  212.  
  213.     if (digitalRead(switchUp) == LOW) {
  214.       delay(10);
  215.       permitUp = true;
  216.     }
  217.     else {
  218.       permitUp = false;
  219.     }
  220.   }
  221.   digitalWrite(relay1_up, HIGH);
  222.   digitalWrite(relay2_up, HIGH);
  223.   delay(2000);                    //czas na zatrzymanie sie silnikow
  224. }
  225. void liftDown() {        //to samo co liftUp lecz w dol
  226.   while (permitDown == true) {
  227.     sensorReading();
  228.     while ((autoLevelingPlus == true) || (autoLevelingMinus == true)) {
  229.       directionDown = true;
  230.       autoLeveling();
  231.     }
  232.     noTone(buzzer);
  233.     digitalWrite(relay1_down, LOW);
  234.     digitalWrite(relay2_down, LOW);
  235.     if (digitalRead(switchDown) == LOW) {
  236.       delay(10);
  237.       permitDown = true;
  238.     }
  239.     else {
  240.       permitDown = false;
  241.     }
  242.   }
  243.   digitalWrite(relay1_down, HIGH);
  244.   digitalWrite(relay2_down, HIGH);
  245.   delay(2000);
  246. }
  247. int checkingOutputs() {     //sprawdzanie stanu wyjsc zabezpieczenie przed wlaczeniem drugiego kierunku keidy jeden jest wlaczony
  248.   if ((digitalRead(relay1_up) == LOW)  && (digitalRead(relay2_up) == LOW)) {
  249.     checkingOutputsStatus = true;
  250.     return checkingOutputsStatus;
  251.   }
  252.   else if ((digitalRead(relay1_down) == LOW)  && (digitalRead(relay2_down) == LOW)) {
  253.  
  254.     checkingOutputsStatus = true;
  255.     return checkingOutputsStatus;
  256.   }
  257.   else {
  258.     checkingOutputsStatus = false;
  259.     return checkingOutputsStatus;
  260.   }
  261. }
  262. int sensorReading() {         //odczyt z czujikow i porownanie oraz informacja zwrotna czy jest powyzej czy ponizej tolerancji
  263.   sens1 = analogRead(sensor1);
  264.   sens2 = analogRead(sensor2);
  265.   val1 = (sens1 / 204.6);
  266.   val2 = (sens2 / 204.6);
  267.   result = (val1 - val2);
  268.   Serial.print("sensor1 ");
  269.   Serial.print(val1);
  270.   Serial.print(" volt   ");
  271.   Serial.print("sensor2 ");
  272.   Serial.print(val2);
  273.   Serial.print(" volt  ");
  274.   Serial.print("roznica");
  275.   Serial.println(result);
  276.   if (result >= tolerancePlus) {
  277.     autoLevelingPlus = true;
  278.     return autoLevelingPlus;
  279.   }
  280.   else if (result < toleranceMinus) {
  281.     autoLevelingMinus = true;
  282.     return autoLevelingMinus;
  283.   }
  284.   else {
  285.     autoLevelingPlus = false;
  286.     autoLevelingMinus = false;
  287.   }
  288. }
  289. //**********KONIEC**PROGRAMU**********
RAW Paste Data