mirror of
https://github.com/isaac879/Pan-Tilt-Mount.git
synced 2026-08-16 13:03:15 +02:00
Add files via upload
This commit is contained in:
isaac879
@@ -16,10 +16,10 @@ AccelStepper stepper_slider = AccelStepper(1, PIN_STEP_SLIDER, PIN_DIRECTION_SLI
|
||||
|
||||
MultiStepper multi_stepper;
|
||||
|
||||
ArrayElement program_elements[ARRAY_LENGTH];
|
||||
KeyframeElement keyframe_array[KEYFRAME_ARRAY_LENGTH];
|
||||
|
||||
int moves_array_elements = 0;
|
||||
int current_moves_array_index = -1;
|
||||
int keyframe_elements = 0;
|
||||
int current_keyframe_index = -1;
|
||||
char stringText[MAX_STRING_LENGTH + 1];
|
||||
float pan_steps_per_degree = (200.0 * SIXTEENTH_STEP * PAN_GEAR_RATIO) / 360.0; //Stepper motor has 200 steps per 360 degrees
|
||||
float tilt_steps_per_degree = (200.0 * SIXTEENTH_STEP * TILT_GEAR_RATIO) / 360.0; //Stepper motor has 200 steps per 360 degrees
|
||||
@@ -27,28 +27,19 @@ float slider_steps_per_millimetre = (200.0 * SIXTEENTH_STEP) / (20 * 2); //Stepp
|
||||
|
||||
int step_mode = SIXTEENTH_STEP;
|
||||
bool enable_state = true;
|
||||
float limit_pan_min = 0;
|
||||
float limit_pan_max = 0;
|
||||
float limit_tilt_min = 0;
|
||||
float limit_tilt_max = 0;
|
||||
float limit_slider_min = 0;
|
||||
float limit_slider_max = 0;
|
||||
byte enable_limits = 0;
|
||||
float pan_acceleration = 5000;
|
||||
float tilt_acceleration = 5000;
|
||||
float slider_acceleration = 5000;
|
||||
float hall_pan_offset_degrees = 0;
|
||||
float hall_tilt_offset_degrees = 0;
|
||||
byte invert_pan = 0;
|
||||
byte invert_tilt = 0;
|
||||
byte invert_slider = 0;
|
||||
byte enable_homing = 0;
|
||||
float pan_max_speed = 20; //degrees/second
|
||||
float tilt_max_speed = 50; //degrees/second
|
||||
float slider_max_speed = 10; //mm/second
|
||||
float pan_max_speed = 15; //degrees/second
|
||||
float tilt_max_speed = 45; //degrees/second
|
||||
float slider_max_speed = 15; //mm/second
|
||||
long target_position[3];
|
||||
float degrees_per_picture = 0.5;
|
||||
unsigned long delay_ms_between_pictures = 1000;
|
||||
FloatCoordinate intercept;
|
||||
|
||||
/*--------------------------------------------------------------------------------------------------------------------------------------------------------*/
|
||||
|
||||
@@ -66,22 +57,17 @@ void initPanTilt(void){
|
||||
pinMode(PIN_STEP_SLIDER, OUTPUT);
|
||||
pinMode(PIN_PAN_HALL, INPUT_PULLUP);
|
||||
pinMode(PIN_TILT_HALL, INPUT_PULLUP);
|
||||
pinMode(PIN_SLIDER_HALL, INPUT_PULLUP);
|
||||
pinMode(PIN_SHUTTER_TRIGGER, OUTPUT);
|
||||
digitalWrite(PIN_SHUTTER_TRIGGER, LOW);
|
||||
FastLED.addLeds<LED_TYPE, PIN_LED_DATA, COLOR_ORDER>(leds, NUM_LEDS);
|
||||
FastLED.setBrightness(BRIGHTNESS);
|
||||
LEDS.showColor(CHSV(160, 255, 255)); //Set led to blue
|
||||
setEEPROMVariables();
|
||||
// stepper_pan.setMinPulseWidth(20);
|
||||
// stepper_tilt.setMinPulseWidth(20);
|
||||
// stepper_slider.setMinPulseWidth(20);
|
||||
setStepMode(step_mode); //steping mode
|
||||
stepper_pan.setMaxSpeed(panDegreesToSteps(pan_max_speed));
|
||||
// stepper_pan.setAcceleration(pan_acceleration);
|
||||
stepper_tilt.setMaxSpeed(tiltDegreesToSteps(tilt_max_speed));
|
||||
// stepper_tilt.setAcceleration(tilt_acceleration);
|
||||
stepper_slider.setMaxSpeed(sliderMillimetresToSteps(slider_max_speed));
|
||||
// stepper_slider.setAcceleration(slider_acceleration);
|
||||
invertPanDirection(invert_pan);
|
||||
invertTiltDirection(invert_tilt);
|
||||
invertSliderDirection(invert_slider);
|
||||
@@ -90,38 +76,16 @@ void initPanTilt(void){
|
||||
multi_stepper.addStepper(stepper_slider);
|
||||
digitalWrite(PIN_ENABLE, LOW); //Enable the stepper drivers
|
||||
enable_state = true;
|
||||
printi(F("Motors enabled.\n"));
|
||||
LEDS.showColor(CHSV(96 , 255, 255));
|
||||
printi(F("Setup complete.\n"));
|
||||
//printi(F("Setup complete.\n"));
|
||||
if(enable_homing == 1){
|
||||
printi(F("Beginning homing...\n"));
|
||||
if(findHome()){
|
||||
printi(F("Homing complete.\n"));
|
||||
LEDS.showColor(CHSV(0 , 0, 255)); //White
|
||||
delay(200);
|
||||
LEDS.showColor(CHSV(0 , 0, 0)); //off
|
||||
delay(200);
|
||||
LEDS.showColor(CHSV(0 , 0, 255)); //White
|
||||
delay(200);
|
||||
LEDS.showColor(CHSV(0 , 0, 0)); //off
|
||||
delay(200);
|
||||
LEDS.showColor(CHSV(0 , 0, 255)); //White
|
||||
delay(200);
|
||||
}
|
||||
else{
|
||||
stepper_pan.setCurrentPosition(0);
|
||||
stepper_tilt.setCurrentPosition(0);
|
||||
printi(F("Error finding home position... Current position has been set as home.\n"));
|
||||
LEDS.showColor(CHSV(240 , 255, 255)); //pink
|
||||
delay(200);
|
||||
LEDS.showColor(CHSV(0 , 0, 0)); //off
|
||||
delay(200);
|
||||
LEDS.showColor(CHSV(240 , 255, 255)); //pink
|
||||
delay(200);
|
||||
LEDS.showColor(CHSV(0 , 0, 0)); //off
|
||||
delay(200);
|
||||
LEDS.showColor(CHSV(240 , 255, 255)); //pink
|
||||
delay(200);
|
||||
printi(F("Error finding home position. Current position has been set as home.\n"));
|
||||
}
|
||||
}
|
||||
ledBatteryLevel(getBatteryPercentage());
|
||||
@@ -238,8 +202,8 @@ float tiltDegreesToSteps(float angle){
|
||||
|
||||
/*--------------------------------------------------------------------------------------------------------------------------------------------------------*/
|
||||
|
||||
float sliderMillimetresToSteps(float mm){
|
||||
return mm * slider_steps_per_millimetre ;
|
||||
long sliderMillimetresToSteps(float mm){
|
||||
return mm * slider_steps_per_millimetre;
|
||||
}
|
||||
|
||||
/*--------------------------------------------------------------------------------------------------------------------------------------------------------*/
|
||||
@@ -257,18 +221,18 @@ void sliderMoveTo(float mm){
|
||||
|
||||
/*--------------------------------------------------------------------------------------------------------------------------------------------------------*/
|
||||
|
||||
void printProgramElements(void){
|
||||
printi(F("---Program Elements---\n"));
|
||||
printi(F("Moves array index: "), current_moves_array_index, F("\n"));
|
||||
for(int row = 0; row < moves_array_elements; row++){
|
||||
void printKeyframeElements(void){
|
||||
printi(F("---Keyframes---\n"));
|
||||
printi(F("Keyframe index: "), current_keyframe_index, F("\n"));
|
||||
for(int row = 0; row < keyframe_elements; row++){
|
||||
printi(F(""), row, F("\t|"));
|
||||
printi(F(" Pan: "), panStepsToDegrees(program_elements[row].panStepCount), 3, F("º\t"));
|
||||
printi(F("Tilt: "), tiltStepsToDegrees(program_elements[row].tiltStepCount), 3, F("º\t"));
|
||||
printi(F("Slider: "), sliderStepsToMillimetres(program_elements[row].sliderStepCount), 3, F("mm\t"));
|
||||
printi(F("Pan Speed: "), panStepsToDegrees(program_elements[row].panSpeed), 3, F(" º/s\t"));
|
||||
printi(F("Tilt Speed: "), tiltStepsToDegrees(program_elements[row].tiltSpeed), 3, F(" º/s\t"));
|
||||
printi(F("Slider Speed: "), sliderStepsToMillimetres(program_elements[row].sliderSpeed), 3, F(" mm/s\t"));
|
||||
printi(F("Delay: "), program_elements[row].msDelay, F("ms |\n"));
|
||||
printi(F(" Pan: "), panStepsToDegrees(keyframe_array[row].panStepCount), 3, F("º\t"));
|
||||
printi(F("Tilt: "), tiltStepsToDegrees(keyframe_array[row].tiltStepCount), 3, F("º\t"));
|
||||
printi(F("Slider: "), sliderStepsToMillimetres(keyframe_array[row].sliderStepCount), 3, F("mm\t"));
|
||||
printi(F("Pan Speed: "), panStepsToDegrees(keyframe_array[row].panSpeed), 3, F(" º/s\t"));
|
||||
printi(F("Tilt Speed: "), tiltStepsToDegrees(keyframe_array[row].tiltSpeed), 3, F(" º/s\t"));
|
||||
printi(F("Slider Speed: "), sliderStepsToMillimetres(keyframe_array[row].sliderSpeed), 3, F(" mm/s\t"));
|
||||
printi(F("Delay: "), keyframe_array[row].msDelay, F("ms |\n"));
|
||||
}
|
||||
printi(F("\n"));
|
||||
}
|
||||
@@ -276,8 +240,8 @@ void printProgramElements(void){
|
||||
/*--------------------------------------------------------------------------------------------------------------------------------------------------------*/
|
||||
|
||||
void debugReport(void){
|
||||
printi(F("---Debug Report---\n"));
|
||||
printi(F("Motor enable state: "), enable_state);
|
||||
printi(F("---Status---\n"));
|
||||
printi(F("Enable state: "), enable_state);
|
||||
printi(F("Step Mode: "), step_mode);
|
||||
// printi(F("Pan Hall sensor state: "), digitalRead(PIN_PAN_HALL));
|
||||
// printi(F("Tilt Hall sensor state: "), digitalRead(PIN_TILT_HALL));
|
||||
@@ -287,9 +251,9 @@ void debugReport(void){
|
||||
printi(F("Pan angle: "), panStepsToDegrees(stepper_pan.currentPosition()), 3, F("º\n"));
|
||||
printi(F("Tilt angle: "), tiltStepsToDegrees(stepper_tilt.currentPosition()), 3, F("º\n"));
|
||||
printi(F("Slider position: "), sliderStepsToMillimetres(stepper_slider.currentPosition()), 3, F("mm\n"));
|
||||
printi(F("Pan steps per º: "), pan_steps_per_degree);
|
||||
printi(F("Tilt steps per º: "), tilt_steps_per_degree);
|
||||
printi(F("Slider steps per mm: "), slider_steps_per_millimetre);
|
||||
// printi(F("Pan steps per º: "), pan_steps_per_degree);
|
||||
// printi(F("Tilt steps per º: "), tilt_steps_per_degree);
|
||||
// printi(F("Slider steps per mm: "), slider_steps_per_millimetre);
|
||||
// printi(F("Pan current steps/s: "), stepper_pan.speed());
|
||||
// printi(F("Tilt current steps/s: "), stepper_tilt.speed());
|
||||
// printi(F("Slider current steps/s: "), stepper_slider.speed());
|
||||
@@ -320,7 +284,7 @@ void debugReport(void){
|
||||
// printi(F("Slider invert direction: "), invert_slider);
|
||||
// printi(F("Pan Hall offset: "), hall_pan_offset_degrees, 3, F("º\n"));
|
||||
// printi(F("Tilt Hall offset: "), hall_tilt_offset_degrees, 3, F("º\n"));
|
||||
printi(F("Battery voltage: "), getBatteryVoltage(), 3, F("V\n"));
|
||||
// printi(F("Battery voltage: "), getBatteryVoltage(), 3, F("V\n"));
|
||||
printi(F("Battery percentage: "), getBatteryPercentage(), 3, F("%\n"));
|
||||
printi(F("Homing on start-up: "), enable_homing);
|
||||
printi(F("Angle between pictures: "), degrees_per_picture, 3, F("º\n"));
|
||||
@@ -329,16 +293,13 @@ void debugReport(void){
|
||||
printi(F(VERSION_NUMBER));
|
||||
printi(F("\n"));
|
||||
printEEPROM();
|
||||
printProgramElements();
|
||||
printi(F("-----------\n"));
|
||||
printKeyframeElements();
|
||||
printi(F("-------\n"));
|
||||
}
|
||||
|
||||
/*--------------------------------------------------------------------------------------------------------------------------------------------------------*/
|
||||
|
||||
int setTargetPositions(float panDeg, float tiltDeg){
|
||||
if(enable_limits == 1 && !((panDeg >= limit_pan_min && panDeg <= limit_pan_max) && (tiltDeg >= limit_tilt_min && tiltDeg <= limit_tilt_max))){
|
||||
return -1;
|
||||
}
|
||||
target_position[0] = panDegreesToSteps(panDeg);
|
||||
target_position[1] = tiltDegreesToSteps(tiltDeg);
|
||||
multi_stepper.moveTo(target_position);
|
||||
@@ -347,10 +308,6 @@ int setTargetPositions(float panDeg, float tiltDeg){
|
||||
/*--------------------------------------------------------------------------------------------------------------------------------------------------------*/
|
||||
|
||||
int setTargetPositions(float panDeg, float tiltDeg, float sliderMillimetre){
|
||||
if(enable_limits == 1 && !((panDeg >= limit_pan_min && panDeg <= limit_pan_max) && (tiltDeg >= limit_tilt_min && tiltDeg <= limit_tilt_max)
|
||||
&& (sliderMillimetre >= limit_slider_min && sliderMillimetre <= limit_slider_max))){
|
||||
return -1;
|
||||
}
|
||||
target_position[0] = panDegreesToSteps(panDeg);
|
||||
target_position[1] = tiltDegreesToSteps(tiltDeg);
|
||||
target_position[2] = sliderMillimetresToSteps(sliderMillimetre);
|
||||
@@ -360,10 +317,6 @@ int setTargetPositions(float panDeg, float tiltDeg, float sliderMillimetre){
|
||||
/*--------------------------------------------------------------------------------------------------------------------------------------------------------*/
|
||||
|
||||
bool findHome(void){
|
||||
if(enable_limits == 1){
|
||||
printi(F("Homing not available with limits enabled\n"));
|
||||
return false;
|
||||
}
|
||||
bool panHomeFlag = false;
|
||||
bool tiltHomeFlag = false;
|
||||
int panHomingDir = -1;
|
||||
@@ -373,7 +326,6 @@ bool findHome(void){
|
||||
stepper_pan.setCurrentPosition(0);//set step count to 0
|
||||
stepper_tilt.setCurrentPosition(0);//set step count to 0
|
||||
|
||||
|
||||
while(digitalRead(PIN_PAN_HALL) == 0 || digitalRead(PIN_TILT_HALL) == 0){//If already on a Hall sensor move off
|
||||
target_position[0] = target_position[0] + panDegreesToSteps(!digitalRead(PIN_PAN_HALL));//increment by 1 degree
|
||||
target_position[1] = target_position[1] + tiltDegreesToSteps(!digitalRead(PIN_TILT_HALL));//increment by 1 degree
|
||||
@@ -481,55 +433,55 @@ float tiltStepsToDegrees(float steps){
|
||||
/*--------------------------------------------------------------------------------------------------------------------------------------------------------*/
|
||||
|
||||
int addPosition(void){
|
||||
if(moves_array_elements >= 0 && moves_array_elements < ARRAY_LENGTH){
|
||||
program_elements[moves_array_elements].panStepCount = stepper_pan.currentPosition();
|
||||
program_elements[moves_array_elements].tiltStepCount = stepper_tilt.currentPosition();
|
||||
program_elements[moves_array_elements].sliderStepCount = stepper_slider.currentPosition();
|
||||
program_elements[moves_array_elements].panSpeed = stepper_pan.maxSpeed();
|
||||
program_elements[moves_array_elements].tiltSpeed = stepper_tilt.maxSpeed();
|
||||
program_elements[moves_array_elements].sliderSpeed = stepper_slider.maxSpeed();
|
||||
current_moves_array_index = moves_array_elements;
|
||||
moves_array_elements++;//increment the index
|
||||
printi(F("Position added at index: "), current_moves_array_index);
|
||||
if(keyframe_elements >= 0 && keyframe_elements < KEYFRAME_ARRAY_LENGTH){
|
||||
keyframe_array[keyframe_elements].panStepCount = stepper_pan.currentPosition();
|
||||
keyframe_array[keyframe_elements].tiltStepCount = stepper_tilt.currentPosition();
|
||||
keyframe_array[keyframe_elements].sliderStepCount = stepper_slider.currentPosition();
|
||||
keyframe_array[keyframe_elements].panSpeed = stepper_pan.maxSpeed();
|
||||
keyframe_array[keyframe_elements].tiltSpeed = stepper_tilt.maxSpeed();
|
||||
keyframe_array[keyframe_elements].sliderSpeed = stepper_slider.maxSpeed();
|
||||
current_keyframe_index = keyframe_elements;
|
||||
keyframe_elements++;//increment the index
|
||||
printi(F("Position added at index: "), current_keyframe_index);
|
||||
return 0;
|
||||
}
|
||||
else{
|
||||
printi(F("Maximum number of position reached\n"));
|
||||
printi(F("Max number of position reached\n"));
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
/*--------------------------------------------------------------------------------------------------------------------------------------------------------*/
|
||||
|
||||
void clearArray(void){
|
||||
for(int row = 0; row < ARRAY_LENGTH; row++){
|
||||
program_elements[row].panStepCount = 0;
|
||||
program_elements[row].tiltStepCount = 0;
|
||||
program_elements[row].sliderStepCount = 0;
|
||||
program_elements[row].panSpeed = 0;
|
||||
program_elements[row].tiltSpeed = 0;
|
||||
program_elements[row].sliderSpeed = 0;
|
||||
program_elements[row].msDelay = 0;
|
||||
void clearKeyframes(void){
|
||||
for(int row = 0; row < KEYFRAME_ARRAY_LENGTH; row++){
|
||||
keyframe_array[row].panStepCount = 0;
|
||||
keyframe_array[row].tiltStepCount = 0;
|
||||
keyframe_array[row].sliderStepCount = 0;
|
||||
keyframe_array[row].panSpeed = 0;
|
||||
keyframe_array[row].tiltSpeed = 0;
|
||||
keyframe_array[row].sliderSpeed = 0;
|
||||
keyframe_array[row].msDelay = 0;
|
||||
}
|
||||
moves_array_elements = 0;
|
||||
current_moves_array_index = -1;
|
||||
printi(F("All positions cleared."));
|
||||
keyframe_elements = 0;
|
||||
current_keyframe_index = -1;
|
||||
printi(F("Keyframes cleared.\n"));
|
||||
}
|
||||
|
||||
/*--------------------------------------------------------------------------------------------------------------------------------------------------------*/
|
||||
|
||||
void moveToIndex(int index){
|
||||
if(index < moves_array_elements && index >= 0){
|
||||
target_position[0] = program_elements[index].panStepCount;
|
||||
target_position[1] = program_elements[index].tiltStepCount;
|
||||
target_position[2] = program_elements[index].sliderStepCount;
|
||||
stepper_pan.setMaxSpeed(program_elements[index].panSpeed);
|
||||
stepper_tilt.setMaxSpeed(program_elements[index].tiltSpeed);
|
||||
stepper_slider.setMaxSpeed(program_elements[index].sliderSpeed);
|
||||
if(index < keyframe_elements && index >= 0){
|
||||
target_position[0] = keyframe_array[index].panStepCount;
|
||||
target_position[1] = keyframe_array[index].tiltStepCount;
|
||||
target_position[2] = keyframe_array[index].sliderStepCount;
|
||||
stepper_pan.setMaxSpeed(keyframe_array[index].panSpeed);
|
||||
stepper_tilt.setMaxSpeed(keyframe_array[index].tiltSpeed);
|
||||
stepper_slider.setMaxSpeed(keyframe_array[index].sliderSpeed);
|
||||
multi_stepper.moveTo(target_position); //Sets new target positions
|
||||
multi_stepper.runSpeedToPosition(); //Moves and blocks until complete
|
||||
delay(program_elements[index].msDelay);
|
||||
current_moves_array_index = index;
|
||||
delay(keyframe_array[index].msDelay);
|
||||
current_keyframe_index = index;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -537,7 +489,7 @@ void moveToIndex(int index){
|
||||
|
||||
void executeMoves(int repeat){
|
||||
for(int i = 0; i < repeat; i++){
|
||||
for(int row = 0; row < moves_array_elements; row++){
|
||||
for(int row = 0; row < keyframe_elements; row++){
|
||||
moveToIndex(row);
|
||||
}
|
||||
ledBatteryLevel(getBatteryPercentage());
|
||||
@@ -553,86 +505,86 @@ void executeMoves(int repeat){
|
||||
|
||||
/*--------------------------------------------------------------------------------------------------------------------------------------------------------*/
|
||||
|
||||
void gotoMovesArrayStart(void){
|
||||
void gotoFirstKeyframe(void){
|
||||
moveToIndex(0);
|
||||
}
|
||||
|
||||
/*--------------------------------------------------------------------------------------------------------------------------------------------------------*/
|
||||
|
||||
void gotoMovesArrayEnd(void){
|
||||
moveToIndex(moves_array_elements - 1);
|
||||
void gotoLastKeyframe(void){
|
||||
moveToIndex(keyframe_elements - 1);
|
||||
}
|
||||
|
||||
/*--------------------------------------------------------------------------------------------------------------------------------------------------------*/
|
||||
|
||||
void editMovesArrayIndex(void){
|
||||
program_elements[current_moves_array_index].panStepCount = stepper_pan.currentPosition();
|
||||
program_elements[current_moves_array_index].tiltStepCount = stepper_tilt.currentPosition();
|
||||
program_elements[current_moves_array_index].sliderStepCount = stepper_slider.currentPosition();
|
||||
program_elements[current_moves_array_index].panSpeed = stepper_pan.maxSpeed();
|
||||
program_elements[current_moves_array_index].tiltSpeed = stepper_tilt.maxSpeed();
|
||||
program_elements[current_moves_array_index].sliderSpeed = stepper_slider.maxSpeed();
|
||||
void editKeyframe(void){
|
||||
keyframe_array[current_keyframe_index].panStepCount = stepper_pan.currentPosition();
|
||||
keyframe_array[current_keyframe_index].tiltStepCount = stepper_tilt.currentPosition();
|
||||
keyframe_array[current_keyframe_index].sliderStepCount = stepper_slider.currentPosition();
|
||||
keyframe_array[current_keyframe_index].panSpeed = stepper_pan.maxSpeed();
|
||||
keyframe_array[current_keyframe_index].tiltSpeed = stepper_tilt.maxSpeed();
|
||||
keyframe_array[current_keyframe_index].sliderSpeed = stepper_slider.maxSpeed();
|
||||
|
||||
printi(F("Edited at index: "), current_moves_array_index);
|
||||
printi(F("Edited index: "), current_keyframe_index);
|
||||
}
|
||||
|
||||
/*--------------------------------------------------------------------------------------------------------------------------------------------------------*/
|
||||
|
||||
void addDelay(unsigned int ms){
|
||||
program_elements[current_moves_array_index].msDelay = ms;
|
||||
keyframe_array[current_keyframe_index].msDelay = ms;
|
||||
printi(ms, F(""));
|
||||
printi(F("ms delay added at index: "), current_moves_array_index);
|
||||
printi(F("ms delay added at index: "), current_keyframe_index);
|
||||
}
|
||||
|
||||
/*--------------------------------------------------------------------------------------------------------------------------------------------------------*/
|
||||
|
||||
void scaleMovesArrayPanMaxSpeed(float newMax){
|
||||
float currentMax = 0;
|
||||
for(int row = 0; row < moves_array_elements; row++){ //Find the maximum pan speed
|
||||
if(program_elements[row].panSpeed > currentMax){
|
||||
currentMax = program_elements[row].panSpeed;
|
||||
}
|
||||
}
|
||||
float speedRatio = newMax / currentMax;
|
||||
for(int row = 0; row < moves_array_elements; row++){ //Scale all the pan speeds
|
||||
program_elements[row].panSpeed = program_elements[row].panSpeed * speedRatio;
|
||||
}
|
||||
}
|
||||
|
||||
/*--------------------------------------------------------------------------------------------------------------------------------------------------------*/
|
||||
|
||||
void scaleMovesArrayTiltMaxSpeed(float newMax){
|
||||
float currentMax = 0;
|
||||
for(int row = 0; row < moves_array_elements; row++){ //Find the maximum pan speed
|
||||
if(program_elements[row].tiltSpeed > currentMax){
|
||||
currentMax = program_elements[row].tiltSpeed;
|
||||
}
|
||||
}
|
||||
float speedRatio = newMax / currentMax;
|
||||
for(int row = 0; row < moves_array_elements; row++){ //Scale all the pan speeds
|
||||
program_elements[row].tiltSpeed = program_elements[row].tiltSpeed * speedRatio;
|
||||
}
|
||||
}
|
||||
|
||||
/*--------------------------------------------------------------------------------------------------------------------------------------------------------*/
|
||||
|
||||
void scaleMovesArraySliderMaxSpeed(float newMax){
|
||||
float currentMax = 0;
|
||||
for(int row = 0; row < moves_array_elements; row++){ //Find the maximum pan speed
|
||||
if(program_elements[row].sliderSpeed > currentMax){
|
||||
currentMax = program_elements[row].sliderSpeed;
|
||||
}
|
||||
}
|
||||
float speedRatio = newMax / currentMax;
|
||||
for(int row = 0; row < moves_array_elements; row++){ //Scale all the pan speeds
|
||||
program_elements[row].sliderSpeed = program_elements[row].sliderSpeed * speedRatio;
|
||||
}
|
||||
}
|
||||
//void scaleMovesArrayPanMaxSpeed(float newMax){
|
||||
// float currentMax = 0;
|
||||
// for(int row = 0; row < moves_array_elements; row++){ //Find the maximum pan speed
|
||||
// if(program_elements[row].panSpeed > currentMax){
|
||||
// currentMax = program_elements[row].panSpeed;
|
||||
// }
|
||||
// }
|
||||
// float speedRatio = newMax / currentMax;
|
||||
// for(int row = 0; row < moves_array_elements; row++){ //Scale all the pan speeds
|
||||
// program_elements[row].panSpeed = program_elements[row].panSpeed * speedRatio;
|
||||
// }
|
||||
//}
|
||||
//
|
||||
///*--------------------------------------------------------------------------------------------------------------------------------------------------------*/
|
||||
//
|
||||
//void scaleMovesArrayTiltMaxSpeed(float newMax){
|
||||
// float currentMax = 0;
|
||||
// for(int row = 0; row < moves_array_elements; row++){ //Find the maximum pan speed
|
||||
// if(program_elements[row].tiltSpeed > currentMax){
|
||||
// currentMax = program_elements[row].tiltSpeed;
|
||||
// }
|
||||
// }
|
||||
// float speedRatio = newMax / currentMax;
|
||||
// for(int row = 0; row < moves_array_elements; row++){ //Scale all the pan speeds
|
||||
// program_elements[row].tiltSpeed = program_elements[row].tiltSpeed * speedRatio;
|
||||
// }
|
||||
//}
|
||||
//
|
||||
///*--------------------------------------------------------------------------------------------------------------------------------------------------------*/
|
||||
//
|
||||
//void scaleMovesArraySliderMaxSpeed(float newMax){
|
||||
// float currentMax = 0;
|
||||
// for(int row = 0; row < moves_array_elements; row++){ //Find the maximum pan speed
|
||||
// if(program_elements[row].sliderSpeed > currentMax){
|
||||
// currentMax = program_elements[row].sliderSpeed;
|
||||
// }
|
||||
// }
|
||||
// float speedRatio = newMax / currentMax;
|
||||
// for(int row = 0; row < moves_array_elements; row++){ //Scale all the pan speeds
|
||||
// program_elements[row].sliderSpeed = program_elements[row].sliderSpeed * speedRatio;
|
||||
// }
|
||||
//}
|
||||
|
||||
/*--------------------------------------------------------------------------------------------------------------------------------------------------------*/
|
||||
|
||||
void invertPanDirection(bool invert){
|
||||
printi(F("Pan inversion set to: "), invert);
|
||||
printi(F("Pan inversion: "), invert);
|
||||
invert_pan = invert;
|
||||
stepper_pan.setPinsInverted(invert, false, false);
|
||||
}
|
||||
@@ -640,7 +592,7 @@ void invertPanDirection(bool invert){
|
||||
/*--------------------------------------------------------------------------------------------------------------------------------------------------------*/
|
||||
|
||||
void invertTiltDirection(bool invert){
|
||||
printi(F("Tilt inversion set to: "), invert);
|
||||
printi(F("Tilt inversion: "), invert);
|
||||
invert_tilt = invert;
|
||||
stepper_tilt.setPinsInverted(invert, false, false);
|
||||
}
|
||||
@@ -648,7 +600,7 @@ void invertTiltDirection(bool invert){
|
||||
/*--------------------------------------------------------------------------------------------------------------------------------------------------------*/
|
||||
|
||||
void invertSliderDirection(bool invert){
|
||||
printi(F("Slider inversion set to: "), invert);
|
||||
printi(F("Slider inversion: "), invert);
|
||||
invert_slider = invert;
|
||||
stepper_slider.setPinsInverted(invert, false, false);
|
||||
}
|
||||
@@ -661,9 +613,6 @@ void saveEEPROM(void){
|
||||
EEPROM.put(EEPROM_ADDRESS_PAN_MAX_SPEED, pan_max_speed);
|
||||
EEPROM.put(EEPROM_ADDRESS_TILT_MAX_SPEED, tilt_max_speed);
|
||||
EEPROM.put(EEPROM_ADDRESS_SLIDER_MAX_SPEED, slider_max_speed);
|
||||
EEPROM.put(EEPROM_ADDRESS_PAN_ACCELERATION, pan_acceleration);
|
||||
EEPROM.put(EEPROM_ADDRESS_TILT_ACCELERATION, tilt_acceleration);
|
||||
EEPROM.put(EEPROM_ADDRESS_SLIDER_ACCELERATION, slider_acceleration);
|
||||
EEPROM.put(EEPROM_ADDRESS_HALL_PAN_OFFSET, hall_pan_offset_degrees);
|
||||
EEPROM.put(EEPROM_ADDRESS_HALL_TILT_OFFSET, hall_tilt_offset_degrees);
|
||||
EEPROM.put(EEPROM_ADDRESS_INVERT_PAN, invert_pan);
|
||||
@@ -671,13 +620,6 @@ void saveEEPROM(void){
|
||||
EEPROM.put(EEPROM_ADDRESS_INVERT_SLIDER, invert_slider);
|
||||
EEPROM.put(EEPROM_ADDRESS_DEGREES_PER_PICTURE, degrees_per_picture);
|
||||
EEPROM.put(EEPROM_ADDRESS_PANORAMICLAPSE_DELAY, delay_ms_between_pictures);
|
||||
EEPROM.put(EEPROM_ADDRESS_ENABLE_LIMITS, enable_limits);
|
||||
EEPROM.put(EEPROM_ADDRESS_PAN_MIN_LIMIT, limit_pan_min);
|
||||
EEPROM.put(EEPROM_ADDRESS_PAN_MAX_LIMIT, limit_pan_max);
|
||||
EEPROM.put(EEPROM_ADDRESS_TILT_MIN_LIMIT, limit_tilt_min);
|
||||
EEPROM.put(EEPROM_ADDRESS_TILT_MAX_LIMIT, limit_tilt_max);
|
||||
EEPROM.put(EEPROM_ADDRESS_SLIDER_MIN_LIMIT, limit_slider_min);
|
||||
EEPROM.put(EEPROM_ADDRESS_SLIDER_MAX_LIMIT, limit_slider_max);
|
||||
}
|
||||
|
||||
/*--------------------------------------------------------------------------------------------------------------------------------------------------------*/
|
||||
@@ -686,7 +628,7 @@ void printEEPROM(void){
|
||||
int itemp;
|
||||
float ftemp;
|
||||
long ltemp;
|
||||
printi(F("---Saved Values---\n"));
|
||||
printi(F("---EEPROM---\n"));
|
||||
EEPROM.get(EEPROM_ADDRESS_MODE, itemp);
|
||||
printi(F("Step mode: "), itemp, F("\n"));
|
||||
EEPROM.get(EEPROM_ADDRESS_PAN_MAX_SPEED, ftemp);
|
||||
@@ -694,13 +636,7 @@ void printEEPROM(void){
|
||||
EEPROM.get(EEPROM_ADDRESS_TILT_MAX_SPEED, ftemp);
|
||||
printi(F("Tilt max speed: "), ftemp, 3, F("º/s\n"));
|
||||
EEPROM.get(EEPROM_ADDRESS_SLIDER_MAX_SPEED, ftemp);
|
||||
printi(F("Slider max speed: "), ftemp, 3, F("mm/s\n"));
|
||||
// EEPROM.get(EEPROM_ADDRESS_PAN_ACCELERATION, ftemp);
|
||||
// printi(F("Pan max acceleration: "), ftemp);
|
||||
// EEPROM.get(EEPROM_ADDRESS_TILT_ACCELERATION, ftemp);
|
||||
// printi(F("Tilt max acceleration: "), ftemp);
|
||||
// EEPROM.get(EEPROM_ADDRESS_SLIDER_ACCELERATION, ftemp);
|
||||
// printi(F("Slider max acceleration: "), ftemp);
|
||||
printi(F("Slider max speed: "), ftemp, 3, F("mm/s\n"));
|
||||
EEPROM.get(EEPROM_ADDRESS_HALL_PAN_OFFSET, ftemp);
|
||||
printi(F("Pan Hall offset: "), ftemp, 3, F("º\n"));
|
||||
EEPROM.get(EEPROM_ADDRESS_HALL_TILT_OFFSET, ftemp);
|
||||
@@ -713,49 +649,25 @@ void printEEPROM(void){
|
||||
printi(F("Tilt invert: "), EEPROM.read(EEPROM_ADDRESS_INVERT_TILT));
|
||||
printi(F("Slider invert: "), EEPROM.read(EEPROM_ADDRESS_INVERT_SLIDER));
|
||||
printi(F("Homing on start-up: "), EEPROM.read(EEPROM_ADDRESS_ENABLE_HOMING));
|
||||
printi(F("Enable limits: "), EEPROM.read(EEPROM_ADDRESS_ENABLE_LIMITS));
|
||||
EEPROM.get(EEPROM_ADDRESS_PAN_MIN_LIMIT, ftemp);
|
||||
printi(F("Pan min limit: "), ftemp, 3, F("º\n"));
|
||||
EEPROM.get(EEPROM_ADDRESS_PAN_MAX_LIMIT, ftemp);
|
||||
printi(F("Pan max limit: "), ftemp, 3, F("º\n"));
|
||||
EEPROM.get(EEPROM_ADDRESS_TILT_MIN_LIMIT, ftemp);
|
||||
printi(F("Tilt min limit: "), ftemp, 3, F("º\n"));
|
||||
EEPROM.get(EEPROM_ADDRESS_TILT_MAX_LIMIT, ftemp);
|
||||
printi(F("Tilt max limit: "), ftemp, 3, F("º\n"));
|
||||
EEPROM.get(EEPROM_ADDRESS_SLIDER_MIN_LIMIT, ftemp);
|
||||
printi(F("Slider min limit: "), ftemp, 3, F("mm\n"));
|
||||
EEPROM.get(EEPROM_ADDRESS_SLIDER_MAX_LIMIT, ftemp);
|
||||
printi(F("Slider max limit: "), ftemp, 3, F("mm\n"));
|
||||
printi(F("\n"));
|
||||
}
|
||||
|
||||
/*--------------------------------------------------------------------------------------------------------------------------------------------------------*/
|
||||
|
||||
void setEEPROMVariables(void){
|
||||
printi(F("Setting values from EEPROM...\n"));
|
||||
EEPROM.get(EEPROM_ADDRESS_MODE, step_mode);
|
||||
EEPROM.get(EEPROM_ADDRESS_PAN_MAX_SPEED, pan_max_speed);
|
||||
EEPROM.get(EEPROM_ADDRESS_TILT_MAX_SPEED, tilt_max_speed);
|
||||
EEPROM.get(EEPROM_ADDRESS_SLIDER_MAX_SPEED, slider_max_speed);
|
||||
EEPROM.get(EEPROM_ADDRESS_PAN_ACCELERATION, pan_acceleration);
|
||||
EEPROM.get(EEPROM_ADDRESS_TILT_ACCELERATION, tilt_acceleration);
|
||||
EEPROM.get(EEPROM_ADDRESS_SLIDER_ACCELERATION, slider_acceleration);
|
||||
EEPROM.get(EEPROM_ADDRESS_HALL_PAN_OFFSET, hall_pan_offset_degrees);
|
||||
EEPROM.get(EEPROM_ADDRESS_HALL_TILT_OFFSET, hall_tilt_offset_degrees);
|
||||
EEPROM.get(EEPROM_ADDRESS_DEGREES_PER_PICTURE, degrees_per_picture);
|
||||
EEPROM.get(EEPROM_ADDRESS_PANORAMICLAPSE_DELAY, delay_ms_between_pictures);
|
||||
EEPROM.get(EEPROM_ADDRESS_ENABLE_LIMITS, enable_limits);
|
||||
EEPROM.get(EEPROM_ADDRESS_PAN_MIN_LIMIT, limit_pan_min);
|
||||
EEPROM.get(EEPROM_ADDRESS_PAN_MAX_LIMIT, limit_pan_max);
|
||||
EEPROM.get(EEPROM_ADDRESS_TILT_MIN_LIMIT, limit_tilt_min);
|
||||
EEPROM.get(EEPROM_ADDRESS_TILT_MAX_LIMIT, limit_tilt_max);
|
||||
EEPROM.get(EEPROM_ADDRESS_SLIDER_MIN_LIMIT, limit_slider_min);
|
||||
EEPROM.get(EEPROM_ADDRESS_SLIDER_MAX_LIMIT, limit_slider_max);
|
||||
EEPROM.get(EEPROM_ADDRESS_PANORAMICLAPSE_DELAY, delay_ms_between_pictures);
|
||||
invert_pan = EEPROM.read(EEPROM_ADDRESS_INVERT_PAN);
|
||||
invert_tilt = EEPROM.read(EEPROM_ADDRESS_INVERT_TILT);
|
||||
invert_slider = EEPROM.read(EEPROM_ADDRESS_INVERT_SLIDER);
|
||||
enable_homing = EEPROM.read(EEPROM_ADDRESS_ENABLE_HOMING);
|
||||
printi(F("Values set.\n"));
|
||||
printi(F("EEPROM values set.\n"));
|
||||
}
|
||||
|
||||
/*--------------------------------------------------------------------------------------------------------------------------------------------------------*/
|
||||
@@ -773,19 +685,6 @@ void toggleAutoHoming(void){
|
||||
|
||||
/*--------------------------------------------------------------------------------------------------------------------------------------------------------*/
|
||||
|
||||
void toggleEnableLimits(void){
|
||||
if(enable_limits == 1){
|
||||
enable_limits = 0;
|
||||
printi(F("Limits disabled.\n"));
|
||||
}
|
||||
else{
|
||||
enable_limits = 1;
|
||||
printi(F("Limits enabled.\n"));
|
||||
}
|
||||
}
|
||||
|
||||
/*--------------------------------------------------------------------------------------------------------------------------------------------------------*/
|
||||
|
||||
void triggerCameraShutter(void){
|
||||
digitalWrite(PIN_SHUTTER_TRIGGER, HIGH);
|
||||
delay(SHUTTER_DELAY);
|
||||
@@ -829,14 +728,14 @@ void panoramiclapseInterpolation(float panStartAngle, float tiltStartAngle, floa
|
||||
/*--------------------------------------------------------------------------------------------------------------------------------------------------------*/
|
||||
|
||||
void panoramiclapse(float degPerPic, unsigned long msDelay, int repeat){
|
||||
if(moves_array_elements < 2){
|
||||
printi(F("Not enough positions recorded\n"));
|
||||
if(keyframe_elements < 2){
|
||||
printi(F("Not enough keyframes recorded\n"));
|
||||
return; //check there are posions to move to
|
||||
}
|
||||
for(int i = 0; i < repeat; i++){
|
||||
for(int index = 0; index < moves_array_elements - 1; index++){
|
||||
panoramiclapseInterpolation(panStepsToDegrees(program_elements[index].panStepCount), tiltStepsToDegrees(program_elements[index].tiltStepCount), sliderStepsToMillimetres(program_elements[index].sliderStepCount),
|
||||
panStepsToDegrees(program_elements[index + 1].panStepCount), tiltStepsToDegrees(program_elements[index + 1].tiltStepCount), sliderStepsToMillimetres(program_elements[index + 1].sliderStepCount), degPerPic, msDelay);
|
||||
for(int index = 0; index < keyframe_elements - 1; index++){
|
||||
panoramiclapseInterpolation(panStepsToDegrees(keyframe_array[index].panStepCount), tiltStepsToDegrees(keyframe_array[index].tiltStepCount), sliderStepsToMillimetres(keyframe_array[index].sliderStepCount),
|
||||
panStepsToDegrees(keyframe_array[index + 1].panStepCount), tiltStepsToDegrees(keyframe_array[index + 1].tiltStepCount), sliderStepsToMillimetres(keyframe_array[index + 1].sliderStepCount), degPerPic, msDelay);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -852,10 +751,10 @@ void timelapse(unsigned int numberOfPictures, unsigned long msDelay){
|
||||
float tiltAngle = 0;
|
||||
float sliderTravel = 0;
|
||||
|
||||
if(moves_array_elements >= 2){
|
||||
panAngle = panStepsToDegrees(program_elements[1].panStepCount) - panStepsToDegrees(program_elements[0].panStepCount);
|
||||
tiltAngle = tiltStepsToDegrees(program_elements[1].tiltStepCount) - tiltStepsToDegrees(program_elements[0].tiltStepCount);
|
||||
sliderTravel = sliderStepsToMillimetres(program_elements[1].sliderStepCount) - sliderStepsToMillimetres(program_elements[0].sliderStepCount);
|
||||
if(keyframe_elements >= 2){
|
||||
panAngle = panStepsToDegrees(keyframe_array[1].panStepCount) - panStepsToDegrees(keyframe_array[0].panStepCount);
|
||||
tiltAngle = tiltStepsToDegrees(keyframe_array[1].tiltStepCount) - tiltStepsToDegrees(keyframe_array[0].tiltStepCount);
|
||||
sliderTravel = sliderStepsToMillimetres(keyframe_array[1].sliderStepCount) - sliderStepsToMillimetres(keyframe_array[0].sliderStepCount);
|
||||
}
|
||||
|
||||
float sliderInc = sliderTravel / numberOfPictures;
|
||||
@@ -874,11 +773,125 @@ void timelapse(unsigned int numberOfPictures, unsigned long msDelay){
|
||||
|
||||
/*--------------------------------------------------------------------------------------------------------------------------------------------------------*/
|
||||
|
||||
bool calculateTargetCoordinate(void){
|
||||
float m1, c1, m2, c2;
|
||||
|
||||
LinePoints line0;
|
||||
line0.x0 = sliderStepsToMillimetres(keyframe_array[0].sliderStepCount);
|
||||
line0.y0 = 0;
|
||||
line0.x1 = line0.x0 + cos(degToRads(panStepsToDegrees(keyframe_array[0].panStepCount)));
|
||||
line0.y1 = sin(degToRads(panStepsToDegrees(keyframe_array[0].panStepCount)));
|
||||
|
||||
LinePoints line1;
|
||||
line1.x0 = sliderStepsToMillimetres(keyframe_array[1].sliderStepCount);
|
||||
line1.y0 = 0;
|
||||
line1.x1 = line1.x0 + cos(degToRads(panStepsToDegrees(keyframe_array[1].panStepCount)));
|
||||
line1.y1 = sin(degToRads(panStepsToDegrees(keyframe_array[1].panStepCount)));
|
||||
|
||||
if((line0.x1 - line0.x0) != 0){
|
||||
m1 = (line0.y1 - line0.y0) / (line0.x1 - line0.x0);
|
||||
c1 = line0.y1 - m1 * line0.x1;
|
||||
}
|
||||
|
||||
if((line1.x1 - line1.x0) != 0){
|
||||
m2 = (line1.y1 - line1.y0) / (line1.x1 - line1.x0);
|
||||
c2 = line1.y1 - m2 * line1.x1;
|
||||
}
|
||||
|
||||
if((line0.x1 - line0.x0) == 0){
|
||||
intercept.x = line0.x0;
|
||||
intercept.y = m2 * intercept.x + c2;
|
||||
}
|
||||
else if((line1.x1 - line1.x0) == 0){
|
||||
intercept.x = line1.x0;
|
||||
intercept.y = m1 * intercept.x + c1;
|
||||
}
|
||||
else{
|
||||
if(m1 == m2){
|
||||
printi(F("Positions do not intersect."));
|
||||
return false;
|
||||
}
|
||||
intercept.x = (c2 - c1) / (m1 - m2);
|
||||
intercept.y = m1 * intercept.x + c1;
|
||||
}
|
||||
intercept.z = tan(degToRads(tiltStepsToDegrees(keyframe_array[0].tiltStepCount))) * sqrt(pow(intercept.x, 2) + pow(intercept.y, 2));
|
||||
if(((panStepsToDegrees(keyframe_array[0].panStepCount) > 0 && panStepsToDegrees(keyframe_array[1].panStepCount) > 0) && intercept.y < 0)
|
||||
|| ((panStepsToDegrees(keyframe_array[0].panStepCount) < 0 && panStepsToDegrees(keyframe_array[1].panStepCount) < 0) && intercept.y > 0)){
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
/*--------------------------------------------------------------------------------------------------------------------------------------------------------*/
|
||||
|
||||
void interpolateTargetPoint(FloatCoordinate targetPoint, int repeat){
|
||||
if(keyframe_elements < 2){
|
||||
printi(F("Not enough keyframes recorded\n"));
|
||||
return; //check there are posions to move to
|
||||
}
|
||||
|
||||
float increment = 1;
|
||||
float sliderStartPos = sliderStepsToMillimetres(keyframe_array[0].sliderStepCount); //slider start position
|
||||
float sliderEndPos = sliderStepsToMillimetres(keyframe_array[1].sliderStepCount);
|
||||
float panAngle = 0;
|
||||
float tiltAngle = 0;
|
||||
float x = targetPoint.x - sliderStepsToMillimetres(keyframe_array[0].sliderStepCount);
|
||||
float ySqared = pow(targetPoint.y, 2);
|
||||
float sliderTravel = sliderStepsToMillimetres(keyframe_array[1].sliderStepCount) - sliderStepsToMillimetres(keyframe_array[0].sliderStepCount);
|
||||
unsigned int numberOfIncrements = sliderTravel / increment;
|
||||
|
||||
for(int j = 0; j < repeat; j++){
|
||||
for(int i = 0; i <= numberOfIncrements; i++){
|
||||
x = targetPoint.x - (sliderStartPos + increment * i);
|
||||
panAngle = radsToDeg(atan2(targetPoint.y, x));
|
||||
tiltAngle = radsToDeg(atan2(targetPoint.z, sqrt(pow(x, 2) + ySqared)));
|
||||
setTargetPositions(panAngle, tiltAngle, sliderStartPos + increment * i);
|
||||
multi_stepper.runSpeedToPosition();//blocking move to the next position
|
||||
}
|
||||
x = targetPoint.x - sliderEndPos;
|
||||
panAngle = radsToDeg(atan2(targetPoint.y, x));
|
||||
tiltAngle = radsToDeg(atan2(targetPoint.z, sqrt(pow(x, 2) + ySqared)));
|
||||
setTargetPositions(panAngle, tiltAngle, sliderEndPos);
|
||||
multi_stepper.runSpeedToPosition();//blocking move to the next position
|
||||
|
||||
for(int i = numberOfIncrements; (i >= 0 && repeat > 0); i--){
|
||||
x = targetPoint.x - (sliderStartPos + increment * i);
|
||||
panAngle = radsToDeg(atan2(targetPoint.y, x));
|
||||
tiltAngle = radsToDeg(atan2(targetPoint.z, sqrt(pow(x, 2) + ySqared)));
|
||||
setTargetPositions(panAngle, tiltAngle, sliderStartPos + increment * i);
|
||||
multi_stepper.runSpeedToPosition();//blocking move to the next position
|
||||
}
|
||||
setTargetPositions(panAngle, tiltAngle, sliderStartPos);
|
||||
multi_stepper.runSpeedToPosition();//blocking move to the next position
|
||||
}
|
||||
}
|
||||
|
||||
/*--------------------------------------------------------------------------------------------------------------------------------------------------------*/
|
||||
|
||||
bool sliderHoming(void){
|
||||
while(digitalRead(PIN_SLIDER_HALL) == 0){ //Move off the hall
|
||||
target_position[2] = target_position[2] + sliderMillimetresToSteps(1);
|
||||
multi_stepper.moveTo(target_position);
|
||||
multi_stepper.runSpeedToPosition();
|
||||
}
|
||||
setTargetPositions(panStepsToDegrees(target_position[0]), tiltStepsToDegrees(target_position[1]), -1200);//1200 is the length of the slider
|
||||
while(multi_stepper.run()){
|
||||
if(digitalRead(PIN_SLIDER_HALL) == 0){
|
||||
stepper_slider.setCurrentPosition(0);//set step count to 0
|
||||
setTargetPositions(panStepsToDegrees(target_position[0]), tiltStepsToDegrees(target_position[1]), 0);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/*--------------------------------------------------------------------------------------------------------------------------------------------------------*/
|
||||
|
||||
void serialData(void){
|
||||
char instruction = Serial.read();
|
||||
if(instruction == INSTRUCTION_BYTES_PAN_TILT_SPEED){
|
||||
if(instruction == INSTRUCTION_BYTES_SLIDER_PAN_TILT_SPEED){
|
||||
int count = 0;
|
||||
while(Serial.available() < 4){//Wait for 4 bytes to be available. Breaks after ~20ms if bytes are not received.
|
||||
while(Serial.available() < 6){//Wait for 6 bytes to be available. Breaks after ~20ms if bytes are not received.
|
||||
delayMicroseconds(200);
|
||||
count++;
|
||||
if(count > 100){
|
||||
@@ -886,11 +899,14 @@ void serialData(void){
|
||||
break;
|
||||
}
|
||||
}
|
||||
int sliderStepSpeed = (Serial.read() << 8) + Serial.read();
|
||||
int panStepSpeed = (Serial.read() << 8) + Serial.read();
|
||||
int tiltStepSpeed = (Serial.read() << 8) + Serial.read();
|
||||
|
||||
|
||||
stepper_slider.setSpeed(sliderStepSpeed);
|
||||
stepper_pan.setSpeed(panStepSpeed);
|
||||
stepper_tilt.setSpeed(tiltStepSpeed);
|
||||
stepper_slider.runSpeed();
|
||||
stepper_pan.runSpeed();
|
||||
stepper_tilt.runSpeed();
|
||||
}
|
||||
@@ -907,17 +923,10 @@ void serialData(void){
|
||||
float serialCommandValueFloat = atof(stringText); //converts stringText to a float
|
||||
if(instruction == 'G' && stringText[0] == 0) return;//For the bluetooth issue of it sending data when it connects...
|
||||
switch(instruction){
|
||||
case INSTRUCTION_SLIDER_MIN_LIMIT:{
|
||||
limit_slider_min = serialCommandValueFloat;
|
||||
printi(F("Slider min limit set to: "), limit_slider_min, 3, F("mm\n"));
|
||||
case INSTRUCTION_SLIDER_HOME:{
|
||||
sliderHoming();
|
||||
}
|
||||
break;
|
||||
case INSTRUCTION_SLIDER_MAX_LIMIT:{
|
||||
limit_slider_max = serialCommandValueFloat;
|
||||
printi(F("Slider max limit set to: "), limit_slider_max, 3, F("mm\n"));
|
||||
}
|
||||
break;
|
||||
|
||||
case INSTRUCTION_SLIDER_MILLIMETRES:{
|
||||
sliderMoveTo(serialCommandValueFloat);
|
||||
}
|
||||
@@ -932,30 +941,6 @@ void serialData(void){
|
||||
printi(F("Degrees per picture: "), degrees_per_picture, 3, F("º\n"));
|
||||
}
|
||||
break;
|
||||
case INSTRUCTION_ENABLE_LIMITS:{
|
||||
toggleEnableLimits();
|
||||
}
|
||||
break;
|
||||
case INSTRUCTION_PAN_MIN_LIMIT:{
|
||||
limit_pan_min = serialCommandValueFloat;
|
||||
printi(F("Pan min limit set to: "), limit_pan_min, 3, F("º\n"));
|
||||
}
|
||||
break;
|
||||
case INSTRUCTION_PAN_MAX_LIMIT:{
|
||||
limit_pan_max = serialCommandValueFloat;
|
||||
printi(F("Pan max limit set to: "), limit_pan_max, 3, F("º\n"));
|
||||
}
|
||||
break;
|
||||
case INSTRUCTION_TILT_MIN_LIMIT:{
|
||||
limit_tilt_min = serialCommandValueFloat;
|
||||
printi(F("Tilt min limit set to: "), limit_tilt_min, 3, F("º\n"));
|
||||
}
|
||||
break;
|
||||
case INSTRUCTION_TILT_MAX_LIMIT:{
|
||||
limit_tilt_max = serialCommandValueFloat;
|
||||
printi(F("Tilt max limit set to: "), limit_tilt_max, 3, F("º\n"));
|
||||
}
|
||||
break;
|
||||
case INSTRUCTION_PANORAMICLAPSE:{
|
||||
printi(F("Starting panorama.\n"));
|
||||
panoramiclapse(degrees_per_picture, delay_ms_between_pictures, 1);
|
||||
@@ -969,14 +954,14 @@ void serialData(void){
|
||||
printi(F("Finished\n"));
|
||||
}
|
||||
break;
|
||||
case INSTRUCTION_SCALE_PAN_SPEED:{
|
||||
scaleMovesArrayPanMaxSpeed(panDegreesToSteps(serialCommandValueFloat));
|
||||
}
|
||||
break;
|
||||
case INSTRUCTION_SCALE_TILT_SPEED:{
|
||||
scaleMovesArrayTiltMaxSpeed(tiltDegreesToSteps(serialCommandValueFloat));
|
||||
}
|
||||
break;
|
||||
// case INSTRUCTION_SCALE_PAN_SPEED:{
|
||||
// scaleMovesArrayPanMaxSpeed(panDegreesToSteps(serialCommandValueFloat));
|
||||
// }
|
||||
// break;
|
||||
// case INSTRUCTION_SCALE_TILT_SPEED:{
|
||||
// scaleMovesArrayTiltMaxSpeed(tiltDegreesToSteps(serialCommandValueFloat));
|
||||
// }
|
||||
// break;
|
||||
case INSTRUCTION_TRIGGER_SHUTTER:{
|
||||
triggerCameraShutter();
|
||||
}
|
||||
@@ -989,7 +974,8 @@ void serialData(void){
|
||||
else{
|
||||
stepper_pan.setCurrentPosition(0);
|
||||
stepper_tilt.setCurrentPosition(0);
|
||||
setTargetPositions(0, 0);
|
||||
stepper_slider.setCurrentPosition(0);
|
||||
setTargetPositions(0, 0, 0);
|
||||
printi(F("Error homing. Current position has been set as home.\n"));
|
||||
}
|
||||
}
|
||||
@@ -1000,12 +986,12 @@ void serialData(void){
|
||||
break;
|
||||
case INSTRUCTION_SET_PAN_HALL_OFFSET:{
|
||||
hall_pan_offset_degrees = serialCommandValueFloat;
|
||||
printi(F("Pan Hall offset set to: "), hall_pan_offset_degrees, 3, F("º\n"));
|
||||
printi(F("Pan Hall offset: "), hall_pan_offset_degrees, 3, F("º\n"));
|
||||
}
|
||||
break;
|
||||
case INSTRUCTION_SET_TILT_HALL_OFFSET:{
|
||||
hall_tilt_offset_degrees = serialCommandValueFloat;
|
||||
printi(F("Tilt Hall offset set to: "), hall_tilt_offset_degrees, 3, F("º\n"));
|
||||
printi(F("Tilt Hall offset: "), hall_tilt_offset_degrees, 3, F("º\n"));
|
||||
}
|
||||
break;
|
||||
case INSTRUCTION_INVERT_SLIDER:{
|
||||
@@ -1021,9 +1007,8 @@ void serialData(void){
|
||||
}
|
||||
break;
|
||||
case INSTRUCTION_SAVE_TO_EEPROM:{
|
||||
printi(F("Saving values to EEPROM...\n"));
|
||||
saveEEPROM();
|
||||
printi(F("Saved.\n"));
|
||||
printi(F("Saved to EEPROM.\n"));
|
||||
}
|
||||
break;
|
||||
case INSTRUCTION_ADD_POSITION:{
|
||||
@@ -1031,27 +1016,27 @@ void serialData(void){
|
||||
}
|
||||
break;
|
||||
case INSTRUCTION_STEP_FORWARD:{
|
||||
moveToIndex(current_moves_array_index + 1);
|
||||
printi(F("Moves array index: "), current_moves_array_index, F("\n"));
|
||||
moveToIndex(current_keyframe_index + 1);
|
||||
printi(F("Index: "), current_keyframe_index, F("\n"));
|
||||
}
|
||||
break;
|
||||
case INSTRUCTION_STEP_BACKWARD:{
|
||||
moveToIndex(current_moves_array_index - 1);
|
||||
printi(F("Moves array index: "), current_moves_array_index, F("\n"));
|
||||
moveToIndex(current_keyframe_index - 1);
|
||||
printi(F("Index: "), current_keyframe_index, F("\n"));
|
||||
}
|
||||
break;
|
||||
case INSTRUCTION_JUMP_TO_START:{
|
||||
gotoMovesArrayStart();
|
||||
printi(F("Moves array index: "), current_moves_array_index, F("\n"));
|
||||
gotoFirstKeyframe();
|
||||
printi(F("Index: "), current_keyframe_index, F("\n"));
|
||||
}
|
||||
break;
|
||||
case INSTRUCTION_JUMP_TO_END:{
|
||||
gotoMovesArrayEnd();
|
||||
printi(F("Moves array index: "), current_moves_array_index, F("\n"));
|
||||
gotoLastKeyframe();
|
||||
printi(F("Index: "), current_keyframe_index, F("\n"));
|
||||
}
|
||||
break;
|
||||
case INSTRUCTION_EDIT_ARRAY:{
|
||||
editMovesArrayIndex();
|
||||
editKeyframe();
|
||||
}
|
||||
break;
|
||||
case INSTRUCTION_ADD_DELAY:{
|
||||
@@ -1059,23 +1044,23 @@ void serialData(void){
|
||||
}
|
||||
break;
|
||||
case INSTRUCTION_CLEAR_ARRAY:{
|
||||
clearArray();
|
||||
clearKeyframes();
|
||||
}
|
||||
break;
|
||||
case INSTRUCTION_EXECUTE_MOVES:{
|
||||
executeMoves(serialCommandValueInt);
|
||||
}
|
||||
break;
|
||||
case INSTRUCTION_PAN_RUN_SPEED:{
|
||||
stepper_pan.setSpeed(panDegreesToSteps(serialCommandValueFloat));
|
||||
stepper_pan.runSpeed();
|
||||
}
|
||||
break;
|
||||
case INSTRUCTION_TILT_RUN_SPEED:{
|
||||
stepper_tilt.setSpeed(tiltDegreesToSteps(serialCommandValueFloat));
|
||||
stepper_tilt.runSpeed();
|
||||
}
|
||||
break;
|
||||
// case INSTRUCTION_PAN_RUN_SPEED:{
|
||||
// stepper_pan.setSpeed(panDegreesToSteps(serialCommandValueFloat));
|
||||
// stepper_pan.runSpeed();
|
||||
// }
|
||||
// break;
|
||||
// case INSTRUCTION_TILT_RUN_SPEED:{
|
||||
// stepper_tilt.setSpeed(tiltDegreesToSteps(serialCommandValueFloat));
|
||||
// stepper_tilt.runSpeed();
|
||||
// }
|
||||
// break;
|
||||
case INSTRUCTION_DEBUG_STATUS:{
|
||||
debugReport();
|
||||
}
|
||||
@@ -1089,9 +1074,10 @@ void serialData(void){
|
||||
}
|
||||
break;
|
||||
case INSTRUCTION_SET_HOME:{
|
||||
setTargetPositions(0, 0, 0);
|
||||
stepper_pan.setCurrentPosition(0);
|
||||
stepper_tilt.setCurrentPosition(0);
|
||||
stepper_slider.setCurrentPosition(0);
|
||||
stepper_slider.setCurrentPosition(0);
|
||||
}
|
||||
break;
|
||||
case INSTRUCTION_ENABLE:{
|
||||
@@ -1103,23 +1089,32 @@ void serialData(void){
|
||||
}
|
||||
break;
|
||||
case INSTRUCTION_SET_PAN_SPEED:{
|
||||
printi("Setting maximum pan speed to ", serialCommandValueFloat, 1, " º/s.\n");
|
||||
printi("Max pan speed: ", serialCommandValueFloat, 1, " º/s.\n");
|
||||
pan_max_speed = serialCommandValueFloat;
|
||||
stepper_pan.setMaxSpeed(panDegreesToSteps(pan_max_speed));
|
||||
}
|
||||
break;
|
||||
case INSTRUCTION_SET_TILT_SPEED:{
|
||||
printi("Setting maximum tilt speed to ", serialCommandValueFloat, 1, " º/s.\n");
|
||||
printi("Max tilt speed: ", serialCommandValueFloat, 1, " º/s.\n");
|
||||
tilt_max_speed = serialCommandValueFloat;
|
||||
stepper_tilt.setMaxSpeed(tiltDegreesToSteps(tilt_max_speed));
|
||||
}
|
||||
break;
|
||||
case INSTRUCTION_SET_SLIDER_SPEED:{
|
||||
printi("Setting maximum slider speed to ", serialCommandValueFloat, 1, " mm/s.\n");
|
||||
printi("Max slider speed: ", serialCommandValueFloat, 1, " mm/s.\n");
|
||||
slider_max_speed = serialCommandValueFloat;
|
||||
stepper_slider.setMaxSpeed(sliderMillimetresToSteps(slider_max_speed));
|
||||
}
|
||||
break;
|
||||
break;
|
||||
case INSTRUCTION_ORIBIT_POINT:{
|
||||
if(calculateTargetCoordinate()){
|
||||
printi("Target coordinates: \nx: ", intercept.x, 3, " mm\n");
|
||||
printi("y: ", intercept.y, 3, " mm\n");
|
||||
printi("z: ", intercept.z, 3, " mm\n");
|
||||
interpolateTargetPoint(intercept, serialCommandValueInt);
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user