diff --git a/pan_tilt_mount_nano_code_pcb/panTiltMount.cpp b/pan_tilt_mount_nano_code_pcb/panTiltMount.cpp index d6720d3..37dab54 100644 --- a/pan_tilt_mount_nano_code_pcb/panTiltMount.cpp +++ b/pan_tilt_mount_nano_code_pcb/panTiltMount.cpp @@ -16,10 +16,10 @@ AccelStepper stepper_slider = AccelStepper(1, PIN_STEP_SLIDER, PIN_DIRECTION_SLI MultiStepper multi_stepper; -ArrayElement program_elements[ARRAY_LENGTH]; +KeyframeElement keyframe_array[KEYFRAME_ARRAY_LENGTH]; -int moves_array_elements = 0; -int current_moves_array_index = -1; +int keyframe_elements = 0; +int current_keyframe_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 @@ -27,28 +27,19 @@ float slider_steps_per_millimetre = (200.0 * SIXTEENTH_STEP) / (20 * 2); //Stepp int step_mode = SIXTEENTH_STEP; 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 = 20; //degrees/second -float tilt_max_speed = 50; //degrees/second -float slider_max_speed = 10; //mm/second +float pan_max_speed = 15; //degrees/second +float tilt_max_speed = 45; //degrees/second +float slider_max_speed = 15; //mm/second long target_position[3]; float degrees_per_picture = 0.5; unsigned long delay_ms_between_pictures = 1000; +FloatCoordinate intercept; /*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ @@ -66,22 +57,17 @@ void initPanTilt(void){ pinMode(PIN_STEP_SLIDER, OUTPUT); pinMode(PIN_PAN_HALL, INPUT_PULLUP); pinMode(PIN_TILT_HALL, INPUT_PULLUP); + pinMode(PIN_SLIDER_HALL, INPUT_PULLUP); pinMode(PIN_SHUTTER_TRIGGER, OUTPUT); digitalWrite(PIN_SHUTTER_TRIGGER, LOW); FastLED.addLeds(leds, NUM_LEDS); FastLED.setBrightness(BRIGHTNESS); LEDS.showColor(CHSV(160, 255, 255)); //Set led to blue setEEPROMVariables(); -// stepper_pan.setMinPulseWidth(20); -// stepper_tilt.setMinPulseWidth(20); -// stepper_slider.setMinPulseWidth(20); setStepMode(step_mode); //steping mode stepper_pan.setMaxSpeed(panDegreesToSteps(pan_max_speed)); -// stepper_pan.setAcceleration(pan_acceleration); stepper_tilt.setMaxSpeed(tiltDegreesToSteps(tilt_max_speed)); -// stepper_tilt.setAcceleration(tilt_acceleration); stepper_slider.setMaxSpeed(sliderMillimetresToSteps(slider_max_speed)); -// stepper_slider.setAcceleration(slider_acceleration); invertPanDirection(invert_pan); invertTiltDirection(invert_tilt); invertSliderDirection(invert_slider); @@ -90,38 +76,16 @@ void initPanTilt(void){ multi_stepper.addStepper(stepper_slider); digitalWrite(PIN_ENABLE, LOW); //Enable the stepper drivers enable_state = true; - printi(F("Motors enabled.\n")); - LEDS.showColor(CHSV(96 , 255, 255)); - printi(F("Setup complete.\n")); + //printi(F("Setup complete.\n")); if(enable_homing == 1){ printi(F("Beginning homing...\n")); if(findHome()){ printi(F("Homing complete.\n")); - LEDS.showColor(CHSV(0 , 0, 255)); //White - delay(200); - LEDS.showColor(CHSV(0 , 0, 0)); //off - delay(200); - LEDS.showColor(CHSV(0 , 0, 255)); //White - delay(200); - LEDS.showColor(CHSV(0 , 0, 0)); //off - delay(200); - LEDS.showColor(CHSV(0 , 0, 255)); //White - delay(200); } else{ stepper_pan.setCurrentPosition(0); stepper_tilt.setCurrentPosition(0); - printi(F("Error finding home position... Current position has been set as home.\n")); - LEDS.showColor(CHSV(240 , 255, 255)); //pink - delay(200); - LEDS.showColor(CHSV(0 , 0, 0)); //off - delay(200); - LEDS.showColor(CHSV(240 , 255, 255)); //pink - delay(200); - LEDS.showColor(CHSV(0 , 0, 0)); //off - delay(200); - LEDS.showColor(CHSV(240 , 255, 255)); //pink - delay(200); + printi(F("Error finding home position. Current position has been set as home.\n")); } } ledBatteryLevel(getBatteryPercentage()); @@ -238,8 +202,8 @@ float tiltDegreesToSteps(float angle){ /*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ -float sliderMillimetresToSteps(float mm){ - return mm * slider_steps_per_millimetre ; +long sliderMillimetresToSteps(float mm){ + return mm * slider_steps_per_millimetre; } /*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ @@ -257,18 +221,18 @@ void sliderMoveTo(float mm){ /*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ -void printProgramElements(void){ - printi(F("---Program Elements---\n")); - printi(F("Moves array index: "), current_moves_array_index, F("\n")); - for(int row = 0; row < moves_array_elements; row++){ +void printKeyframeElements(void){ + printi(F("---Keyframes---\n")); + printi(F("Keyframe index: "), current_keyframe_index, F("\n")); + for(int row = 0; row < keyframe_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(" Pan: "), panStepsToDegrees(keyframe_array[row].panStepCount), 3, F("º\t")); + printi(F("Tilt: "), tiltStepsToDegrees(keyframe_array[row].tiltStepCount), 3, F("º\t")); + printi(F("Slider: "), sliderStepsToMillimetres(keyframe_array[row].sliderStepCount), 3, F("mm\t")); + printi(F("Pan Speed: "), panStepsToDegrees(keyframe_array[row].panSpeed), 3, F(" º/s\t")); + printi(F("Tilt Speed: "), tiltStepsToDegrees(keyframe_array[row].tiltSpeed), 3, F(" º/s\t")); + printi(F("Slider Speed: "), sliderStepsToMillimetres(keyframe_array[row].sliderSpeed), 3, F(" mm/s\t")); + printi(F("Delay: "), keyframe_array[row].msDelay, F("ms |\n")); } printi(F("\n")); } @@ -276,8 +240,8 @@ void printProgramElements(void){ /*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ void debugReport(void){ - printi(F("---Debug Report---\n")); - printi(F("Motor enable state: "), enable_state); + printi(F("---Status---\n")); + printi(F("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)); @@ -287,9 +251,9 @@ void debugReport(void){ printi(F("Pan angle: "), panStepsToDegrees(stepper_pan.currentPosition()), 3, F("º\n")); printi(F("Tilt angle: "), tiltStepsToDegrees(stepper_tilt.currentPosition()), 3, F("º\n")); 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 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()); @@ -320,7 +284,7 @@ void debugReport(void){ // 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")); +// printi(F("Battery voltage: "), getBatteryVoltage(), 3, F("V\n")); printi(F("Battery percentage: "), getBatteryPercentage(), 3, F("%\n")); printi(F("Homing on start-up: "), enable_homing); printi(F("Angle between pictures: "), degrees_per_picture, 3, F("º\n")); @@ -329,16 +293,13 @@ void debugReport(void){ printi(F(VERSION_NUMBER)); printi(F("\n")); printEEPROM(); - printProgramElements(); - printi(F("-----------\n")); + printKeyframeElements(); + printi(F("-------\n")); } /*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ 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; - } target_position[0] = panDegreesToSteps(panDeg); target_position[1] = tiltDegreesToSteps(tiltDeg); multi_stepper.moveTo(target_position); @@ -347,10 +308,6 @@ int setTargetPositions(float panDeg, float tiltDeg){ /*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ 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); @@ -360,10 +317,6 @@ int setTargetPositions(float panDeg, float tiltDeg, float sliderMillimetre){ /*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ bool findHome(void){ - if(enable_limits == 1){ - printi(F("Homing not available with limits enabled\n")); - return false; - } bool panHomeFlag = false; bool tiltHomeFlag = false; int panHomingDir = -1; @@ -373,7 +326,6 @@ bool findHome(void){ stepper_pan.setCurrentPosition(0);//set step count to 0 stepper_tilt.setCurrentPosition(0);//set step count to 0 - while(digitalRead(PIN_PAN_HALL) == 0 || digitalRead(PIN_TILT_HALL) == 0){//If already on a Hall sensor move off target_position[0] = target_position[0] + panDegreesToSteps(!digitalRead(PIN_PAN_HALL));//increment by 1 degree target_position[1] = target_position[1] + tiltDegreesToSteps(!digitalRead(PIN_TILT_HALL));//increment by 1 degree @@ -481,55 +433,55 @@ float tiltStepsToDegrees(float steps){ /*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ 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); + if(keyframe_elements >= 0 && keyframe_elements < KEYFRAME_ARRAY_LENGTH){ + keyframe_array[keyframe_elements].panStepCount = stepper_pan.currentPosition(); + keyframe_array[keyframe_elements].tiltStepCount = stepper_tilt.currentPosition(); + keyframe_array[keyframe_elements].sliderStepCount = stepper_slider.currentPosition(); + keyframe_array[keyframe_elements].panSpeed = stepper_pan.maxSpeed(); + keyframe_array[keyframe_elements].tiltSpeed = stepper_tilt.maxSpeed(); + keyframe_array[keyframe_elements].sliderSpeed = stepper_slider.maxSpeed(); + current_keyframe_index = keyframe_elements; + keyframe_elements++;//increment the index + printi(F("Position added at index: "), current_keyframe_index); return 0; } else{ - printi(F("Maximum number of position reached\n")); + printi(F("Max number of position reached\n")); } return -1; } /*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ -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; +void clearKeyframes(void){ + for(int row = 0; row < KEYFRAME_ARRAY_LENGTH; row++){ + keyframe_array[row].panStepCount = 0; + keyframe_array[row].tiltStepCount = 0; + keyframe_array[row].sliderStepCount = 0; + keyframe_array[row].panSpeed = 0; + keyframe_array[row].tiltSpeed = 0; + keyframe_array[row].sliderSpeed = 0; + keyframe_array[row].msDelay = 0; } - moves_array_elements = 0; - current_moves_array_index = -1; - printi(F("All positions cleared.")); + keyframe_elements = 0; + current_keyframe_index = -1; + printi(F("Keyframes cleared.\n")); } /*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ 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); + if(index < keyframe_elements && index >= 0){ + target_position[0] = keyframe_array[index].panStepCount; + target_position[1] = keyframe_array[index].tiltStepCount; + target_position[2] = keyframe_array[index].sliderStepCount; + stepper_pan.setMaxSpeed(keyframe_array[index].panSpeed); + stepper_tilt.setMaxSpeed(keyframe_array[index].tiltSpeed); + stepper_slider.setMaxSpeed(keyframe_array[index].sliderSpeed); multi_stepper.moveTo(target_position); //Sets new target positions multi_stepper.runSpeedToPosition(); //Moves and blocks until complete - delay(program_elements[index].msDelay); - current_moves_array_index = index; + delay(keyframe_array[index].msDelay); + current_keyframe_index = index; } } @@ -537,7 +489,7 @@ void moveToIndex(int index){ void executeMoves(int repeat){ for(int i = 0; i < repeat; i++){ - for(int row = 0; row < moves_array_elements; row++){ + for(int row = 0; row < keyframe_elements; row++){ moveToIndex(row); } ledBatteryLevel(getBatteryPercentage()); @@ -553,86 +505,86 @@ void executeMoves(int repeat){ /*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ -void gotoMovesArrayStart(void){ +void gotoFirstKeyframe(void){ moveToIndex(0); } /*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ -void gotoMovesArrayEnd(void){ - moveToIndex(moves_array_elements - 1); +void gotoLastKeyframe(void){ + moveToIndex(keyframe_elements - 1); } /*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ -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].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(); +void editKeyframe(void){ + keyframe_array[current_keyframe_index].panStepCount = stepper_pan.currentPosition(); + keyframe_array[current_keyframe_index].tiltStepCount = stepper_tilt.currentPosition(); + keyframe_array[current_keyframe_index].sliderStepCount = stepper_slider.currentPosition(); + keyframe_array[current_keyframe_index].panSpeed = stepper_pan.maxSpeed(); + keyframe_array[current_keyframe_index].tiltSpeed = stepper_tilt.maxSpeed(); + keyframe_array[current_keyframe_index].sliderSpeed = stepper_slider.maxSpeed(); - printi(F("Edited at index: "), current_moves_array_index); + printi(F("Edited index: "), current_keyframe_index); } /*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ void addDelay(unsigned int ms){ - program_elements[current_moves_array_index].msDelay = ms; + keyframe_array[current_keyframe_index].msDelay = ms; printi(ms, F("")); - printi(F("ms delay added at index: "), current_moves_array_index); + printi(F("ms delay added at index: "), current_keyframe_index); } /*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ -void scaleMovesArrayPanMaxSpeed(float newMax){ - float currentMax = 0; - for(int row = 0; row < moves_array_elements; row++){ //Find the maximum pan speed - if(program_elements[row].panSpeed > currentMax){ - currentMax = program_elements[row].panSpeed; - } - } - float speedRatio = newMax / currentMax; - for(int row = 0; row < moves_array_elements; row++){ //Scale all the pan speeds - program_elements[row].panSpeed = program_elements[row].panSpeed * speedRatio; - } -} - -/*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ - -void scaleMovesArrayTiltMaxSpeed(float newMax){ - float currentMax = 0; - for(int row = 0; row < moves_array_elements; row++){ //Find the maximum pan speed - if(program_elements[row].tiltSpeed > currentMax){ - currentMax = program_elements[row].tiltSpeed; - } - } - float speedRatio = newMax / currentMax; - for(int row = 0; row < moves_array_elements; row++){ //Scale all the pan speeds - program_elements[row].tiltSpeed = program_elements[row].tiltSpeed * speedRatio; - } -} - -/*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ - -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 scaleMovesArrayPanMaxSpeed(float newMax){ +// float currentMax = 0; +// for(int row = 0; row < moves_array_elements; row++){ //Find the maximum pan speed +// if(program_elements[row].panSpeed > currentMax){ +// currentMax = program_elements[row].panSpeed; +// } +// } +// float speedRatio = newMax / currentMax; +// for(int row = 0; row < moves_array_elements; row++){ //Scale all the pan speeds +// program_elements[row].panSpeed = program_elements[row].panSpeed * speedRatio; +// } +//} +// +///*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ +// +//void scaleMovesArrayTiltMaxSpeed(float newMax){ +// float currentMax = 0; +// for(int row = 0; row < moves_array_elements; row++){ //Find the maximum pan speed +// if(program_elements[row].tiltSpeed > currentMax){ +// currentMax = program_elements[row].tiltSpeed; +// } +// } +// float speedRatio = newMax / currentMax; +// for(int row = 0; row < moves_array_elements; row++){ //Scale all the pan speeds +// program_elements[row].tiltSpeed = program_elements[row].tiltSpeed * speedRatio; +// } +//} +// +///*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ +// +//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("Pan inversion set to: "), invert); + printi(F("Pan inversion: "), invert); invert_pan = invert; stepper_pan.setPinsInverted(invert, false, false); } @@ -640,7 +592,7 @@ void invertPanDirection(bool invert){ /*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ void invertTiltDirection(bool invert){ - printi(F("Tilt inversion set to: "), invert); + printi(F("Tilt inversion: "), invert); invert_tilt = invert; stepper_tilt.setPinsInverted(invert, false, false); } @@ -648,7 +600,7 @@ void invertTiltDirection(bool invert){ /*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ void invertSliderDirection(bool invert){ - printi(F("Slider inversion set to: "), invert); + printi(F("Slider inversion: "), invert); invert_slider = invert; stepper_slider.setPinsInverted(invert, false, false); } @@ -661,9 +613,6 @@ void saveEEPROM(void){ 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); @@ -671,13 +620,6 @@ void saveEEPROM(void){ EEPROM.put(EEPROM_ADDRESS_INVERT_SLIDER, invert_slider); EEPROM.put(EEPROM_ADDRESS_DEGREES_PER_PICTURE, degrees_per_picture); EEPROM.put(EEPROM_ADDRESS_PANORAMICLAPSE_DELAY, delay_ms_between_pictures); - EEPROM.put(EEPROM_ADDRESS_ENABLE_LIMITS, enable_limits); - EEPROM.put(EEPROM_ADDRESS_PAN_MIN_LIMIT, limit_pan_min); - 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); } /*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ @@ -686,7 +628,7 @@ void printEEPROM(void){ int itemp; float ftemp; long ltemp; - printi(F("---Saved Values---\n")); + printi(F("---EEPROM---\n")); EEPROM.get(EEPROM_ADDRESS_MODE, itemp); printi(F("Step mode: "), itemp, F("\n")); EEPROM.get(EEPROM_ADDRESS_PAN_MAX_SPEED, ftemp); @@ -694,13 +636,7 @@ void printEEPROM(void){ EEPROM.get(EEPROM_ADDRESS_TILT_MAX_SPEED, ftemp); printi(F("Tilt max speed: "), ftemp, 3, F("º/s\n")); EEPROM.get(EEPROM_ADDRESS_SLIDER_MAX_SPEED, ftemp); - printi(F("Slider max speed: "), ftemp, 3, F("mm/s\n")); -// 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); + printi(F("Slider max speed: "), ftemp, 3, F("mm/s\n")); EEPROM.get(EEPROM_ADDRESS_HALL_PAN_OFFSET, ftemp); printi(F("Pan Hall offset: "), ftemp, 3, F("º\n")); EEPROM.get(EEPROM_ADDRESS_HALL_TILT_OFFSET, ftemp); @@ -713,49 +649,25 @@ void printEEPROM(void){ 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); - printi(F("Pan min limit: "), ftemp, 3, F("º\n")); - EEPROM.get(EEPROM_ADDRESS_PAN_MAX_LIMIT, ftemp); - printi(F("Pan max limit: "), ftemp, 3, F("º\n")); - EEPROM.get(EEPROM_ADDRESS_TILT_MIN_LIMIT, ftemp); - printi(F("Tilt min limit: "), ftemp, 3, F("º\n")); - EEPROM.get(EEPROM_ADDRESS_TILT_MAX_LIMIT, ftemp); - printi(F("Tilt max limit: "), ftemp, 3, F("º\n")); - EEPROM.get(EEPROM_ADDRESS_SLIDER_MIN_LIMIT, ftemp); - printi(F("Slider min limit: "), ftemp, 3, F("mm\n")); - EEPROM.get(EEPROM_ADDRESS_SLIDER_MAX_LIMIT, ftemp); - printi(F("Slider max limit: "), ftemp, 3, F("mm\n")); printi(F("\n")); } /*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ void setEEPROMVariables(void){ - printi(F("Setting values from EEPROM...\n")); EEPROM.get(EEPROM_ADDRESS_MODE, step_mode); 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); - EEPROM.get(EEPROM_ADDRESS_PANORAMICLAPSE_DELAY, delay_ms_between_pictures); - EEPROM.get(EEPROM_ADDRESS_ENABLE_LIMITS, enable_limits); - EEPROM.get(EEPROM_ADDRESS_PAN_MIN_LIMIT, limit_pan_min); - 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); + EEPROM.get(EEPROM_ADDRESS_PANORAMICLAPSE_DELAY, delay_ms_between_pictures); 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")); + printi(F("EEPROM values set.\n")); } /*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ @@ -773,19 +685,6 @@ void toggleAutoHoming(void){ /*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ -void toggleEnableLimits(void){ - if(enable_limits == 1){ - enable_limits = 0; - printi(F("Limits disabled.\n")); - } - else{ - enable_limits = 1; - printi(F("Limits enabled.\n")); - } -} - -/*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ - void triggerCameraShutter(void){ digitalWrite(PIN_SHUTTER_TRIGGER, HIGH); delay(SHUTTER_DELAY); @@ -829,14 +728,14 @@ void panoramiclapseInterpolation(float panStartAngle, float tiltStartAngle, floa /*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ void panoramiclapse(float degPerPic, unsigned long msDelay, int repeat){ - if(moves_array_elements < 2){ - printi(F("Not enough positions recorded\n")); + if(keyframe_elements < 2){ + printi(F("Not enough keyframes recorded\n")); return; //check there are posions to move to } for(int i = 0; i < repeat; i++){ - for(int index = 0; index < moves_array_elements - 1; index++){ - panoramiclapseInterpolation(panStepsToDegrees(program_elements[index].panStepCount), tiltStepsToDegrees(program_elements[index].tiltStepCount), sliderStepsToMillimetres(program_elements[index].sliderStepCount), - panStepsToDegrees(program_elements[index + 1].panStepCount), tiltStepsToDegrees(program_elements[index + 1].tiltStepCount), sliderStepsToMillimetres(program_elements[index + 1].sliderStepCount), degPerPic, msDelay); + for(int index = 0; index < keyframe_elements - 1; index++){ + panoramiclapseInterpolation(panStepsToDegrees(keyframe_array[index].panStepCount), tiltStepsToDegrees(keyframe_array[index].tiltStepCount), sliderStepsToMillimetres(keyframe_array[index].sliderStepCount), + panStepsToDegrees(keyframe_array[index + 1].panStepCount), tiltStepsToDegrees(keyframe_array[index + 1].tiltStepCount), sliderStepsToMillimetres(keyframe_array[index + 1].sliderStepCount), degPerPic, msDelay); } } } @@ -852,10 +751,10 @@ void timelapse(unsigned int numberOfPictures, unsigned long msDelay){ float tiltAngle = 0; float sliderTravel = 0; - if(moves_array_elements >= 2){ - panAngle = panStepsToDegrees(program_elements[1].panStepCount) - panStepsToDegrees(program_elements[0].panStepCount); - tiltAngle = tiltStepsToDegrees(program_elements[1].tiltStepCount) - tiltStepsToDegrees(program_elements[0].tiltStepCount); - sliderTravel = sliderStepsToMillimetres(program_elements[1].sliderStepCount) - sliderStepsToMillimetres(program_elements[0].sliderStepCount); + if(keyframe_elements >= 2){ + panAngle = panStepsToDegrees(keyframe_array[1].panStepCount) - panStepsToDegrees(keyframe_array[0].panStepCount); + tiltAngle = tiltStepsToDegrees(keyframe_array[1].tiltStepCount) - tiltStepsToDegrees(keyframe_array[0].tiltStepCount); + sliderTravel = sliderStepsToMillimetres(keyframe_array[1].sliderStepCount) - sliderStepsToMillimetres(keyframe_array[0].sliderStepCount); } float sliderInc = sliderTravel / numberOfPictures; @@ -874,11 +773,125 @@ void timelapse(unsigned int numberOfPictures, unsigned long msDelay){ /*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ +bool calculateTargetCoordinate(void){ + float m1, c1, m2, c2; + + LinePoints line0; + line0.x0 = sliderStepsToMillimetres(keyframe_array[0].sliderStepCount); + line0.y0 = 0; + line0.x1 = line0.x0 + cos(degToRads(panStepsToDegrees(keyframe_array[0].panStepCount))); + line0.y1 = sin(degToRads(panStepsToDegrees(keyframe_array[0].panStepCount))); + + LinePoints line1; + line1.x0 = sliderStepsToMillimetres(keyframe_array[1].sliderStepCount); + line1.y0 = 0; + line1.x1 = line1.x0 + cos(degToRads(panStepsToDegrees(keyframe_array[1].panStepCount))); + line1.y1 = sin(degToRads(panStepsToDegrees(keyframe_array[1].panStepCount))); + + if((line0.x1 - line0.x0) != 0){ + m1 = (line0.y1 - line0.y0) / (line0.x1 - line0.x0); + c1 = line0.y1 - m1 * line0.x1; + } + + if((line1.x1 - line1.x0) != 0){ + m2 = (line1.y1 - line1.y0) / (line1.x1 - line1.x0); + c2 = line1.y1 - m2 * line1.x1; + } + + if((line0.x1 - line0.x0) == 0){ + intercept.x = line0.x0; + intercept.y = m2 * intercept.x + c2; + } + else if((line1.x1 - line1.x0) == 0){ + intercept.x = line1.x0; + intercept.y = m1 * intercept.x + c1; + } + else{ + if(m1 == m2){ + printi(F("Positions do not intersect.")); + return false; + } + intercept.x = (c2 - c1) / (m1 - m2); + intercept.y = m1 * intercept.x + c1; + } + intercept.z = tan(degToRads(tiltStepsToDegrees(keyframe_array[0].tiltStepCount))) * sqrt(pow(intercept.x, 2) + pow(intercept.y, 2)); + if(((panStepsToDegrees(keyframe_array[0].panStepCount) > 0 && panStepsToDegrees(keyframe_array[1].panStepCount) > 0) && intercept.y < 0) + || ((panStepsToDegrees(keyframe_array[0].panStepCount) < 0 && panStepsToDegrees(keyframe_array[1].panStepCount) < 0) && intercept.y > 0)){ + return false; + } + return true; +} + +/*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ + +void interpolateTargetPoint(FloatCoordinate targetPoint, int repeat){ + if(keyframe_elements < 2){ + printi(F("Not enough keyframes recorded\n")); + return; //check there are posions to move to + } + + float increment = 1; + float sliderStartPos = sliderStepsToMillimetres(keyframe_array[0].sliderStepCount); //slider start position + float sliderEndPos = sliderStepsToMillimetres(keyframe_array[1].sliderStepCount); + float panAngle = 0; + float tiltAngle = 0; + float x = targetPoint.x - sliderStepsToMillimetres(keyframe_array[0].sliderStepCount); + float ySqared = pow(targetPoint.y, 2); + float sliderTravel = sliderStepsToMillimetres(keyframe_array[1].sliderStepCount) - sliderStepsToMillimetres(keyframe_array[0].sliderStepCount); + unsigned int numberOfIncrements = sliderTravel / increment; + + for(int j = 0; j < repeat; j++){ + for(int i = 0; i <= numberOfIncrements; i++){ + x = targetPoint.x - (sliderStartPos + increment * i); + panAngle = radsToDeg(atan2(targetPoint.y, x)); + tiltAngle = radsToDeg(atan2(targetPoint.z, sqrt(pow(x, 2) + ySqared))); + setTargetPositions(panAngle, tiltAngle, sliderStartPos + increment * i); + multi_stepper.runSpeedToPosition();//blocking move to the next position + } + x = targetPoint.x - sliderEndPos; + panAngle = radsToDeg(atan2(targetPoint.y, x)); + tiltAngle = radsToDeg(atan2(targetPoint.z, sqrt(pow(x, 2) + ySqared))); + setTargetPositions(panAngle, tiltAngle, sliderEndPos); + multi_stepper.runSpeedToPosition();//blocking move to the next position + + for(int i = numberOfIncrements; (i >= 0 && repeat > 0); i--){ + x = targetPoint.x - (sliderStartPos + increment * i); + panAngle = radsToDeg(atan2(targetPoint.y, x)); + tiltAngle = radsToDeg(atan2(targetPoint.z, sqrt(pow(x, 2) + ySqared))); + setTargetPositions(panAngle, tiltAngle, sliderStartPos + increment * i); + multi_stepper.runSpeedToPosition();//blocking move to the next position + } + setTargetPositions(panAngle, tiltAngle, sliderStartPos); + multi_stepper.runSpeedToPosition();//blocking move to the next position + } +} + +/*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ + +bool sliderHoming(void){ + while(digitalRead(PIN_SLIDER_HALL) == 0){ //Move off the hall + target_position[2] = target_position[2] + sliderMillimetresToSteps(1); + multi_stepper.moveTo(target_position); + multi_stepper.runSpeedToPosition(); + } + setTargetPositions(panStepsToDegrees(target_position[0]), tiltStepsToDegrees(target_position[1]), -1200);//1200 is the length of the slider + while(multi_stepper.run()){ + if(digitalRead(PIN_SLIDER_HALL) == 0){ + stepper_slider.setCurrentPosition(0);//set step count to 0 + setTargetPositions(panStepsToDegrees(target_position[0]), tiltStepsToDegrees(target_position[1]), 0); + return true; + } + } + return false; +} + +/*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ + void serialData(void){ char instruction = Serial.read(); - if(instruction == INSTRUCTION_BYTES_PAN_TILT_SPEED){ + if(instruction == INSTRUCTION_BYTES_SLIDER_PAN_TILT_SPEED){ int count = 0; - while(Serial.available() < 4){//Wait for 4 bytes to be available. Breaks after ~20ms if bytes are not received. + while(Serial.available() < 6){//Wait for 6 bytes to be available. Breaks after ~20ms if bytes are not received. delayMicroseconds(200); count++; if(count > 100){ @@ -886,11 +899,14 @@ void serialData(void){ break; } } + int sliderStepSpeed = (Serial.read() << 8) + Serial.read(); int panStepSpeed = (Serial.read() << 8) + Serial.read(); int tiltStepSpeed = (Serial.read() << 8) + Serial.read(); - + + stepper_slider.setSpeed(sliderStepSpeed); stepper_pan.setSpeed(panStepSpeed); stepper_tilt.setSpeed(tiltStepSpeed); + stepper_slider.runSpeed(); stepper_pan.runSpeed(); stepper_tilt.runSpeed(); } @@ -907,17 +923,10 @@ 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")); + case INSTRUCTION_SLIDER_HOME:{ + sliderHoming(); } 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); } @@ -932,30 +941,6 @@ void serialData(void){ printi(F("Degrees per picture: "), degrees_per_picture, 3, F("º\n")); } break; - case INSTRUCTION_ENABLE_LIMITS:{ - toggleEnableLimits(); - } - break; - case INSTRUCTION_PAN_MIN_LIMIT:{ - limit_pan_min = serialCommandValueFloat; - printi(F("Pan min limit set to: "), limit_pan_min, 3, F("º\n")); - } - break; - case INSTRUCTION_PAN_MAX_LIMIT:{ - limit_pan_max = serialCommandValueFloat; - printi(F("Pan max limit set to: "), limit_pan_max, 3, F("º\n")); - } - break; - case INSTRUCTION_TILT_MIN_LIMIT:{ - limit_tilt_min = serialCommandValueFloat; - printi(F("Tilt min limit set to: "), limit_tilt_min, 3, F("º\n")); - } - break; - case INSTRUCTION_TILT_MAX_LIMIT:{ - limit_tilt_max = serialCommandValueFloat; - printi(F("Tilt max limit set to: "), limit_tilt_max, 3, F("º\n")); - } - break; case INSTRUCTION_PANORAMICLAPSE:{ printi(F("Starting panorama.\n")); panoramiclapse(degrees_per_picture, delay_ms_between_pictures, 1); @@ -969,14 +954,14 @@ void serialData(void){ printi(F("Finished\n")); } break; - case INSTRUCTION_SCALE_PAN_SPEED:{ - scaleMovesArrayPanMaxSpeed(panDegreesToSteps(serialCommandValueFloat)); - } - break; - case INSTRUCTION_SCALE_TILT_SPEED:{ - scaleMovesArrayTiltMaxSpeed(tiltDegreesToSteps(serialCommandValueFloat)); - } - break; +// case INSTRUCTION_SCALE_PAN_SPEED:{ +// scaleMovesArrayPanMaxSpeed(panDegreesToSteps(serialCommandValueFloat)); +// } +// break; +// case INSTRUCTION_SCALE_TILT_SPEED:{ +// scaleMovesArrayTiltMaxSpeed(tiltDegreesToSteps(serialCommandValueFloat)); +// } +// break; case INSTRUCTION_TRIGGER_SHUTTER:{ triggerCameraShutter(); } @@ -989,7 +974,8 @@ void serialData(void){ else{ stepper_pan.setCurrentPosition(0); stepper_tilt.setCurrentPosition(0); - setTargetPositions(0, 0); + stepper_slider.setCurrentPosition(0); + setTargetPositions(0, 0, 0); printi(F("Error homing. Current position has been set as home.\n")); } } @@ -1000,12 +986,12 @@ void serialData(void){ break; case INSTRUCTION_SET_PAN_HALL_OFFSET:{ hall_pan_offset_degrees = serialCommandValueFloat; - printi(F("Pan Hall offset set to: "), hall_pan_offset_degrees, 3, F("º\n")); + printi(F("Pan Hall offset: "), hall_pan_offset_degrees, 3, F("º\n")); } break; case INSTRUCTION_SET_TILT_HALL_OFFSET:{ hall_tilt_offset_degrees = serialCommandValueFloat; - printi(F("Tilt Hall offset set to: "), hall_tilt_offset_degrees, 3, F("º\n")); + printi(F("Tilt Hall offset: "), hall_tilt_offset_degrees, 3, F("º\n")); } break; case INSTRUCTION_INVERT_SLIDER:{ @@ -1021,9 +1007,8 @@ void serialData(void){ } break; case INSTRUCTION_SAVE_TO_EEPROM:{ - printi(F("Saving values to EEPROM...\n")); saveEEPROM(); - printi(F("Saved.\n")); + printi(F("Saved to EEPROM.\n")); } break; case INSTRUCTION_ADD_POSITION:{ @@ -1031,27 +1016,27 @@ void serialData(void){ } break; case INSTRUCTION_STEP_FORWARD:{ - moveToIndex(current_moves_array_index + 1); - printi(F("Moves array index: "), current_moves_array_index, F("\n")); + moveToIndex(current_keyframe_index + 1); + printi(F("Index: "), current_keyframe_index, F("\n")); } break; case INSTRUCTION_STEP_BACKWARD:{ - moveToIndex(current_moves_array_index - 1); - printi(F("Moves array index: "), current_moves_array_index, F("\n")); + moveToIndex(current_keyframe_index - 1); + printi(F("Index: "), current_keyframe_index, F("\n")); } break; case INSTRUCTION_JUMP_TO_START:{ - gotoMovesArrayStart(); - printi(F("Moves array index: "), current_moves_array_index, F("\n")); + gotoFirstKeyframe(); + printi(F("Index: "), current_keyframe_index, F("\n")); } break; case INSTRUCTION_JUMP_TO_END:{ - gotoMovesArrayEnd(); - printi(F("Moves array index: "), current_moves_array_index, F("\n")); + gotoLastKeyframe(); + printi(F("Index: "), current_keyframe_index, F("\n")); } break; case INSTRUCTION_EDIT_ARRAY:{ - editMovesArrayIndex(); + editKeyframe(); } break; case INSTRUCTION_ADD_DELAY:{ @@ -1059,23 +1044,23 @@ void serialData(void){ } break; case INSTRUCTION_CLEAR_ARRAY:{ - clearArray(); + clearKeyframes(); } break; case INSTRUCTION_EXECUTE_MOVES:{ executeMoves(serialCommandValueInt); } break; - case INSTRUCTION_PAN_RUN_SPEED:{ - stepper_pan.setSpeed(panDegreesToSteps(serialCommandValueFloat)); - stepper_pan.runSpeed(); - } - break; - case INSTRUCTION_TILT_RUN_SPEED:{ - stepper_tilt.setSpeed(tiltDegreesToSteps(serialCommandValueFloat)); - stepper_tilt.runSpeed(); - } - break; +// case INSTRUCTION_PAN_RUN_SPEED:{ +// stepper_pan.setSpeed(panDegreesToSteps(serialCommandValueFloat)); +// stepper_pan.runSpeed(); +// } +// break; +// case INSTRUCTION_TILT_RUN_SPEED:{ +// stepper_tilt.setSpeed(tiltDegreesToSteps(serialCommandValueFloat)); +// stepper_tilt.runSpeed(); +// } +// break; case INSTRUCTION_DEBUG_STATUS:{ debugReport(); } @@ -1089,9 +1074,10 @@ void serialData(void){ } break; case INSTRUCTION_SET_HOME:{ + setTargetPositions(0, 0, 0); stepper_pan.setCurrentPosition(0); stepper_tilt.setCurrentPosition(0); - stepper_slider.setCurrentPosition(0); + stepper_slider.setCurrentPosition(0); } break; case INSTRUCTION_ENABLE:{ @@ -1103,23 +1089,32 @@ void serialData(void){ } break; case INSTRUCTION_SET_PAN_SPEED:{ - printi("Setting maximum pan speed to ", serialCommandValueFloat, 1, " º/s.\n"); + printi("Max pan speed: ", serialCommandValueFloat, 1, " º/s.\n"); pan_max_speed = serialCommandValueFloat; stepper_pan.setMaxSpeed(panDegreesToSteps(pan_max_speed)); } break; case INSTRUCTION_SET_TILT_SPEED:{ - printi("Setting maximum tilt speed to ", serialCommandValueFloat, 1, " º/s.\n"); + printi("Max tilt speed: ", serialCommandValueFloat, 1, " º/s.\n"); tilt_max_speed = serialCommandValueFloat; stepper_tilt.setMaxSpeed(tiltDegreesToSteps(tilt_max_speed)); } break; case INSTRUCTION_SET_SLIDER_SPEED:{ - printi("Setting maximum slider speed to ", serialCommandValueFloat, 1, " mm/s.\n"); + printi("Max slider speed: ", serialCommandValueFloat, 1, " mm/s.\n"); slider_max_speed = serialCommandValueFloat; stepper_slider.setMaxSpeed(sliderMillimetresToSteps(slider_max_speed)); } - break; + break; + case INSTRUCTION_ORIBIT_POINT:{ + if(calculateTargetCoordinate()){ + printi("Target coordinates: \nx: ", intercept.x, 3, " mm\n"); + printi("y: ", intercept.y, 3, " mm\n"); + printi("z: ", intercept.z, 3, " mm\n"); + interpolateTargetPoint(intercept, serialCommandValueInt); + } + } + break; } } diff --git a/pan_tilt_mount_nano_code_pcb/panTiltMount.h b/pan_tilt_mount_nano_code_pcb/panTiltMount.h index 99be651..7d0249d 100644 --- a/pan_tilt_mount_nano_code_pcb/panTiltMount.h +++ b/pan_tilt_mount_nano_code_pcb/panTiltMount.h @@ -20,7 +20,7 @@ #define PIN_DIRECTION_TILT 5 #define PIN_STEP_PAN 4 #define PIN_DIRECTION_PAN 3 -#define PIN_LASER 2 +#define PIN_SLIDER_HALL 2 #define FULL_STEP 1 #define HALF_STEP 2 @@ -32,21 +32,19 @@ #define TILT_GEAR_RATIO 3.047619047619047619047619047619 //64/21 teeth #define MAX_STRING_LENGTH 10 -#define ARRAY_LENGTH 20 +#define KEYFRAME_ARRAY_LENGTH 20 #define SHUTTER_DELAY 200 #define INSTRUCTION_BYTES_PAN_SPEED 1 #define INSTRUCTION_BYTES_TILT_SPEED 2 #define INSTRUCTION_BYTES_PAN_TILT_SPEED 3 +#define INSTRUCTION_BYTES_SLIDER_PAN_TILT_SPEED 4 #define INSTRUCTION_STEP_MODE 'm' -#define INSTRUCTION_PAN_STEPS 'P' -#define INSTRUCTION_TILT_STEPS 'T' #define INSTRUCTION_PAN_DEGREES 'p' #define INSTRUCTION_TILT_DEGREES 't' #define INSTRUCTION_SET_HOME 'h' #define INSTRUCTION_ENABLE 'e' -#define INSTRUCTION_SET_ACCELLERATION 'a' #define INSTRUCTION_SET_PAN_SPEED 's' #define INSTRUCTION_SET_TILT_SPEED 'S' #define INSTRUCTION_INVERT_PAN 'i' @@ -72,29 +70,18 @@ #define INSTRUCTION_SCALE_TILT_SPEED 'N' #define INSTRUCTION_SAVE_TO_EEPROM 'U' #define INSTRUCTION_PANORAMICLAPSE 'L' -#define INSTRUCTION_ENABLE_LIMITS 'y' -#define INSTRUCTION_PAN_MIN_LIMIT 'f' -#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_TIMELAPSE 'l' #define INSTRUCTION_SLIDER_MILLIMETRES 'x' #define INSTRUCTION_INVERT_SLIDER 'j' #define INSTRUCTION_SET_SLIDER_SPEED 'X' +#define INSTRUCTION_ORIBIT_POINT '@' +#define INSTRUCTION_SLIDER_HOME 'Z' #define EEPROM_ADDRESS_ENABLE_HOMING 0 -#define EEPROM_ADDRESS_LIMIT_PAN_MIN 1 -#define EEPROM_ADDRESS_LIMIT_PAN_MAX 5 -#define EEPROM_ADDRESS_LIMIT_TILT_MIN 9 -#define EEPROM_ADDRESS_LIMIT_TILT_MAX 13 #define EEPROM_ADDRESS_PAN_MAX_SPEED 17 #define EEPROM_ADDRESS_TILT_MAX_SPEED 21 -#define EEPROM_ADDRESS_PAN_ACCELERATION 25 -#define EEPROM_ADDRESS_TILT_ACCELERATION 29 #define EEPROM_ADDRESS_HALL_PAN_OFFSET 33 #define EEPROM_ADDRESS_HALL_TILT_OFFSET 37 #define EEPROM_ADDRESS_INVERT_PAN 41 @@ -102,27 +89,20 @@ #define EEPROM_ADDRESS_MODE 43 #define EEPROM_ADDRESS_DEGREES_PER_PICTURE 45 #define EEPROM_ADDRESS_PANORAMICLAPSE_DELAY 49 -#define EEPROM_ADDRESS_ENABLE_LIMITS 53 -#define EEPROM_ADDRESS_PAN_MIN_LIMIT 54 -#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 "3.0.2" +#define VERSION_NUMBER "3.2.0" /*------------------------------------------------------------------------------------------------------------------------------------------------------*/ -struct ArrayElement { +struct KeyframeElement { long panStepCount = 0; float panSpeed = 0; long tiltStepCount = 0; @@ -132,6 +112,19 @@ struct ArrayElement { int msDelay = 0; }; +struct FloatCoordinate { + float x; + float y; + float z; +}; + +struct LinePoints { + float x0; + float y0; + float x1; + float y1; +}; + /*------------------------------------------------------------------------------------------------------------------------------------------------------*/ void initPanTilt(void); @@ -154,14 +147,14 @@ float panStepsToDegrees(float); float tiltStepsToDegrees(long); float tiltStepsToDegrees(float); int addPosition(void); -void clearArray(void); +void clearKeyframes(void); void executeMoves(int); void moveToIndex(int); -void gotoMovesArrayStart(void); -void gotoMovesArrayEnd(void); -void editMovesArrayIndex(void); +void gotoFirstKeyframe(void); +void gotoLastKeyframe(void); +void editKeyframe(void); void addDelay(unsigned int ms); -void printProgramElements(void); +void printKeyframeElements(void); void saveEEPROM(void); void printEEPROM(void); void setEEPROMVariables(void); @@ -171,19 +164,17 @@ 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); void panoramiclapseInterpolation(float, float, float, float, float, float, float, unsigned long); void panoramiclapse(float, unsigned long, int); -void toggleEnableLimits(void); -float sliderMillimetresToSteps(float); +long sliderMillimetresToSteps(float); float sliderStepsToMillimetres(long); void sliderMoveTo(float); -void scaleMovesArraySliderMaxSpeed(float); void invertSliderDirection(bool); void timelapse(unsigned int, unsigned long); +bool calculateTargetCoordinate(void); +void interpolateTargetPoint(FloatCoordinate); +bool sliderHoming(void); /*------------------------------------------------------------------------------------------------------------------------------------------------------*/ diff --git a/pan_tilt_mount_nano_code_pcb/pan_tilt_mount_nano_code_pcb.ino b/pan_tilt_mount_nano_code_pcb/pan_tilt_mount_nano_code_pcb.ino index 5822e24..5aa02f4 100644 --- a/pan_tilt_mount_nano_code_pcb/pan_tilt_mount_nano_code_pcb.ino +++ b/pan_tilt_mount_nano_code_pcb/pan_tilt_mount_nano_code_pcb.ino @@ -5,9 +5,9 @@ * The code is developed for a 3D printed pan/tilt mount for a Canon EOS 250D DSLR. It is controlled by an Arduino Nano, JDY-31 Bluetooth module, * A4988 stepper motor drivers and some custom circuitry. * - * Pan Tilt Mount STL files: https://www.thingiverse.com/thing:4316563 (Not currently published but will be bfore 31/05/2020) + * Pan Tilt Mount STL files: https://www.thingiverse.com/thing:4316563 * - * Project video: https://www.youtube.com/c/isaac879 + * Project video: https://youtu.be/uJO7mv4-0PY * * All measurements are in SI units unless otherwise specified. * @@ -25,14 +25,10 @@ //EEPROM values will need to be set after uploading the code and then a reset is required. /*----------Future development----------*/ -//function to keep focus on a point -//can probably remove most acceleration stuff from EEPROM //program array in deg -//point to point in x time //Make an AT+ command set //report commands -//Rename arrays to Keyframes //Refactor code /*--------------------------------------------------------------------------------------------------------------------------------------------------------*/