API tools faq
paste
Advertisement
gio_aggiustatutto

Camera Robot Arduino Code

gio_aggiustatutto
Mar 20th, 2023 (edited)
237
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 15.77 KB | None | 0 0
raw download clone embed print report
  1. #include <AccelStepper.h>
  2. #include <MultiStepper.h>
  3. #include <LiquidCrystal_I2C.h>
  4.  
  5. // Define the stepper motor and the pins that is connected to
  6. AccelStepper stepper1(1, 2, 5); // (Type of driver: with 2 pins, STEP, DIR)
  7. AccelStepper stepper2(1, 3, 6);
  8.  
  9. MultiStepper steppers;
  10.  
  11. LiquidCrystal_I2C lcd(0x27, 16, 2);
  12.  
  13. int xpin = A0;
  14. int ypin = A1;
  15. int v1pin = A2;
  16. int v2pin = A3;
  17.  
  18. int homepin = 10;
  19. int Apin = 9;
  20. int Bpin = 8;
  21. int SETpin = 7;
  22. int timelapseMode = 11;
  23. int autoMode = 12;
  24.  
  25. const int longPress = 600;
  26.  
  27. int v1;
  28. int v2;
  29. int v;
  30. bool vSET; //true: v1 - false: v2
  31. bool isMoving = true;
  32. bool page = true;
  33.  
  34. int mode; //1: live - 2: auto - 3: timelapse
  35.  
  36. int xA;
  37. int xB;
  38. int yA;
  39. int yB;
  40.  
  41. long timeBetweenPhotos;
  42. long totalPhotos;
  43. long photosTaken;
  44. int xStep;
  45. int yStep;
  46.  
  47. long gotoposition[2];
  48.  
  49.  
  50. void setup() {
  51.   pinMode(homepin, INPUT_PULLUP);
  52.   pinMode(Apin, INPUT_PULLUP);
  53.   pinMode(Bpin, INPUT_PULLUP);
  54.   pinMode(SETpin, INPUT_PULLUP);
  55.   pinMode(timelapseMode, INPUT_PULLUP);
  56.   pinMode(autoMode, INPUT_PULLUP);
  57.  
  58.   // Set maximum speed value for the stepper
  59.   stepper1.setMaxSpeed(1000);
  60.   stepper1.setAcceleration(1000);
  61.   stepper1.setCurrentPosition(0);
  62.  
  63.   stepper2.setMaxSpeed(1000);
  64.   stepper2.setAcceleration(1000);
  65.   stepper2.setCurrentPosition(0);
  66.  
  67.   steppers.addStepper(stepper1);
  68.   steppers.addStepper(stepper2);
  69.  
  70.   lcd.init();
  71.   lcd.backlight();
  72.   lcd.setCursor(2, 0);
  73.   lcd.print("Camera Robot");
  74.   delay(1000);
  75.   lcd.clear();
  76. }
  77.  
  78. void loop() {
  79.  
  80. //// LIVE mode ///////////////////////////////////////////////////////////////////////////
  81.   if(digitalRead(timelapseMode) == 1 && digitalRead(autoMode) == 1) {
  82.     if(mode != 1) {
  83.       delay(500);
  84.       if(digitalRead(timelapseMode) == 1 && digitalRead(autoMode) == 1) {
  85.       mode = 1;
  86.       isMoving = true;
  87.       lcd.clear();
  88.       lcd.setCursor(2,0);
  89.       lcd.print("-LIVE MODE-");
  90.       delay(1000);
  91.       lcd.clear();
  92.       }
  93.     }
  94.    
  95.     v1 = map(analogRead(v1pin), 0, 1023, 0, 99)*10;
  96.     v2 = map(analogRead(v2pin), 0, 1023, 0, 99)*10;    
  97.  
  98.     //select speed with A and B buttons
  99.     if(digitalRead(Apin) == 0) {
  100.       vSET = true;
  101.      
  102.       lcd.setCursor(0,0);
  103.       lcd.print(">");
  104.       lcd.setCursor(0,1);
  105.       lcd.print(" ");
  106.     }
  107.     if(digitalRead(Bpin) == 0) {
  108.       vSET = false;
  109.      
  110.       lcd.setCursor(0,0);
  111.       lcd.print(" ");
  112.       lcd.setCursor(0,1);
  113.       lcd.print(">");
  114.      
  115.     }
  116.     if(vSET == true) {
  117.       v = v1;
  118.     }
  119.     if(vSET == false) {
  120.       v = v2;
  121.     }
  122.  
  123.     //home motors with button
  124.     if(digitalRead(homepin) == 0 && !digitalRead(SETpin) == 0 && (stepper1.currentPosition() != 0 || stepper2.currentPosition() != 0) ) {
  125.       lcd.clear();
  126.       lcd.setCursor(0,0);
  127.       lcd.print("Going to HOME...");
  128.       lcd.setCursor(0,1);
  129.       lcd.print("X 0");
  130.       lcd.setCursor(9,1);
  131.       lcd.print("Y 0");
  132.      
  133.       isMoving = true;
  134.       stepper2.setMaxSpeed(v);
  135.       stepper1.setMaxSpeed(v);
  136.       gotoposition[0] = 0;
  137.       gotoposition[1] = 0;
  138.       steppers.moveTo(gotoposition);
  139.       steppers.run();
  140.       while(steppers.run() == true && digitalRead(SETpin) == 1) {
  141.         steppers.run();
  142.       }
  143.       stepper2.setMaxSpeed(1000);
  144.       stepper1.setMaxSpeed(1000);
  145.     }
  146.    
  147.     //set new home position
  148.     if(digitalRead(homepin) == 0 && digitalRead(SETpin) == 0) {
  149.       isMoving = true;
  150.       stepper2.setCurrentPosition(0);
  151.       stepper1.setCurrentPosition(0);
  152.       delay(longPress);
  153.     }
  154.    
  155.     //move camera using the joystick
  156.     if(analogRead(xpin) > 600){
  157.       stepper1.setSpeed(map(analogRead(xpin), 600, 1023, 0, v));
  158.       stepper1.runSpeed();
  159.       isMoving = true;
  160.     }
  161.  
  162.     if(analogRead(xpin) < 400){
  163.       stepper1.setSpeed(map(analogRead(xpin), 400, 0, 0, -v));
  164.       stepper1.runSpeed();
  165.       isMoving = true;
  166.     }
  167.  
  168.     if(analogRead(ypin) > 600){
  169.       stepper2.setSpeed(map(analogRead(ypin), 600, 1023, 0, v));
  170.       stepper2.runSpeed();
  171.       isMoving = true;
  172.     }
  173.  
  174.     if(analogRead(ypin) < 400){
  175.       stepper2.setSpeed(map(analogRead(ypin), 400, 0, 0, -v));
  176.       stepper2.runSpeed();
  177.       isMoving = true;
  178.     }
  179.  
  180.     //update display only when the motors are stopped, to avoid overloading the Arduino
  181.     if(analogRead(xpin) > 400 && analogRead(xpin) < 600 && analogRead(ypin) > 400 && analogRead(ypin) < 600) {
  182.       stepper1.setSpeed(0);
  183.       stepper2.setSpeed(0);
  184.    
  185.       lcd.setCursor(1,0);
  186.       lcd.print("A");
  187.       lcd.setCursor(3,0);
  188.       lcd.print(v1);
  189.       lcd.setCursor(1,1);
  190.       lcd.print("B");
  191.       lcd.setCursor(3,3);
  192.       lcd.print(v2);
  193.       lcd.setCursor(7,0);
  194.       lcd.print("|");
  195.       lcd.setCursor(7,1);
  196.       lcd.print("|");
  197.       if(v1 < 100) {
  198.         lcd.setCursor(5,0);
  199.         lcd.print(" ");
  200.       }
  201.       if(v2 < 100) {
  202.         lcd.setCursor(5,1);
  203.         lcd.print(" ");
  204.       }
  205.       if(vSET == true) {
  206.         lcd.setCursor(0,0);
  207.         lcd.print(">");
  208.         lcd.setCursor(0,1);
  209.         lcd.print(" ");
  210.       }
  211.       if(vSET == false) {
  212.         lcd.setCursor(0,0);
  213.         lcd.print(" ");
  214.         lcd.setCursor(0,1);
  215.         lcd.print(">");
  216.       }
  217.       if(isMoving == true) {
  218.         lcd.clear();
  219.         lcd.setCursor(9,0);
  220.         lcd.print("X");
  221.         lcd.setCursor(11,0);
  222.         lcd.print(stepper1.currentPosition());
  223.  
  224.         lcd.setCursor(9,1);
  225.         lcd.print("Y");
  226.         lcd.setCursor(11,1);
  227.         lcd.print(stepper2.currentPosition());
  228.  
  229.         isMoving = false;
  230.       }
  231.     }
  232.   }
  233.  
  234. //// AUTO mode ///////////////////////////////////////////////////////////////////////////
  235.   if(digitalRead(timelapseMode) == 1 && digitalRead(autoMode) == 0) {
  236.     if(mode != 2) {
  237.       mode = 2;
  238.       xA = 0;
  239.       xB = 0;
  240.       yA = 0;
  241.       yB = 0;
  242.       isMoving = true;
  243.       lcd.clear();
  244.       lcd.setCursor(2,0);
  245.       lcd.print("-AUTO MODE-");
  246.       lcd.setCursor(0,1);
  247.       lcd.print("Set speed: A");
  248.       delay(2000);
  249.       lcd.clear();
  250.     }
  251.    
  252.     v1 = map(analogRead(v1pin), 0, 1023, 0, 99)*10;
  253.     v2 = map(analogRead(v2pin), 0, 1023, 0, 99)*100;
  254.  
  255.     //move camera using the joystick
  256.     if(analogRead(xpin) > 600){
  257.       stepper1.setSpeed(map(analogRead(xpin), 600, 1023, 0, v2));
  258.       stepper1.runSpeed();
  259.       isMoving = true;
  260.     }
  261.  
  262.     if(analogRead(xpin) < 400){
  263.       stepper1.setSpeed(map(analogRead(xpin), 400, 0, 0, -v2));
  264.       stepper1.runSpeed();
  265.       isMoving = true;
  266.     }
  267.  
  268.     if(analogRead(ypin) > 600){
  269.       stepper2.setSpeed(map(analogRead(ypin), 600, 1023, 0, v2));
  270.       stepper2.runSpeed();
  271.       isMoving = true;
  272.     }
  273.  
  274.     if(analogRead(ypin) < 400){
  275.       stepper2.setSpeed(map(analogRead(ypin), 400, 0, 0, -v2));
  276.       stepper2.runSpeed();
  277.       isMoving = true;
  278.     }
  279.  
  280.     //set A and B positions
  281.     if(digitalRead(Apin) == 0 && digitalRead(SETpin) == 0) {
  282.       xA = stepper1.currentPosition();
  283.       yA = stepper2.currentPosition();
  284.       isMoving = true;
  285.       delay(longPress);
  286.     }
  287.  
  288.     if(digitalRead(Bpin) == 0 && digitalRead(SETpin) == 0) {
  289.       xB = stepper1.currentPosition();
  290.       yB = stepper2.currentPosition();
  291.       isMoving = true;
  292.       delay(longPress);
  293.     }
  294.  
  295.     //go to A and B positions
  296.     if(digitalRead(Apin) == 0 && digitalRead(SETpin) == 1 && (stepper1.currentPosition() != xA || stepper2.currentPosition() != yA)) {
  297.       lcd.clear();
  298.       lcd.setCursor(0,0);
  299.       lcd.print("Going to A...");
  300.       lcd.setCursor(0,1);
  301.       lcd.print("X");
  302.       lcd.setCursor(2,1);
  303.       lcd.print(xA);
  304.       lcd.setCursor(9,1);
  305.       lcd.print("Y");
  306.       lcd.setCursor(11,1);
  307.       lcd.print(yA);
  308.      
  309.       gotoposition[0] = xA;
  310.       gotoposition[1] = yA;
  311.       stepper1.setMaxSpeed(v1);
  312.       stepper2.setMaxSpeed(v1);
  313.       steppers.moveTo(gotoposition);
  314.       while(steppers.run() == true && digitalRead(homepin) == 1 && digitalRead(SETpin) == 1) {
  315.         steppers.run();
  316.       }
  317.       stepper1.setMaxSpeed(1000);
  318.       stepper2.setMaxSpeed(1000);
  319.       isMoving = true;
  320.     }
  321.  
  322.     if(digitalRead(Bpin) == 0 && digitalRead(SETpin) == 1 && (stepper1.currentPosition() != xB || stepper2.currentPosition() != yB)) {
  323.       lcd.clear();
  324.       lcd.setCursor(0,0);
  325.       lcd.print("Going to B...");
  326.       lcd.setCursor(0,1);
  327.       lcd.print("X");
  328.       lcd.setCursor(2,1);
  329.       lcd.print(xB);
  330.       lcd.setCursor(9,1);
  331.       lcd.print("Y");
  332.       lcd.setCursor(11,1);
  333.       lcd.print(yB);
  334.      
  335.       gotoposition[0] = xB;
  336.       gotoposition[1] = yB;
  337.       stepper1.setMaxSpeed(v1);
  338.       stepper2.setMaxSpeed(v1);
  339.       steppers.moveTo(gotoposition);
  340.       steppers.run();
  341.       while(steppers.run() == true && digitalRead(homepin) == 1 && digitalRead(SETpin) == 1) {
  342.         steppers.run();
  343.       }
  344.       stepper1.setMaxSpeed(1000);
  345.       stepper2.setMaxSpeed(1000);
  346.       isMoving = true;
  347.     }
  348.    
  349.     //update display only when the motors are stopped, to avoid overloading the Arduino
  350.     if(analogRead(xpin) > 400 && analogRead(xpin) < 600 && analogRead(ypin) > 400 && analogRead(ypin) < 600) {
  351.       stepper1.setSpeed(0);
  352.       stepper2.setSpeed(0);
  353.  
  354.       lcd.setCursor(0,0);
  355.       lcd.print("VEL");
  356.       lcd.setCursor(0,1);
  357.       lcd.print(v1);
  358.       if(v1 < 100) {
  359.         lcd.setCursor(2,1);
  360.         lcd.print(" ");
  361.       }
  362.       if(isMoving == true) {
  363.         lcd.clear();
  364.         lcd.setCursor(4,0);
  365.         lcd.print("X");
  366.         lcd.setCursor(5,0);
  367.         lcd.print(xA);
  368.        
  369.         lcd.setCursor(10,0);
  370.         lcd.print(">");
  371.         lcd.setCursor(11,0);
  372.         lcd.print(xB);
  373.  
  374.         lcd.setCursor(4,1);
  375.         lcd.print("Y");
  376.         lcd.setCursor(5,1);
  377.         lcd.print(yA);
  378.        
  379.         lcd.setCursor(10,1);
  380.         lcd.print(">");
  381.         lcd.setCursor(11,1);
  382.         lcd.print(yB);
  383.  
  384.         isMoving = false;
  385.       }
  386.     }
  387.   }
  388.  
  389. //// TIME-LAPSE mode ///////////////////////////////////////////////////////////////////////////
  390.   if(digitalRead(timelapseMode) == 0 && digitalRead(autoMode) == 1) {
  391.     if(mode != 3) {
  392.       mode = 3;
  393.       xA = 0;
  394.       xB = 0;
  395.       yA = 0;
  396.       yB = 0;
  397.       isMoving = true;
  398.       lcd.clear();
  399.       lcd.setCursor(0,0);
  400.       lcd.print("TIME-LAPSE MODE");
  401.       lcd.setCursor(0,1);
  402.       lcd.print("Time: A - NR: B");
  403.       delay(2000);
  404.       lcd.clear();
  405.     }
  406.    
  407.     timeBetweenPhotos = map(analogRead(v1pin), 0, 1023, 0, 20000)/200;
  408.     totalPhotos = map(analogRead(v2pin), 0, 1023, 0, 99)*10;
  409.  
  410.     //move camera using the joystick
  411.     if(analogRead(xpin) > 600){
  412.       stepper1.setSpeed(300);
  413.       stepper1.runSpeed();
  414.     }
  415.  
  416.     if(analogRead(xpin) < 400){
  417.       stepper1.setSpeed(-300);
  418.       stepper1.runSpeed();
  419.     }
  420.  
  421.     if(analogRead(ypin) > 600){
  422.       stepper2.setSpeed(300);
  423.       stepper2.runSpeed();
  424.     }
  425.  
  426.     if(analogRead(ypin) < 400){
  427.       stepper2.setSpeed(-300);
  428.       stepper2.runSpeed();
  429.     }
  430.  
  431.     //set A and B positions
  432.     if(digitalRead(Apin) == 0) {
  433.       xA = stepper1.currentPosition();
  434.       yA = stepper2.currentPosition();
  435.       delay(longPress);
  436.     }
  437.  
  438.     if(digitalRead(Bpin) == 0) {
  439.       xB = stepper1.currentPosition();
  440.       yB = stepper2.currentPosition();
  441.       delay(longPress);
  442.     }
  443.  
  444.     //calculate how much the motors should move for each photo that is taken
  445.     xStep = (xB - xA)/totalPhotos;
  446.     yStep = (yB - yA)/totalPhotos;
  447.    
  448.     //start timelapse
  449.     if(digitalRead(homepin) == 0 && digitalRead(SETpin) == 1) {      
  450.       photosTaken = 0;
  451.      
  452.       //go to start (A) position
  453.       bool goneToA = false;
  454.       gotoposition[0] = xA;
  455.       gotoposition[1] = yA;
  456.       stepper1.setMaxSpeed(200);
  457.       stepper2.setMaxSpeed(200);
  458.       steppers.moveTo(gotoposition);
  459.       if(stepper1.currentPosition() == xA && stepper2.currentPosition() == yA) {
  460.         goneToA = true;
  461.       }
  462.       steppers.run();
  463.       if(goneToA == false) {
  464.         stepper1.setMaxSpeed(200);
  465.         stepper2.setMaxSpeed(200);
  466.         lcd.clear();
  467.         lcd.setCursor(0,0);
  468.         lcd.print("Going to A...");
  469.         lcd.setCursor(0,1);
  470.         lcd.print("X");
  471.         lcd.setCursor(2,1);
  472.         lcd.print(xA);
  473.         lcd.setCursor(9,1);
  474.         lcd.print("Y");
  475.         lcd.setCursor(11,1);
  476.         lcd.print(yA);
  477.         while(steppers.run() == true && digitalRead(SETpin) == 1) {
  478.           steppers.run();
  479.           goneToA = true;  
  480.         }
  481.       }
  482.      
  483.       //do timelapse
  484.       while(digitalRead(SETpin) == 1 && photosTaken < totalPhotos) {
  485.         gotoposition[0] = stepper1.currentPosition() + xStep;
  486.         gotoposition[1] = stepper2.currentPosition() + yStep;
  487.  
  488.         stepper1.setMaxSpeed(50);
  489.         stepper2.setMaxSpeed(50);
  490.        
  491.         steppers.moveTo(gotoposition);
  492.         steppers.run();
  493.         while(steppers.run() == true && digitalRead(SETpin) == 1) {
  494.           steppers.run();
  495.         }
  496.         photosTaken++;
  497.        
  498.         lcd.clear();
  499.         lcd.setCursor(0,0);
  500.         lcd.print("Remain:");
  501.         lcd.setCursor(8,0);
  502.         lcd.print(timeBetweenPhotos*(totalPhotos - photosTaken)/60);
  503.         lcd.setCursor(12,0);
  504.         lcd.print("min");
  505.         lcd.setCursor(7,1);
  506.         lcd.print(totalPhotos - photosTaken);
  507.         lcd.setCursor(11,1);
  508.         lcd.print("photo");
  509.        
  510.         while(digitalRead(SETpin) == 1 && !(millis() % (timeBetweenPhotos*1000)) == 0) {}
  511.        
  512.       }
  513.       stepper1.setMaxSpeed(1000);
  514.       stepper2.setMaxSpeed(1000);
  515.       lcd.clear();
  516.     }
  517.    
  518.     //update display only when the motors are stopped, to avoid overloading the Arduino
  519.     if(analogRead(xpin) > 400 && analogRead(xpin) < 600 && analogRead(ypin) > 400 && analogRead(ypin) < 600) {
  520.       stepper1.setSpeed(0);
  521.       stepper2.setSpeed(0);
  522.      
  523.       //display time between photos and total time
  524.       if(digitalRead(SETpin) == 1) {
  525.         if(page == false) {
  526.           lcd.clear();
  527.           page = true;
  528.         }
  529.         //lcd.setCursor(0,0);
  530.         //lcd.print("Time");
  531.         lcd.setCursor(0,0);
  532.         lcd.print(timeBetweenPhotos);
  533.         lcd.setCursor(3,0);
  534.         lcd.print("s");
  535.         if(timeBetweenPhotos < 100) {
  536.           lcd.setCursor(2,0);
  537.           lcd.print(" ");
  538.         }
  539.         if(timeBetweenPhotos < 10) {
  540.           lcd.setCursor(1,0);
  541.           lcd.print(" ");
  542.         }
  543.        
  544.         lcd.setCursor(0,1);
  545.         lcd.print("Total");
  546.         lcd.setCursor(6,1);
  547.         lcd.print((timeBetweenPhotos*totalPhotos)/60);
  548.         lcd.setCursor(10,1);
  549.         lcd.print("min");
  550.         if(((timeBetweenPhotos*totalPhotos)/60) < 1000) {
  551.           lcd.setCursor(9,1);
  552.           lcd.print(" ");
  553.         }
  554.         if(((timeBetweenPhotos*totalPhotos)/60) < 100) {
  555.           lcd.setCursor(8,1);
  556.           lcd.print(" ");
  557.         }
  558.         if(((timeBetweenPhotos*totalPhotos)/60) < 10) {
  559.           lcd.setCursor(7,1);
  560.           lcd.print(" ");
  561.         }
  562.         //display total photos
  563.         lcd.setCursor(6,0);
  564.         lcd.print(totalPhotos);
  565.         lcd.setCursor(10,0);
  566.         lcd.print("photos");
  567.         if(totalPhotos < 100) {
  568.           lcd.setCursor(8,0);
  569.           lcd.print(" ");
  570.         }
  571.       }
  572.  
  573.       //display A and B positions when SET is pressed
  574.       if(digitalRead(SETpin) == 0) {
  575.         if(page == true) {
  576.           lcd.clear();
  577.           page = false;
  578.         }
  579.         lcd.setCursor(0,0);
  580.         lcd.print("X");
  581.         lcd.setCursor(2,0);
  582.         lcd.print(xA);
  583.        
  584.         lcd.setCursor(8,0);
  585.         lcd.print(">");
  586.         lcd.setCursor(10,0);
  587.         lcd.print(xB);
  588.  
  589.         lcd.setCursor(0,1);
  590.         lcd.print("Y");
  591.         lcd.setCursor(2,1);
  592.         lcd.print(yA);
  593.        
  594.         lcd.setCursor(8,1);
  595.         lcd.print(">");
  596.         lcd.setCursor(10,1);
  597.         lcd.print(yB);
  598.       }
  599.     }    
  600.   }
  601. }
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!