Foreign-Mirrors/Pan-Tilt-Mount
1
0
Fork 0
mirror of https://github.com/isaac879/Pan-Tilt-Mount.git synced 2026-08-16 13:03:15 +02:00
Code Issues Packages Projects Releases Wiki Activity

Add files via upload

Browse Source
This commit is contained in:
isaac879
2020-06-04 03:16:25 +01:00
committed by GitHub
parent bb43cfc314
commit 9971372be4
3 changed files with 336 additions and 354 deletions
Download Patch File Download Diff File Expand all files Collapse all files
pan_tilt_mount_nano_code_pcb/panTiltMount.cpp
+299 -304
View File
@@ -16,10 +16,10 @@ AccelStepper stepper_slider = AccelStepper(1, PIN_STEP_SLIDER, PIN_DIRECTION_SLI
MultiStepper multi_stepper; MultiStepper multi_stepper;
ArrayElement program_elements[ARRAY_LENGTH]; KeyframeElement keyframe_array[KEYFRAME_ARRAY_LENGTH];
int moves_array_elements = 0; int keyframe_elements = 0;
int current_moves_array_index = -1; int current_keyframe_index = -1;
char stringText[MAX_STRING_LENGTH + 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 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 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; int step_mode = SIXTEENTH_STEP;
bool enable_state = true; 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_pan_offset_degrees = 0;
float hall_tilt_offset_degrees = 0; float hall_tilt_offset_degrees = 0;
byte invert_pan = 0; byte invert_pan = 0;
byte invert_tilt = 0; byte invert_tilt = 0;
byte invert_slider = 0; byte invert_slider = 0;
byte enable_homing = 0; byte enable_homing = 0;
float pan_max_speed = 20; //degrees/second float pan_max_speed = 15; //degrees/second
float tilt_max_speed = 50; //degrees/second float tilt_max_speed = 45; //degrees/second
float slider_max_speed = 10; //mm/second float slider_max_speed = 15; //mm/second
long target_position[3]; long target_position[3];
float degrees_per_picture = 0.5; float degrees_per_picture = 0.5;
unsigned long delay_ms_between_pictures = 1000; unsigned long delay_ms_between_pictures = 1000;
FloatCoordinate intercept;
/*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------------------------------------------------------------------------------------*/
@@ -66,22 +57,17 @@ void initPanTilt(void){
pinMode(PIN_STEP_SLIDER, OUTPUT); pinMode(PIN_STEP_SLIDER, OUTPUT);
pinMode(PIN_PAN_HALL, INPUT_PULLUP); pinMode(PIN_PAN_HALL, INPUT_PULLUP);
pinMode(PIN_TILT_HALL, INPUT_PULLUP); pinMode(PIN_TILT_HALL, INPUT_PULLUP);
pinMode(PIN_SLIDER_HALL, INPUT_PULLUP);
pinMode(PIN_SHUTTER_TRIGGER, OUTPUT); pinMode(PIN_SHUTTER_TRIGGER, OUTPUT);
digitalWrite(PIN_SHUTTER_TRIGGER, LOW); digitalWrite(PIN_SHUTTER_TRIGGER, LOW);
FastLED.addLeds<LED_TYPE, PIN_LED_DATA, COLOR_ORDER>(leds, NUM_LEDS); FastLED.addLeds<LED_TYPE, PIN_LED_DATA, COLOR_ORDER>(leds, NUM_LEDS);
FastLED.setBrightness(BRIGHTNESS); FastLED.setBrightness(BRIGHTNESS);
LEDS.showColor(CHSV(160, 255, 255)); //Set led to blue LEDS.showColor(CHSV(160, 255, 255)); //Set led to blue
setEEPROMVariables(); setEEPROMVariables();
// stepper_pan.setMinPulseWidth(20);
// stepper_tilt.setMinPulseWidth(20);
// stepper_slider.setMinPulseWidth(20);
setStepMode(step_mode); //steping mode setStepMode(step_mode); //steping mode
stepper_pan.setMaxSpeed(panDegreesToSteps(pan_max_speed)); stepper_pan.setMaxSpeed(panDegreesToSteps(pan_max_speed));
// stepper_pan.setAcceleration(pan_acceleration);
stepper_tilt.setMaxSpeed(tiltDegreesToSteps(tilt_max_speed)); stepper_tilt.setMaxSpeed(tiltDegreesToSteps(tilt_max_speed));
// stepper_tilt.setAcceleration(tilt_acceleration);
stepper_slider.setMaxSpeed(sliderMillimetresToSteps(slider_max_speed)); stepper_slider.setMaxSpeed(sliderMillimetresToSteps(slider_max_speed));
// stepper_slider.setAcceleration(slider_acceleration);
invertPanDirection(invert_pan); invertPanDirection(invert_pan);
invertTiltDirection(invert_tilt); invertTiltDirection(invert_tilt);
invertSliderDirection(invert_slider); invertSliderDirection(invert_slider);
@@ -90,38 +76,16 @@ void initPanTilt(void){
multi_stepper.addStepper(stepper_slider); multi_stepper.addStepper(stepper_slider);
digitalWrite(PIN_ENABLE, LOW); //Enable the stepper drivers digitalWrite(PIN_ENABLE, LOW); //Enable the stepper drivers
enable_state = true; enable_state = true;
printi(F("Motors enabled.\n")); //printi(F("Setup complete.\n"));
LEDS.showColor(CHSV(96 , 255, 255));
printi(F("Setup complete.\n"));
if(enable_homing == 1){ if(enable_homing == 1){
printi(F("Beginning homing...\n")); printi(F("Beginning homing...\n"));
if(findHome()){ if(findHome()){
printi(F("Homing complete.\n")); 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{ else{
stepper_pan.setCurrentPosition(0); stepper_pan.setCurrentPosition(0);
stepper_tilt.setCurrentPosition(0); stepper_tilt.setCurrentPosition(0);
printi(F("Error finding home position... Current position has been set as home.\n")); 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);
} }
} }
ledBatteryLevel(getBatteryPercentage()); ledBatteryLevel(getBatteryPercentage());
@@ -238,7 +202,7 @@ float tiltDegreesToSteps(float angle){
/*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------------------------------------------------------------------------------------*/
float sliderMillimetresToSteps(float mm){ long sliderMillimetresToSteps(float mm){
return mm * slider_steps_per_millimetre; return mm * slider_steps_per_millimetre;
} }
@@ -257,18 +221,18 @@ void sliderMoveTo(float mm){
/*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------------------------------------------------------------------------------------*/
void printProgramElements(void){ void printKeyframeElements(void){
printi(F("---Program Elements---\n")); printi(F("---Keyframes---\n"));
printi(F("Moves array index: "), current_moves_array_index, F("\n")); printi(F("Keyframe index: "), current_keyframe_index, F("\n"));
for(int row = 0; row < moves_array_elements; row++){ for(int row = 0; row < keyframe_elements; row++){
printi(F(""), row, F("\t|")); printi(F(""), row, F("\t|"));
printi(F(" Pan: "), panStepsToDegrees(program_elements[row].panStepCount), 3, F("º\t")); printi(F(" Pan: "), panStepsToDegrees(keyframe_array[row].panStepCount), 3, F("º\t"));
printi(F("Tilt: "), tiltStepsToDegrees(program_elements[row].tiltStepCount), 3, F("º\t")); printi(F("Tilt: "), tiltStepsToDegrees(keyframe_array[row].tiltStepCount), 3, F("º\t"));
printi(F("Slider: "), sliderStepsToMillimetres(program_elements[row].sliderStepCount), 3, F("mm\t")); printi(F("Slider: "), sliderStepsToMillimetres(keyframe_array[row].sliderStepCount), 3, F("mm\t"));
printi(F("Pan Speed: "), panStepsToDegrees(program_elements[row].panSpeed), 3, F(" º/s\t")); printi(F("Pan Speed: "), panStepsToDegrees(keyframe_array[row].panSpeed), 3, F(" º/s\t"));
printi(F("Tilt Speed: "), tiltStepsToDegrees(program_elements[row].tiltSpeed), 3, F(" º/s\t")); printi(F("Tilt Speed: "), tiltStepsToDegrees(keyframe_array[row].tiltSpeed), 3, F(" º/s\t"));
printi(F("Slider Speed: "), sliderStepsToMillimetres(program_elements[row].sliderSpeed), 3, F(" mm/s\t")); printi(F("Slider Speed: "), sliderStepsToMillimetres(keyframe_array[row].sliderSpeed), 3, F(" mm/s\t"));
printi(F("Delay: "), program_elements[row].msDelay, F("ms |\n")); printi(F("Delay: "), keyframe_array[row].msDelay, F("ms |\n"));
} }
printi(F("\n")); printi(F("\n"));
} }
@@ -276,8 +240,8 @@ void printProgramElements(void){
/*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------------------------------------------------------------------------------------*/
void debugReport(void){ void debugReport(void){
printi(F("---Debug Report---\n")); printi(F("---Status---\n"));
printi(F("Motor enable state: "), enable_state); printi(F("Enable state: "), enable_state);
printi(F("Step Mode: "), step_mode); printi(F("Step Mode: "), step_mode);
// printi(F("Pan Hall sensor state: "), digitalRead(PIN_PAN_HALL)); // printi(F("Pan Hall sensor state: "), digitalRead(PIN_PAN_HALL));
// printi(F("Tilt Hall sensor state: "), digitalRead(PIN_TILT_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("Pan angle: "), panStepsToDegrees(stepper_pan.currentPosition()), 3, F("º\n"));
printi(F("Tilt angle: "), tiltStepsToDegrees(stepper_tilt.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("Slider position: "), sliderStepsToMillimetres(stepper_slider.currentPosition()), 3, F("mm\n"));
printi(F("Pan steps per º: "), pan_steps_per_degree); // printi(F("Pan steps per º: "), pan_steps_per_degree);
printi(F("Tilt steps per º: "), tilt_steps_per_degree); // printi(F("Tilt steps per º: "), tilt_steps_per_degree);
printi(F("Slider steps per mm: "), slider_steps_per_millimetre); // printi(F("Slider steps per mm: "), slider_steps_per_millimetre);
// printi(F("Pan current steps/s: "), stepper_pan.speed()); // printi(F("Pan current steps/s: "), stepper_pan.speed());
// printi(F("Tilt current steps/s: "), stepper_tilt.speed()); // printi(F("Tilt current steps/s: "), stepper_tilt.speed());
// printi(F("Slider current steps/s: "), stepper_slider.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("Slider invert direction: "), invert_slider);
// printi(F("Pan Hall offset: "), hall_pan_offset_degrees, 3, F("º\n")); // 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("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("Battery percentage: "), getBatteryPercentage(), 3, F("%\n"));
printi(F("Homing on start-up: "), enable_homing); printi(F("Homing on start-up: "), enable_homing);
printi(F("Angle between pictures: "), degrees_per_picture, 3, F("º\n")); printi(F("Angle between pictures: "), degrees_per_picture, 3, F("º\n"));
@@ -329,16 +293,13 @@ void debugReport(void){
printi(F(VERSION_NUMBER)); printi(F(VERSION_NUMBER));
printi(F("\n")); printi(F("\n"));
printEEPROM(); printEEPROM();
printProgramElements(); printKeyframeElements();
printi(F("-----------\n")); printi(F("-------\n"));
} }
/*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------------------------------------------------------------------------------------*/
int setTargetPositions(float panDeg, float tiltDeg){ 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[0] = panDegreesToSteps(panDeg);
target_position[1] = tiltDegreesToSteps(tiltDeg); target_position[1] = tiltDegreesToSteps(tiltDeg);
multi_stepper.moveTo(target_position); multi_stepper.moveTo(target_position);
@@ -347,10 +308,6 @@ int setTargetPositions(float panDeg, float tiltDeg){
/*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------------------------------------------------------------------------------------*/
int setTargetPositions(float panDeg, float tiltDeg, float sliderMillimetre){ 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[0] = panDegreesToSteps(panDeg);
target_position[1] = tiltDegreesToSteps(tiltDeg); target_position[1] = tiltDegreesToSteps(tiltDeg);
target_position[2] = sliderMillimetresToSteps(sliderMillimetre); target_position[2] = sliderMillimetresToSteps(sliderMillimetre);
@@ -360,10 +317,6 @@ int setTargetPositions(float panDeg, float tiltDeg, float sliderMillimetre){
/*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------------------------------------------------------------------------------------*/
bool findHome(void){ bool findHome(void){
if(enable_limits == 1){
printi(F("Homing not available with limits enabled\n"));
return false;
}
bool panHomeFlag = false; bool panHomeFlag = false;
bool tiltHomeFlag = false; bool tiltHomeFlag = false;
int panHomingDir = -1; int panHomingDir = -1;
@@ -373,7 +326,6 @@ bool findHome(void){
stepper_pan.setCurrentPosition(0);//set step count to 0 stepper_pan.setCurrentPosition(0);//set step count to 0
stepper_tilt.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 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[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 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){ int addPosition(void){
if(moves_array_elements >= 0 && moves_array_elements < ARRAY_LENGTH){ if(keyframe_elements >= 0 && keyframe_elements < KEYFRAME_ARRAY_LENGTH){
program_elements[moves_array_elements].panStepCount = stepper_pan.currentPosition(); keyframe_array[keyframe_elements].panStepCount = stepper_pan.currentPosition();
program_elements[moves_array_elements].tiltStepCount = stepper_tilt.currentPosition(); keyframe_array[keyframe_elements].tiltStepCount = stepper_tilt.currentPosition();
program_elements[moves_array_elements].sliderStepCount = stepper_slider.currentPosition(); keyframe_array[keyframe_elements].sliderStepCount = stepper_slider.currentPosition();
program_elements[moves_array_elements].panSpeed = stepper_pan.maxSpeed(); keyframe_array[keyframe_elements].panSpeed = stepper_pan.maxSpeed();
program_elements[moves_array_elements].tiltSpeed = stepper_tilt.maxSpeed(); keyframe_array[keyframe_elements].tiltSpeed = stepper_tilt.maxSpeed();
program_elements[moves_array_elements].sliderSpeed = stepper_slider.maxSpeed(); keyframe_array[keyframe_elements].sliderSpeed = stepper_slider.maxSpeed();
current_moves_array_index = moves_array_elements; current_keyframe_index = keyframe_elements;
moves_array_elements++;//increment the index keyframe_elements++;//increment the index
printi(F("Position added at index: "), current_moves_array_index); printi(F("Position added at index: "), current_keyframe_index);
return 0; return 0;
} }
else{ else{
printi(F("Maximum number of position reached\n")); printi(F("Max number of position reached\n"));
} }
return -1; return -1;
} }
/*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------------------------------------------------------------------------------------*/
void clearArray(void){ void clearKeyframes(void){
for(int row = 0; row < ARRAY_LENGTH; row++){ for(int row = 0; row < KEYFRAME_ARRAY_LENGTH; row++){
program_elements[row].panStepCount = 0; keyframe_array[row].panStepCount = 0;
program_elements[row].tiltStepCount = 0; keyframe_array[row].tiltStepCount = 0;
program_elements[row].sliderStepCount = 0; keyframe_array[row].sliderStepCount = 0;
program_elements[row].panSpeed = 0; keyframe_array[row].panSpeed = 0;
program_elements[row].tiltSpeed = 0; keyframe_array[row].tiltSpeed = 0;
program_elements[row].sliderSpeed = 0; keyframe_array[row].sliderSpeed = 0;
program_elements[row].msDelay = 0; keyframe_array[row].msDelay = 0;
} }
moves_array_elements = 0; keyframe_elements = 0;
current_moves_array_index = -1; current_keyframe_index = -1;
printi(F("All positions cleared.")); printi(F("Keyframes cleared.\n"));
} }
/*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------------------------------------------------------------------------------------*/
void moveToIndex(int index){ void moveToIndex(int index){
if(index < moves_array_elements && index >= 0){ if(index < keyframe_elements && index >= 0){
target_position[0] = program_elements[index].panStepCount; target_position[0] = keyframe_array[index].panStepCount;
target_position[1] = program_elements[index].tiltStepCount; target_position[1] = keyframe_array[index].tiltStepCount;
target_position[2] = program_elements[index].sliderStepCount; target_position[2] = keyframe_array[index].sliderStepCount;
stepper_pan.setMaxSpeed(program_elements[index].panSpeed); stepper_pan.setMaxSpeed(keyframe_array[index].panSpeed);
stepper_tilt.setMaxSpeed(program_elements[index].tiltSpeed); stepper_tilt.setMaxSpeed(keyframe_array[index].tiltSpeed);
stepper_slider.setMaxSpeed(program_elements[index].sliderSpeed); stepper_slider.setMaxSpeed(keyframe_array[index].sliderSpeed);
multi_stepper.moveTo(target_position); //Sets new target positions multi_stepper.moveTo(target_position); //Sets new target positions
multi_stepper.runSpeedToPosition(); //Moves and blocks until complete multi_stepper.runSpeedToPosition(); //Moves and blocks until complete
delay(program_elements[index].msDelay); delay(keyframe_array[index].msDelay);
current_moves_array_index = index; current_keyframe_index = index;
} }
} }
@@ -537,7 +489,7 @@ void moveToIndex(int index){
void executeMoves(int repeat){ void executeMoves(int repeat){
for(int i = 0; i < repeat; i++){ 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); moveToIndex(row);
} }
ledBatteryLevel(getBatteryPercentage()); ledBatteryLevel(getBatteryPercentage());
@@ -553,86 +505,86 @@ void executeMoves(int repeat){
/*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------------------------------------------------------------------------------------*/
void gotoMovesArrayStart(void){ void gotoFirstKeyframe(void){
moveToIndex(0); moveToIndex(0);
} }
/*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------------------------------------------------------------------------------------*/
void gotoMovesArrayEnd(void){ void gotoLastKeyframe(void){
moveToIndex(moves_array_elements - 1); moveToIndex(keyframe_elements - 1);
} }
/*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------------------------------------------------------------------------------------*/
void editMovesArrayIndex(void){ void editKeyframe(void){
program_elements[current_moves_array_index].panStepCount = stepper_pan.currentPosition(); keyframe_array[current_keyframe_index].panStepCount = stepper_pan.currentPosition();
program_elements[current_moves_array_index].tiltStepCount = stepper_tilt.currentPosition(); keyframe_array[current_keyframe_index].tiltStepCount = stepper_tilt.currentPosition();
program_elements[current_moves_array_index].sliderStepCount = stepper_slider.currentPosition(); keyframe_array[current_keyframe_index].sliderStepCount = stepper_slider.currentPosition();
program_elements[current_moves_array_index].panSpeed = stepper_pan.maxSpeed(); keyframe_array[current_keyframe_index].panSpeed = stepper_pan.maxSpeed();
program_elements[current_moves_array_index].tiltSpeed = stepper_tilt.maxSpeed(); keyframe_array[current_keyframe_index].tiltSpeed = stepper_tilt.maxSpeed();
program_elements[current_moves_array_index].sliderSpeed = stepper_slider.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){ void addDelay(unsigned int ms){
program_elements[current_moves_array_index].msDelay = ms; keyframe_array[current_keyframe_index].msDelay = ms;
printi(ms, F("")); 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){ //void scaleMovesArrayPanMaxSpeed(float newMax){
float currentMax = 0; // float currentMax = 0;
for(int row = 0; row < moves_array_elements; row++){ //Find the maximum pan speed // for(int row = 0; row < moves_array_elements; row++){ //Find the maximum pan speed
if(program_elements[row].panSpeed > currentMax){ // if(program_elements[row].panSpeed > currentMax){
currentMax = program_elements[row].panSpeed; // currentMax = program_elements[row].panSpeed;
} // }
} // }
float speedRatio = newMax / currentMax; // float speedRatio = newMax / currentMax;
for(int row = 0; row < moves_array_elements; row++){ //Scale all the pan speeds // for(int row = 0; row < moves_array_elements; row++){ //Scale all the pan speeds
program_elements[row].panSpeed = program_elements[row].panSpeed * speedRatio; // program_elements[row].panSpeed = program_elements[row].panSpeed * speedRatio;
} // }
} //}
//
/*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ ///*--------------------------------------------------------------------------------------------------------------------------------------------------------*/
//
void scaleMovesArrayTiltMaxSpeed(float newMax){ //void scaleMovesArrayTiltMaxSpeed(float newMax){
float currentMax = 0; // float currentMax = 0;
for(int row = 0; row < moves_array_elements; row++){ //Find the maximum pan speed // for(int row = 0; row < moves_array_elements; row++){ //Find the maximum pan speed
if(program_elements[row].tiltSpeed > currentMax){ // if(program_elements[row].tiltSpeed > currentMax){
currentMax = program_elements[row].tiltSpeed; // currentMax = program_elements[row].tiltSpeed;
} // }
} // }
float speedRatio = newMax / currentMax; // float speedRatio = newMax / currentMax;
for(int row = 0; row < moves_array_elements; row++){ //Scale all the pan speeds // for(int row = 0; row < moves_array_elements; row++){ //Scale all the pan speeds
program_elements[row].tiltSpeed = program_elements[row].tiltSpeed * speedRatio; // program_elements[row].tiltSpeed = program_elements[row].tiltSpeed * speedRatio;
} // }
} //}
//
/*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ ///*--------------------------------------------------------------------------------------------------------------------------------------------------------*/
//
void scaleMovesArraySliderMaxSpeed(float newMax){ //void scaleMovesArraySliderMaxSpeed(float newMax){
float currentMax = 0; // float currentMax = 0;
for(int row = 0; row < moves_array_elements; row++){ //Find the maximum pan speed // for(int row = 0; row < moves_array_elements; row++){ //Find the maximum pan speed
if(program_elements[row].sliderSpeed > currentMax){ // if(program_elements[row].sliderSpeed > currentMax){
currentMax = program_elements[row].sliderSpeed; // currentMax = program_elements[row].sliderSpeed;
} // }
} // }
float speedRatio = newMax / currentMax; // float speedRatio = newMax / currentMax;
for(int row = 0; row < moves_array_elements; row++){ //Scale all the pan speeds // for(int row = 0; row < moves_array_elements; row++){ //Scale all the pan speeds
program_elements[row].sliderSpeed = program_elements[row].sliderSpeed * speedRatio; // program_elements[row].sliderSpeed = program_elements[row].sliderSpeed * speedRatio;
} // }
} //}
/*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------------------------------------------------------------------------------------*/
void invertPanDirection(bool invert){ void invertPanDirection(bool invert){
printi(F("Pan inversion set to: "), invert); printi(F("Pan inversion: "), invert);
invert_pan = invert; invert_pan = invert;
stepper_pan.setPinsInverted(invert, false, false); stepper_pan.setPinsInverted(invert, false, false);
} }
@@ -640,7 +592,7 @@ void invertPanDirection(bool invert){
/*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------------------------------------------------------------------------------------*/
void invertTiltDirection(bool invert){ void invertTiltDirection(bool invert){
printi(F("Tilt inversion set to: "), invert); printi(F("Tilt inversion: "), invert);
invert_tilt = invert; invert_tilt = invert;
stepper_tilt.setPinsInverted(invert, false, false); stepper_tilt.setPinsInverted(invert, false, false);
} }
@@ -648,7 +600,7 @@ void invertTiltDirection(bool invert){
/*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------------------------------------------------------------------------------------*/
void invertSliderDirection(bool invert){ void invertSliderDirection(bool invert){
printi(F("Slider inversion set to: "), invert); printi(F("Slider inversion: "), invert);
invert_slider = invert; invert_slider = invert;
stepper_slider.setPinsInverted(invert, false, false); 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_PAN_MAX_SPEED, pan_max_speed);
EEPROM.put(EEPROM_ADDRESS_TILT_MAX_SPEED, tilt_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_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_PAN_OFFSET, hall_pan_offset_degrees);
EEPROM.put(EEPROM_ADDRESS_HALL_TILT_OFFSET, hall_tilt_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_PAN, invert_pan);
@@ -671,13 +620,6 @@ void saveEEPROM(void){
EEPROM.put(EEPROM_ADDRESS_INVERT_SLIDER, invert_slider); EEPROM.put(EEPROM_ADDRESS_INVERT_SLIDER, invert_slider);
EEPROM.put(EEPROM_ADDRESS_DEGREES_PER_PICTURE, degrees_per_picture); EEPROM.put(EEPROM_ADDRESS_DEGREES_PER_PICTURE, degrees_per_picture);
EEPROM.put(EEPROM_ADDRESS_PANORAMICLAPSE_DELAY, delay_ms_between_pictures); 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; int itemp;
float ftemp; float ftemp;
long ltemp; long ltemp;
printi(F("---Saved Values---\n")); printi(F("---EEPROM---\n"));
EEPROM.get(EEPROM_ADDRESS_MODE, itemp); EEPROM.get(EEPROM_ADDRESS_MODE, itemp);
printi(F("Step mode: "), itemp, F("\n")); printi(F("Step mode: "), itemp, F("\n"));
EEPROM.get(EEPROM_ADDRESS_PAN_MAX_SPEED, ftemp); EEPROM.get(EEPROM_ADDRESS_PAN_MAX_SPEED, ftemp);
@@ -695,12 +637,6 @@ void printEEPROM(void){
printi(F("Tilt max speed: "), ftemp, 3, F("º/s\n")); printi(F("Tilt max speed: "), ftemp, 3, F("º/s\n"));
EEPROM.get(EEPROM_ADDRESS_SLIDER_MAX_SPEED, ftemp); EEPROM.get(EEPROM_ADDRESS_SLIDER_MAX_SPEED, ftemp);
printi(F("Slider max speed: "), ftemp, 3, F("mm/s\n")); 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);
EEPROM.get(EEPROM_ADDRESS_HALL_PAN_OFFSET, ftemp); EEPROM.get(EEPROM_ADDRESS_HALL_PAN_OFFSET, ftemp);
printi(F("Pan Hall offset: "), ftemp, 3, F("º\n")); printi(F("Pan Hall offset: "), ftemp, 3, F("º\n"));
EEPROM.get(EEPROM_ADDRESS_HALL_TILT_OFFSET, ftemp); 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("Tilt invert: "), EEPROM.read(EEPROM_ADDRESS_INVERT_TILT));
printi(F("Slider invert: "), EEPROM.read(EEPROM_ADDRESS_INVERT_SLIDER)); printi(F("Slider invert: "), EEPROM.read(EEPROM_ADDRESS_INVERT_SLIDER));
printi(F("Homing on start-up: "), EEPROM.read(EEPROM_ADDRESS_ENABLE_HOMING)); 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")); printi(F("\n"));
} }
/*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------------------------------------------------------------------------------------*/
void setEEPROMVariables(void){ void setEEPROMVariables(void){
printi(F("Setting values from EEPROM...\n"));
EEPROM.get(EEPROM_ADDRESS_MODE, step_mode); EEPROM.get(EEPROM_ADDRESS_MODE, step_mode);
EEPROM.get(EEPROM_ADDRESS_PAN_MAX_SPEED, pan_max_speed); EEPROM.get(EEPROM_ADDRESS_PAN_MAX_SPEED, pan_max_speed);
EEPROM.get(EEPROM_ADDRESS_TILT_MAX_SPEED, tilt_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_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_PAN_OFFSET, hall_pan_offset_degrees);
EEPROM.get(EEPROM_ADDRESS_HALL_TILT_OFFSET, hall_tilt_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_DEGREES_PER_PICTURE, degrees_per_picture);
EEPROM.get(EEPROM_ADDRESS_PANORAMICLAPSE_DELAY, delay_ms_between_pictures); 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);
invert_pan = EEPROM.read(EEPROM_ADDRESS_INVERT_PAN); invert_pan = EEPROM.read(EEPROM_ADDRESS_INVERT_PAN);
invert_tilt = EEPROM.read(EEPROM_ADDRESS_INVERT_TILT); invert_tilt = EEPROM.read(EEPROM_ADDRESS_INVERT_TILT);
invert_slider = EEPROM.read(EEPROM_ADDRESS_INVERT_SLIDER); invert_slider = EEPROM.read(EEPROM_ADDRESS_INVERT_SLIDER);
enable_homing = EEPROM.read(EEPROM_ADDRESS_ENABLE_HOMING); 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){ void triggerCameraShutter(void){
digitalWrite(PIN_SHUTTER_TRIGGER, HIGH); digitalWrite(PIN_SHUTTER_TRIGGER, HIGH);
delay(SHUTTER_DELAY); delay(SHUTTER_DELAY);
@@ -829,14 +728,14 @@ void panoramiclapseInterpolation(float panStartAngle, float tiltStartAngle, floa
/*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------------------------------------------------------------------------------------*/
void panoramiclapse(float degPerPic, unsigned long msDelay, int repeat){ void panoramiclapse(float degPerPic, unsigned long msDelay, int repeat){
if(moves_array_elements < 2){ if(keyframe_elements < 2){
printi(F("Not enough positions recorded\n")); printi(F("Not enough keyframes recorded\n"));
return; //check there are posions to move to return; //check there are posions to move to
} }
for(int i = 0; i < repeat; i++){ for(int i = 0; i < repeat; i++){
for(int index = 0; index < moves_array_elements - 1; index++){ for(int index = 0; index < keyframe_elements - 1; index++){
panoramiclapseInterpolation(panStepsToDegrees(program_elements[index].panStepCount), tiltStepsToDegrees(program_elements[index].tiltStepCount), sliderStepsToMillimetres(program_elements[index].sliderStepCount), panoramiclapseInterpolation(panStepsToDegrees(keyframe_array[index].panStepCount), tiltStepsToDegrees(keyframe_array[index].tiltStepCount), sliderStepsToMillimetres(keyframe_array[index].sliderStepCount),
panStepsToDegrees(program_elements[index + 1].panStepCount), tiltStepsToDegrees(program_elements[index + 1].tiltStepCount), sliderStepsToMillimetres(program_elements[index + 1].sliderStepCount), degPerPic, msDelay); 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 tiltAngle = 0;
float sliderTravel = 0; float sliderTravel = 0;
if(moves_array_elements >= 2){ if(keyframe_elements >= 2){
panAngle = panStepsToDegrees(program_elements[1].panStepCount) - panStepsToDegrees(program_elements[0].panStepCount); panAngle = panStepsToDegrees(keyframe_array[1].panStepCount) - panStepsToDegrees(keyframe_array[0].panStepCount);
tiltAngle = tiltStepsToDegrees(program_elements[1].tiltStepCount) - tiltStepsToDegrees(program_elements[0].tiltStepCount); tiltAngle = tiltStepsToDegrees(keyframe_array[1].tiltStepCount) - tiltStepsToDegrees(keyframe_array[0].tiltStepCount);
sliderTravel = sliderStepsToMillimetres(program_elements[1].sliderStepCount) - sliderStepsToMillimetres(program_elements[0].sliderStepCount); sliderTravel = sliderStepsToMillimetres(keyframe_array[1].sliderStepCount) - sliderStepsToMillimetres(keyframe_array[0].sliderStepCount);
} }
float sliderInc = sliderTravel / numberOfPictures; 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){ void serialData(void){
char instruction = Serial.read(); char instruction = Serial.read();
if(instruction == INSTRUCTION_BYTES_PAN_TILT_SPEED){ if(instruction == INSTRUCTION_BYTES_SLIDER_PAN_TILT_SPEED){
int count = 0; 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); delayMicroseconds(200);
count++; count++;
if(count > 100){ if(count > 100){
@@ -886,11 +899,14 @@ void serialData(void){
break; break;
} }
} }
int sliderStepSpeed = (Serial.read() << 8) + Serial.read();
int panStepSpeed = (Serial.read() << 8) + Serial.read(); int panStepSpeed = (Serial.read() << 8) + Serial.read();
int tiltStepSpeed = (Serial.read() << 8) + Serial.read(); int tiltStepSpeed = (Serial.read() << 8) + Serial.read();
stepper_slider.setSpeed(sliderStepSpeed);
stepper_pan.setSpeed(panStepSpeed); stepper_pan.setSpeed(panStepSpeed);
stepper_tilt.setSpeed(tiltStepSpeed); stepper_tilt.setSpeed(tiltStepSpeed);
stepper_slider.runSpeed();
stepper_pan.runSpeed(); stepper_pan.runSpeed();
stepper_tilt.runSpeed(); stepper_tilt.runSpeed();
} }
@@ -907,17 +923,10 @@ void serialData(void){
float serialCommandValueFloat = atof(stringText); //converts stringText to a float 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... if(instruction == 'G' && stringText[0] == 0) return;//For the bluetooth issue of it sending data when it connects...
switch(instruction){ switch(instruction){
case INSTRUCTION_SLIDER_MIN_LIMIT:{ case INSTRUCTION_SLIDER_HOME:{
limit_slider_min = serialCommandValueFloat; sliderHoming();
printi(F("Slider min limit set to: "), limit_slider_min, 3, F("mm\n"));
} }
break; 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:{ case INSTRUCTION_SLIDER_MILLIMETRES:{
sliderMoveTo(serialCommandValueFloat); sliderMoveTo(serialCommandValueFloat);
} }
@@ -932,30 +941,6 @@ void serialData(void){
printi(F("Degrees per picture: "), degrees_per_picture, 3, F("º\n")); printi(F("Degrees per picture: "), degrees_per_picture, 3, F("º\n"));
} }
break; 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:{ case INSTRUCTION_PANORAMICLAPSE:{
printi(F("Starting panorama.\n")); printi(F("Starting panorama.\n"));
panoramiclapse(degrees_per_picture, delay_ms_between_pictures, 1); panoramiclapse(degrees_per_picture, delay_ms_between_pictures, 1);
@@ -969,14 +954,14 @@ void serialData(void){
printi(F("Finished\n")); printi(F("Finished\n"));
} }
break; break;
case INSTRUCTION_SCALE_PAN_SPEED:{ // case INSTRUCTION_SCALE_PAN_SPEED:{
scaleMovesArrayPanMaxSpeed(panDegreesToSteps(serialCommandValueFloat)); // scaleMovesArrayPanMaxSpeed(panDegreesToSteps(serialCommandValueFloat));
} // }
break; // break;
case INSTRUCTION_SCALE_TILT_SPEED:{ // case INSTRUCTION_SCALE_TILT_SPEED:{
scaleMovesArrayTiltMaxSpeed(tiltDegreesToSteps(serialCommandValueFloat)); // scaleMovesArrayTiltMaxSpeed(tiltDegreesToSteps(serialCommandValueFloat));
} // }
break; // break;
case INSTRUCTION_TRIGGER_SHUTTER:{ case INSTRUCTION_TRIGGER_SHUTTER:{
triggerCameraShutter(); triggerCameraShutter();
} }
@@ -989,7 +974,8 @@ void serialData(void){
else{ else{
stepper_pan.setCurrentPosition(0); stepper_pan.setCurrentPosition(0);
stepper_tilt.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")); printi(F("Error homing. Current position has been set as home.\n"));
} }
} }
@@ -1000,12 +986,12 @@ void serialData(void){
break; break;
case INSTRUCTION_SET_PAN_HALL_OFFSET:{ case INSTRUCTION_SET_PAN_HALL_OFFSET:{
hall_pan_offset_degrees = serialCommandValueFloat; 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; break;
case INSTRUCTION_SET_TILT_HALL_OFFSET:{ case INSTRUCTION_SET_TILT_HALL_OFFSET:{
hall_tilt_offset_degrees = serialCommandValueFloat; 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; break;
case INSTRUCTION_INVERT_SLIDER:{ case INSTRUCTION_INVERT_SLIDER:{
@@ -1021,9 +1007,8 @@ void serialData(void){
} }
break; break;
case INSTRUCTION_SAVE_TO_EEPROM:{ case INSTRUCTION_SAVE_TO_EEPROM:{
printi(F("Saving values to EEPROM...\n"));
saveEEPROM(); saveEEPROM();
printi(F("Saved.\n")); printi(F("Saved to EEPROM.\n"));
} }
break; break;
case INSTRUCTION_ADD_POSITION:{ case INSTRUCTION_ADD_POSITION:{
@@ -1031,27 +1016,27 @@ void serialData(void){
} }
break; break;
case INSTRUCTION_STEP_FORWARD:{ case INSTRUCTION_STEP_FORWARD:{
moveToIndex(current_moves_array_index + 1); moveToIndex(current_keyframe_index + 1);
printi(F("Moves array index: "), current_moves_array_index, F("\n")); printi(F("Index: "), current_keyframe_index, F("\n"));
} }
break; break;
case INSTRUCTION_STEP_BACKWARD:{ case INSTRUCTION_STEP_BACKWARD:{
moveToIndex(current_moves_array_index - 1); moveToIndex(current_keyframe_index - 1);
printi(F("Moves array index: "), current_moves_array_index, F("\n")); printi(F("Index: "), current_keyframe_index, F("\n"));
} }
break; break;
case INSTRUCTION_JUMP_TO_START:{ case INSTRUCTION_JUMP_TO_START:{
gotoMovesArrayStart(); gotoFirstKeyframe();
printi(F("Moves array index: "), current_moves_array_index, F("\n")); printi(F("Index: "), current_keyframe_index, F("\n"));
} }
break; break;
case INSTRUCTION_JUMP_TO_END:{ case INSTRUCTION_JUMP_TO_END:{
gotoMovesArrayEnd(); gotoLastKeyframe();
printi(F("Moves array index: "), current_moves_array_index, F("\n")); printi(F("Index: "), current_keyframe_index, F("\n"));
} }
break; break;
case INSTRUCTION_EDIT_ARRAY:{ case INSTRUCTION_EDIT_ARRAY:{
editMovesArrayIndex(); editKeyframe();
} }
break; break;
case INSTRUCTION_ADD_DELAY:{ case INSTRUCTION_ADD_DELAY:{
@@ -1059,23 +1044,23 @@ void serialData(void){
} }
break; break;
case INSTRUCTION_CLEAR_ARRAY:{ case INSTRUCTION_CLEAR_ARRAY:{
clearArray(); clearKeyframes();
} }
break; break;
case INSTRUCTION_EXECUTE_MOVES:{ case INSTRUCTION_EXECUTE_MOVES:{
executeMoves(serialCommandValueInt); executeMoves(serialCommandValueInt);
} }
break; break;
case INSTRUCTION_PAN_RUN_SPEED:{ // case INSTRUCTION_PAN_RUN_SPEED:{
stepper_pan.setSpeed(panDegreesToSteps(serialCommandValueFloat)); // stepper_pan.setSpeed(panDegreesToSteps(serialCommandValueFloat));
stepper_pan.runSpeed(); // stepper_pan.runSpeed();
} // }
break; // break;
case INSTRUCTION_TILT_RUN_SPEED:{ // case INSTRUCTION_TILT_RUN_SPEED:{
stepper_tilt.setSpeed(tiltDegreesToSteps(serialCommandValueFloat)); // stepper_tilt.setSpeed(tiltDegreesToSteps(serialCommandValueFloat));
stepper_tilt.runSpeed(); // stepper_tilt.runSpeed();
} // }
break; // break;
case INSTRUCTION_DEBUG_STATUS:{ case INSTRUCTION_DEBUG_STATUS:{
debugReport(); debugReport();
} }
@@ -1089,6 +1074,7 @@ void serialData(void){
} }
break; break;
case INSTRUCTION_SET_HOME:{ case INSTRUCTION_SET_HOME:{
setTargetPositions(0, 0, 0);
stepper_pan.setCurrentPosition(0); stepper_pan.setCurrentPosition(0);
stepper_tilt.setCurrentPosition(0); stepper_tilt.setCurrentPosition(0);
stepper_slider.setCurrentPosition(0); stepper_slider.setCurrentPosition(0);
@@ -1103,23 +1089,32 @@ void serialData(void){
} }
break; break;
case INSTRUCTION_SET_PAN_SPEED:{ 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; pan_max_speed = serialCommandValueFloat;
stepper_pan.setMaxSpeed(panDegreesToSteps(pan_max_speed)); stepper_pan.setMaxSpeed(panDegreesToSteps(pan_max_speed));
} }
break; break;
case INSTRUCTION_SET_TILT_SPEED:{ 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; tilt_max_speed = serialCommandValueFloat;
stepper_tilt.setMaxSpeed(tiltDegreesToSteps(tilt_max_speed)); stepper_tilt.setMaxSpeed(tiltDegreesToSteps(tilt_max_speed));
} }
break; break;
case INSTRUCTION_SET_SLIDER_SPEED:{ 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; slider_max_speed = serialCommandValueFloat;
stepper_slider.setMaxSpeed(sliderMillimetresToSteps(slider_max_speed)); 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;
} }
} }
pan_tilt_mount_nano_code_pcb/panTiltMount.h
+29 -38
View File
@@ -20,7 +20,7 @@
#define PIN_DIRECTION_TILT 5 #define PIN_DIRECTION_TILT 5
#define PIN_STEP_PAN 4 #define PIN_STEP_PAN 4
#define PIN_DIRECTION_PAN 3 #define PIN_DIRECTION_PAN 3
#define PIN_LASER 2 #define PIN_SLIDER_HALL 2
#define FULL_STEP 1 #define FULL_STEP 1
#define HALF_STEP 2 #define HALF_STEP 2
@@ -32,21 +32,19 @@
#define TILT_GEAR_RATIO 3.047619047619047619047619047619 //64/21 teeth #define TILT_GEAR_RATIO 3.047619047619047619047619047619 //64/21 teeth
#define MAX_STRING_LENGTH 10 #define MAX_STRING_LENGTH 10
#define ARRAY_LENGTH 20 #define KEYFRAME_ARRAY_LENGTH 20
#define SHUTTER_DELAY 200 #define SHUTTER_DELAY 200
#define INSTRUCTION_BYTES_PAN_SPEED 1 #define INSTRUCTION_BYTES_PAN_SPEED 1
#define INSTRUCTION_BYTES_TILT_SPEED 2 #define INSTRUCTION_BYTES_TILT_SPEED 2
#define INSTRUCTION_BYTES_PAN_TILT_SPEED 3 #define INSTRUCTION_BYTES_PAN_TILT_SPEED 3
#define INSTRUCTION_BYTES_SLIDER_PAN_TILT_SPEED 4
#define INSTRUCTION_STEP_MODE 'm' #define INSTRUCTION_STEP_MODE 'm'
#define INSTRUCTION_PAN_STEPS 'P'
#define INSTRUCTION_TILT_STEPS 'T'
#define INSTRUCTION_PAN_DEGREES 'p' #define INSTRUCTION_PAN_DEGREES 'p'
#define INSTRUCTION_TILT_DEGREES 't' #define INSTRUCTION_TILT_DEGREES 't'
#define INSTRUCTION_SET_HOME 'h' #define INSTRUCTION_SET_HOME 'h'
#define INSTRUCTION_ENABLE 'e' #define INSTRUCTION_ENABLE 'e'
#define INSTRUCTION_SET_ACCELLERATION 'a'
#define INSTRUCTION_SET_PAN_SPEED 's' #define INSTRUCTION_SET_PAN_SPEED 's'
#define INSTRUCTION_SET_TILT_SPEED 'S' #define INSTRUCTION_SET_TILT_SPEED 'S'
#define INSTRUCTION_INVERT_PAN 'i' #define INSTRUCTION_INVERT_PAN 'i'
@@ -72,29 +70,18 @@
#define INSTRUCTION_SCALE_TILT_SPEED 'N' #define INSTRUCTION_SCALE_TILT_SPEED 'N'
#define INSTRUCTION_SAVE_TO_EEPROM 'U' #define INSTRUCTION_SAVE_TO_EEPROM 'U'
#define INSTRUCTION_PANORAMICLAPSE 'L' #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_ANGLE_BETWEEN_PICTURES 'b'
#define INSTRUCTION_DELAY_BETWEEN_PICTURES 'B' #define INSTRUCTION_DELAY_BETWEEN_PICTURES 'B'
#define INSTRUCTION_TIMELAPSE 'l' #define INSTRUCTION_TIMELAPSE 'l'
#define INSTRUCTION_SLIDER_MILLIMETRES 'x' #define INSTRUCTION_SLIDER_MILLIMETRES 'x'
#define INSTRUCTION_INVERT_SLIDER 'j' #define INSTRUCTION_INVERT_SLIDER 'j'
#define INSTRUCTION_SET_SLIDER_SPEED 'X' #define INSTRUCTION_SET_SLIDER_SPEED 'X'
#define INSTRUCTION_ORIBIT_POINT '@'
#define INSTRUCTION_SLIDER_HOME 'Z'
#define EEPROM_ADDRESS_ENABLE_HOMING 0 #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_PAN_MAX_SPEED 17
#define EEPROM_ADDRESS_TILT_MAX_SPEED 21 #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_PAN_OFFSET 33
#define EEPROM_ADDRESS_HALL_TILT_OFFSET 37 #define EEPROM_ADDRESS_HALL_TILT_OFFSET 37
#define EEPROM_ADDRESS_INVERT_PAN 41 #define EEPROM_ADDRESS_INVERT_PAN 41
@@ -102,27 +89,20 @@
#define EEPROM_ADDRESS_MODE 43 #define EEPROM_ADDRESS_MODE 43
#define EEPROM_ADDRESS_DEGREES_PER_PICTURE 45 #define EEPROM_ADDRESS_DEGREES_PER_PICTURE 45
#define EEPROM_ADDRESS_PANORAMICLAPSE_DELAY 49 #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_MAX_SPEED 70
#define EEPROM_ADDRESS_SLIDER_ACCELERATION 74 #define EEPROM_ADDRESS_SLIDER_ACCELERATION 74
#define EEPROM_ADDRESS_INVERT_SLIDER 78 #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 LED_TYPE WS2812B
#define COLOR_ORDER GRB #define COLOR_ORDER GRB
#define NUM_LEDS 1 #define NUM_LEDS 1
#define BRIGHTNESS 255 #define BRIGHTNESS 255
#define VERSION_NUMBER "3.0.2" #define VERSION_NUMBER "3.2.0"
/*------------------------------------------------------------------------------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------------------------------------------------------------------------------*/
struct ArrayElement { struct KeyframeElement {
long panStepCount = 0; long panStepCount = 0;
float panSpeed = 0; float panSpeed = 0;
long tiltStepCount = 0; long tiltStepCount = 0;
@@ -132,6 +112,19 @@ struct ArrayElement {
int msDelay = 0; int msDelay = 0;
}; };
struct FloatCoordinate {
float x;
float y;
float z;
};
struct LinePoints {
float x0;
float y0;
float x1;
float y1;
};
/*------------------------------------------------------------------------------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------------------------------------------------------------------------------*/
void initPanTilt(void); void initPanTilt(void);
@@ -154,14 +147,14 @@ float panStepsToDegrees(float);
float tiltStepsToDegrees(long); float tiltStepsToDegrees(long);
float tiltStepsToDegrees(float); float tiltStepsToDegrees(float);
int addPosition(void); int addPosition(void);
void clearArray(void); void clearKeyframes(void);
void executeMoves(int); void executeMoves(int);
void moveToIndex(int); void moveToIndex(int);
void gotoMovesArrayStart(void); void gotoFirstKeyframe(void);
void gotoMovesArrayEnd(void); void gotoLastKeyframe(void);
void editMovesArrayIndex(void); void editKeyframe(void);
void addDelay(unsigned int ms); void addDelay(unsigned int ms);
void printProgramElements(void); void printKeyframeElements(void);
void saveEEPROM(void); void saveEEPROM(void);
void printEEPROM(void); void printEEPROM(void);
void setEEPROMVariables(void); void setEEPROMVariables(void);
@@ -171,19 +164,17 @@ int setTargetPositions(float, float);
int setTargetPositions(float, float, float); int setTargetPositions(float, float, float);
void toggleAutoHoming(void); void toggleAutoHoming(void);
void triggerCameraShutter(void); void triggerCameraShutter(void);
void scaleMovesArrayPanMaxSpeed(float newMax);
void scaleMovesArrayTiltMaxSpeed(float newMax);
void ledBatteryLevel(float batteryPercentage); void ledBatteryLevel(float batteryPercentage);
//int setTargetPositionsSteps(long panSteps, long tiltSteps);
void panoramiclapseInterpolation(float, float, float, float, float, float, float, unsigned long); void panoramiclapseInterpolation(float, float, float, float, float, float, float, unsigned long);
void panoramiclapse(float, unsigned long, int); void panoramiclapse(float, unsigned long, int);
void toggleEnableLimits(void); long sliderMillimetresToSteps(float);
float sliderMillimetresToSteps(float);
float sliderStepsToMillimetres(long); float sliderStepsToMillimetres(long);
void sliderMoveTo(float); void sliderMoveTo(float);
void scaleMovesArraySliderMaxSpeed(float);
void invertSliderDirection(bool); void invertSliderDirection(bool);
void timelapse(unsigned int, unsigned long); void timelapse(unsigned int, unsigned long);
bool calculateTargetCoordinate(void);
void interpolateTargetPoint(FloatCoordinate);
bool sliderHoming(void);
/*------------------------------------------------------------------------------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------------------------------------------------------------------------------*/
pan_tilt_mount_nano_code_pcb/pan_tilt_mount_nano_code_pcb.ino
+2 -6
View File
@@ -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, * 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. * 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. * 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. //EEPROM values will need to be set after uploading the code and then a reset is required.
/*----------Future development----------*/ /*----------Future development----------*/
//function to keep focus on a point
//can probably remove most acceleration stuff from EEPROM
//program array in deg //program array in deg
//point to point in x time
//Make an AT+ command set //Make an AT+ command set
//report commands //report commands
//Rename arrays to Keyframes
//Refactor code //Refactor code
/*--------------------------------------------------------------------------------------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------------------------------------------------------------------------------------*/