daily pastebin goal
24%
SHARE
TWEET

Untitled

a guest May 17th, 2018 112 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. //Main motor
  2. int Pin1 = 10;
  3. int Pin2 = 11;
  4. int Pin3 = 12;
  5. int Pin4 = 13;
  6.  
  7. //Water emitting motor
  8. int Pin5 = 5;
  9. int Pin6 = 6;
  10. int Pin7 = 7;
  11. int Pin8 = 8;
  12.  
  13. int Firepin = 4;
  14.  
  15. int _step = 0;
  16. int times=1;//Only for main motor.
  17. int desired_angle;
  18. int angle;
  19. //boolean dir; false = anti..true = clock //NOW Varified by MAIN
  20.  
  21. //For positioning
  22. int btn_pin = 2;
  23. int is_btn_pressed = false;
  24. int current_main = 0;
  25. int current_water = 0;
  26.  
  27.  
  28. void setup()
  29. {
  30.  Serial.begin(9600);
  31.  
  32.  pinMode(Firepin,INPUT);
  33.  pinMode(btn_pin,INPUT);
  34.  
  35.  //Main
  36.  pinMode(Pin1, OUTPUT);  
  37.  pinMode(Pin2, OUTPUT);  
  38.  pinMode(Pin3, OUTPUT);  
  39.  pinMode(Pin4, OUTPUT);
  40.  
  41.  //Water
  42.  pinMode(Pin5, OUTPUT);  
  43.  pinMode(Pin6, OUTPUT);  
  44.  pinMode(Pin7, OUTPUT);  
  45.  pinMode(Pin8, OUTPUT);
  46.  
  47. }
  48.  
  49. void loop()
  50. {
  51.   //delay(2000);
  52.   if(is_btn_pressed){
  53.     times = 1;
  54.     is_btn_pressed = false;
  55.   }
  56.  
  57.   //FIRE...FIRE...
  58.   if(!digitalRead(Firepin)){
  59.     fire_handle();
  60.   }
  61.  
  62.   //SAFE.............SAFE......
  63.   else {
  64.     //Water Motor
  65.     desired_angle = 120;
  66.     angle = (1050/90)*desired_angle;
  67.  
  68.     for(int i=0;i<angle;i++){
  69.      
  70.       if(!digitalRead(Firepin)){
  71.         fire_handle();
  72.       }
  73.  
  74.       if(digitalRead(btn_pin)){
  75.         go_to_init();
  76.         is_btn_pressed = true;
  77.         break;
  78.       }
  79.  
  80.       if(is_btn_pressed){
  81.         break;
  82.       }
  83.       water_motor(false);
  84.     }
  85.  
  86.  
  87.     for(int i=0;i<angle;i++){
  88.       if(!digitalRead(Firepin)){
  89.         fire_handle();
  90.       }
  91.  
  92.       if(digitalRead(btn_pin)){
  93.         go_to_init();
  94.         is_btn_pressed = true;
  95.         break;
  96.       }
  97.  
  98.       if(is_btn_pressed){
  99.         break;
  100.       }
  101.       water_motor(true);
  102.     }
  103.  
  104.    
  105.     //Main Motor
  106.     if(digitalRead(Firepin) && !is_btn_pressed){
  107.       desired_angle = 30;
  108.       angle = (1050/90)*desired_angle;
  109.  
  110.       if(times<=6){
  111.         //Serial.println("FALSE");
  112.         for(int i=0;i<angle;i++){
  113.           if(!digitalRead(Firepin)){
  114.             fire_handle();
  115.           }
  116.  
  117.           if(digitalRead(btn_pin)){
  118.             go_to_init();
  119.             is_btn_pressed = true;
  120.             break;
  121.           }
  122.  
  123.           if(is_btn_pressed){
  124.             break;
  125.           }
  126.          
  127.           else {
  128.             main_motor(false);
  129.           }
  130.         }
  131.       }
  132.       else if(times>=7 && times<=12){
  133.         //Serial.println("TRUEEEEEEEEEEEE");
  134.         for(int i=0;i<angle;i++){
  135.           if(!digitalRead(Firepin)){
  136.             fire_handle();
  137.           }
  138.  
  139.           if(digitalRead(btn_pin)){
  140.             go_to_init();
  141.             is_btn_pressed = true;
  142.             break;
  143.           }
  144.  
  145.           if(is_btn_pressed){
  146.             break;
  147.           }
  148.  
  149.           else {
  150.             main_motor(true);
  151.           }
  152.         }
  153.       }
  154.       times++;
  155.       //Serial.print("TIME = ");
  156.       //Serial.println(times);
  157.  
  158.       if(times==13){
  159.         //Serial.println("BECAME 13");
  160.         times=1;
  161.       }
  162.     }
  163.   }  
  164. }
  165.  
  166.  
  167. void go_to_init()
  168. {
  169. //  Serial.println("Button Pressed ");
  170. //  Serial.println(current_main);
  171. //  Serial.println(current_water);
  172.  
  173.   delay(2000);
  174.   int m = current_main;
  175.   int w = current_water;
  176.   Serial.println(w);
  177.  
  178.   for(int i=0;i<m;i++){
  179.     main_motor(true);
  180.   }
  181.   //Serial.println("WENT BACK ");
  182.  
  183.   for(int i=0;i<w;i++){
  184.     water_motor(true);
  185.   }
  186.   delay(50000);
  187. }
  188.  
  189. //void go_to_init()
  190. //{
  191. //  delay(7000);
  192. //}
  193.  
  194. void fire_handle()
  195. {
  196.   for(int j=0;j<10;j++){
  197.     for(int i=0;i<((1050/90)*25);i++){
  198.      both_motor(false);
  199.     }
  200.  
  201.     for(int i=0;i<((1050/90)*25);i++){
  202.      both_motor(true);
  203.     }
  204.   }
  205. }
  206.  
  207.  
  208. void both_motor(boolean dir) {
  209.   switch(_step){
  210.      case 0:
  211.        digitalWrite(Pin1, LOW);  
  212.        digitalWrite(Pin2, LOW);
  213.        digitalWrite(Pin3, LOW);
  214.        digitalWrite(Pin4, HIGH);
  215.  
  216.        digitalWrite(Pin5, LOW);  
  217.        digitalWrite(Pin6, LOW);
  218.        digitalWrite(Pin7, LOW);
  219.        digitalWrite(Pin8, HIGH);
  220.        break;  
  221.      case 1:
  222.        digitalWrite(Pin1, LOW);  
  223.        digitalWrite(Pin2, LOW);
  224.        digitalWrite(Pin3, HIGH);
  225.        digitalWrite(Pin4, HIGH);
  226.  
  227.        digitalWrite(Pin5, LOW);  
  228.        digitalWrite(Pin6, LOW);
  229.        digitalWrite(Pin7, HIGH);
  230.        digitalWrite(Pin8, HIGH);
  231.        break;  
  232.      case 2:
  233.        digitalWrite(Pin1, LOW);  
  234.        digitalWrite(Pin2, LOW);
  235.        digitalWrite(Pin3, HIGH);
  236.        digitalWrite(Pin4, LOW);
  237.  
  238.        digitalWrite(Pin5, LOW);  
  239.        digitalWrite(Pin6, LOW);
  240.        digitalWrite(Pin7, HIGH);
  241.        digitalWrite(Pin8, LOW);
  242.        break;  
  243.      case 3:
  244.        digitalWrite(Pin1, LOW);  
  245.        digitalWrite(Pin2, HIGH);
  246.        digitalWrite(Pin3, HIGH);
  247.        digitalWrite(Pin4, LOW);
  248.  
  249.        digitalWrite(Pin5, LOW);  
  250.        digitalWrite(Pin6, HIGH);
  251.        digitalWrite(Pin7, HIGH);
  252.        digitalWrite(Pin8, LOW);
  253.        break;  
  254.      case 4:
  255.        digitalWrite(Pin1, LOW);  
  256.        digitalWrite(Pin2, HIGH);
  257.        digitalWrite(Pin3, LOW);
  258.        digitalWrite(Pin4, LOW);
  259.  
  260.        digitalWrite(Pin5, LOW);  
  261.        digitalWrite(Pin6, HIGH);
  262.        digitalWrite(Pin7, LOW);
  263.        digitalWrite(Pin8, LOW);
  264.        break;  
  265.      case 5:
  266.        digitalWrite(Pin1, HIGH);  
  267.        digitalWrite(Pin2, HIGH);
  268.        digitalWrite(Pin3, LOW);
  269.        digitalWrite(Pin4, LOW);
  270.  
  271.        digitalWrite(Pin5, HIGH);  
  272.        digitalWrite(Pin6, HIGH);
  273.        digitalWrite(Pin7, LOW);
  274.        digitalWrite(Pin8, LOW);
  275.        break;  
  276.      case 6:
  277.        digitalWrite(Pin1, HIGH);  
  278.        digitalWrite(Pin2, LOW);
  279.        digitalWrite(Pin3, LOW);
  280.        digitalWrite(Pin4, LOW);
  281.  
  282.        digitalWrite(Pin5, HIGH);  
  283.        digitalWrite(Pin6, LOW);
  284.        digitalWrite(Pin7, LOW);
  285.        digitalWrite(Pin8, LOW);
  286.        break;  
  287.      case 7:
  288.        digitalWrite(Pin1, HIGH);  
  289.        digitalWrite(Pin2, LOW);
  290.        digitalWrite(Pin3, LOW);
  291.        digitalWrite(Pin4, HIGH);
  292.  
  293.        digitalWrite(Pin5, HIGH);  
  294.        digitalWrite(Pin6, LOW);
  295.        digitalWrite(Pin7, LOW);
  296.        digitalWrite(Pin8, HIGH);
  297.        break;  
  298.      default:
  299.        digitalWrite(Pin1, LOW);  
  300.        digitalWrite(Pin2, LOW);
  301.        digitalWrite(Pin3, LOW);
  302.        digitalWrite(Pin4, LOW);
  303.  
  304.        digitalWrite(Pin5, LOW);  
  305.        digitalWrite(Pin6, LOW);
  306.        digitalWrite(Pin7, LOW);
  307.        digitalWrite(Pin8, LOW);
  308.        break;  
  309.   }
  310.    
  311.   if(dir){
  312.    _step++;
  313.   }
  314.  
  315.   else{
  316.    _step--;
  317.   }
  318.  
  319.   if(_step>7){
  320.    _step=0;
  321.   }
  322.  
  323.   if(_step<0){
  324.    _step=7;
  325.   }
  326.  
  327.   delay(1);
  328.  
  329. }
  330.  
  331.  
  332. void water_motor(boolean dir){
  333.    if(dir==true){
  334.     current_water=current_water-1;
  335.    }
  336.  
  337.    else if(dir==false){
  338.     current_water=current_water+1;
  339.    }
  340.    
  341.    switch(_step){
  342.     case 0:
  343.       digitalWrite(Pin5, LOW);  
  344.       digitalWrite(Pin6, LOW);
  345.       digitalWrite(Pin7, LOW);
  346.       digitalWrite(Pin8, HIGH);
  347.       break;  
  348.     case 1:
  349.       digitalWrite(Pin5, LOW);  
  350.       digitalWrite(Pin6, LOW);
  351.       digitalWrite(Pin7, HIGH);
  352.       digitalWrite(Pin8, HIGH);
  353.       break;  
  354.     case 2:
  355.       digitalWrite(Pin5, LOW);  
  356.       digitalWrite(Pin6, LOW);
  357.       digitalWrite(Pin7, HIGH);
  358.       digitalWrite(Pin8, LOW);
  359.       break;  
  360.     case 3:
  361.       digitalWrite(Pin5, LOW);  
  362.       digitalWrite(Pin6, HIGH);
  363.       digitalWrite(Pin7, HIGH);
  364.       digitalWrite(Pin8, LOW);
  365.       break;  
  366.     case 4:
  367.       digitalWrite(Pin5, LOW);  
  368.       digitalWrite(Pin6, HIGH);
  369.       digitalWrite(Pin7, LOW);
  370.       digitalWrite(Pin8, LOW);
  371.       break;  
  372.     case 5:
  373.       digitalWrite(Pin5, HIGH);  
  374.       digitalWrite(Pin6, HIGH);
  375.       digitalWrite(Pin7, LOW);
  376.       digitalWrite(Pin8, LOW);
  377.       break;  
  378.     case 6:
  379.       digitalWrite(Pin5, HIGH);  
  380.       digitalWrite(Pin6, LOW);
  381.       digitalWrite(Pin7, LOW);
  382.       digitalWrite(Pin8, LOW);
  383.       break;  
  384.     case 7:
  385.       digitalWrite(Pin5, HIGH);  
  386.       digitalWrite(Pin6, LOW);
  387.       digitalWrite(Pin7, LOW);
  388.       digitalWrite(Pin8, HIGH);
  389.       break;  
  390.     default:
  391.       digitalWrite(Pin5, LOW);  
  392.       digitalWrite(Pin6, LOW);
  393.       digitalWrite(Pin7, LOW);
  394.       digitalWrite(Pin8, LOW);
  395.       break;  
  396.   }
  397.  
  398.   if(dir){
  399.   _step++;
  400.   }
  401.  
  402.   else{
  403.   _step--;
  404.   }
  405.  
  406.   if(_step>7){
  407.   _step=0;
  408.   }
  409.  
  410.   if(_step<0){
  411.   _step=7;
  412.   }
  413.  
  414.   delay(1);
  415.    
  416. }
  417.  
  418.  
  419. void main_motor(boolean dir) {
  420.   if(dir==true){
  421.     current_main=current_main-1;
  422.   }
  423.  
  424.   else if(dir==false){
  425.     current_main=current_main+1;
  426.   }
  427.  
  428.   switch(_step){
  429.      case 0:
  430.        digitalWrite(Pin1, LOW);  
  431.        digitalWrite(Pin2, LOW);
  432.        digitalWrite(Pin3, LOW);
  433.        digitalWrite(Pin4, HIGH);
  434.        break;  
  435.      case 1:
  436.        digitalWrite(Pin1, LOW);  
  437.        digitalWrite(Pin2, LOW);
  438.        digitalWrite(Pin3, HIGH);
  439.        digitalWrite(Pin4, HIGH);
  440.        break;  
  441.      case 2:
  442.        digitalWrite(Pin1, LOW);  
  443.        digitalWrite(Pin2, LOW);
  444.        digitalWrite(Pin3, HIGH);
  445.        digitalWrite(Pin4, LOW);
  446.        break;  
  447.      case 3:
  448.        digitalWrite(Pin1, LOW);  
  449.        digitalWrite(Pin2, HIGH);
  450.        digitalWrite(Pin3, HIGH);
  451.        digitalWrite(Pin4, LOW);
  452.        break;  
  453.      case 4:
  454.        digitalWrite(Pin1, LOW);  
  455.        digitalWrite(Pin2, HIGH);
  456.        digitalWrite(Pin3, LOW);
  457.        digitalWrite(Pin4, LOW);
  458.        break;  
  459.      case 5:
  460.        digitalWrite(Pin1, HIGH);  
  461.        digitalWrite(Pin2, HIGH);
  462.        digitalWrite(Pin3, LOW);
  463.        digitalWrite(Pin4, LOW);
  464.        break;  
  465.        case 6:
  466.        digitalWrite(Pin1, HIGH);  
  467.        digitalWrite(Pin2, LOW);
  468.        digitalWrite(Pin3, LOW);
  469.        digitalWrite(Pin4, LOW);
  470.        break;  
  471.      case 7:
  472.        digitalWrite(Pin1, HIGH);  
  473.        digitalWrite(Pin2, LOW);
  474.        digitalWrite(Pin3, LOW);
  475.        digitalWrite(Pin4, HIGH);
  476.        break;  
  477.      default:
  478.        digitalWrite(Pin1, LOW);  
  479.        digitalWrite(Pin2, LOW);
  480.        digitalWrite(Pin3, LOW);
  481.        digitalWrite(Pin4, LOW);
  482.        break;  
  483.   }
  484.    
  485.   if(dir){
  486.    _step++;
  487.   }
  488.  
  489.   else{
  490.    _step--;
  491.   }
  492.  
  493.   if(_step>7){
  494.    _step=0;
  495.   }
  496.  
  497.   if(_step<0){
  498.    _step=7;
  499.   }
  500.  
  501.   delay(1);
  502.  
  503. }
RAW Paste Data
Top