diff --git a/pan_tilt_mount_nano_code/panTiltMount.cpp b/pan_tilt_mount_nano_code/panTiltMount.cpp index df1dddc..3acf4f0 100644 --- a/pan_tilt_mount_nano_code/panTiltMount.cpp +++ b/pan_tilt_mount_nano_code/panTiltMount.cpp @@ -12,7 +12,7 @@ CRGB leds[NUM_LEDS]; AccelStepper stepper_pan = AccelStepper(1, PIN_STEP_PAN, PIN_DIRECTION_PAN); AccelStepper stepper_tilt = AccelStepper(1, PIN_STEP_TILT, PIN_DIRECTION_TILT); -//AccelStepper stepper_slider = AccelStepper(1, PIN_STEP_SLIDER, PIN_DIRECTION_SLIDER); +AccelStepper stepper_slider = AccelStepper(1, PIN_STEP_SLIDER, PIN_DIRECTION_SLIDER); MultiStepper multi_stepper; @@ -23,24 +23,30 @@ int current_moves_array_index = -1; char stringText[MAX_STRING_LENGTH + 1]; float pan_steps_per_degree = (200.0 * SIXTEENTH_STEP * PAN_GEAR_RATIO) / 360.0; //Stepper motor has 200 steps per 360 degrees float tilt_steps_per_degree = (200.0 * SIXTEENTH_STEP * TILT_GEAR_RATIO) / 360.0; //Stepper motor has 200 steps per 360 degrees -//float slider_steps_per_millimetre = (200.0 * SIXTEENTH_STEP) / (20 * 2); //Stepper motor has 200 steps per 360 degrees, the timing pully has 20 teeth and the belt has a pitch of 2mm +float slider_steps_per_millimetre = (200.0 * SIXTEENTH_STEP) / (20 * 2); //Stepper motor has 200 steps per 360 degrees, the timing pully has 20 teeth and the belt has a pitch of 2mm + int step_mode = 1; bool enable_state = true; float limit_pan_min = 0; float limit_pan_max = 0; float limit_tilt_min = 0; float limit_tilt_max = 0; +float limit_slider_min = 0; +float limit_slider_max = 0; byte enable_limits = 0; float pan_acceleration = 5000; float tilt_acceleration = 5000; +float slider_acceleration = 5000; float hall_pan_offset_degrees = 0; float hall_tilt_offset_degrees = 0; byte invert_pan = 0; byte invert_tilt = 0; +byte invert_slider = 0; byte enable_homing = 0; float pan_max_speed = 2000; float tilt_max_speed = 2000; -long target_position[2]; +float slider_max_speed = 2000; +long target_position[3]; float degrees_per_picture = 0.5; unsigned long delay_ms_between_pictures = 1000; @@ -66,19 +72,20 @@ void initPanTilt(void){ setEEPROMVariables(); stepper_pan.setMinPulseWidth(20); stepper_tilt.setMinPulseWidth(20); - //stepper_slider.setMinPulseWidth(20); + stepper_slider.setMinPulseWidth(20); setStepMode(step_mode); //steping mode stepper_pan.setMaxSpeed(pan_max_speed); stepper_pan.setAcceleration(pan_acceleration); stepper_tilt.setMaxSpeed(tilt_max_speed); stepper_tilt.setAcceleration(tilt_acceleration); - //stepper_slider.setMaxSpeed(slider_max_speed); - //stepper_slider.setAcceleration(slider_acceleration); + stepper_slider.setMaxSpeed(slider_max_speed); + stepper_slider.setAcceleration(slider_acceleration); invertPanDirection(invert_pan); invertTiltDirection(invert_tilt); + invertSliderDirection(invert_slider); multi_stepper.addStepper(stepper_pan); multi_stepper.addStepper(stepper_tilt); - //multi_stepper.addStepper(stepper_slider); + multi_stepper.addStepper(stepper_slider); enableSteppers(true); LEDS.showColor(CHSV(96 , 255, 255)); printi(F("Setup complete.\n")); @@ -158,10 +165,12 @@ void setStepMode(int mode){ if(step_mode == 1){//was in sixteenth step mode stepper_pan.setCurrentPosition(stepper_pan.currentPosition() / SIXTEENTH_STEP); stepper_tilt.setCurrentPosition(stepper_tilt.currentPosition() / SIXTEENTH_STEP); + stepper_slider.setCurrentPosition(stepper_slider.currentPosition() / SIXTEENTH_STEP); } digitalWrite(PIN_MS, LOW); pan_steps_per_degree = (200.0 * FULL_STEP * PAN_GEAR_RATIO) / 360.0; //Stepper motor has 200 steps per 360 degrees tilt_steps_per_degree = (200.0 * FULL_STEP * TILT_GEAR_RATIO) / 360.0; //Stepper motor has 200 steps per 360 degrees + slider_steps_per_millimetre = (200.0 * FULL_STEP) / (20 * 2); step_mode = 0; printi(F("Set to Full Step mode.\n")); } @@ -169,10 +178,12 @@ void setStepMode(int mode){ if(step_mode == 0){//was in full step mode stepper_pan.setCurrentPosition(stepper_pan.currentPosition() * SIXTEENTH_STEP); stepper_tilt.setCurrentPosition(stepper_tilt.currentPosition() * SIXTEENTH_STEP); + stepper_slider.setCurrentPosition(stepper_slider.currentPosition() * SIXTEENTH_STEP); } digitalWrite(PIN_MS, HIGH); pan_steps_per_degree = (200.0 * SIXTEENTH_STEP * PAN_GEAR_RATIO) / 360.0; //Stepper motor has 200 steps per 360 degrees tilt_steps_per_degree = (200.0 * SIXTEENTH_STEP * TILT_GEAR_RATIO) / 360.0; //Stepper motor has 200 steps per 360 degrees + slider_steps_per_millimetre = (200.0 * SIXTEENTH_STEP) / (20 * 2); step_mode = 1; printi(F("Set to Sixteenth Step mode.\n")); } @@ -208,14 +219,35 @@ float tiltDegreesToSteps(float angle){ /*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ +float sliderMillimetresToSteps(float mm){ + return mm * slider_steps_per_millimetre ; +} + +/*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ + +float sliderStepsToMillimetres(long steps){ + return steps / slider_steps_per_millimetre; +} + +/*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ + +void sliderMoveTo(float mm){ + target_position[2] = sliderMillimetresToSteps(mm); + multi_stepper.moveTo(target_position); +} + +/*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ + void printProgramElements(void){ printi(F("-----Program Elements-----\n")); for(int row = 0; row < moves_array_elements; row++){ printi(F(""), row, F("\t|")); printi(F(" Pan: "), panStepsToDegrees(program_elements[row].panStepCount), 3, F("º\t")); printi(F("Tilt: "), tiltStepsToDegrees(program_elements[row].tiltStepCount), 3, F("º\t")); + printi(F("Slider: "), sliderStepsToMillimetres(program_elements[row].sliderStepCount), 3, F("mm\t")); printi(F("Pan Speed: "), panStepsToDegrees(program_elements[row].panSpeed), 3, F(" º/s\t")); printi(F("Tilt Speed: "), tiltStepsToDegrees(program_elements[row].tiltSpeed), 3, F(" º/s\t")); + printi(F("Slider Speed: "), sliderStepsToMillimetres(program_elements[row].sliderSpeed), 3, F(" mm/s\t")); printi(F("Delay: "), program_elements[row].msDelay, F("ms |\n")); } printi(F("\n")); @@ -227,33 +259,45 @@ void debugReport(void){ printi(F("----------Debug Report----------\n")); printi(F("Stepper enable state: "), enable_state); printi(F("Step Mode: "), step_mode); - printi(F("Pan Hall sensor state: "), digitalRead(PIN_PAN_HALL)); - printi(F("Tilt Hall sensor state: "), digitalRead(PIN_TILT_HALL)); - printi(F("Pan step count: "), stepper_pan.currentPosition()); - printi("Tilt step count: ", stepper_tilt.currentPosition()); +// printi(F("Pan Hall sensor state: "), digitalRead(PIN_PAN_HALL)); +// printi(F("Tilt Hall sensor state: "), digitalRead(PIN_TILT_HALL)); +// printi(F("Pan step count: "), stepper_pan.currentPosition()); +// printi("Tilt step count: ", stepper_tilt.currentPosition()); + printi("Slider step count: ", stepper_slider.currentPosition()); printi(F("Pan angle: "), panStepsToDegrees(stepper_pan.currentPosition()), 3, F("º\n")); printi(F("Tilt angle: "), tiltStepsToDegrees(stepper_tilt.currentPosition()), 3, F("º\n")); - printi(F("Pan steps per º: "), pan_steps_per_degree); - printi(F("Tilt steps per º: "), tilt_steps_per_degree); - printi(F("Pan current steps/s: "), stepper_pan.speed()); - printi(F("Tilt current steps/s: "), stepper_tilt.speed()); + printi(F("Slider position: "), sliderStepsToMillimetres(stepper_slider.currentPosition()), 3, F("mm\n")); +// printi(F("Pan steps per º: "), pan_steps_per_degree); +// printi(F("Tilt steps per º: "), tilt_steps_per_degree); + printi(F("Slider steps per mm: "), slider_steps_per_millimetre); +// printi(F("Pan current steps/s: "), stepper_pan.speed()); +// printi(F("Tilt current steps/s: "), stepper_tilt.speed()); + printi(F("Slider current steps/s: "), stepper_slider.speed()); printi(F("Pan current º/s: "), panStepsToDegrees(stepper_pan.speed())); printi(F("Tilt current º/s: "), tiltStepsToDegrees(stepper_tilt.speed())); - printi(F("Pan maximum steps/s: "), stepper_pan.maxSpeed()); - printi(F("Tilt maximum steps/s: "), stepper_tilt.maxSpeed()); + printi(F("Slider current mm/s: "), sliderStepsToMillimetres(stepper_slider.speed())); +// printi(F("Pan maximum steps/s: "), stepper_pan.maxSpeed()); +// printi(F("Tilt maximum steps/s: "), stepper_tilt.maxSpeed()); + printi(F("Slider maximum steps/s: "), stepper_slider.maxSpeed()); printi(F("Pan maximum º/s: "), panStepsToDegrees(stepper_pan.maxSpeed())); printi(F("Tilt maximum º/s: "), tiltStepsToDegrees(stepper_tilt.maxSpeed())); - printi(F("Pan acceleration steps/s/s: "), pan_acceleration); - printi(F("Tilt acceleration steps/s/s: "), tilt_acceleration); - printi(F("Pan acceleration steps/s/s: "), panStepsToDegrees(pan_acceleration)); - printi(F("Tilt acceleration steps/s/s: "), tiltStepsToDegrees(tilt_acceleration)); + printi(F("Slider maximum mm/s: "), sliderStepsToMillimetres(stepper_slider.maxSpeed())); +// printi(F("Pan acceleration steps/s/s: "), pan_acceleration); +// printi(F("Tilt acceleration steps/s/s: "), tilt_acceleration); + printi(F("Slider acceleration steps/s/s: "), slider_acceleration); +// printi(F("Pan acceleration º/s/s: "), panStepsToDegrees(pan_acceleration)); +// printi(F("Tilt acceleration º/s/s: "), tiltStepsToDegrees(tilt_acceleration)); + printi(F("Slider acceleration mm/s/s: "), sliderStepsToMillimetres(slider_acceleration)); printi(F("Pan min limit: "), limit_pan_min, 3, F("º\n")); - printi(F("Pan max limit: "), limit_pan_max, 3, F("º\n")); + printi(F("Pan max limit: "), limit_pan_max, 3, F("º\n")); printi(F("Tilt min limit: "), limit_tilt_min, 3, F("º\n")); printi(F("Tilt max limit: "), limit_tilt_max, 3, F("º\n")); + printi(F("Slider min limit: "), limit_slider_min, 3, F("mm\n")); + printi(F("Slider max limit: "), limit_slider_max, 3, F("mm\n")); printi(F("Enable limits: "), enable_limits); printi(F("Pan invert direction: "), invert_pan); printi(F("Tilt invert direction: "), invert_tilt); + printi(F("Slider invert direction: "), invert_slider); printi(F("Pan Hall offset: "), hall_pan_offset_degrees, 3, F("º\n")); printi(F("Tilt Hall offset: "), hall_tilt_offset_degrees, 3, F("º\n")); printi(F("Battery voltage: "), getBatteryVoltage(), 3, F("V\n")); @@ -271,7 +315,7 @@ void debugReport(void){ /*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ -int setTargetPositions(float panDeg, float tiltDeg){//TODO: limits +int setTargetPositions(float panDeg, float tiltDeg){ if(enable_limits == 1 && !((panDeg >= limit_pan_min && panDeg <= limit_pan_max) && (tiltDeg >= limit_tilt_min && tiltDeg <= limit_tilt_max))){ return -1; } @@ -282,12 +326,25 @@ int setTargetPositions(float panDeg, float tiltDeg){//TODO: limits /*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ -int setTargetPositionsSteps(long panSteps, long tiltSteps){//TODO: limits - target_position[0] = panSteps; - target_position[1] = tiltSteps; +int setTargetPositions(float panDeg, float tiltDeg, float sliderMillimetre){ + if(enable_limits == 1 && !((panDeg >= limit_pan_min && panDeg <= limit_pan_max) && (tiltDeg >= limit_tilt_min && tiltDeg <= limit_tilt_max) + && (sliderMillimetre >= limit_slider_min && sliderMillimetre <= limit_slider_max))){ + return -1; + } + target_position[0] = panDegreesToSteps(panDeg); + target_position[1] = tiltDegreesToSteps(tiltDeg); + target_position[2] = sliderMillimetresToSteps(sliderMillimetre); multi_stepper.moveTo(target_position); } +///*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ +// +//int setTargetPositionsSteps(long panSteps, long tiltSteps){//TODO: limits +// target_position[0] = panSteps; +// target_position[1] = tiltSteps; +// multi_stepper.moveTo(target_position); +//} + /*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ bool findHome(void){ @@ -415,8 +472,10 @@ int addPosition(void){ if(moves_array_elements >= 0 && moves_array_elements < ARRAY_LENGTH){ program_elements[moves_array_elements].panStepCount = stepper_pan.currentPosition(); program_elements[moves_array_elements].tiltStepCount = stepper_tilt.currentPosition(); + program_elements[moves_array_elements].sliderStepCount = stepper_slider.currentPosition(); program_elements[moves_array_elements].panSpeed = stepper_pan.maxSpeed(); program_elements[moves_array_elements].tiltSpeed = stepper_tilt.maxSpeed(); + program_elements[moves_array_elements].sliderSpeed = stepper_slider.maxSpeed(); current_moves_array_index = moves_array_elements; moves_array_elements++;//increment the index printi(F("Position added at index: "), current_moves_array_index); @@ -434,8 +493,10 @@ void clearArray(void){ for(int row = 0; row < ARRAY_LENGTH; row++){ program_elements[row].panStepCount = 0; program_elements[row].tiltStepCount = 0; + program_elements[row].sliderStepCount = 0; program_elements[row].panSpeed = 0; program_elements[row].tiltSpeed = 0; + program_elements[row].sliderSpeed = 0; program_elements[row].msDelay = 0; } moves_array_elements = 0; @@ -449,8 +510,10 @@ void moveToIndex(int index){ if(index < moves_array_elements && index >= 0){ target_position[0] = program_elements[index].panStepCount; target_position[1] = program_elements[index].tiltStepCount; + target_position[2] = program_elements[index].sliderStepCount; stepper_pan.setMaxSpeed(program_elements[index].panSpeed); stepper_tilt.setMaxSpeed(program_elements[index].tiltSpeed); + stepper_slider.setMaxSpeed(program_elements[index].sliderSpeed); multi_stepper.moveTo(target_position); //Sets new target positions multi_stepper.runSpeedToPosition(); //Moves and blocks until complete delay(program_elements[index].msDelay); @@ -493,9 +556,12 @@ void gotoMovesArrayEnd(void){ void editMovesArrayIndex(void){ program_elements[current_moves_array_index].panStepCount = stepper_pan.currentPosition(); - program_elements[current_moves_array_index].tiltStepCount = stepper_tilt.currentPosition(); + program_elements[current_moves_array_index].tiltStepCount = stepper_tilt.currentPosition(); + program_elements[current_moves_array_index].sliderStepCount = stepper_slider.currentPosition(); program_elements[current_moves_array_index].panSpeed = stepper_pan.maxSpeed(); program_elements[current_moves_array_index].tiltSpeed = stepper_tilt.maxSpeed(); + program_elements[current_moves_array_index].sliderSpeed = stepper_slider.maxSpeed(); + printi(F("Position edited at index: "), current_moves_array_index); } @@ -539,6 +605,21 @@ void scaleMovesArrayTiltMaxSpeed(float newMax){ /*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ +void scaleMovesArraySliderMaxSpeed(float newMax){ + float currentMax = 0; + for(int row = 0; row < moves_array_elements; row++){ //Find the maximum pan speed + if(program_elements[row].sliderSpeed > currentMax){ + currentMax = program_elements[row].sliderSpeed; + } + } + float speedRatio = newMax / currentMax; + for(int row = 0; row < moves_array_elements; row++){ //Scale all the pan speeds + program_elements[row].sliderSpeed = program_elements[row].sliderSpeed * speedRatio; + } +} + +/*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ + void invertPanDirection(bool invert){ printi(F("Setting pan inversion to: "), invert); invert_pan = invert; @@ -550,7 +631,15 @@ void invertPanDirection(bool invert){ void invertTiltDirection(bool invert){ printi(F("Setting tilt inversion to: "), invert); invert_tilt = invert; - stepper_pan.setPinsInverted(invert, false, false); + stepper_tilt.setPinsInverted(invert, false, false); +} + +/*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ + +void invertSliderDirection(bool invert){ + printi(F("Setting slider inversion to: "), invert); + invert_slider = invert; + stepper_slider.setPinsInverted(invert, false, false); } /*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ @@ -564,12 +653,15 @@ void saveEEPROM(void){ // EEPROM.put(EEPROM_ADDRESS_LIMIT_TILT_MAX, limit_tilt_max); EEPROM.put(EEPROM_ADDRESS_PAN_MAX_SPEED, pan_max_speed); EEPROM.put(EEPROM_ADDRESS_TILT_MAX_SPEED, tilt_max_speed); + EEPROM.put(EEPROM_ADDRESS_SLIDER_MAX_SPEED, slider_max_speed); EEPROM.put(EEPROM_ADDRESS_PAN_ACCELERATION, pan_acceleration); EEPROM.put(EEPROM_ADDRESS_TILT_ACCELERATION, tilt_acceleration); + EEPROM.put(EEPROM_ADDRESS_SLIDER_ACCELERATION, slider_acceleration); EEPROM.put(EEPROM_ADDRESS_HALL_PAN_OFFSET, hall_pan_offset_degrees); EEPROM.put(EEPROM_ADDRESS_HALL_TILT_OFFSET, hall_tilt_offset_degrees); EEPROM.put(EEPROM_ADDRESS_INVERT_PAN, invert_pan); EEPROM.put(EEPROM_ADDRESS_INVERT_TILT, invert_tilt); + EEPROM.put(EEPROM_ADDRESS_INVERT_SLIDER, invert_slider); EEPROM.put(EEPROM_ADDRESS_DEGREES_PER_PICTURE, degrees_per_picture); EEPROM.put(EEPROM_ADDRESS_TIMELAPSE_DELAY, delay_ms_between_pictures); EEPROM.put(EEPROM_ADDRESS_ENABLE_LIMITS, enable_limits); @@ -577,6 +669,8 @@ void saveEEPROM(void){ EEPROM.put(EEPROM_ADDRESS_PAN_MAX_LIMIT, limit_pan_max); EEPROM.put(EEPROM_ADDRESS_TILT_MIN_LIMIT, limit_tilt_min); EEPROM.put(EEPROM_ADDRESS_TILT_MAX_LIMIT, limit_tilt_max); + EEPROM.put(EEPROM_ADDRESS_SLIDER_MIN_LIMIT, limit_slider_min); + EEPROM.put(EEPROM_ADDRESS_SLIDER_MAX_LIMIT, limit_slider_max); } /*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ @@ -605,10 +699,14 @@ void printEEPROM(void){ printi(F("Pan max speed: "), ftemp); EEPROM.get(EEPROM_ADDRESS_TILT_MAX_SPEED, ftemp); printi(F("Tilt max speed: "), ftemp); - EEPROM.get(EEPROM_ADDRESS_PAN_ACCELERATION, ftemp); - printi(F("Pan max acceleration: "), ftemp); - EEPROM.get(EEPROM_ADDRESS_TILT_ACCELERATION, ftemp); - printi(F("Tilt max acceleration: "), ftemp); + EEPROM.get(EEPROM_ADDRESS_SLIDER_MAX_SPEED, ftemp); + printi(F("Slider max speed: "), ftemp); +// EEPROM.get(EEPROM_ADDRESS_PAN_ACCELERATION, ftemp); +// printi(F("Pan max acceleration: "), ftemp); +// EEPROM.get(EEPROM_ADDRESS_TILT_ACCELERATION, ftemp); +// printi(F("Tilt max acceleration: "), ftemp); + EEPROM.get(EEPROM_ADDRESS_SLIDER_ACCELERATION, ftemp); + printi(F("Slider max acceleration: "), ftemp); EEPROM.get(EEPROM_ADDRESS_HALL_PAN_OFFSET, ftemp); printi(F("Pan Hall offset: "), ftemp); EEPROM.get(EEPROM_ADDRESS_HALL_TILT_OFFSET, ftemp); @@ -616,9 +714,10 @@ void printEEPROM(void){ EEPROM.get(EEPROM_ADDRESS_DEGREES_PER_PICTURE, ftemp); printi(F("Angle between pictures: "), ftemp, 3, F(" degrees\n")); EEPROM.get(EEPROM_ADDRESS_TIMELAPSE_DELAY, ltemp); - printi(F("Timelapse delay between pictures: "), ltemp, F("ms\n")); + printi(F("Delay between pictures: "), ltemp, F("ms\n")); printi(F("Pan invert: "), EEPROM.read(EEPROM_ADDRESS_INVERT_PAN)); printi(F("Tilt invert: "), EEPROM.read(EEPROM_ADDRESS_INVERT_TILT)); + printi(F("Slider invert: "), EEPROM.read(EEPROM_ADDRESS_INVERT_SLIDER)); printi(F("Homing on start-up: "), EEPROM.read(EEPROM_ADDRESS_ENABLE_HOMING)); printi(F("Enable limits: "), EEPROM.read(EEPROM_ADDRESS_ENABLE_LIMITS)); EEPROM.get(EEPROM_ADDRESS_PAN_MIN_LIMIT, ftemp); @@ -628,7 +727,11 @@ void printEEPROM(void){ EEPROM.get(EEPROM_ADDRESS_TILT_MIN_LIMIT, ftemp); printi(F("Tilt min limit: "), ftemp); EEPROM.get(EEPROM_ADDRESS_TILT_MAX_LIMIT, ftemp); - printi(F("Tilt max limit: "), ftemp); + printi(F("Tilt max limit: "), ftemp); + EEPROM.get(EEPROM_ADDRESS_SLIDER_MIN_LIMIT, ftemp); + printi(F("Slider min limit: "), ftemp); + EEPROM.get(EEPROM_ADDRESS_SLIDER_MAX_LIMIT, ftemp); + printi(F("Slider max limit: "), ftemp); printi(F("--------------------\n")); } @@ -643,8 +746,10 @@ void setEEPROMVariables(void){ // EEPROM.get(EEPROM_ADDRESS_LIMIT_TILT_MAX, limit_tilt_max); EEPROM.get(EEPROM_ADDRESS_PAN_MAX_SPEED, pan_max_speed); EEPROM.get(EEPROM_ADDRESS_TILT_MAX_SPEED, tilt_max_speed); + EEPROM.get(EEPROM_ADDRESS_SLIDER_MAX_SPEED, slider_max_speed); EEPROM.get(EEPROM_ADDRESS_PAN_ACCELERATION, pan_acceleration); EEPROM.get(EEPROM_ADDRESS_TILT_ACCELERATION, tilt_acceleration); + EEPROM.get(EEPROM_ADDRESS_SLIDER_ACCELERATION, slider_acceleration); EEPROM.get(EEPROM_ADDRESS_HALL_PAN_OFFSET, hall_pan_offset_degrees); EEPROM.get(EEPROM_ADDRESS_HALL_TILT_OFFSET, hall_tilt_offset_degrees); EEPROM.get(EEPROM_ADDRESS_DEGREES_PER_PICTURE, degrees_per_picture); @@ -654,8 +759,11 @@ void setEEPROMVariables(void){ EEPROM.get(EEPROM_ADDRESS_PAN_MAX_LIMIT, limit_pan_max); EEPROM.get(EEPROM_ADDRESS_TILT_MIN_LIMIT, limit_tilt_min); EEPROM.get(EEPROM_ADDRESS_TILT_MAX_LIMIT, limit_tilt_max); + EEPROM.get(EEPROM_ADDRESS_SLIDER_MIN_LIMIT, limit_slider_min); + EEPROM.get(EEPROM_ADDRESS_SLIDER_MAX_LIMIT, limit_slider_max); invert_pan = EEPROM.read(EEPROM_ADDRESS_INVERT_PAN); invert_tilt = EEPROM.read(EEPROM_ADDRESS_INVERT_TILT); + invert_slider = EEPROM.read(EEPROM_ADDRESS_INVERT_SLIDER); enable_homing = EEPROM.read(EEPROM_ADDRESS_ENABLE_HOMING); printi(F("Values set.\n")); } @@ -704,6 +812,7 @@ void ledBatteryLevel(float batteryPercentage){ /*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ void timeLapseInterpolation(float panStartAngle, float tiltStartAngle, float panStopAngle, float tiltStopAngle, float degPerPic, unsigned long msDelay){ + if(degPerPic == 0) return; if(msDelay > SHUTTER_DELAY){ msDelay = msDelay - SHUTTER_DELAY; } @@ -719,7 +828,9 @@ void timeLapseInterpolation(float panStartAngle, float tiltStartAngle, float pan setTargetPositions(panStartAngle + (panInc * i), tiltStartAngle + (tiltInc * i)); multi_stepper.runSpeedToPosition();//blocking move to the next position delay(msDelay); + LEDS.showColor(CHSV(160 , 255, 255)); //blue triggerCameraShutter();//capture the picture + LEDS.showColor(CHSV(160 , 255, 0)); //off } } @@ -731,9 +842,7 @@ void timeLapse(float degPerPic, unsigned long msDelay, int repeat){ return; //check there are posions to move to } for(int i = 0; i < repeat; i++){ - //printi(F("Loop: "), repeat); - for(int index = 0; index < moves_array_elements - 1; index++){//check what hapens at last element (loop back) - //printi(F("Index: "), index); + for(int index = 0; index < moves_array_elements - 1; index++){//check what happens at last element (loop back) timeLapseInterpolation(panStepsToDegrees(program_elements[index].panStepCount), tiltStepsToDegrees(program_elements[index].tiltStepCount), panStepsToDegrees(program_elements[index + 1].panStepCount), tiltStepsToDegrees(program_elements[index + 1].tiltStepCount), degPerPic, msDelay); } @@ -742,15 +851,17 @@ void timeLapse(float degPerPic, unsigned long msDelay, int repeat){ /*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ -//float sliderStepsToMillimetres(long steps){ -// return steps / SLIDER_MILLIMETRE_RATIO; -//} - -/*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ - -//long sliderMilimeterToSteps(float mm){ -// return mm * SLIDER_MILLIMETRE_RATIO; -//} +void staticTimeLapse(unsigned int numberOfPictures, unsigned long msDelay){ + if(msDelay > SHUTTER_DELAY){ + msDelay = msDelay - SHUTTER_DELAY; + } + for(int i = 0; i < numberOfPictures; i++){ + delay(msDelay); + LEDS.showColor(CHSV(160 , 255, 255)); //blue + triggerCameraShutter();//capture the picture + LEDS.showColor(CHSV(160 , 255, 0)); //off + } +} /*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ @@ -768,6 +879,21 @@ void serialData(void){ float serialCommandValueFloat = atof(stringText); //converts stringText to a float if(instruction == 'G' && stringText[0] == 0) return;//For the bluetooth issue of it sending data when it connects... switch(instruction){ + case INSTRUCTION_SLIDER_MIN_LIMIT:{ + limit_slider_min = serialCommandValueFloat; + printi(F("Slider min limit set to: "), limit_slider_min, 3, F("mm\n")); + } + break; + case INSTRUCTION_SLIDER_MAX_LIMIT:{ + limit_slider_max = serialCommandValueFloat; + printi(F("Slider max limit set to: "), limit_slider_max, 3, F("mm\n")); + } + break; + + case INSTRUCTION_SLIDER_MILLIMETRES:{ + sliderMoveTo(serialCommandValueFloat); + } + break; case INSTRUCTION_DELAY_BETWEEN_PICTURES:{ delay_ms_between_pictures = serialCommandValueFloat; printi(F("Delay between pictures: "), delay_ms_between_pictures, F("ms\n")); @@ -803,9 +929,16 @@ void serialData(void){ } break; case INSTRUCTION_TIMELAPSE:{ - printi(F("Starting timelapse...\n")); + printi(F("Starting panorama.\n")); timeLapse(degrees_per_picture, delay_ms_between_pictures, 1); - printi(F("Timelapse finished\n")); + printi(F("Finished\n")); + } + break; + case INSTRUCTION_STATIC_TIMELAPSE:{ + printi(F("Starting timelapse with:\n"), serialCommandValueInt, F(" pics\n")); + printi(F(""), delay_ms_between_pictures, F("ms between pics\n")); + timeLapse(serialCommandValueInt, delay_ms_between_pictures, 1); + printi(F("Finished\n")); } break; case INSTRUCTION_SCALE_PAN_SPEED:{ @@ -821,7 +954,7 @@ void serialData(void){ } break; case INSTRUCTION_AUTO_HOME:{ - printi(F("Beginning homing...\n")); + printi(F("Beginning homing.\n")); if(findHome()){ printi(F("Homing complete.\n")); } @@ -829,7 +962,7 @@ void serialData(void){ stepper_pan.setCurrentPosition(0); stepper_tilt.setCurrentPosition(0); setTargetPositions(0, 0); - printi(F("Error finding home position... Current position has been set as home.\n")); + printi(F("Error homing. Current position has been set as home.\n")); } } break; @@ -844,6 +977,10 @@ void serialData(void){ case INSTRUCTION_SET_TILT_HALL_OFFSET:{ hall_tilt_offset_degrees = serialCommandValueFloat; } + break; + case INSTRUCTION_INVERT_SLIDER:{ + invertSliderDirection(serialCommandValueInt); + } break; case INSTRUCTION_INVERT_TILT:{ invertTiltDirection(serialCommandValueInt); @@ -854,7 +991,7 @@ void serialData(void){ } break; case INSTRUCTION_SAVE_TO_EEPROM:{ - printi(F("Saving values to EEPROM... \n")); + printi(F("Saving values to EEPROM.\n")); saveEEPROM(); printi(F("Current valuses saved.\n")); } @@ -900,11 +1037,11 @@ void serialData(void){ stepper_pan.runSpeed(); } break; - case INSTRUCTION_TILT_RUN_SPEED:{ - stepper_tilt.setSpeed(tiltDegreesToSteps(serialCommandValueFloat)); - stepper_tilt.runSpeed(); - } - break; +// case INSTRUCTION_TILT_RUN_SPEED:{ +// stepper_tilt.setSpeed(tiltDegreesToSteps(serialCommandValueFloat)); +// stepper_tilt.runSpeed(); +// } +// break; case INSTRUCTION_DEBUG_STATUS:{ debugReport(); } @@ -930,6 +1067,7 @@ void serialData(void){ case INSTRUCTION_SET_HOME:{ stepper_pan.setCurrentPosition(0); stepper_tilt.setCurrentPosition(0); + stepper_slider.setCurrentPosition(0); } break; case INSTRUCTION_ENABLE:{ @@ -944,34 +1082,42 @@ void serialData(void){ printi("Setting acceleration to ", serialCommandValueFloat, 1, " steps/s/s.\n"); pan_acceleration = serialCommandValueFloat; tilt_acceleration = serialCommandValueFloat; + slider_acceleration = serialCommandValueFloat; stepper_pan.setAcceleration(pan_acceleration); stepper_tilt.setAcceleration(tilt_acceleration); + stepper_slider.setAcceleration(slider_acceleration); } break; case INSTRUCTION_SET_PAN_SPEED:{ - printi("Setting maximum pan speed to ", serialCommandValueFloat, 1, " steps/s.\n"); + printi("Setting maximum pan speed to ", serialCommandValueFloat, 1, " º/s.\n"); pan_max_speed = panDegreesToSteps(serialCommandValueFloat); stepper_pan.setMaxSpeed(pan_max_speed); } break; case INSTRUCTION_SET_TILT_SPEED:{ - printi("Setting maximum tilt speed to ", serialCommandValueFloat, 1, " steps/s.\n"); + printi("Setting maximum tilt speed to ", serialCommandValueFloat, 1, " º/s.\n"); tilt_max_speed = tiltDegreesToSteps(serialCommandValueFloat); stepper_tilt.setMaxSpeed(tilt_max_speed); } break; - case INSTRUCTION_MULTISTEPPER_TEST_2:{ - target_position[0] = panDegreesToSteps(45); - target_position[1] = tiltDegreesToSteps(180); - multi_stepper.moveTo(target_position); - } - break; - case INSTRUCTION_MULTISTEPPER_TEST_3:{ - target_position[0] = panDegreesToSteps(-45); - target_position[1] = tiltDegreesToSteps(-180); - multi_stepper.moveTo(target_position); + case INSTRUCTION_SET_SLIDER_SPEED:{ + printi("Setting maximum slider speed to ", serialCommandValueFloat, 1, " mm/s.\n"); + slider_max_speed = sliderMillimetresToSteps(serialCommandValueFloat); + stepper_slider.setMaxSpeed(slider_max_speed); } break; +// case INSTRUCTION_MULTISTEPPER_TEST_2:{ +// target_position[0] = panDegreesToSteps(45); +// target_position[1] = tiltDegreesToSteps(180); +// multi_stepper.moveTo(target_position); +// } +// break; +// case INSTRUCTION_MULTISTEPPER_TEST_3:{ +// target_position[0] = panDegreesToSteps(-45); +// target_position[1] = tiltDegreesToSteps(-180); +// multi_stepper.moveTo(target_position); +// } +// break; // case COMMAND_CARTESIAN:{//Moves relitive to the current position // while(Serial.available() != 6){//Wait for six bytes to be available. Breaks after ~200ms if bytes are not received. // delayMicroseconds(200); diff --git a/pan_tilt_mount_nano_code/panTiltMount.h b/pan_tilt_mount_nano_code/panTiltMount.h index 569083d..79c9d50 100644 --- a/pan_tilt_mount_nano_code/panTiltMount.h +++ b/pan_tilt_mount_nano_code/panTiltMount.h @@ -27,13 +27,11 @@ #define PAN_GEAR_RATIO 8.4705882352941176470588235294118 //144/17 teeth #define TILT_GEAR_RATIO 3.047619047619047619047619047619 //64/21 teeth -//#define SLIDER_MILLIMETRE_RATIO //mm/steps -// 200 * #define MAX_STRING_LENGTH 10 #define ARRAY_LENGTH 20 -#define SHUTTER_DELAY 300 +#define SHUTTER_DELAY 200 #define INSTRUCTION_STEP_MODE 'm' #define INSTRUCTION_PAN_STEPS 'P' @@ -52,11 +50,11 @@ #define INSTRUCTION_TOGGLE_HOMING 'H' #define INSTRUCTION_TRIGGER_SHUTTER 'c' #define INSTRUCTION_AUTO_HOME 'A' -#define INSTRUCTION_MULTISTEPPER_TEST_2 '2' -#define INSTRUCTION_MULTISTEPPER_TEST_3 '3' +//#define INSTRUCTION_MULTISTEPPER_TEST_2 '2' +//#define INSTRUCTION_MULTISTEPPER_TEST_3 '3' #define INSTRUCTION_DEBUG_STATUS 'R' #define INSTRUCTION_PAN_RUN_SPEED 'k' -#define INSTRUCTION_TILT_RUN_SPEED 'l' +//#define INSTRUCTION_TILT_RUN_SPEED 'l' #define INSTRUCTION_EXECUTE_MOVES ';' #define INSTRUCTION_ADD_POSITION '#' #define INSTRUCTION_STEP_FORWARD '>' @@ -76,8 +74,14 @@ #define INSTRUCTION_PAN_MAX_LIMIT 'F' #define INSTRUCTION_TILT_MIN_LIMIT 'g' #define INSTRUCTION_TILT_MAX_LIMIT 'G' +#define INSTRUCTION_SLIDER_MIN_LIMIT 'z' +#define INSTRUCTION_SLIDER_MAX_LIMIT 'Z' #define INSTRUCTION_ANGLE_BETWEEN_PICTURES 'b' #define INSTRUCTION_DELAY_BETWEEN_PICTURES 'B' +#define INSTRUCTION_STATIC_TIMELAPSE 'l' +#define INSTRUCTION_SLIDER_MILLIMETRES 'x' +#define INSTRUCTION_INVERT_SLIDER 'j' +#define INSTRUCTION_SET_SLIDER_SPEED 'X' #define EEPROM_ADDRESS_ENABLE_HOMING 0 #define EEPROM_ADDRESS_LIMIT_PAN_MIN 1 @@ -100,13 +104,18 @@ #define EEPROM_ADDRESS_PAN_MAX_LIMIT 58 #define EEPROM_ADDRESS_TILT_MIN_LIMIT 62 #define EEPROM_ADDRESS_TILT_MAX_LIMIT 66 +#define EEPROM_ADDRESS_SLIDER_MAX_SPEED 70 +#define EEPROM_ADDRESS_SLIDER_ACCELERATION 74 +#define EEPROM_ADDRESS_INVERT_SLIDER 78 +#define EEPROM_ADDRESS_SLIDER_MIN_LIMIT 79 +#define EEPROM_ADDRESS_SLIDER_MAX_LIMIT 83 #define LED_TYPE WS2812B #define COLOR_ORDER GRB #define NUM_LEDS 1 #define BRIGHTNESS 255 -#define VERSION_NUMBER "1.5.1" +#define VERSION_NUMBER "2.0.1" /*------------------------------------------------------------------------------------------------------------------------------------------------------*/ @@ -115,6 +124,8 @@ struct ArrayElement { float panSpeed = 0; long tiltStepCount = 0; float tiltSpeed = 0; + long sliderStepCount = 0; + float sliderSpeed = 0; int msDelay = 0; }; @@ -157,15 +168,22 @@ void setEEPROMVariables(void); void invertPanDirection(bool); void invertTiltDirection(bool); int setTargetPositions(float, float); +int setTargetPositions(float, float, float); void toggleAutoHoming(void); void triggerCameraShutter(void); void scaleMovesArrayPanMaxSpeed(float newMax); void scaleMovesArrayTiltMaxSpeed(float newMax); void ledBatteryLevel(float batteryPercentage); -int setTargetPositionsSteps(long panSteps, long tiltSteps); +//int setTargetPositionsSteps(long panSteps, long tiltSteps); void timeLapseInterpolation(float, float, float, float, float, unsigned long); void timeLapse(float, unsigned long, int); void toggleEnableLimits(void); +float sliderMillimetresToSteps(float); +float sliderStepsToMillimetres(long); +void sliderMoveTo(float); +void scaleMovesArraySliderMaxSpeed(float); +void invertSliderDirection(bool); +void staticTimeLapse(unsigned int, unsigned long); /*------------------------------------------------------------------------------------------------------------------------------------------------------*/ diff --git a/pan_tilt_mount_nano_code/pan_tilt_mount_nano_code.ino b/pan_tilt_mount_nano_code/pan_tilt_mount_nano_code.ino index 16b09dd..ba8dabd 100644 --- a/pan_tilt_mount_nano_code/pan_tilt_mount_nano_code.ino +++ b/pan_tilt_mount_nano_code/pan_tilt_mount_nano_code.ino @@ -17,21 +17,18 @@ * * Code written by isaac879 * - * Last modified: 27/03/2020 + * Last modified: 07/04/2020 * *--------------------------------------------------------------------------------------------------------------------------------------------------------*/ //TODOs: //program array in deg //point to point in x time //report commands -//slider stuff - //steps per mm - //move x mm - //limits - //all array operations - //all printi - //all eeprom +//slider in panorama lapse +//function to keep focus on a point +//can probably remove most acelleration stuff +//Change step counts for other step modes //Make an AT+ command set //Rename arrays stuff to Keyframes