Messaggi: 899
Discussioni: 26
Registrato: Nov 2021
i parametri sono nel firmware e poi bisgna vedere quanto di ttutta quella roba e´stata messa, si usa quel che c´e´ conservativo ma che va´bene un po´per tutto
Messaggi: 154
Discussioni: 1
Registrato: Jun 2021
Ciao,
aggiungo i miei due centesimi.
Mi pare di capire che il parametro delay fosse presente nella prima versione del programma che gestisce la tavola (la versione che state usando).
A questa pagina si parla dell'evoluzione del programma.
Il probabile motivo per cui si impianta il motore e' la mancata gestione dell'accelerazione.
Nella versione evoluta sono state implementate anche le rampe di accelerazione e decelerazione.
Da quanto posso capire nel leggere lo sketch, i piedini per la gestione del driver rimangono gli stessi:
// stepper motor
const int stp = 2; // connect pin 2 to step
const int dir = 3; // connect pin 3 to dir
Da qui potete scaricare il codice:
Arduino_Rotary_Table_Control_2019_V2-Rev4.69.ino
Per semplicita' lo trovate anche allegato sotto.
Ciao :-)
Mauro
Codice: /* Arduino Rotary Table Control Program
**************************************************************
WARNING! THIS IS A BETA VERSION OF THE PROGRAM FOR
TESTING AND DE-BUGGING PURPOSES ONLY.
**************************************************************
4x4 matrix keypad and a 20 x 4 LCD.
A4988 Stepstick/Pololu driver
Inspired by sketches written by bmac2 and tjwal;
See here: http://www.homemodelenginemachinist.com/showthread.php?t=26744
New sketch written by K. Quiggle 2019
This sketch improves on the original in these ways:
- movement is implemented with acceleration and deceleration
- movement accuracy is improved by calculating moves using float variables before converting to int steps,
so as to avoid cumulative rounding errors
- an option is included for continuous rotation with varying speed settings
- an option is included for arc movements (rotation between within a fixed angle)
WARNING! : This may not be the most recent version of this program, and may have uncorrected errors.
See the link below for more information and links to more recent versions (if any):
https://sites.google.com/site/lagadoacademy/miscellaneous-projects/stepper-motor---accelstepper-h
See this link for hardware details:
https://sites.google.com/site/lagadoacademy/machining---lathes-mills-etc/build---electronic-indexing-head
NOTES ON FIRST USE:
1. You may need to change the address in the line starting "LiquidCrystal_I2C lcd(0x3F,20,4)" to match the address of your display.
If 0x3F doesnot work try 0x27 and vice-versa.
2. The first time you use the sketch, use the Settings option to enter the appropriate settings for your indexer.
Settings are stored in permanent memory, so you only need to do this once unless you change your hardware or
decide to change a setting.
3. You MUST set the backlash correction to either 0 (no correction) or to the correct value for your hardware. Any other
setting will give erratic results when changing rotational direction.
4. On first use you should rotate a full rotation in the direction you plan to use your rotary table, so as to remove
any initial backlash in the system and to establish the initial rotation direction.
5. Rotation directions are clockWise and counterClockWise - these are indicated on the display. If your table rotation
does not match the display, reverse the values of these two variables in the program.
Instructions:
This program enables operation of a rotary index table in four modes:
Mode 1: Index mode: Move the table in indexed steps
- step size may be set either in degrees of number of sides (or gear teeth)
Mode 2: Jog mode: Move the table in jog steps; that is, move the stepper motor in increments of 1, 10 or 100 steps.
This mode is used to to set arc movement position, and to help determine backlash correction.
Mode 3: Arc mode: Move the table in a defined arc, with back and forth movement between set positions.
Mode 4: Continuous Mode: Move the table continuously until stopped.
The program also enables backlash compensation. The amount of backlash must first be experimentally determined (see
instructions); this can then be entered into the program settings. Backlash correction can be turned on or off
as desired. When backlash correction is turned on, a ← back-arrow symbol is shown in the relevant displays.
Program initialization:
When the program is first started, the program version number is displayed, along with an option for "Initial rotation"
in either the clockwise (CW) or counterclockwise (CCW) direction.
START-UP MENU
+--------------------+
|Rotary Table Control|
|V2-Rev.4.67 2019 |
|Initial rotation? |
|#=EXIT A=CW B=CCW|
+--------------------+
Note: IF YOUR ARE USING THE PROGRAM (OR AN UPDATE) FOR THE FIRST TIME, then use the #=EXIT key
to move to the Main Menu and select D=Settings to enter your data. You can also use the #=EXIT key to
just skip this step.
If you have previously entered the program settings for your stepper motor and rotary table, then it is still advised to
perform an initial rotation for two reasons:
1. Remove any backlash from your system to establish a well defined start position
2. Provide the program with a defined "direction of last move" (clockDir in the program); the
program needs this information to make accurate moves. Otherwise the default setting is
clockDir = CW
MAIN MENU:
The main menu looks like this:
+--------------------+
|1: Degrees 3: Sides|
|4: Jog 6: Arc |
|7: Continuous |
|9: Settings |
+--------------------+
The selection numbers are chosen so that the keypad position and the display position approximately correspond.
The above keypad choices select the following:
1: Enter the desired number of degrees per move. Move the rotary table the specified number of degrees
with each move, in either CW or CCW direction.
3: Enter the desired number of polygon sides or gear teeth; from this the required number of degrees per
move will be calculated. Move the rotary table the calculated number of degrees with each move,
in either CW or CCW direction.
4: Move the rotary table by motor steps in increments of 1, 10, or 100 steps in either the forward or reverse
direction. This enables miving the rotary table to a specific position.
6: Moving the rotary table back and forth in an arc, starting at the current position, and ending at a second
position CW from the starting position. A sub-menu of this choice enables setting the second position either
by specifying a number of degrees, or by jog moves.
7: Move the rotary table continuously in either the CW or CCW direction. A sub-menu for this choice enables
setting the motor speed and acceleration for this choice.
9: This option enters the settings mode, which enables entering (and storing in permanent memory) the
program settings explained below.
PROGRAM SETTINGS:
The first time you use the program, the required settings for your stepper motor and rotary table are undefined.
The 9=Settings option enables you to enter the intial settings for your system, or to change the settings as
needed. All settings entered will be stored in permanent memory, so you do not need to re-enter them if you turn
off the program. You may change the initial settings at any time by using the Settings option again. The values
stored by this option are as follows:
1. The total number of full steps in a complete stepper motor rotation (typically 200, but other values are possible)
2. The number of micro-steps per full step (as set on the stepper motor controller hardware)
3. The rotary table gear ratio
5. Backlash setting - On (use backlash compensation) or Off (do not compensate for backlash)
6. Backlash compensation: The total number of micro-steps of backlash in the system (see BACKLASH CORRECTION below).
Note: If backlash compensation is turned off you will not be asked for a backlash compensation value
7. Beeper start setting - On or Off ; this is for an optional hardware beeper (see comments below). If a beeper is used
and this is set on, then the controller will beep on start of a move.
8. Beeper halt setting - On or Off ; this is for an optional hardware beeper (see comments below). If a beeper is used
and this is set on, then the controller will beep on completion of a move, or to alert to the need for keypad entry.
9. Maximum speed setting for the stepper motor. This will be different for every stepper motor and rotary table
combination. See MAXIMUM SPEED and ACCELERATION below.
10. Acceleration - how quickly the motor acclerates to maximum speed, and decelerates to a stop. See
MAXIMUM SPEED and ACCELERATION below.
10. Percent maximum speed - this setting enables the stepper motor to be run at some percentage of the full
maximum speed. The percentage can be less that 100% or greater than 100%. This is used to quickly select
different motor speeds when rotating continuously.
11. Stop mode - the method for stopping continuous rotation. This is explained in more detail under Continuous
Mode below.
MAXIMUM SPEED and ACCELERATION:
If you are using this program for the first time, or you have made hardware changes or changed the micro-stepping
value, you should set the maximum motor speed and acceleration first. The easiest way to quickly determine
good speed and acceleration values is to use the Continuous Mode, which has an option for setting these values
(see more on this mode below).
The maximum motor speed should be set to a "conservative" value that will prevent stalling or skipping. The
maximum possible value found through experiment is 4000 (steps/sec), but your actual setting will be much
less than this. My indexer uses the values below, but your vaues will likely be very different.
Similarly, set acceleration to a value that will not cause your system to "lose position." Since this program
receives no feedback on the actual physical positionof the rotary table, it assumes that the table moves one step
for every step signal given; if for any reason the table fails to advance when a step signal is given then
the table and program will be out of sync and table movements will no longer be accurate.
Micro- Max
stepping speed Acceleration
-------- ----- ------------
1 850 200
2 2500 1000
The only way to determine the best values for speed and acceleration is by trial and error. Start with low values
that work well, and then increase the values until the motor starts to stall, hesitate,or skip. Then set the
values for actual use to numbers 10% or 20% below the stall values to allow a margin of safety. Because mass
inertia is a big factor in these settings, the trial runs should be made with the rotary table PLUS a typical
workpiece so that the "working load" of the table is taken into account.
Per the AccelStepper documentation: "The fastest motor
speed that can be reliably supported is about 4000 steps per second
at a clock frequency of 16 MHz on Arduino such as Uno etc."
BACKLASH CORRECTION:
The procedure for determining backlash correction is as follows:
1. Using Settings, turn backlash correction to OFF
2. Put the Arduino into Degree Mode and set for 360 degrees.
3. Advance the motor CCW one full turn.
4. Mark the existing position of the rotary table. A good way to do this is to mount a laser pointer on the
rotary table and shine the laser dot on a nearby surface; mark the position of the laser dot at the
existing position (a black dot on a sticky-note works well for this).
5. Move one full turn in the opposite direction (CW). You will see that the laser dot did not return to the
marked position - this is the backlash error.
5. Exit and switch to JogMode. Using Jog Mode rotate the table in CW direction until the spot returns to the
original position. The total number of steps shown is the amount of required backlash compensation.
6. Repeat the procedure several times to verify that the backlash compensation is accurate and repeatable.
7. Use the Settings option to save the backlash compensation value.
Note on settings: After setting maximum speed, acceleration, and backlash compensation, I recommend retesting
your chosen values by rotating the indexer back and forth by 360 degrees using the laser pointer method to mark
position. If you find that the pointer is off by a tiny amount, you may be missing steps. Try reducing the
speed or accleration to see if this corrects the problem.Alternatively, you may beed to adjust the backlash by
a step or two.
PROGRAM MODES: This program enables rotary table movement in several different modes.
-------------------------------------------------------------------------------------
INDEX MODE: Degrees or Sides)
This mode moves the rotary table in a pre-defined increment with each move, in either the CW or CCW direction.
Backlash compensation may be switched on or off for this mode. After the increment is defiend the display will
show the increment in degrees at the top-left of the display, and the totalnumber of degrees moved at the
top-right of the display. Total degrees moved resets to 0 after a full rotation, so this number will always be
between 0 and 360.
The pre-defined move increments can be set in one of two ways:
1. Degrees: Specify a number of degrees for each move. The number of degrees can be any positive number,
including fractional degrees and 0 (0 will of course result in no movement).
2. Sides (or teeth): Specify the number of sides of a polygon, or the number of teeth in a gear; the controller
will calculate the required number of degrees per increment.
Backlash compensation may be switched on or off for this mode.
You must set backlash compensation ON for this mode, unless you make index steps in only one direction. Note
also that (regardless of backlash setting) it is considered good practice to make index moves in only one
direction for best machining accuracy.
JOG MODE:
Jog mode moves the stepper motor in increments of 1, 10, or 100 steps in either the CW or CCW direction. Backlash
compensation may be switched on or off for this mode.
You must set backlash compensation ON for this mode, unless you make jog steps in only one direction.
ARC MODE:
Arc mode moves back and forth between a start position and an end position. When arc mode is selected, the
table position at that time is set as the start position, so you should move the table to the desired arc
start position before selecting this mode. The suggested method is to first use degree mode to move the
table to the approximate start position, and then use jog mode to fine tune the desired start position.
Once arc mode has been selected, the end position can be set in a simlar manner:
1. By degrees: Enter the number of degrees to rotate CW from the current position. When you enter degrees the
table will rotate immediately to that position.
2. Then move by jog steps (either CW or CCW) to fine tune the desired end position.
To summarize:
- use Degrees mode to move to approximate start position
- use Jog mode to fine tune start position
- enter Arc mode
- use Degrees to set arc end position
- if necessary, use Jog to fine tune end position
Once the start and end positions have been set (these will show on the display), press the Go key to move in
the defined arc; the display will show the direction of the next move. Each Go key press will move to the end
of the arc and then stop; pressing the Go key again will move in reverse to the other end of the arc. Backlash
compensation may be switched on or off for this mode.
You must set backlash compensation ON for this mode, unless you make an arc move in only one direction.
CONTINUOUS MODE:
This mode moves the motor continuously in either the CW or CCW direction. Backlash compensation does NOT work
in this mode, and the backlash compensation status is not shown in the display menu for this mode regardless
of the setting.
This mode includes an option for setting speed, acceleration, and stop mode. The LCD display for this mode
looks like this:
+--------------------+
|CONTINUOUS [stopkey]| [stopkey] indicates the current stop mode setting
|sp= 80%=1840 ac=1000| sp is the % of maximum speed setting, and the resulting speed,
|C=settings D=STOP| acis the current acceleration setting
|A=CW B=CCW #=EXIT|
+--+-----------------+
In this mode you can set the motor speed as a percentage of the maximum speed setting. This % setting applies only to
continuous run mode. However, this setting is stored so if changed the changed value will be restored on
the next program run. The sp setting can be any integer > 0,including numbers greater than 100%.
Entering a % sp greater than 100% is useful when trying to determine the maximum useful motor speed. In this mode
different acceleration and speed combinations can be tested relatively quickly. If you are using this option
to help determine optimal maximum motor speed, then be sure to update that value in the Settings Mode. Note that
the choice of stop mode affects the maximum speed value as explained below.
Continuous running Stop Modes:
The AccelStepper.h library used with this program does not have a built in method for accelerating to and then
running at a set speed. In order to emulate this the continuous run mode simply defines a rotation end position
as the highest possible number (so "continuous" is actually "continuous for several days" which is the same
thing for practical use).
The problem then becomes: How to stop continuous rotation on demand? The obvious method of waiting for a keypad
keypress has the drawback that the keypad scan introduces a fairly large delay time which has the result of
reducing the maximum usable run speed. The ideal solution might be to use an interrupt, but I have not yet been able
to make this work. On an interim basis, this program instead provides three options for stopping continuous mode;
these options are set and saved in Settings. The options are as follows:
Option Option
Number Type Comments
====== ================= =======================================================================
1 stopkey Press a defined key on the keypad.
- works reliably
- stops with deceleration
- limits maximum practical speed
2* detect key press Detect a key press directly without scanning the entire keypad
- works, but not reliably
- may require several keypad presses to work; I get best results
when I hold down the key for 1 second before releasing
- stops with deceleration
- does not limit maximum practical speed
3 reset Press the Arduino reset button to stop
- works reliably
- STOPS IMMEDIATELY - no deceleration
- does not limit maximum practical speed
- results in program restart
* The key press detection is essentially treating a keypad key as a "button" which is not ideal from
an electronic/hardware point of view, although it does (sort of) work.
====================================================================================================
Comments about this program:
- int variables start with a lower case letter
- float variables starting with an Uppercase letter
- you might see comments with "debug" in them; these are notes to myself to check or remove program code.
You will likely find these in beta releases of the program, or I may have neglected to remove some of these.
If using optional beeper:
- Connect speaker or piezo buzzer to pin 13 and ground
- Adjust frequency between 2000 - 5000 for desired tone by setting beepFrequency variable
Possibility of overflow in step counting variables unlikely:
When the stepper motor drives the rotary table through a complete rotation and then
continues to rotate, the AccelStepper step count will continue to accumulate. In theory,
if there are enough rotations the step count variable could overflow leading to program errors.
However, consider this: Assume a "worst case scenario" of a 400 step stepper motor with
microstepping set to 64, and a gear ratio of 40; then
400 x 64 x 40 = 1,024,000
The step count variable is an int long (max possible value 2,147,483,647; this means
the table would have to rotate 2,147,483,647/1,024,000 ≈ 2,097 times and this is highly
unlikely to happen in actual practice. Consequently, this program does no error checking
for this possibility.
Revision changes:
Rev.4.60 - removed rounding in step calculations; this is already done by AccelStepper.h
- program settings are now all undefined on first use
- added option at start for an initial rotation to remove backlash and set logical direction
- modified moveToTarget to include backlash correction
- added backlash on/off indicator to display (back-arrow symbol)
- modifed display text for consistency
Rev.4.61 - revise Jog Mode to use moveToTarget ("standard" move subroutine)
Rev.4.63 - initial settings set to "conservative" values
- many menu changes to make menus more consistent
- menu changes to reduce levels of menus
- jog mode changes to make jog mode work with arc mode
- single subroutine used for motor movement in index, jog, and arc modes
Rev.4.64 - added selectable options for continuous run stop method
- defined stop key
- detect key press
- reset
Rev.4.65 - Settings now read from memory on every program start
- quick patch to prevent leftover bits from breaking stop mode setting
- fixed bugs in moving by Sides
Rev.4.66 - fixed bug in Sides "Moving" display not clearing
- additional edits to introductory comments
- revised display for showing indexing moves (removed step count
and other changes to improve clarity)
Rev.4.67 - removed unused "settings changed" stored variable
- added beep to end of settings
- removed old debug code
- added "Percent of max speed" to Settings (otherwise there is a random
value for first time users)
- fixed bug in Jog menu display
- improved continuous run menu to remove stop-key option in [reset] mode display
Rev.4.68 - code refactoring to improve clarity of program flow and simplify code
- arc degree entry now shows 2 decimal places
- arc position entry changed:
- degrees and jog sum together instead of reset
- immediate move after degree entry to enable fine tuning of end position
- option added to continuous run menu to set speed, accelerations, and stop mode
- expanded beep options to independently choose beep on start and beep on halt
- updated explanatory comments above
Rev.4.69 - fixed display bug in index move when number of degrees per move > 360
- revised code to prevent arc move when number of degrees entered = 0.0
*/
#include <AccelStepper.h>
#include <LiquidCrystal_I2C.h>
#include <Keypad.h>
#include <EEPROM.h>
String ProgramName = "Rotary Table Control"; // Name of this program
String VersionNumber = "V2-Rev4.69 2019"; // The version Number of this program
// SET indicates a variable that will be stored in EEPROM if changed.
// The variable settings below will be used unless changed via the
// program Settings function.
int stepsPerFullRotation = 200; // SET Number of *full* steps per full 360 degree rotation for your motor
int microStepping = 1; // SET microsteps per full step; 1,2,4,8,16,etc.
float TableRatio = 1.0; // SET TableRatio for indexer = 26.851239669 for my hardware
int backlash = 0; // SET Number of microsteps needed to cancel out backlash
boolean backlashOn = false; // SET backlash correction is switched on (true) or off (false)
// - set to 0 if no backlash correction is desired
boolean beepStart = false; // SET beep on start of a move (true=ON, false=OFF)
boolean beepHalt = false; // SET beep on completion of a move (true=ON, false=OFF)
boolean start = 1;
boolean halt = 0;
byte beepPin = 13; // the pin to which the beeper is connected
int beepFrequency = 3800; // the beep audio frequency
float MicroStepsPerFullRotation = 0.0; // actual value calculated when values saved/retrieved from EEPROM
//stepper motor settings
/* SET maximum stepper speed.
Per the AccelStepper documentation: "The fastest motor
speed that can be reliably supported is about 4000 steps per second
at a clock frequency of 16 MHz on Arduino such as Uno etc.
*/
float StepperMaximumSpeed = 500.0; // SET maximum allowed stepper speed
float StepperAcceleration = 100.0; // SET acceleration rate for stepper motor
int percentMaxSpeed = 100; // SET percentage of maximum speed to use for reduced speed setting
int continuousRunStopMode = 1; // SET the method for stopping continuous running (see program comments above)
String stopMode[] = {"stopkey", "keypress", "reset" }; //Names of the stop modes
String prompt = "";
int clockDir = 1; // Direction of rotation initially set to clockWise
int clockWise = 1; // clockwise direction
int counterClockWise = -1; // counter-clockwise direction
boolean stopFlag = false; // flag to show whether the stopKey was used to stop the motor
// Set up key pad
const byte ROWS = 4;
const byte COLS = 4;
char keys[ROWS][COLS] = {
{'1', '2', '3', 'A'},
{'4', '5', '6', 'B'},
{'7', '8', '9', 'C'},
{'.', '0', '#', 'D'}
};
byte rowPINS[ROWS] = {11, 10, 9, 8};
byte colPINS[COLS] = {7, 6, 5, 4};
Keypad kpd = Keypad(makeKeymap(keys), rowPINS, colPINS, ROWS, COLS);
LiquidCrystal_I2C lcd(0x3F, 20, 4); // set the LCD address to 0x20 for a 16 chars and 4 line display
// some displays may use 0x3F for the address.
// Connections: SCL->A5, SDA->A4, VCC->+5, Gnd->Gnd
// stepper motor
const int stp = 2; // connect pin 2 to step
const int dir = 3; // connect pin 3 to dir
// Define a stepper and the pins it will use
AccelStepper stepper(1, stp, dir);
float Degrees = 0.0; // Number of degrees in a move
float TotalDegrees = 0.0; // total Number of degrees moved
float StepsPerIncrementTheoretical = 0.0; // Number of *theoretical* microsteps to move (can be a fractional Number)
float TotalStepsTheoretical = 0.0; // Theoretical total Number of steps moved
long stepToMoveTo = 0; // Target step value for the next move
// This information is needed for backlash correction. On initial start-up,
// the clockDir is undefined.
char key = kpd.getKey();
//=====================================================================================================
//=====================================================================================================
void setup() {
//debug Serial.begin( 9600 );
//debug Serial.println("ready");
getSettings(); //Read the stored program settings
lcd.init(); // initialize the lcd
lcd.backlight(); // turn on backlight
// Print welcome message and greeting menu to the LCD.
lcd.setCursor(0, 0); lcd.print(ProgramName);
lcd.setCursor(0, 1); lcd.print(VersionNumber);
lcd.setCursor(0, 2); lcd.print("Initial rotation?");
lcd.setCursor(0, 3); lcd.print("#=EXIT A=CW B=CCW");
makeBeep(halt);
stepperInitialize(); //reset stepper settings, steps and degrees to initial values
choiceInitialize(); //select choice from greeting menu
} //end Setup
//=====================================================================================================
//=====================================================================================================
void loop() {
stepperInitialize(); //reset stepper settings, steps and degrees to initial values
mainMenu(); //display the main menu
/*
Main menu choice values are:
key value
--- -------------------------
1 move by degrees
3 move by sides or teeth
4 jog move
6 arc move
end set degrees
end set jog
7 continuous move
9 update settings
*/
key = NO_KEY; //clear exit from previous menu
while (key != '#') //select choice from main menu
{
key = kpd.getKey();
switch (key)
{
case NO_KEY:
break;
case '1': //Move by degrees
Degrees = updateNumber("Degrees per move", 0, 0);
StepsPerIncrementTheoretical = Degrees / 360.0 * MicroStepsPerFullRotation;
indexMove();
key = '#'; //exit this loop
break;
case '3': //Move by sides
Degrees = 360.0 / (float) updateNumber("Sides or Teeth", 0, 0);
StepsPerIncrementTheoretical = Degrees / 360.0 * MicroStepsPerFullRotation;
indexMove();
key = '#'; //exit this loop
break;
case '4': //Jog move
getJog();
key = '#'; //exit this loop
break;
case '6': //Arc movement
choiceArc();
key = '#'; //exit this loop
break;
case '7': //Continuous movement
choiceContinuous(); //choose options for continuous running
key = '#'; //exit this loop
break;
case '9': // Update Settings
Settings();
key = '#'; //exit this loop
break;
}
} //end switchcase
} //end loop
//=====================================================================================================
//=====================================================================================================
/* updateNumber gets a float value with the prompt string provided. If a new number is not
entered then the current value of the float is returned.
To get an integer Number use
int getNumber("prompt", float someinteger, 0);
Screen display looks like this:
+--------------------+
| Provided prompt str|
| Value = |
| |
| #=ENTER D=CLEAR|
+--------------------+
*/
float updateNumber(String prompt, float FloatValue, int decPlaces) //decPlaces is the number of decimal places to display
{
float Num = 0.0;
float Decimal = 0.0;
float DecNum = 0.0;
int counter = 0;
lcd.clear();
lcd.print(prompt);
lcd.setCursor(0, 1); lcd.print("Value = ");
lcd.print(FloatValue, decPlaces);
lcd.setCursor(0, 3); lcd.print("#=EXIT D=CLEAR");
lcd.setCursor(8, 1);
boolean decOffset = false;
char key = kpd.getKey();
while (key != '#')
{
switch (key)
{
case NO_KEY:
break;
case '.':
if (!decOffset)
{
decOffset = true; //Set Decimal flag and print Decimal point (but not if already printed)
lcd.print(key);
}
break;
case 'D': //Clear data entry and reset Decimal point flag
Num = 0.0;
lcd.setCursor(8, 1);
lcd.print(" "); //clear data field with spaces
lcd.setCursor(8, 1);
decOffset = false;
break;
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
if (Num == 0.0) //Clear data entry field if new entry
{
lcd.setCursor(8, 1);
lcd.print(" "); //clear data field with spaces
lcd.setCursor(8, 1);
}
if (!decOffset)
{
Num = Num * 10.0 + (key - '0');
lcd.print(key);
}
else if ((decOffset) && (counter <= 4)) //Counter Number = Number of Decimal places minus one
{
Num = Num * 10.0 + (key - '0');
lcd.print(key);
counter++;
}
break;
} //end switchcase
DecNum = Num / pow(10, counter);
key = kpd.getKey();
} //end while not #
if (DecNum != 0) {
return DecNum; //return new number if one is entered
}
else
{
return FloatValue; //return the original number if no change
}
return DecNum;
} //end getNumber
// getBoolean toggles a yes/no or true/false and returns the result.
boolean getBoolean(String prompt, boolean flip)
{
lcd.clear();
lcd.home();
lcd.print(prompt);
lcd.setCursor(0, 1); lcd.print("Value = ");
lcd.setCursor(8, 1); if (flip) { //If the beep setting is currently set to True
lcd.print("ON ");
} else {
lcd.print("OFF");
}
lcd.setCursor(0, 3); lcd.print("#=EXIT D=Toggle");
char key = kpd.getKey();
while (key != '#')
{
switch (key)
{
case NO_KEY:
break;
case 'D': // Toggle boolean value
flip = !flip;
lcd.setCursor(8, 1); if (flip) {
lcd.print("ON ");
} else {
lcd.print("OFF");
}
break;
} //end switchcase
key = kpd.getKey();
} //end while
return flip;
} //end getBoolean
void mainMenu() //The initial menu for the system
{
lcd.clear();
lcd.setCursor(0, 0); lcd.print("1: Degrees 3: Sides");
lcd.setCursor(0, 1); lcd.print("4: Jog 6: Arc" );
lcd.setCursor(0, 2); lcd.print("7: Continuous");
lcd.setCursor(0, 3); lcd.print("9: Settings" );
} //end mainMenu
void choiceInitialize() //select choice from greeting menu
{
while (key != '#')
{
key = kpd.getKey();
switch (key)
{
case NO_KEY:
break;
case 'A': //Move one full rotation CW
{
stepperInitialize();
TotalStepsTheoretical = MicroStepsPerFullRotation;
moveToTarget();
break;
}
case 'B': //Move one full rotation CCW
{
stepperInitialize();
TotalStepsTheoretical = -MicroStepsPerFullRotation;
moveToTarget();
break;
}
} // end case
} // end while choice != #
} //end choiceInitialize
void jogMenu() //Menu for jog entry - used for jog move and arc end setting by jog
{
lcd.clear();
lcd.setCursor(0, 0); lcd.print("JOG sum=");
if (backlashOn) {
lcd.print(char(127));
}; //Include a back-arrow symbol if backlash is on
//print the current steps and degrees totals
lcd.setCursor(10, 0); lcd.print(" ");
lcd.setCursor(10, 0); lcd.print(TotalStepsTheoretical, 0);
/* */lcd.print(" "); lcd.print(TotalDegrees, 1); lcd.print((char)223);
lcd.setCursor(0, 1);
for (int i = 1; i < 4; i++)
{
lcd.print((float)i, 0); lcd.print("=+"); lcd.print((float)pow(10, i - 1), 0); lcd.print(" ");
}
lcd.setCursor(0, 2);
for (int i = 4; i < 7; i++)
{
lcd.print((float)i, 0); lcd.print("=-"); lcd.print((float)pow(10, i - 4), 0); lcd.print(" ");
}
lcd.setCursor(0, 3); lcd.print("#=EXIT");
}
void getJog() //Calculate jog movements
{
jogMenu(); //display the jog menu
char key = kpd.getKey();
while (key != '#')
{
key = kpd.getKey();
switch (key)
{
case NO_KEY: break;
case '1': case '2': case '3':
{
StepsPerIncrementTheoretical = pow(10.0, (float)(key - '0') - 1.0);
TotalStepsTheoretical = TotalStepsTheoretical + StepsPerIncrementTheoretical;
TotalDegrees = (TotalStepsTheoretical / MicroStepsPerFullRotation) * 360.0;
lcd.setCursor(10, 0); lcd.print(" ");
lcd.setCursor(10, 0); lcd.print(TotalStepsTheoretical, 0);
/* */lcd.print(" "); lcd.print(TotalDegrees, 1); lcd.print((char)223);
moveToTarget();
break;
}
case '4': case '5': case '6':
{
StepsPerIncrementTheoretical = -(pow(10.0, (float)(key - '0') - 4.0));
TotalStepsTheoretical = TotalStepsTheoretical + StepsPerIncrementTheoretical;
TotalDegrees = (TotalStepsTheoretical / MicroStepsPerFullRotation) * 360.0;
lcd.setCursor(10, 0); lcd.print(" ");
lcd.setCursor(10, 0); lcd.print(TotalStepsTheoretical, 0);
/* */lcd.print(" "); lcd.print(TotalDegrees, 1); lcd.print((char)223);
moveToTarget();
break;
}
case '#':
break;
}
} //end while
} //end getJog
void continuousMenu()
{
//LCD LINE 0
lcd.clear();
lcd.setCursor(0, 0); lcd.print("CONTINUOUS ["); lcd.print((String) stopMode[continuousRunStopMode]); lcd.print(']');
//LCD LINE 1 - note extra spaces to clear data fields
lcd.setCursor(0, 1); lcd.print("sp= ");
lcd.setCursor(3, 1); lcd.print(float (percentMaxSpeed), 0); lcd.print("%= ");
lcd.setCursor(8, 1); lcd.print( (percentMaxSpeed / 100.0) * StepperMaximumSpeed, 0);
lcd.setCursor(13, 1); lcd.print("ac= ");
lcd.setCursor(16, 1); lcd.print(float (StepperAcceleration), 0);
//LCD LINE 2
lcd.setCursor(0, 2); lcd.print("C=settings ");
if (continuousRunStopMode < 2) //If stop mode != reset then print stop-key option
{
lcd.setCursor(14, 2); lcd.print("D=STOP");
}
else
{
lcd.setCursor(13, 2); lcd.print(":reset:");
}
//LCD LINE 3
lcd.setCursor(0, 3); lcd.print("A=CW B=CCW ");
if (continuousRunStopMode < 2) //If stop mode != reset then print EXIT option
{
lcd.setCursor(14, 3); lcd.print("#=EXIT");
}
else
{
lcd.setCursor(13, 3); lcd.print(": STOP:");
}
}
void choiceContinuous()
{
continuousMenu();
while (key != '#') //select choice from continuousMenu
{
key = kpd.getKey();
switch (key)
{
case NO_KEY:
break;
case 'A': //Move clockWise
{
//Reset the maximum stepper speed as a percentage of the stored maximum
//StepperContinuousSpeed = (percentMaxSpeed / 100.0) * StepperMaximumSpeed;
accelerateThenRun(StepperAcceleration, (percentMaxSpeed / 100.0) * StepperMaximumSpeed , clockWise, 'D');
makeBeep(2);
break;
}
case 'B': //Move counterClockWise
{
//Reset the maximum stepper speed as a percentage of the stored maximum
//StepperContinuousSpeed = (percentMaxSpeed / 100.0) * StepperMaximumSpeed;
accelerateThenRun(StepperAcceleration, (percentMaxSpeed / 100.0) * StepperMaximumSpeed , counterClockWise, 'D');
makeBeep(2);
break;
}
case 'C': //Set new percent of max speed
{
choiceSettingsContinuous();
continuousMenu();
key = NO_KEY; //clear # from settings menu
break;
} //end case C
case '#': //Exit
{
break;
}
} // end case
} // end while choice != #
} //end choiceContinuous()
//Sub-menu for settings in Continuous mode
void choiceSettingsContinuous()
{
//Set percent of maximum speed
percentMaxSpeed = updateNumber("% of max speed:", percentMaxSpeed, 0);
//Set acceleration value
StepperAcceleration = updateNumber("Acceleration rate:", StepperAcceleration, 0);
//Set stop mode
getStopMode();
putSettings(); //save the new values to permanent storage
} // end choiceSettingsContinuous
void arcMenu()
{
lcd.clear();
lcd.print("ARC Movement");
if (backlashOn) {
lcd.print(char(127));
}; //Include a back-arrow symbol if backlash is on
//if (TotalStepsTheoretical == 0) //show next rotation direction
//{
// lcd.setCursor(8, 1); lcd.print ("CW>>");
//}
//else
//{
lcd.setCursor(8, 1); lcd.print ("<CCW");
//}
lcd.setCursor(2, 1); lcd.print (0.0, 2); lcd.print((char)223); //print 0.0 start position
lcd.setCursor(14, 1); lcd.print (TotalStepsTheoretical / MicroStepsPerFullRotation * 360.0, 2); lcd.print((char)223); //print value
lcd.setCursor(0, 2); lcd.print ("end set: B=Deg C=Jog");
lcd.setCursor(0, 3); lcd.print ("#=EXIT A=GO");
}
void choiceArc()
{
arcMenu();
while (key != '#') //select choice for arc move
{
key = kpd.getKey();
switch (key)
{
case NO_KEY:
break;
case 'A': //Move back and forth in arc; current position is start position
{
if (TotalStepsTheoretical > 0) // If stepper is at end of arc
{
//clockDir = counterClockWise;
//TotalStepsTheoretical = -TotalStepsTheoretical; // Set next target position back to start of arc
StepsPerIncrementTheoretical = TotalStepsTheoretical; //save current value of StepsPerIncrementTheoretical
TotalStepsTheoretical = 0.0;
lcd.setCursor(8, 1); lcd.print ("CW>>"); // Set direction for *next* move
}
else //else stepper is at start of arc
{
//clockDir = clockWise;
//TotalStepsTheoretical = -TotalStepsTheoretical; // Reset target position back to TotalStepsTheoretical
TotalStepsTheoretical = StepsPerIncrementTheoretical;
lcd.setCursor(8, 1); lcd.print ("<CCW"); //Set direction for *next* move
}
moveToTarget(); //target is always TotalStepsTheoretical for moveToTarget
break;
}
case 'B': //Set arc end position by number of degrees
{
TotalDegrees = updateNumber("Degrees in arc/move", TotalDegrees, 2);
TotalStepsTheoretical = TotalDegrees / 360.0 * MicroStepsPerFullRotation;
StepsPerIncrementTheoretical = TotalStepsTheoretical; // save the current value of TotalStepsTheoretical
if (TotalDegrees != 0.0) {
moveToTarget(); //Move immediately to the degree position
}
arcMenu();
break;
}
case 'C': //Set arc end position by jog moving rotary table to desired position
{
getJog();
StepsPerIncrementTheoretical = TotalStepsTheoretical; // (debug - need this?) save the current value of TotalStepsTheoretical
arcMenu();
break;
} //end case C
case '#': //Exit
{
break;
}
} // end switchcase
} // end while != #
} //end choiceArc()
void Settings() //Get the basic settings for the stepper motor, gear reduction, etc.
//Display the current value for each setting
//If no new Number is entered, keep the current value
{
//Get Number of steps per full revolution of the stepper motor
String prompt = "Full steps in 360";
prompt += char(223); //degree symbol
prompt += ":";
stepsPerFullRotation = updateNumber(prompt, stepsPerFullRotation, 0);
//Get the micro-stepping setting
microStepping = updateNumber("Micro-stepping:", microStepping, 0);
//Get the table (gear) ratio
TableRatio = updateNumber("Table Gear Ratio:", TableRatio, 6);
//Get the backlash correction
//If a number is entered for backlash correction, it will be stored even if backlash correction is turned off.
backlashOn = getBoolean("Fix backlash? ", backlashOn);
if (backlashOn) // If backlash correction is switched on
{
backlash = updateNumber("Backlash amount:", backlash, 0);
}
//Set start beep on or off
beepStart = getBoolean("Beep on start?", beepStart);
//Set halt beep on or off
beepHalt = getBoolean("Beep on stop?", beepHalt);
//Get the maximum motor speed
StepperMaximumSpeed = updateNumber("Max motor speed:", StepperMaximumSpeed, 0);
//Get the motor acceleration
StepperAcceleration = updateNumber("Acceleration rate:", StepperAcceleration, 0);
//Get the % of maximum speed for continuous run
percentMaxSpeed = updateNumber("% of max speed:", percentMaxSpeed, 0);
//Get the continuousRunStopMode
getStopMode();
putSettings(); // Save the new settings to EEPROM
makeBeep(halt);
} //end settings
void getStopMode()
{
lcd.clear();
lcd.print("Continuous-stop mode");
lcd.setCursor(0, 1); lcd.print("Mode =");
lcd.setCursor(0, 3); lcd.print("#=EXIT D=Toggle");
int i = continuousRunStopMode;
if (i < 0 || i > 2) {
i = 0; //If stray bits are read from storage, default to a true value
}
lcd.setCursor(8, 1); lcd.print(" "); //Print the current mode value
lcd.setCursor(8, 1); lcd.print((String) stopMode[i]);
key = NO_KEY; //Clear previous # keypress
while (key != '#')
{
key = kpd.getKey();
switch (key)
{
case 'D':
{
i = i + 1; //Increment i, if > 2 start over at 0
if (i > 2) {
i = 0;
}
continuousRunStopMode = i;
lcd.setCursor(8, 1); lcd.print(" ");
lcd.setCursor(8, 1); lcd.print((String) stopMode[i]);
}
case '#':
break;
}
}
}
void getSettings()
{
EEPROM.get(0, stepsPerFullRotation); // 2 byte int
EEPROM.get(2, microStepping); // 2 byte int
EEPROM.get(4, TableRatio); // 4 byte float
EEPROM.get(8, backlash); // 2 byte int
EEPROM.get(10, backlashOn); // 1 byte boolean
EEPROM.get(11, beepStart); // 1 byte boolean
EEPROM.get(12, beepHalt); // 1 byte boolean
EEPROM.get(13, StepperMaximumSpeed); // 4 byte float
EEPROM.get(17, StepperAcceleration); // 4 byte float
EEPROM.get(21, percentMaxSpeed); // 2 byte int
EEPROM.get(23, continuousRunStopMode); // 2 byte int
// Set the total theoretical number of microsteps required for a full 360 degree revolution:
MicroStepsPerFullRotation = (float) stepsPerFullRotation * (float) microStepping * TableRatio;
} //end getSettings
void putSettings()
{
EEPROM.put(0, stepsPerFullRotation); // 2 byte int
EEPROM.put(2, microStepping); // 2 byte int
EEPROM.put(4, TableRatio); // 4 byte float
EEPROM.put(8, backlash); // 2 byte int
EEPROM.put(10, backlashOn); // 1 byte boolean
EEPROM.put(11, beepStart); // 1 byte boolean
EEPROM.put(12, beepHalt); // 1 byte boolean
EEPROM.put(13, StepperMaximumSpeed); // 4 byte float
EEPROM.put(17, StepperAcceleration); // 4 byte float - also changed/stored via choiceContinuous function
EEPROM.put(21, percentMaxSpeed); // 2 byte int - also changed/stored via choiceContinuous function
EEPROM.put(23, continuousRunStopMode); // 2 byte int
// Re-calculate the MicroStepsPerFullRotation from the updated values
MicroStepsPerFullRotation = (float) stepsPerFullRotation * (float) microStepping * TableRatio;
} //end putSettings
//Initialize the AccelStepper settings, and degree and step position variables
void stepperInitialize()
{
// Initialize variables
Degrees = 0.0;
TotalDegrees = 0.0;
stepToMoveTo = 0; //Target position for stepper.moveTo()
stepper.setCurrentPosition(0); // Set stepper current position and speed to zero
TotalStepsTheoretical = 0.0;
stepper.setMaxSpeed(StepperMaximumSpeed);
stepper.setAcceleration(StepperAcceleration);
}
// indexMove calculates the theoretical step position and the end of the next move
void indexMove()
{
lcd.clear();
lcd.print("INDEXING =");
if (backlashOn) {
lcd.print(char(127));
}; //Include a back-arrow symbol if backlash is on
lcd.setCursor(11, 0); lcd.print(Degrees, 2); lcd.print((char)223); //print degrees per index step
lcd.setCursor(0, 1); lcd.print("Position =");
lcd.setCursor(11, 1); lcd.print(TotalDegrees, 2); lcd.print((char)223); //print total degrees moved
lcd.setCursor(0, 3); lcd.print("#=EXIT A=CW B=CCW");
while (key != '#') // # will return to start menu
{
key = kpd.getKey();
if (key == 'A') // MOVE CLOCKWISE
{
TotalDegrees = TotalDegrees + Degrees;
// When making a full rotation, restart count at 360 degrees
TotalDegrees = ((TotalDegrees / 360.0) - int (TotalDegrees / 360.0)) * 360.0;
TotalStepsTheoretical = TotalStepsTheoretical + StepsPerIncrementTheoretical;
lcd.setCursor(6, 2); lcd.print("Moving");
lcd.setCursor(11, 1); lcd.print(" "); // clear print field
lcd.setCursor(11, 1);
lcd.print(TotalDegrees, 2); lcd.print((char)223);
moveToTarget();
lcd.setCursor(6, 2); lcd.print(" ");
}
if (key == 'B') // MOVE COUNTERCLOCKWISE
{
TotalDegrees = TotalDegrees - Degrees;
// When making a full rotation, restart count at 360 degrees
TotalDegrees = ((TotalDegrees / 360.0) - int (TotalDegrees / 360.0)) * 360.0;
TotalStepsTheoretical = TotalStepsTheoretical - StepsPerIncrementTheoretical; // For reverse moves steps are negative
lcd.setCursor(6, 2); lcd.print("Moving");
lcd.setCursor(11, 1); lcd.print(" "); // clear print field
lcd.setCursor(11, 1);
lcd.print(TotalDegrees, 2); lcd.print((char)223);
moveToTarget();
lcd.setCursor(6, 2); lcd.print(" ");
}
} // end while not # loop
}
// Update display and move to the a target step number; apply backlash correction if
// rotation has reversed and backlash correction is on. Backlash correction is applied
// by resetting the stepper.currentPosition by an amount equal to the backlash correction
void moveToTarget()
{
makeBeep(start);
//Check to see if reversing direction
if (clockDir == clockWise && TotalStepsTheoretical < stepper.currentPosition() ) //change from CW to CCW?
{
stepper.setCurrentPosition( stepper.currentPosition() + (backlashOn * backlash) ); //apply backlash correction
clockDir = counterClockWise;
}
if (clockDir == counterClockWise && TotalStepsTheoretical > stepper.currentPosition() ) //change from CCW to CW?
{
stepper.setCurrentPosition( stepper.currentPosition() - (backlashOn * backlash) ); //apply backlash correction
clockDir = clockWise;
}
/* debug include this code to enable stopKey
while ( stepper.isRunning() && kpd.getKey() != 'D') //loop until motor stops or stopKey is pressed
{
stepper.run();
}
if (stepper.speed() != 0.0) {
stopFlag = true; //If stopKey was used set the stopFlag
}
stepper.stop(); //Reset target for deceleration and then stop
*/
stepper.moveTo(TotalStepsTheoretical); //Set target position for move
stepper.runToPosition();
makeBeep(halt);
} //end moveToTarget
//*makeBeep beeps the specified number of times if the beeper function is switched on.
void makeBeep( int mode)
{
if (mode == start && beepStart) //Beep at start if beep switched on
{
tone(beepPin, beepFrequency, 290); //tone(pin,frequency,duration-milliseconds)
delay(340);
}
if (mode == halt && beepHalt) //Beep at stop if beep switched on
{
tone(beepPin, beepFrequency, 290); //tone(pin,frequency,duration-milliseconds)
delay(340);
}
}
/*Accelerate to designated speed and then continue running until key is pressed
- if key is pressed then decelerate to a stop
- if key pressed while decelerating then immediate stop
The initial target position is the highest possible long int = 2,147,483,647
Ignoring the acceleration phase, and assuming a highest possible speed of 4,000 steps/second
this is
2,147,483,647/4,000 = 536870 seconds or approx 6.2 days
In other words, the motor will run "continuously" until the stop button is pushed, or stop by itself
in 6.2 days (longer for lower maximum speeds). While this is not true continuous running, it should
be a good compromise for rotary table use.
acceleration = the acceleration rate in steps/sec/sec
StepperMaximumSpeed = speed to accelerate to and then run at
clockDir = direction of rotation (CW=1, CCW=-1)
stopKey = designated key to press to stop running
When numsteps is negative rotation is reversed and speed becomes negative also; this is addressed
by the clockDir variable.
*/
void accelerateThenRun(float acceleration, float StepperContinuousSpeed, int rotateDirection, char stopKey)
{
makeBeep(start);
switch (continuousRunStopMode)
{
case 0: //stop with stopkey
stepper.setCurrentPosition(0); //Initialize position and speed to zero for next start
stepper.move(long (rotateDirection * 2147483647)); //Set direction; set target position to number that will not be reached
stepper.setMaxSpeed(rotateDirection * StepperContinuousSpeed);
stepper.setAcceleration(acceleration);
while ( kpd.getKey() != stopKey ) //Press stop key to stop acceleration phase
{
stepper.run();
}
//decelerate to a stop
stepper.stop(); //Reset target for deceleration
stepper.runToPosition();
makeBeep(halt);
break;
case 1: //stop with detect key press
//Variation Rev4.50b : Use a digital pin read to check for stop button in continuous run. You will need to hold the
// stop button down for 1 - 3 seconds. There is no immediate stop option, but there is deceleration to a stop.
{
stepper.setCurrentPosition(0); //Initialize position and speed to zero for next start
stepper.move(long (rotateDirection * 2147483647)); //Set direction; set target position to number that will not be reached
stepper.setMaxSpeed(rotateDirection * StepperContinuousSpeed);
stepper.setAcceleration(acceleration);
//while ( digitalRead(4) == HIGH ) //Press stop key to stop acceleration phase
while ( PIND & 0b00010000) //Read pin 4 "directly" for fastest read
{
stepper.run();
}
//decelerate to a stop
stepper.stop(); //Reset target for deceleration
stepper.runToPosition();
makeBeep(halt);
}
break;
case 2: //stop with reset
stepper.setCurrentPosition(0); //Initialize position and speed to zero for next start
stepper.move(long (rotateDirection * 2147483647)); //Set direction; set target position to number that will not be reached
stepper.setMaxSpeed(rotateDirection * StepperContinuousSpeed);
stepper.setAcceleration(acceleration);
stepper.runToPosition();
break;
} //end switch case
}
Messaggi: 477
Discussioni: 25
Registrato: Apr 2021
Quel programma non è stato scritto per una rotazione continua della tavola ma per una logica posizionale. Perciò visto lo scopo (muovere la tavola per gradi) è senza senso implementare accelerazione e decelerazione. Poi chiaro se si vuole usare per altro c'è bisogno di altro. Per l'invio del segnale di step non è stato nemmeno usato il pwm hw ma è stato implementato il pwm in modalità bang-bang ovvero segnale alto, aspetto delay segnale basso delay e così via. Non c'entra niente ne grbl ne altre robe, questo è un programma super basico che da tanti impulsi quanti gradi sono necessari. Visto come funziona (senza rampe) è scontato che se si abbassa troppo il delay il motore stalla perché va in risonanza. Se leggete questa AN (molto interessante) capite anche il perché https://www.google.com/url?sa=t&source=w...u_muGCzqwT
Messaggi: 154
Discussioni: 1
Registrato: Jun 2021
Ciao umbez,
concordo che GRBL sia fuori luogo per quel poco che si vuole fare.
Ciononostante, senza mettere in dubbio le competenze di nessuno, la versione migliorata dello sketch (quella con le rampe) e' stata resa disponibile dalle stesse persone che hanno creato la versione super basica.
Mi sono limitato a suggerire della sua disponibilita' per offrire a Carlino una possibile soluzione alternativa.
Carlino non e' obbligato a usarla.
Ciao :-)
Mauro
P.S. L'application note della TI l'ho letta ma forse mi e' sfuggito quello a cui fai riferimento. A me sembra parlino proprio dell'importanza dell'accelerazione.
Messaggi: 477
Discussioni: 25
Registrato: Apr 2021
02-06-2022, 06:57 AM
(Questo messaggio è stato modificato l'ultima volta il: 02-06-2022, 07:02 AM da umbez.)
billielliot c'è stato un fraintendimento, la mia risposta non era indirizzata a qualcuno, soprattutto a te. Era solo per chiarire quello che c'è scritto in quel programma rispetto all'aspettativa d'uso. Il link che hai postato con accelstepper, pur conoscendo la libreria, non l'ho letto ancora. L'app note l'ho linkata proprio per chiarire l'utilizzo dello stepper ed evidentemente non era indirizzata a nessuno nello specifico. Quando ho parlato con Carlo al telefono la prima volta, già ero scettico rispetto all'uso del programma come quarto asse, ed ad onore del vero, non me l'ero posto nemmeno come un possibile utilizzo perché per me il punto di arrivo era il divisore. Poi oh, se c'è la possibilità di usarlo come 4 asse ancora meglio, a cambiare il firm ci vogliono 5 secondi, ma ad ora non l'ho nemmeno letto quindi non ho idea di come funzioni, suppongo però che ci siano dei valori ulteriori da impostare per regolare la pendenza delle rampe.
Messaggi: 5,218
Discussioni: 66
Registrato: Mar 2021
Seguo con interesse questa discussione , se posso vi disturberò telefonicamente per approfondire , data la mia ignoranza in materia.
Messaggi: 1,069
Discussioni: 61
Registrato: May 2021
A questo punto chiedo scusa per i miei interventi fuorvianti.
Credevo che il sistema fosse basato su GRBL, e che, oltre alla logica posizionale, potesse rispondere anche all'uso dinamico.
Messaggi: 485
Discussioni: 35
Registrato: Mar 2021
02-06-2022, 10:15 AM
(Questo messaggio è stato modificato l'ultima volta il: 02-06-2022, 10:15 AM da brunart.)
LEO, non solo non devi chiedere scusa, ma vedo utile i tuoi interventi, perchè questo divisore digitale si presta a notevoli miglioramenti ed innovazioni.
io immagino una macchina ancora più versatile
per esempio
ti può aiutare a fare le eliche
le chiocciole piane
si può usare la fresatrice come una specie di tornio
senza diventare una CNC si potrebbe interfacciare con uno o più assi della fresatrice
per cui benvenute tutte le idee, i commenti, le critiche e i ripensamenti
se due si scambiano 2 oggetti restano sempre con un oggetto a testa, ma se si scambiano due idee ...
e... se vuoi volare ricordati che devi battere le ali.
..... Quando tutto sembra andare contro, ricorda che gli aeroplani decollano contro vento, non con lui!
Messaggi: 477
Discussioni: 25
Registrato: Apr 2021
02-06-2022, 10:18 AM
(Questo messaggio è stato modificato l'ultima volta il: 02-06-2022, 10:18 AM da umbez.)
Leo nessuna scusa, siamo qui a fare Brainstorming e troubleshooting, da questa fase vengono fuori le cose migliori. Quello che a me interessa sarebbe capire l'utilità
di questa funzionalità (muovere la tavola in continuo) nel concreto, perché se non ho il controllo degli altri tre assi, che me ne faccio? (E qui si va in quello che dicevi tu con grbl) potete farmi qualche esempio...? Perché in futuro volevo implementare anche io questo sistema, ma con un nema17, decisamente meno ingombrante, ma se questa funzionalità è utile allora meglio il nema23
Messaggi: 899
Discussioni: 26
Registrato: Nov 2021
Complimenti a Umbez che si e´preso la briga di guardarsi il codice, non sara´ obbligatorio ma visto che cé´meglio usare la versione con le rampe che se per disgrazia si perdon passi poi a somma di errori vien fuori un macello.
Per l úso del 4 asse a motorizzarlo e´peggio di un lineare, cambia il diametro cambian risoluzioni velocita´e forza quindi e´meglio andarci coi piedi di piombi, sul Dania e sill´Hobbymat ho fatto in modo di poter lavorare con un 4 asse, lo stepper sull´Hobbimat e´un nema 17 molto ridotto siamo al 10 a 1 , sul Grazioli nema 23 il piu´grosso sempre sul 10 a 1 ma li lélettromandrino e´in entrambe i casi piccolo e piu´di tanto non potra´mai asportare in una passata
Per un inseguitore che sto facendo, come altri di la´, per fare ingranaggi . Verrei implementare la funzione anche di divisore e poi perche´no visto che cé´4 asse
Dato che va´sulla fresa grossa con una testa che permette lavori pesanti ho scelto un nema 34 da 9nm l autocentrante e´da 160.
Uso come 4 asse: come controlli cé´ poco ma i sono Mach3 e Grbl lo fanno poi se si sale su roba costosa e´meglio implementato.
Generare percorsi per il 4 asse non ho trovato nulla di veramente completo che non sia a pagamento e caro, la roba semplice si limita ad avvolgere un disegno piano sull´aase rotativo.
Lúnica cosa che genera bene per il 4 asse e´ Gmax con dei plugin, ilo usavo 20 anni fa´e quello e´rimasto lo sviluppo e´fermo,,complicato ma funziona
Bello il 4 ase ma a farci veramente qualcosa di complesso e´un gran lavoro
|
divisore digitale, una comodità in più
