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