3D printer from scratch - User contributions [en]

Mathematics

2018-09-03T07:49:47Z

Sensille: /* Current (lacking) Solution */

== Requirements for the Controller ==

* The head has to be moved along a given curve. Currently the curve consists of segments of lines, clothoids and arcs. Later on they may also be described by Bezier-Splines/B-Splines/NURBS.
* The movement speed is independent from the parameterization of the curve. Most of the time the head is required to move at constant |v|, but it also accelerates/decelerates.
* Head movement has to be continuous in position, speed and acceleration and bounded in jerk. The source curves are at least <math>C^2</math>.
* The path the head is moved along should not deviate from the given curve by more than 0.01mm, total range is 300mm. So an accuracy of <math>10^{-5}</math> is striven for.
* The velocity of the head should not deviate by more than <math>10^{-4}</math>, the acceleration has to be continuous and bounded, the jerk only has to be bounded.
* The motor controller is implemented in an FPGA and communicates with the host via UART.
* Required step frequency up to 6 MHz, FPGA running at 20MHz.
* The solution should accommodate multiple kinematics, like cartesian, corexy, delta and polar.

== Current (lacking) Solution ==

Currently the controller accepts commands of tuples of jerk values for each axis along with a duration. Velocity and acceleration initially start at zero and are maintained between commands. This is good for straight lines with s-curve motion profiles, but to follow a curve tightly many control commands would be necessary, overwhelming the host and the communication interface.

Commands are queued so that they can be executed back-to-back.

== Possible Solution ==

If the controller would implement a 5th order polynomial, each control command would consist of a tuple of (jerk, snap, crackle) per axis and a duration, while again velocity and acceleration start at zero and are maintained between commands. This would allow the controller to control the movement of the head up to jerk, while approximating the curve with a 2nd order path. The resulting motion would be continuous up to acceleration, while between segment jerk, snap and crackle can jump.

To derive the parameters one would partition the curve into segments, calculating position, velocity and acceleration on start and end point. These 6 values determine exactly all parameters and ensure that the resulting path is <math>C^2</math>.

The segments could be evenly spaced in terms of arc length or varied depending on the sharpness (change of curvature) of the curve. This is very easy for lines, arcs and clothoids as they are already parameterized in arc length, whereas for splines it would be necessary to approximate the arc length numerically.

Note that the source curve is two dimensional, while the controller commands are per axis. Velocity and acceleration information are provided seperatly.

One advantage of this solution is that there is no curve fitting necessary, because at the end of each segments the exact values of position, direction, velocity and acceleration are met.

Mathematics

2018-09-03T07:49:13Z

Sensille: /* Current (lacking) Solution */

== Requirements for the Controller ==

* The head has to be moved along a given curve. Currently the curve consists of segments of lines, clothoids and arcs. Later on they may also be described by Bezier-Splines/B-Splines/NURBS.
* The movement speed is independent from the parameterization of the curve. Most of the time the head is required to move at constant |v|, but it also accelerates/decelerates.
* Head movement has to be continuous in position, speed and acceleration and bounded in jerk. The source curves are at least <math>C^2</math>.
* The path the head is moved along should not deviate from the given curve by more than 0.01mm, total range is 300mm. So an accuracy of <math>10^{-5}</math> is striven for.
* The velocity of the head should not deviate by more than <math>10^{-4}</math>, the acceleration has to be continuous and bounded, the jerk only has to be bounded.
* The motor controller is implemented in an FPGA and communicates with the host via UART.
* Required step frequency up to 6 MHz, FPGA running at 20MHz.
* The solution should accommodate multiple kinematics, like cartesian, corexy, delta and polar.

== Current (lacking) Solution ==

Currently the controller accepts commands of tuples of jerk values for each axis along with a duration. Velocity and acceleration initially start at zero and are maintained between commands. This is good for straight lines with s-curve motion profiles, but to follow a curve tightly many control commands would be necessary, overwhelming the host and the communication interface.

Commands are queued to avoid pauses between commands.

== Possible Solution ==

If the controller would implement a 5th order polynomial, each control command would consist of a tuple of (jerk, snap, crackle) per axis and a duration, while again velocity and acceleration start at zero and are maintained between commands. This would allow the controller to control the movement of the head up to jerk, while approximating the curve with a 2nd order path. The resulting motion would be continuous up to acceleration, while between segment jerk, snap and crackle can jump.

To derive the parameters one would partition the curve into segments, calculating position, velocity and acceleration on start and end point. These 6 values determine exactly all parameters and ensure that the resulting path is <math>C^2</math>.

The segments could be evenly spaced in terms of arc length or varied depending on the sharpness (change of curvature) of the curve. This is very easy for lines, arcs and clothoids as they are already parameterized in arc length, whereas for splines it would be necessary to approximate the arc length numerically.

Note that the source curve is two dimensional, while the controller commands are per axis. Velocity and acceleration information are provided seperatly.

One advantage of this solution is that there is no curve fitting necessary, because at the end of each segments the exact values of position, direction, velocity and acceleration are met.

Mathematics

2018-09-03T07:12:08Z

Sensille:

== Requirements for the Controller ==

* The head has to be moved along a given curve. Currently the curve consists of segments of lines, clothoids and arcs. Later on they may also be described by Bezier-Splines/B-Splines/NURBS.
* The movement speed is independent from the parameterization of the curve. Most of the time the head is required to move at constant |v|, but it also accelerates/decelerates.
* Head movement has to be continuous in position, speed and acceleration and bounded in jerk. The source curves are at least <math>C^2</math>.
* The path the head is moved along should not deviate from the given curve by more than 0.01mm, total range is 300mm. So an accuracy of <math>10^{-5}</math> is striven for.
* The velocity of the head should not deviate by more than <math>10^{-4}</math>, the acceleration has to be continuous and bounded, the jerk only has to be bounded.
* The motor controller is implemented in an FPGA and communicates with the host via UART.
* Required step frequency up to 6 MHz, FPGA running at 20MHz.
* The solution should accommodate multiple kinematics, like cartesian, corexy, delta and polar.

== Current (lacking) Solution ==

Currently the controller accepts commands of tuples of jerk values for each axis along with a duration. Velocity and acceleration initially start at zero and are maintained between commands. This is good for straight lines with s-curve motion profiles, but to follow a curve tightly many control commands would be necessary, overwhelming the host and the communication interface.

== Possible Solution ==

If the controller would implement a 5th order polynomial, each control command would consist of a tuple of (jerk, snap, crackle) per axis and a duration, while again velocity and acceleration start at zero and are maintained between commands. This would allow the controller to control the movement of the head up to jerk, while approximating the curve with a 2nd order path. The resulting motion would be continuous up to acceleration, while between segment jerk, snap and crackle can jump.

To derive the parameters one would partition the curve into segments, calculating position, velocity and acceleration on start and end point. These 6 values determine exactly all parameters and ensure that the resulting path is <math>C^2</math>.

The segments could be evenly spaced in terms of arc length or varied depending on the sharpness (change of curvature) of the curve. This is very easy for lines, arcs and clothoids as they are already parameterized in arc length, whereas for splines it would be necessary to approximate the arc length numerically.

Note that the source curve is two dimensional, while the controller commands are per axis. Velocity and acceleration information are provided seperatly.

One advantage of this solution is that there is no curve fitting necessary, because at the end of each segments the exact values of position, direction, velocity and acceleration are met.

Mathematics

2018-09-03T07:10:15Z

Sensille:

== Requirements for the Controller ==

* The head has to be moved along a given curve. Currently the curve consists of segments of lines, clothoids and arcs. Later on they may also be described by Bezier-Splines/B-Splines/NURBS.
* The movement speed is independent from the parameterization of the curve. Most of the time the head is required to move at constant |v|, but it also accelerates/decelerates.
* Head movement has to be continuous in position, speed and acceleration and bounded in jerk. The source curves are at least <math>C^2</math>.
* The path the head is moved along should not deviate from the given curve by more than 0.01mm, total range is 300mm. So an accuracy of <math>10^{-5}</math> is striven for.
* The velocity of the head should not deviate by more than <math>10{^-4}</math>, the acceleration has to be continuous and bounded, the jerk only has to be bounded.
* The motor controller is implemented in an FPGA and communicates with the host via UART.
* Required step frequency up to 6 MHz, FPGA running at 20MHz.
* The solution should accommodate multiple kinematics, like cartesian, corexy, delta and polar.

== Current (lacking) Solution ==

Currently the controller accepts commands of tuples of jerk values for each axis along with a duration. Velocity and acceleration initially start at zero and are maintained between commands. This is good for straight lines with s-curve motion profiles, but to follow a curve tightly many control commands would be necessary, overwhelming the host and the communication interface.

== Possible Solution ==

If the controller would implement a 5th order polynomial, each control command would consist of a tuple of (jerk, snap, crackle) per axis and a duration, while again velocity and acceleration start at zero and are maintained between commands. This would allow the controller to control the movement of the head up to jerk, while approximating the curve with a 2nd order path. The resulting motion would be continuous up to acceleration, while between segment jerk, snap and crackle can jump.

To derive the parameters one would partition the curve into segments, calculating position, velocity and acceleration on start and end point. These 6 values determine exactly all parameters and ensure that the resulting path is <math>C^2</math>.

The segments could be evenly spaced in terms of arc length or varied depending on the sharpness (change of curvature) of the curve. This is very easy for lines, arcs and clothoids as they are already parameterized in arc length, whereas for splines it would be necessary to approximate the arc length numerically.

Note that the source curve is two dimensional, while the controller commands are per axis. Velocity and acceleration information are provided seperatly.

One advantage of this solution is that there is no curve fitting necessary, because at the end of each segments the exact values of position, direction, velocity and acceleration are met.

File:Railcore.png

2018-09-03T06:31:34Z

Sensille:

Mathematics

2018-09-03T06:11:27Z

Sensille:

== Requirements for the Controller ==

* The head has to be moved along a given curve. Currently the curve consists of segments of lines, clothoids and arcs. Later on they may also be described by Bezier-Splines/B-Splines/NURBS.
* The movement speed is independent from the parameterization of the curve. Most of the time the head is required to move at constant |v|, but it also accelerates/decelerates.
* Head movement has to be continuous in position, speed and acceleration and bounded in jerk. The source curves are at least C2.
* The path the head is moved along should not deviate from the given curve by more than 0.01mm, total range is 300mm. So an accuracy of 10^-5 is striven for.
* The velocity of the head should not deviate by more than 10^-4, the acceleration has to be continuous and bounded, the jerk only has to be bounded.
* The motor controller is implemented in an FPGA and communicates with the host via UART.
* Required step frequency up to 6 MHz, FPGA running at 20MHz.
* The solution should accommodate multiple kinematics, like cartesian, corexy, delta and polar.

== Current (lacking) Solution ==

Currently the controller accepts commands of tuples of jerk values for each axis along with a duration. Velocity and acceleration initially start at zero and are maintained between commands. This is good for straight lines with s-curve motion profiles, but to follow a curve tightly many control commands would be necessary, overwhelming the host and the communication interface.

== Possible Solution ==

If the controller would implement a 5th order polynomial, each control command would consist of a tuple of (jerk, snap, crackle) per axis and a duration, while again velocity and acceleration start at zero and are maintained between commands. This would allow the controller to control the movement of the head up to jerk, while approximating the curve with a 2nd order path. The resulting motion would be continuous up to acceleration, while between segment jerk, snap and crackle can jump.

To derive the parameters one would partition the curve into segments, calculating position, velocity and acceleration on start and end point. These 6 values determine exactly all parameters and ensure that the resulting path is C2.

The segments could be evenly spaced in terms of arc length or varied depending on the sharpness (change of curvature) of the curve. This is very easy for lines, arcs and clothoids as they are already parameterized in arc length, whereas for splines it would be necessary to approximate the arc length numerically.

Note that the source curve is two dimensional, while the controller commands are per axis. Velocity and acceleration information are provided seperatly.

One advantage of this solution is that there is no curve fitting necessary, because at the end of each segments the exact values of position, direction, velocity and acceleration are met.

Mathematics

2018-09-03T06:08:27Z

Sensille:

== Requirements for the Controller ==

* The head has to be moved along a given curve. Currently the curve consists of segments of lines, clothoids and arcs. Later on they may also be described by Bezier-Splines/B-Splines/NURBS.
* The movement speed is independent from the parameterization of the curve. Most of the time the head is required to move at constant |v|, but it also accelerates/decelerates.
* Head movement has to be continuous in position, speed and acceleration and bounded in jerk. The source curves are at least C2.
* The path the head is moved along should not deviate from the given curve by more than 0.01mm, total range is 300mm. So an accuracy of 10^-5 is striven for.
* The velocity of the head should not deviate by more than 10^-4, the acceleration has to be continuous and bounded, the jerk only has to be bounded.
* The motor controller is implemented in an FPGA and communicates with the host via UART.
* Required step frequency up to 6 MHz, FPGA running at 20MHz.
* The solution should accommodate multiple kinematics, like cartesian, corexy, delta and polar.

== Current (lacking) Solution ==

Currently the controller accepts commands of tuples of jerk values for each axis along with a duration. Velocity and acceleration initially start at zero and are maintained between commands. This is good for straight lines with s-curve motion profiles, but to follow a curve tightly many control commands would be necessary, overwhelming the host and the communication interface.

== Possible Solution ==

If the controller would implement a 5th order polynomial, each control command would consist of a tuple of (jerk, snap, crackle) per axis and a duration, while again velocity and acceleration start at zero and are maintained between commands. This would allow the controller to control the movement of the head up to jerk, while approximating the curve with a 2nd order path. The resulting motion would be continuous up to acceleration, while between segment jerk, snap and crackle can jump.

To derive the parameters one would partition the curve into segments, calculating position, velocity and acceleration on start and end point. These 6 values determine exactly all parameters and ensure that the resulting path is C2.

The segments could be evenly spaced in terms of arc length or varied depending on the sharpness (change of curvature) of the curve. This is very easy for lines, arcs and clothoids as they are already parameterized in arc length, whereas for splines it would be necessary to approximate the arc length numerically.

Note that the source curve is two dimensional, while the controller commands are per axis. Velocity and acceleration information are provided seperatly.

Mathematics

2018-09-03T05:56:57Z

Sensille:

== Requirements for the Controller ==

* The head has to be moved along a given curve. Currently the curve consists of segments of lines, clothoids and arcs. Later on they may also be described by Bezier-Splines/B-Splines/NURBS.
* The movement speed is independent from the parameterization of the curve. Most of the time the head is required to move at constant |v|, but it also accelerates/decelerates.
* Head movement has to be continuous in position, speed and acceleration and bounded in jerk. The source curves are at least C2.
* The path the head is moved along should not deviate from the given curve more than, 0.01mm, total range of motion is 300mm. So a accuracy of 10^-5 is striven for.
* The velocity of the head should not deviate by more than 10^-4, the acceleration has to be continuous and bounded, the jerk has only to be bounded.
* The motor controller is implemented in an FPGA and communicates with the host via UART.
* Required step frequency up to 6 MHz, FPGA running at 20MHz
* The solution should accommodate multiple kinematics, like cartesian, corexy, delta and polar

== Current (lacking) Solution ==

Currently the controller accepts commands of tuples of jerk values for each axis along with a duration. Velocity and acceleration initially start at zero and are maintained between commands. This is good for straight lines with s-curve motion profiles, but to follow a curve tightly many control commands would be necessary, overwhelming the host and the communication interface.

== Possible Solution ==

If the controller would implement a 5th order polynomial, each control command would consist of a tuple of (jerk, snap, crackle) per axis and a duration, while again velocity and acceleration start at zero and are maintained between command. This would allow the controller to control the movement of the head up to jerk, while approximating the curve with a 2nd order path. The resulting motion would bei continuous up to acceleration, while between segment jerk, snap and crackle can jump.

To derive the parameters one would partition the curve into segments, calculating position, velocity and acceleration on start and end point. These 6 values determine exactly all parameters and ensure that the resulting path is C2.

The segments could be evenly spaced in terms of arc length or varied depending on the sharpness (change of curvature) of the curve. This is very easy for lines, arcs and clothoids as they are already parametrized in arc length, whereas for splines it would be necessary to approximate the arc length.

Mathematics

2018-09-03T05:28:51Z

Sensille: Created page with "== Requirements for the Controller == * The head has to be moved along a given curve. Currently the curve consists of segments of lines, clothoids and arcs. Later on they may..."

Main Page

2018-09-03T05:09:02Z

Sensille:

[[Stepper]]

[[Controller]]

[[Controller v2]]

[[Mathematics]]

[[Slicing]]

Slicing

2018-09-03T05:08:31Z

Sensille: Sensille moved page Mathematics to Slicing without leaving a redirect

= Transformation Chain =

== Input ==
* STL
* STEP

== Slicing output ==
* lines
* arcs
* b-splines

=== Options ===
* approximate everything with lines (gcode)
* approximate everything with bezier splines

== Adding velocity profile ==
* trapezoidal
* s-curve
* higher order

== Transform into target kinematics ==
* cartesian
* corexy
* delta
* polar

=== Options ===
* transform mathematically
* quantize into oversampled steps before transformation and translate only points Oversampling may depend on the target kinematics and must be high enough that after transformation the resolution still exceeds the microstepping resolution

== Generate per-axis motion data ==
* either mathematically
* or step data

== Transfer per-axis motion data ==
* transfer mathematically
* transfer ((lossily) compressed) step data

== Generate steps ==

= Potential Solutions =

== Most complex solution: Transport mathematically correct data up to the fpga ==
* transformations for lines, arcs and splines needed into target kinematics
* projections into single axis and combination with velocity profiles for each transformation needed
* fpga needs to know all projected profiles

== Intermediate solution: Approximate at or after slicing and transport mathematically ==
* only one motion (lines or splines) need to be translated into all target kinematics
* fpga need to know one profile for each kinematics

== Simplest solution: Approximate at or after slicing ==
* only points need to be translated to target kinematics
* computationally intensive because each point needs to be translated individually, plus needed oversampling for some kinematics
* steps need to be compressed for transmission. If the compression is lossy, it degrades the precision slightly

Controller v2

2018-07-29T15:29:12Z

Sensille: /* SET_ROUTING */

= UART-based Controller =

The controller has two UARTs, one for control and one for motion data. The motion-UART can use hardware flow control.

== Framing ==

The framing is self synchronizing. Each frame ends with an EOF marker. Everywhere else the EOF marker is escaped.

=== Frame Format ===

* 1 byte sequence number
* n byte frame data
* 2 byte crc16 (CCITT) of frame data
* 0x7e as EOF marker

=== Escaping ===

Escaping is done by byte stuffing. Escape character is 0x7d. Bytes to be escaped are 0x7d and 0x7e. The escape character is following by the byte to by escaped XOR 0x20.

=== Sequence Number ===

The sequence number is echoed by the controller. The controller expects sequence numbers in ascending order. The sequence number has 7 bits. The special sequence nuber 0x80 resets the expected number in the controller to 0, so that the next frame has to be sent with the number 0x01. This is needed to achieve a resynchronization.
The controller signals a receive error by setting the MSB in the response sequence number, echoing the received number.

== Control Commands ==

<vardata> is an 8-120 bit unsigned integer. If less than 120 bit are sent, the date is 0-extended to 120 bit.

=== SPI ===

Format: 0x8X <vardata>

Sends <vardata> to SPI, asserting CS X. The read data are sent in a response packet of full length.

=== GPOUT_HI ===

Format: 0x70 <X>

Sets GPIO X to HI.

=== GPOUT_LO ===

Format: 0x71 <X>

sets GPIO X to LO.

=== GPIN ===

Format: 0x78

Sends the value of all GPIN-pins as a bitmask in a response packet.

== Motion Commands ==

<vardata> is an 8-64 bit signed integer. If less than 64 bit are sent, the date is sign extended to 64 bit.

=== SET_ROUTING ===

Format: 0x60 <output channel> <controller source>

Controllers are numbered here starting from 1. Setting the controller to 0 means disabling the output.

=== NOTIFY ===

Format: 0x61 <vardata>

Echoes <vardata> to host as full 64 bit value.

=== LOADALLREGS ===

Format: 0x70 <vardata>

Load all preload registers to vardata.

=== LOADCNT ===

Format: 0x71 <vardata>

Load the count register to vardata and latch all registers with the preload registers.

=== LOADREG ===

Format: 0x8X <vardata>

Load the preload register belonging to controller X with vardata.

Controller v2

2018-07-29T15:26:33Z

Sensille: /* UART-based Controller */

= UART-based Controller =

The controller has two UARTs, one for control and one for motion data. The motion-UART can use hardware flow control.

== Framing ==

The framing is self synchronizing. Each frame ends with an EOF marker. Everywhere else the EOF marker is escaped.

=== Frame Format ===

* 1 byte sequence number
* n byte frame data
* 2 byte crc16 (CCITT) of frame data
* 0x7e as EOF marker

=== Escaping ===

Escaping is done by byte stuffing. Escape character is 0x7d. Bytes to be escaped are 0x7d and 0x7e. The escape character is following by the byte to by escaped XOR 0x20.

=== Sequence Number ===

The sequence number is echoed by the controller. The controller expects sequence numbers in ascending order. The sequence number has 7 bits. The special sequence nuber 0x80 resets the expected number in the controller to 0, so that the next frame has to be sent with the number 0x01. This is needed to achieve a resynchronization.
The controller signals a receive error by setting the MSB in the response sequence number, echoing the received number.

== Control Commands ==

<vardata> is an 8-120 bit unsigned integer. If less than 120 bit are sent, the date is 0-extended to 120 bit.

=== SPI ===

Format: 0x8X <vardata>

Sends <vardata> to SPI, asserting CS X. The read data are sent in a response packet of full length.

=== GPOUT_HI ===

Format: 0x70 <X>

Sets GPIO X to HI.

=== GPOUT_LO ===

Format: 0x71 <X>

sets GPIO X to LO.

=== GPIN ===

Format: 0x78

Sends the value of all GPIN-pins as a bitmask in a response packet.

== Motion Commands ==

<vardata> is an 8-64 bit signed integer. If less than 64 bit are sent, the date is sign extended to 64 bit.

=== SET_ROUTING ===

Format: 0x60 <output channel> <controller source>

=== NOTIFY ===

Format: 0x61 <vardata>

Echoes <vardata> to host as full 64 bit value.

=== LOADALLREGS ===

Format: 0x70 <vardata>

Load all preload registers to vardata.

=== LOADCNT ===

Format: 0x71 <vardata>

Load the count register to vardata and latch all registers with the preload registers.

=== LOADREG ===

Format: 0x8X <vardata>

Load the preload register belonging to controller X with vardata.

Controller v2

2018-07-29T15:18:09Z

Sensille: /* UART-based Controller */

= UART-based Controller =

The controller has two UARTs, one for control and one for motion data. The motion-UART can use hardware flow control.

== Framing ==

The framing is self synchronizing. Each frame ends with an EOF marker. Everywhere else the EOF marker is escaped.

=== Frame Format ===

* 1 byte sequence number
* n byte frame data
* 2 byte crc16 (CCITT) of frame data
* 0x7e as EOF marker

=== Escaping ===

Escaping is done by byte stuffing. Escape character is 0x7d. Bytes to be escaped are 0x7d and 0x7e. The escape character is following by the byte to by escaped XOR 0x20.

=== Sequence Number ===

The sequence number is echoed by the controller. The controller expects sequence numbers in ascending order. The sequence number has 7 bits. The special sequence nuber 0x80 resets the expected number in the controller to 0, so that the next frame has to be sent with the number 0x01. This is needed to achieve a resynchronization.
The controller signals a receive error by setting the MSB in the response sequence number, echoing the received number.

== Control Commands ==

== Motion Commands ==

<vardata> is an 8-64 bit signed integer. If less than 64 bit are sent, the date is sign extended to 64 bit.

=== SET_ROUTING ===

Format: 0x60 <output channel> <controller source>

=== NOTIFY ===

Format: 0x61

=== LOADALLREGS ===

Format: 0x70 <vardata>

Load all preload registers to vardata.

=== LOADCNT ===

Format: 0x71 <vardata>

Load the count register to vardata and latch all registers with the preload registers.

=== LOADREG ===

Format: 0x8X <vardata>

Load the preload register belonging to controller X with vardata.

Controller v2

2018-07-29T15:03:45Z

Sensille: /* UART-based Controller */

= UART-based Controller =

Command Format

== Framing ==

The framing is self synchronizing. Each frame ends with an EOF marker. Everywhere else the EOF marker is escaped.

=== Frame Format ===

* 1 byte sequence number
* n byte frame data
* 2 byte crc16 (CCITT) of frame data
* 0x7e as EOF marker

=== Escaping ===

Escaping is done by byte stuffing. Escape character is 0x7d. Bytes to be escaped are 0x7d and 0x7e. The escape character is following by the byte to by escaped XOR 0x20.

=== Sequence Number ===

The sequence number is echoed by the controller. The controller expects sequence numbers in ascending order. The sequence number has 7 bits. The special sequence nuber 0x80 resets the expected number in the controller to 0, so that the next frame has to be sent with the number 0x01. This is needed to achieve a resynchronization.
The controller signals a receive error by setting the MSB in the response sequence number, echoing the received number.

Controller v2

2018-07-29T14:55:58Z

Sensille: /* UART-based Controller */

Controller v2

2018-06-10T18:38:40Z

Sensille: Created page with "= UART-based Controller = Command Format Framing * 1 byte frame length * n byte frame data * 2 byte crc16 (CCITT) of frame data"

= UART-based Controller =

Command Format

Framing

* 1 byte frame length
* n byte frame data
* 2 byte crc16 (CCITT) of frame data

Main Page

2018-06-10T18:36:14Z

Sensille:

[[Stepper]]

[[Controller]]

[[Controller v2]]

[[Mathematics]]

Slicing

2018-06-03T10:11:23Z

Sensille:

Slicing

2018-06-03T10:00:20Z

Sensille: Created page with "Input ===== - STL - STEP Slicing output ============== - lines - arcs - b-splines Options: - approximate everything with lines (gcode) - approximate everything..."

Input
=====
- STL
- STEP

Slicing output
==============
- lines
- arcs
- b-splines

Options:
- approximate everything with lines (gcode)
- approximate everything with bezier splines

Adding velocity profile
=======================
- trapezoidal
- s-curve
- higher order

Transform into target kinematics
================================
- cartesian
- corexy
- delta
- polar

Options:
- transform mathematically
- quantize into oversampled steps before transformation and translate only points
Oversampling may depend on the target kinematics and must be high enough that
after transformation the resolution still exceeds the microstepping resolution

Generate per-axis motion data
=============================
- either mathematically
- or step data

Transfer per-axis motion data
=============================
- transfer mathematically
- transfer ((lossily) compressed) step data

Generate steps

Most complex solution: Transport mathematically correct data up to the fpga
- transformations for lines, arcs and splines needed into target kinematics
- projections into single axis and combination with velocity profiles for each
transformatino needed
- fpga needs to know all projected profiles

Intermediate solution: Approximate at or after slicing and transport mathematically
- only one motion (lines or splines) need to be translated into all target kinematics
- fpga need to know one profile for each kinematics

Simplest solution: Approximate at or after slicing
- only points need to be translated to target kinematics
- computationally intensive because each point needs to be translated individually,
plus needed oversampling for some kinematics
- steps need to be compressed for transmission. If the compression is lossy, it degrades
the precision slightly

Main Page

2018-06-03T09:49:46Z

Sensille:

[[Stepper]]

[[Controller]]

[[Mathematics]]

Stepper

2018-05-13T13:27:04Z

Sensille:

== General Setup ==

Used Stepper: 17HM19-2004S

Driver Voltage: 37V

Driver: TMC2130

Max RPM reached with the motor, unloaded: 3600RPM
This is the limit of the driver. It runs from the internal oscillator at 12.1MHz. Measure by giving a 9.765kHz pulse and read out register TSTEP as 0x277 (DEDGE=true).

== Take One, Lifting Weights ==

Driver Configuration is basically the recommended default from the datasheet for a coil current of about 2A:
reg 0x6c -> 0x200100c3
reg 0x10 -> 0x00061c02
reg 0x91 -> 0x0000000a
reg 0x80 -> 0x00003144
reg 0x93 -> 0x000001f4
reg 0xf0 -> 0x000401c8

For very slow step rates stealthChop was disabled

Load Testing at 1/256 microstepping. Testing done lifting a weight by winding a rope on a cylinder with effective radius of 16.5mm.

<gallery>
Weightlifting.jpeg|Weight Lifting Setup
</gallery>

9.5kHz 2250g
19.5kHz 2150g
39kHz 2240g
58.5kHz 2220g
78kHz 2240g
97.5kHz 2230g
117kHz 2230g
137kHz 2130g
156kHz 2150g
195kHz 2030g
234kHz 2050g
312kHz 2030g
468kHz 1700g
624kHz 1300g
936kHz 740g
1092kHz 556g
1400kHz 250g
1700kHz 150g

{{
Graph:Chart|width=600|height=200|
xAxisTitle=RPM|
yAxisTitle=Torque in Ncm|
legend=Legend|
type=line|
x=11.13,22.85,45.70,68.55,91.41,114.26,137.11,160.55,182.81,228.52,274.22,365.62,548.44,731.25,1096.88,1279.69,1640.62,1992.19|
y1=37.12,35.48,36.96,36.63,36.96,36.80,36.80,35.14,35.48,33.49,33.82,33.49,28.05,21.45,12.21,9.17,4.12,2.47|
y1Title=Measured|
y2=,,,,24,26,32,34,34,34.5,36,35.5,34,16|
y2Title=From Datasheet (rough estimate)|
interpolate=monotone|
colors=seagreen,orchid|
}}

Source for torque curve from datasheet: https://www.omc-stepperonline.com/download/17HM19-2004S_Torque_Curve.pdf

Full data sheet of the motor: https://www.omc-stepperonline.com/download/17HM19-2004S.pdf

== Take Two, Weight Spinning ==

<Gallery>
Weightspinning.jpeg|Setup for torque measurement by a spinning weight
</Gallery>

The idea here is to measure the torque at a given RPM by testing how fast the stepper can accelerate to a higher RPM. This way the measurement is not limit to the length of a linear motion as in the previous chapter.

=== Lost step detection ===

With each round the rotor goes through a photo interruptor. The controller has an internal counter to keep track of the current angle with respect to an arbitrary reference. The home command puts the controller into a mode where it resets the counter if the rotor goes through the interruptor. After that, with each round it checks if the interruptor signal asserts during a given window around the reference. The window can be programmed and is currently set to +/- 4 full steps.

=== Measurement ===

We spin the motor to the RPM under test and try to accelerate it to the next higher RPM level. We use the interruptor signal to detect lost steps.
The acceleration directly corresponds to the torque the motor can generate at the given RPM.

We now have a detailed torque curve RPM vs. Ncm.

Do the same for deceleration

Repeat everything with the other set of weights.

The following series are all done with two 50g weights. The full setup corresponds roughly to a moving mass of 11kg when using a 16T pulley.

=== 1st Series ===

The following graph shows the max acceleration in RPM/s in steps of 200 RPM.

Driver config (just pasted here for reference):

reg 0x04 -> 0x00000000
reg 0xec -> 0x200100c3
reg 0x90 -> 0x00061802
reg 0x91 -> 0x0000000a
reg 0x80 -> 0x00003144
reg 0x93 -> 0x000001f4
reg 0xf0 -> 0x000401c8

{{
Graph:Chart|width=600|height=200|
xAxisTitle=RPM|
yAxisTitle=RPM/s|
type=line|
x=0.00,200.00,400.00,600.00,800.00,1000.00,1200.00,1400.00,1600.00,1800.00,2000.00,2200.00,2400.00,2600.00,2800.00,3000.00,3200.00|
y=7101.94,7611.49,6377.73,5601.97,3675.27,2408.02,1860.57,1763.62,1583.96,1071.46,935.91,891.38,776.37,751.01,664.83,612.14,581.51|
interpolate=monotone|
colors=seagreen,orchid|
}}

=== StealthChop ===

4 Series with StealthChop

tmcw(TMCR_CHOPCONF,
TMC_CHOPCONF_DEDGE |
(2 << TMC_CHOPCONF_TBL_SHIFT) |
(7 << TMC_CHOPCONF_HEND_SHIFT) |
(2 << TMC_CHOPCONF_HSTRT_SHIFT) |
(5 << TMC_CHOPCONF_TOFF_SHIFT));
tmcw(TMCR_IHOLD_IRUN,
( 6 << TMC_IHOLD_IRUN_IHOLDDELAY_SHIFT) |
(24 << TMC_IHOLD_IRUN_IRUN_SHIFT) |
( 3 << TMC_IHOLD_IRUN_IHOLD_SHIFT));
tmcw(TMCR_TPOWER_DOWN, 0x0a);
tmcw(TMCR_GCONF,
TMC_GCONF_DIAG0_INT_PUSHPULL |
TMC_GCONF_DIAG1_PUSHPULL |
TMC_GCONF_DIAG1_STALL |
TMC_GCONF_DIAG0_OTPW |
TMC_GCONF_EN_PWM_MODE
);
tmcw(TMCR_TPWMTHRS, 0);
tmcw(TMCR_PWMCONF,
TMC_PWMCONF_PWM_AUTOSCALE |
( 1 << TMC_PWMCONF_PWM_GRAD_SHIFT) |
(200 << TMC_PWMCONF_PWM_AMPL_SHIFT));

{{
Graph:Chart|width=600|height=200|
xAxisTitle=RPM|
yAxisTitle=RPM/s|
type=line|
x=0,200.00, 400.00, 600.00, 800.00, 1000.00, 1200.00, 1400.00,1600,1800,2000,2200,2400,2600,2800,3000|
y1=4652.11,8270.53,6688.88,4508.25,2932.28,2138.08,1581.30,1271.33,1328.75,1022.06|
y2=4771.72, 7918.49, 6734.86, 5036.72, 3401.45, 2294.83, 1554.91, 1694.32, 1295.62, 1284.12, 723.39, 704.20, 564.93, 578.95, 699.80, 502.95|
y3=4701.81, 7671.34, 6738.24, 5021.65, 3757.66, 2462.01, 1405.32, 1644.94, 1242.94, 1150.06, 902.61|
y4=4378.76, 7908.38, 6726.26, 5059.55, 3786.02, 2977.99, 1582.61, 1773.34, 1360.92, 1319.06, 700.13, 593.96, 497.86, 611.02, 609.19, 492.01|
interpolate=monotone|
colors=seagreen,orchid|
}}

=== SpreadCycle vs. StealthChop at 37V ===

{{
Graph:Chart|width=600|height=200|
xAxisTitle=RPM|
yAxisTitle=RPM/s|
type=line|
x=0,200.00, 400.00, 600.00, 800.00, 1000.00, 1200.00, 1400.00,1600,1800,2000,2200,2400,2600,2800,3000,3200|
y1=7101.94,7611.49,6377.73,5601.97,3675.27,2408.02,1860.57,1763.62,1583.96,1071.46,935.91,891.38,776.37,751.01,664.83,612.14,581.51|
y2=4771.72, 7918.49, 6734.86, 5036.72, 3401.45, 2294.83, 1554.91, 1694.32, 1295.62, 1284.12, 723.39, 704.20, 564.93, 578.95, 699.80, 502.95|
y1Title=SpreadCycle|y2Title=StealthChop|legend=Legend|
interpolate=monotone|
colors=seagreen,orchid|
}}

=== SpreadCycle vs. StealthChop at 24V ===

{{
Graph:Chart|width=600|height=200|
xAxisTitle=RPM|
yAxisTitle=RPM/s|
type=line|
x=0,200.00, 400.00, 600.00, 800.00, 1000.00, 1200.00, 1400.00,1600,1800,2000,2200,2400,2600,2800,3000,3200|
y1=7542.89,7479.90,6916.74,5115.56,3970.36,2537.81,1991.76,1270.71,974.54,1100.13,654.58,493.23,526.57,475.44|
y2=5023.15,6511.14,4549.33,2146.70,1382.23,1040.71,890.69,754.43,372.66,406.07|
y1Title=SpreadCycle|y2Title=StealthChop|legend=Legend|
interpolate=monotone|
colors=seagreen,orchid|
}}

=== SpreadCycle vs. StealthChop at 45V ===

{{
Graph:Chart|width=600|height=200|
xAxisTitle=RPM|
yAxisTitle=RPM/s|
type=line|
x=0,200.00, 400.00, 600.00, 800.00, 1000.00, 1200.00, 1400.00,1600,1800,2000,2200,2400,2600,2800,3000,3200|
y1=6833.09,6936.92,6967.79,5795.93,5090.94,4218.19,4093.83,2910.22,3110.80,2005.70,1814.99,1182.57,1083.50|
y2=4627.26,6868.87,6580.90,5164.92,3780.01,2877.61,2168.31,1452.74,1413.20,1641.69,865.66|
y1Title=SpreadCycle|y2Title=StealthChop|legend=Legend|
interpolate=monotone|
colors=seagreen,orchid|
}}

=== SpreadCycle at different Voltages ===
{{
Graph:Chart|width=600|height=200|
xAxisTitle=RPM|
yAxisTitle=RPM/s|
type=line|
x=0,200.00, 400.00, 600.00, 800.00, 1000.00, 1200.00, 1400.00,1600,1800,2000,2200,2400,2600,2800,3000,3200|
y1=7542.89,7479.90,6916.74,5115.56,3970.36,2537.81,1991.76,1270.71,974.54,1100.13,654.58,493.23,526.57,475.44|
y2=7101.94,7611.49,6377.73,5601.97,3675.27,2408.02,1860.57,1763.62,1583.96,1071.46,935.91,891.38,776.37,751.01,664.83,612.14,581.51|
y3=6833.09,6936.92,6967.79,5795.93,5090.94,4218.19,4093.83,2910.22,3110.80,2005.70,1814.99,1182.57,1083.50|
y1Title=24V|y2Title=37V|y3Title=45V|legend=Legend|
interpolate=monotone|
colors=seagreen,orchid,blue|
}}

=== StealthChop at different Voltages ===
{{
Graph:Chart|width=600|height=200|
xAxisTitle=RPM|
yAxisTitle=RPM/s|
type=line|
x=0,200.00, 400.00, 600.00, 800.00, 1000.00, 1200.00, 1400.00,1600,1800,2000,2200,2400,2600,2800,3000,3200|
y1=5023.15,6511.14,4549.33,2146.70,1382.23,1040.71,890.69,754.43,372.66,406.07|
y2=4771.72, 7918.49, 6734.86, 5036.72, 3401.45, 2294.83, 1554.91, 1694.32, 1295.62, 1284.12, 723.39, 704.20, 564.93, 578.95, 699.80, 502.95|
y3=4627.26,6868.87,6580.90,5164.92,3780.01,2877.61,2168.31,1452.74,1413.20,1641.69,865.66|
y1Title=24V|y2Title=37V|y3Title=45V|legend=Legend|
interpolate=monotone|
colors=seagreen,orchid,blue|
}}

== Series without weights, corresponds to ~1.4kg ==

=== StealthChop at 40V ===

{{
Graph:Chart|width=600|height=200|
xAxisTitle=RPM|
yAxisTitle=RPM/s|
type=line|
x=0,200.00, 400.00, 600.00, 800.00, 1000.00, 1200.00, 1400.00,1600,1800,2000,2200,2400,2600,2800,3000,3200,3400,3600|
y1=20918.88,31064.29,49822.66,30495.68,19954.14,16975.80,15092.86,12889.57,7374.21,6677.21,6548.32,6316.87,5661.69,5542.80,3859.08,3112.40|
y2=30349.05,52366.55,59085.26,38463.68,23076.22,16421.99,16383.62,12566.21,12533.29,7263.07,6329.07,5970.43,6619.73,4893.02,3537.95,3102.99,4084.08,2583.17|
interpolate=monotone|
colors=seagreen,orchid,blue|
}}

== Series with light carriage, corresponds to ~1.0kg ==

=== StealthChop vs. SpreadCycle at 40V ===

The maximum acceleration is limited by the test at around 115kRPM/s.

{{
Graph:Chart|width=600|height=200|
xAxisTitle=RPM|
yAxisTitle=RPM/s|
type=line|
x=0,200,400,600,800,1000,1200,1400,1600,1800,2000,2200,2400,2600,2800,3000,3200,3400,3600|
y1=23137.12,45351.95,73983.21,42162.44,29957.53,21268.41,19982.27,13800.77,9733.59,7626.85,8532.23,6685.51,7317.66,8956.42|
y2=23137.12,59027.42,82641.29,49993.23,30113.92,26132.31,21437.48,17065.80,12562.94,10972.92,10575.51,7747.58,7276.92|
y3=88892.94,115697.80,115697.80,71927.42,42162.44,40650.53,27954.04,26407.05,21147.65,20060.77,15362.09,10972.92,10566.26,10187.33|
y4=88892.94,115697.80,115697.80,115567.90,53737.80,41659.46,29454.54,25967.47,21488.81,20673.65,15362.09,13912.91,12951.11,9789.92|
interpolate=monotone|
legend=Legend|
y1Title=StealthChop run 1|
y2Title=StealthChop run 2|
y3Title=SpreadCycle run 1|
y4Title=SpreadCycle run 2|
colors=seagreen,seagreen,orchid,orchid|
}}

=== StealthChop vs. SpreadCycle at 24V ===

{{
Graph:Chart|width=600|height=200|
xAxisTitle=RPM|
yAxisTitle=RPM/s|
type=line|
x=0,200,400,600,800,1000,1200,1400,1600,1800,2000,2200,2400,2600,2800,3000,3200,3400,3600|
y1=32391.97, 115697.80, 42156.53, 29577.12, 19773.95, 14572.80, 13153.82, 7835.60, 6139.66, 5751.55, 4382.65, 4462.05, 3427.55,2647.98|
y2=32391.97, 112596.44, 41973.08, 29238.98, 19834.33, 14628.87, 13848.22, 7835.60, 6139.66, 4378.46, 3977.58, 4204.04, 3292.27,3025.32|
y3=88892.94, 115697.80, 71602.67, 35348.48, 21509.94, 19674.32, 15362.09, 14395.97, 9789.92, 7670.99, 6010.68, 6052.91,4742.82,3714.20|
y4=88892.94, 115697.80, 73736.75, 34591.05, 24944.59, 19568.65, 15362.09, 14395.97, 10778.83, 10193.49, 6776.97, 5310.16,5406.36,5434.36|
interpolate=monotone|
legend=Legend|
y1Title=StealthChop run 1|
y2Title=StealthChop run 2|
y3Title=SpreadCycle run 1|
y4Title=SpreadCycle run 2|
colors=seagreen,seagreen,orchid,orchid|
}}

Stepper

2018-05-13T10:48:00Z

Sensille:

Stepper

2018-05-06T18:45:19Z

Sensille:

== General Setup ==

Used Stepper: 17HM19-2004S

Driver Voltage: 37V

Driver: TMC2130

Max RPM reached with the motor, unloaded: 3600RPM
This is the limit of the driver. It runs from the internal oscillator at 12.1MHz. Measure by giving a 9.765kHz pulse and read out register TSTEP as 0x277 (DEDGE=true).

== Take One, Lifting Weights ==

Driver Configuration is basically the recommended default from the datasheet for a coil current of about 2A:
reg 0x6c -> 0x200100c3
reg 0x10 -> 0x00061c02
reg 0x91 -> 0x0000000a
reg 0x80 -> 0x00003144
reg 0x93 -> 0x000001f4
reg 0xf0 -> 0x000401c8

For very slow step rates stealthChop was disabled

Load Testing at 1/256 microstepping. Testing done lifting a weight by winding a rope on a cylinder with effective radius of 16.5mm.

<gallery>
Weightlifting.jpeg|Weight Lifting Setup
</gallery>

9.5kHz 2250g
19.5kHz 2150g
39kHz 2240g
58.5kHz 2220g
78kHz 2240g
97.5kHz 2230g
117kHz 2230g
137kHz 2130g
156kHz 2150g
195kHz 2030g
234kHz 2050g
312kHz 2030g
468kHz 1700g
624kHz 1300g
936kHz 740g
1092kHz 556g
1400kHz 250g
1700kHz 150g

{{
Graph:Chart|width=600|height=200|
xAxisTitle=RPM|
yAxisTitle=Torque in Ncm|
legend=Legend|
type=line|
x=11.13,22.85,45.70,68.55,91.41,114.26,137.11,160.55,182.81,228.52,274.22,365.62,548.44,731.25,1096.88,1279.69,1640.62,1992.19|
y1=37.12,35.48,36.96,36.63,36.96,36.80,36.80,35.14,35.48,33.49,33.82,33.49,28.05,21.45,12.21,9.17,4.12,2.47|
y1Title=Measured|
y2=,,,,24,26,32,34,34,34.5,36,35.5,34,16|
y2Title=From Datasheet (rough estimate)|
interpolate=monotone|
colors=seagreen,orchid|
}}

Source for torque curve from datasheet: https://www.omc-stepperonline.com/download/17HM19-2004S_Torque_Curve.pdf

Full data sheet of the motor: https://www.omc-stepperonline.com/download/17HM19-2004S.pdf

== Take Two, Weight Spinning ==

<Gallery>
Weightspinning.jpeg|Setup for torque measurement by a spinning weight
</Gallery>

The idea here is to measure the torque at a given RPM by testing how fast the stepper can accelerate to a higher RPM. This way the measurement is not limit to the length of a linear motion as in the previous chapter.

=== Lost step detection ===

With each round the rotor goes through a photo interruptor. The controller has an internal counter to keep track of the current angle with respect to an arbitrary reference. The home command puts the controller into a mode where it resets the counter if the rotor goes through the interruptor. After that, with each round it checks if the interruptor signal asserts during a given window around the reference. The window can be programmed and is currently set to +/- 4 full steps.

=== Measurement ===

We spin the motor to the RPM under test and try to accelerate it to the next higher RPM level. We use the interruptor signal to detect lost steps.
The acceleration directly corresponds to the torque the motor can generate at the given RPM.

We now have a detailed torque curve RPM vs. Ncm.

Do the same for deceleration

Repeat everything with the other set of weights.

The following series are all done with two 50g weights. The full setup corresponds roughly to a moving mass of 11kg when using a 16T pulley.

=== 1st Series ===

The following graph shows the max acceleration in RPM/s in steps of 200 RPM.

Driver config (just pasted here for reference):

reg 0x04 -> 0x00000000
reg 0xec -> 0x200100c3
reg 0x90 -> 0x00061802
reg 0x91 -> 0x0000000a
reg 0x80 -> 0x00003144
reg 0x93 -> 0x000001f4
reg 0xf0 -> 0x000401c8

{{
Graph:Chart|width=600|height=200|
xAxisTitle=RPM|
yAxisTitle=RPM/s|
type=line|
x=0.00,200.00,400.00,600.00,800.00,1000.00,1200.00,1400.00,1600.00,1800.00,2000.00,2200.00,2400.00,2600.00,2800.00,3000.00,3200.00|
y=7101.94,7611.49,6377.73,5601.97,3675.27,2408.02,1860.57,1763.62,1583.96,1071.46,935.91,891.38,776.37,751.01,664.83,612.14,581.51|
interpolate=monotone|
colors=seagreen,orchid|
}}

=== StealthChop ===

4 Series with StealthChop

tmcw(TMCR_CHOPCONF,
TMC_CHOPCONF_DEDGE |
(2 << TMC_CHOPCONF_TBL_SHIFT) |
(7 << TMC_CHOPCONF_HEND_SHIFT) |
(2 << TMC_CHOPCONF_HSTRT_SHIFT) |
(5 << TMC_CHOPCONF_TOFF_SHIFT));
tmcw(TMCR_IHOLD_IRUN,
( 6 << TMC_IHOLD_IRUN_IHOLDDELAY_SHIFT) |
(24 << TMC_IHOLD_IRUN_IRUN_SHIFT) |
( 3 << TMC_IHOLD_IRUN_IHOLD_SHIFT));
tmcw(TMCR_TPOWER_DOWN, 0x0a);
tmcw(TMCR_GCONF,
TMC_GCONF_DIAG0_INT_PUSHPULL |
TMC_GCONF_DIAG1_PUSHPULL |
TMC_GCONF_DIAG1_STALL |
TMC_GCONF_DIAG0_OTPW |
TMC_GCONF_EN_PWM_MODE
);
tmcw(TMCR_TPWMTHRS, 0);
tmcw(TMCR_PWMCONF,
TMC_PWMCONF_PWM_AUTOSCALE |
( 1 << TMC_PWMCONF_PWM_GRAD_SHIFT) |
(200 << TMC_PWMCONF_PWM_AMPL_SHIFT));

{{
Graph:Chart|width=600|height=200|
xAxisTitle=RPM|
yAxisTitle=RPM/s|
type=line|
x=0,200.00, 400.00, 600.00, 800.00, 1000.00, 1200.00, 1400.00,1600,1800,2000,2200,2400,2600,2800,3000|
y1=4652.11,8270.53,6688.88,4508.25,2932.28,2138.08,1581.30,1271.33,1328.75,1022.06|
y2=4771.72, 7918.49, 6734.86, 5036.72, 3401.45, 2294.83, 1554.91, 1694.32, 1295.62, 1284.12, 723.39, 704.20, 564.93, 578.95, 699.80, 502.95|
y3=4701.81, 7671.34, 6738.24, 5021.65, 3757.66, 2462.01, 1405.32, 1644.94, 1242.94, 1150.06, 902.61|
y4=4378.76, 7908.38, 6726.26, 5059.55, 3786.02, 2977.99, 1582.61, 1773.34, 1360.92, 1319.06, 700.13, 593.96, 497.86, 611.02, 609.19, 492.01|
interpolate=monotone|
colors=seagreen,orchid|
}}

=== SpreadCycle vs. StealthChop at 37V ===

{{
Graph:Chart|width=600|height=200|
xAxisTitle=RPM|
yAxisTitle=RPM/s|
type=line|
x=0,200.00, 400.00, 600.00, 800.00, 1000.00, 1200.00, 1400.00,1600,1800,2000,2200,2400,2600,2800,3000,3200|
y1=7101.94,7611.49,6377.73,5601.97,3675.27,2408.02,1860.57,1763.62,1583.96,1071.46,935.91,891.38,776.37,751.01,664.83,612.14,581.51|
y2=4771.72, 7918.49, 6734.86, 5036.72, 3401.45, 2294.83, 1554.91, 1694.32, 1295.62, 1284.12, 723.39, 704.20, 564.93, 578.95, 699.80, 502.95|
y1Title=SpreadCycle|y2Title=StealthChop|legend=Legend|
interpolate=monotone|
colors=seagreen,orchid|
}}

=== SpreadCycle vs. StealthChop at 24V ===

{{
Graph:Chart|width=600|height=200|
xAxisTitle=RPM|
yAxisTitle=RPM/s|
type=line|
x=0,200.00, 400.00, 600.00, 800.00, 1000.00, 1200.00, 1400.00,1600,1800,2000,2200,2400,2600,2800,3000,3200|
y1=7542.89,7479.90,6916.74,5115.56,3970.36,2537.81,1991.76,1270.71,974.54,1100.13,654.58,493.23,526.57,475.44|
y2=5023.15,6511.14,4549.33,2146.70,1382.23,1040.71,890.69,754.43,372.66,406.07|
y1Title=SpreadCycle|y2Title=StealthChop|legend=Legend|
interpolate=monotone|
colors=seagreen,orchid|
}}

=== SpreadCycle vs. StealthChop at 45V ===

{{
Graph:Chart|width=600|height=200|
xAxisTitle=RPM|
yAxisTitle=RPM/s|
type=line|
x=0,200.00, 400.00, 600.00, 800.00, 1000.00, 1200.00, 1400.00,1600,1800,2000,2200,2400,2600,2800,3000,3200|
y1=6833.09,6936.92,6967.79,5795.93,5090.94,4218.19,4093.83,2910.22,3110.80,2005.70,1814.99,1182.57,1083.50|
y2=4627.26,6868.87,6580.90,5164.92,3780.01,2877.61,2168.31,1452.74,1413.20,1641.69,865.66|
y1Title=SpreadCycle|y2Title=StealthChop|legend=Legend|
interpolate=monotone|
colors=seagreen,orchid|
}}

=== SpreadCycle at different Voltages ===
{{
Graph:Chart|width=600|height=200|
xAxisTitle=RPM|
yAxisTitle=RPM/s|
type=line|
x=0,200.00, 400.00, 600.00, 800.00, 1000.00, 1200.00, 1400.00,1600,1800,2000,2200,2400,2600,2800,3000,3200|
y1=7542.89,7479.90,6916.74,5115.56,3970.36,2537.81,1991.76,1270.71,974.54,1100.13,654.58,493.23,526.57,475.44|
y2=7101.94,7611.49,6377.73,5601.97,3675.27,2408.02,1860.57,1763.62,1583.96,1071.46,935.91,891.38,776.37,751.01,664.83,612.14,581.51|
y3=6833.09,6936.92,6967.79,5795.93,5090.94,4218.19,4093.83,2910.22,3110.80,2005.70,1814.99,1182.57,1083.50|
y1Title=24V|y2Title=37V|y3Title=45V|legend=Legend|
interpolate=monotone|
colors=seagreen,orchid,blue|
}}

=== StealthChop at different Voltages ===
{{
Graph:Chart|width=600|height=200|
xAxisTitle=RPM|
yAxisTitle=RPM/s|
type=line|
x=0,200.00, 400.00, 600.00, 800.00, 1000.00, 1200.00, 1400.00,1600,1800,2000,2200,2400,2600,2800,3000,3200|
y1=5023.15,6511.14,4549.33,2146.70,1382.23,1040.71,890.69,754.43,372.66,406.07|
y2=4771.72, 7918.49, 6734.86, 5036.72, 3401.45, 2294.83, 1554.91, 1694.32, 1295.62, 1284.12, 723.39, 704.20, 564.93, 578.95, 699.80, 502.95|
y3=4627.26,6868.87,6580.90,5164.92,3780.01,2877.61,2168.31,1452.74,1413.20,1641.69,865.66|
y1Title=24V|y2Title=37V|y3Title=45V|legend=Legend|
interpolate=monotone|
colors=seagreen,orchid,blue|
}}

== Series without weights, corresponds to ~1.4kg ==

=== StealthChop at 40V ===

{{
Graph:Chart|width=600|height=200|
xAxisTitle=RPM|
yAxisTitle=RPM/s|
type=line|
x=0,200.00, 400.00, 600.00, 800.00, 1000.00, 1200.00, 1400.00,1600,1800,2000,2200,2400,2600,2800,3000,3200,3400,3600|
y1=20918.88,31064.29,49822.66,30495.68,19954.14,16975.80,15092.86,12889.57,7374.21,6677.21,6548.32,6316.87,5661.69,5542.80,3859.08,3112.40|
y2=30349.05,52366.55,59085.26,38463.68,23076.22,16421.99,16383.62,12566.21,12533.29,7263.07,6329.07,5970.43,6619.73,4893.02,3537.95,3102.99,4084.08,2583.17|
interpolate=monotone|
colors=seagreen,orchid,blue|
}}

== Series with light carriage, corresponds to ~1.0kg ==

=== StealthChop at 40V ===

{{
Graph:Chart|width=600|height=200|
xAxisTitle=RPM|
yAxisTitle=RPM/s|
type=line|
x=0,200.00, 400.00, 600.00, 800.00, 1000.00, 1200.00, 1400.00,1600,1800,2000,2200,2400,2600,2800,3000,3200,3400,3600|
y1=55316.57,21992.95,18022.20,12759.15,13058.61,11814.60,17029.31,11135.32,9198.56,10195.55,8955.41,9256.09,9221.37,9739.58,9716.82,8534.92,7496.77,6519.68|
interpolate=monotone|
colors=seagreen,orchid,blue|
}}

Stepper

2018-05-06T16:09:40Z

Sensille:

== General Setup ==

Used Stepper: 17HM19-2004S

Driver Voltage: 37V

Driver: TMC2130

Max RPM reached with the motor, unloaded: 3600RPM
This is the limit of the driver. It runs from the internal oscillator at 12.1MHz. Measure by giving a 9.765kHz pulse and read out register TSTEP as 0x277 (DEDGE=true).

== Take One, Lifting Weights ==

Driver Configuration is basically the recommended default from the datasheet for a coil current of about 2A:
reg 0x6c -> 0x200100c3
reg 0x10 -> 0x00061c02
reg 0x91 -> 0x0000000a
reg 0x80 -> 0x00003144
reg 0x93 -> 0x000001f4
reg 0xf0 -> 0x000401c8

For very slow step rates stealthChop was disabled

Load Testing at 1/256 microstepping. Testing done lifting a weight by winding a rope on a cylinder with effective radius of 16.5mm.

<gallery>
Weightlifting.jpeg|Weight Lifting Setup
</gallery>

9.5kHz 2250g
19.5kHz 2150g
39kHz 2240g
58.5kHz 2220g
78kHz 2240g
97.5kHz 2230g
117kHz 2230g
137kHz 2130g
156kHz 2150g
195kHz 2030g
234kHz 2050g
312kHz 2030g
468kHz 1700g
624kHz 1300g
936kHz 740g
1092kHz 556g
1400kHz 250g
1700kHz 150g

{{
Graph:Chart|width=600|height=200|
xAxisTitle=RPM|
yAxisTitle=Torque in Ncm|
legend=Legend|
type=line|
x=11.13,22.85,45.70,68.55,91.41,114.26,137.11,160.55,182.81,228.52,274.22,365.62,548.44,731.25,1096.88,1279.69,1640.62,1992.19|
y1=37.12,35.48,36.96,36.63,36.96,36.80,36.80,35.14,35.48,33.49,33.82,33.49,28.05,21.45,12.21,9.17,4.12,2.47|
y1Title=Measured|
y2=,,,,24,26,32,34,34,34.5,36,35.5,34,16|
y2Title=From Datasheet (rough estimate)|
interpolate=monotone|
colors=seagreen,orchid|
}}

Source for torque curve from datasheet: https://www.omc-stepperonline.com/download/17HM19-2004S_Torque_Curve.pdf

Full data sheet of the motor: https://www.omc-stepperonline.com/download/17HM19-2004S.pdf

== Take Two, Weight Spinning ==

<Gallery>
Weightspinning.jpeg|Setup for torque measurement by a spinning weight
</Gallery>

The idea here is to measure the torque at a given RPM by testing how fast the stepper can accelerate to a higher RPM. This way the measurement is not limit to the length of a linear motion as in the previous chapter.

=== Lost step detection ===

With each round the rotor goes through a photo interruptor. The controller has an internal counter to keep track of the current angle with respect to an arbitrary reference. The home command puts the controller into a mode where it resets the counter if the rotor goes through the interruptor. After that, with each round it checks if the interruptor signal asserts during a given window around the reference. The window can be programmed and is currently set to +/- 4 full steps.

=== Measurement ===

We spin the motor to the RPM under test and try to accelerate it to the next higher RPM level. We use the interruptor signal to detect lost steps.
The acceleration directly corresponds to the torque the motor can generate at the given RPM.

We now have a detailed torque curve RPM vs. Ncm.

Do the same for deceleration

Repeat everything with the other set of weights.

The following series are all done with two 50g weights. The full setup corresponds roughly to a moving mass of 11kg when using a 16T pulley.

=== 1st Series ===

The following graph shows the max acceleration in RPM/s in steps of 200 RPM.

Driver config (just pasted here for reference):

reg 0x04 -> 0x00000000
reg 0xec -> 0x200100c3
reg 0x90 -> 0x00061802
reg 0x91 -> 0x0000000a
reg 0x80 -> 0x00003144
reg 0x93 -> 0x000001f4
reg 0xf0 -> 0x000401c8

{{
Graph:Chart|width=600|height=200|
xAxisTitle=RPM|
yAxisTitle=RPM/s|
type=line|
x=0.00,200.00,400.00,600.00,800.00,1000.00,1200.00,1400.00,1600.00,1800.00,2000.00,2200.00,2400.00,2600.00,2800.00,3000.00,3200.00|
y=7101.94,7611.49,6377.73,5601.97,3675.27,2408.02,1860.57,1763.62,1583.96,1071.46,935.91,891.38,776.37,751.01,664.83,612.14,581.51|
interpolate=monotone|
colors=seagreen,orchid|
}}

=== StealthChop ===

4 Series with StealthChop

tmcw(TMCR_CHOPCONF,
TMC_CHOPCONF_DEDGE |
(2 << TMC_CHOPCONF_TBL_SHIFT) |
(7 << TMC_CHOPCONF_HEND_SHIFT) |
(2 << TMC_CHOPCONF_HSTRT_SHIFT) |
(5 << TMC_CHOPCONF_TOFF_SHIFT));
tmcw(TMCR_IHOLD_IRUN,
( 6 << TMC_IHOLD_IRUN_IHOLDDELAY_SHIFT) |
(24 << TMC_IHOLD_IRUN_IRUN_SHIFT) |
( 3 << TMC_IHOLD_IRUN_IHOLD_SHIFT));
tmcw(TMCR_TPOWER_DOWN, 0x0a);
tmcw(TMCR_GCONF,
TMC_GCONF_DIAG0_INT_PUSHPULL |
TMC_GCONF_DIAG1_PUSHPULL |
TMC_GCONF_DIAG1_STALL |
TMC_GCONF_DIAG0_OTPW |
TMC_GCONF_EN_PWM_MODE
);
tmcw(TMCR_TPWMTHRS, 0);
tmcw(TMCR_PWMCONF,
TMC_PWMCONF_PWM_AUTOSCALE |
( 1 << TMC_PWMCONF_PWM_GRAD_SHIFT) |
(200 << TMC_PWMCONF_PWM_AMPL_SHIFT));

{{
Graph:Chart|width=600|height=200|
xAxisTitle=RPM|
yAxisTitle=RPM/s|
type=line|
x=0,200.00, 400.00, 600.00, 800.00, 1000.00, 1200.00, 1400.00,1600,1800,2000,2200,2400,2600,2800,3000|
y1=4652.11,8270.53,6688.88,4508.25,2932.28,2138.08,1581.30,1271.33,1328.75,1022.06|
y2=4771.72, 7918.49, 6734.86, 5036.72, 3401.45, 2294.83, 1554.91, 1694.32, 1295.62, 1284.12, 723.39, 704.20, 564.93, 578.95, 699.80, 502.95|
y3=4701.81, 7671.34, 6738.24, 5021.65, 3757.66, 2462.01, 1405.32, 1644.94, 1242.94, 1150.06, 902.61|
y4=4378.76, 7908.38, 6726.26, 5059.55, 3786.02, 2977.99, 1582.61, 1773.34, 1360.92, 1319.06, 700.13, 593.96, 497.86, 611.02, 609.19, 492.01|
interpolate=monotone|
colors=seagreen,orchid|
}}

=== SpreadCycle vs. StealthChop at 37V ===

{{
Graph:Chart|width=600|height=200|
xAxisTitle=RPM|
yAxisTitle=RPM/s|
type=line|
x=0,200.00, 400.00, 600.00, 800.00, 1000.00, 1200.00, 1400.00,1600,1800,2000,2200,2400,2600,2800,3000,3200|
y1=7101.94,7611.49,6377.73,5601.97,3675.27,2408.02,1860.57,1763.62,1583.96,1071.46,935.91,891.38,776.37,751.01,664.83,612.14,581.51|
y2=4771.72, 7918.49, 6734.86, 5036.72, 3401.45, 2294.83, 1554.91, 1694.32, 1295.62, 1284.12, 723.39, 704.20, 564.93, 578.95, 699.80, 502.95|
y1Title=SpreadCycle|y2Title=StealthChop|legend=Legend|
interpolate=monotone|
colors=seagreen,orchid|
}}

=== SpreadCycle vs. StealthChop at 24V ===

{{
Graph:Chart|width=600|height=200|
xAxisTitle=RPM|
yAxisTitle=RPM/s|
type=line|
x=0,200.00, 400.00, 600.00, 800.00, 1000.00, 1200.00, 1400.00,1600,1800,2000,2200,2400,2600,2800,3000,3200|
y1=7542.89,7479.90,6916.74,5115.56,3970.36,2537.81,1991.76,1270.71,974.54,1100.13,654.58,493.23,526.57,475.44|
y2=5023.15,6511.14,4549.33,2146.70,1382.23,1040.71,890.69,754.43,372.66,406.07|
y1Title=SpreadCycle|y2Title=StealthChop|legend=Legend|
interpolate=monotone|
colors=seagreen,orchid|
}}

=== SpreadCycle vs. StealthChop at 45V ===

{{
Graph:Chart|width=600|height=200|
xAxisTitle=RPM|
yAxisTitle=RPM/s|
type=line|
x=0,200.00, 400.00, 600.00, 800.00, 1000.00, 1200.00, 1400.00,1600,1800,2000,2200,2400,2600,2800,3000,3200|
y1=6833.09,6936.92,6967.79,5795.93,5090.94,4218.19,4093.83,2910.22,3110.80,2005.70,1814.99,1182.57,1083.50|
y2=4627.26,6868.87,6580.90,5164.92,3780.01,2877.61,2168.31,1452.74,1413.20,1641.69,865.66|
y1Title=SpreadCycle|y2Title=StealthChop|legend=Legend|
interpolate=monotone|
colors=seagreen,orchid|
}}

=== SpreadCycle at different Voltages ===
{{
Graph:Chart|width=600|height=200|
xAxisTitle=RPM|
yAxisTitle=RPM/s|
type=line|
x=0,200.00, 400.00, 600.00, 800.00, 1000.00, 1200.00, 1400.00,1600,1800,2000,2200,2400,2600,2800,3000,3200|
y1=7542.89,7479.90,6916.74,5115.56,3970.36,2537.81,1991.76,1270.71,974.54,1100.13,654.58,493.23,526.57,475.44|
y2=7101.94,7611.49,6377.73,5601.97,3675.27,2408.02,1860.57,1763.62,1583.96,1071.46,935.91,891.38,776.37,751.01,664.83,612.14,581.51|
y3=6833.09,6936.92,6967.79,5795.93,5090.94,4218.19,4093.83,2910.22,3110.80,2005.70,1814.99,1182.57,1083.50|
y1Title=24V|y2Title=37V|y3Title=45V|legend=Legend|
interpolate=monotone|
colors=seagreen,orchid,blue|
}}

=== StealthChop at different Voltages ===
{{
Graph:Chart|width=600|height=200|
xAxisTitle=RPM|
yAxisTitle=RPM/s|
type=line|
x=0,200.00, 400.00, 600.00, 800.00, 1000.00, 1200.00, 1400.00,1600,1800,2000,2200,2400,2600,2800,3000,3200|
y1=5023.15,6511.14,4549.33,2146.70,1382.23,1040.71,890.69,754.43,372.66,406.07|
y2=4771.72, 7918.49, 6734.86, 5036.72, 3401.45, 2294.83, 1554.91, 1694.32, 1295.62, 1284.12, 723.39, 704.20, 564.93, 578.95, 699.80, 502.95|
y3=4627.26,6868.87,6580.90,5164.92,3780.01,2877.61,2168.31,1452.74,1413.20,1641.69,865.66|
y1Title=24V|y2Title=37V|y3Title=45V|legend=Legend|
interpolate=monotone|
colors=seagreen,orchid,blue|
}}

== Series without weights, corresponds to ~1.4kg ==

== StealthChop at 40V ==

{{
Graph:Chart|width=600|height=200|
xAxisTitle=RPM|
yAxisTitle=RPM/s|
type=line|
x=0,200.00, 400.00, 600.00, 800.00, 1000.00, 1200.00, 1400.00,1600,1800,2000,2200,2400,2600,2800,3000,3200,3400,3600|
y1=20918.88,31064.29,49822.66,30495.68,19954.14,16975.80,15092.86,12889.57,7374.21,6677.21,6548.32,6316.87,5661.69,5542.80,3859.08,3112.40|
y2=30349.05,52366.55,59085.26,38463.68,23076.22,16421.99,16383.62,12566.21,12533.29,7263.07,6329.07,5970.43,6619.73,4893.02,3537.95,3102.99,4084.08,2583.17|
4.92,3780.01,2877.61,2168.31,1452.74,1413.20,1641.69,865.66|
interpolate=monotone|
colors=seagreen,orchid,blue|
}}

Stepper

2018-05-06T16:09:07Z

Sensille:

== General Setup ==

Used Stepper: 17HM19-2004S

Driver Voltage: 37V

Driver: TMC2130

Max RPM reached with the motor, unloaded: 3600RPM
This is the limit of the driver. It runs from the internal oscillator at 12.1MHz. Measure by giving a 9.765kHz pulse and read out register TSTEP as 0x277 (DEDGE=true).

== Take One, Lifting Weights ==

Driver Configuration is basically the recommended default from the datasheet for a coil current of about 2A:
reg 0x6c -> 0x200100c3
reg 0x10 -> 0x00061c02
reg 0x91 -> 0x0000000a
reg 0x80 -> 0x00003144
reg 0x93 -> 0x000001f4
reg 0xf0 -> 0x000401c8

For very slow step rates stealthChop was disabled

Load Testing at 1/256 microstepping. Testing done lifting a weight by winding a rope on a cylinder with effective radius of 16.5mm.

<gallery>
Weightlifting.jpeg|Weight Lifting Setup
</gallery>

9.5kHz 2250g
19.5kHz 2150g
39kHz 2240g
58.5kHz 2220g
78kHz 2240g
97.5kHz 2230g
117kHz 2230g
137kHz 2130g
156kHz 2150g
195kHz 2030g
234kHz 2050g
312kHz 2030g
468kHz 1700g
624kHz 1300g
936kHz 740g
1092kHz 556g
1400kHz 250g
1700kHz 150g

{{
Graph:Chart|width=600|height=200|
xAxisTitle=RPM|
yAxisTitle=Torque in Ncm|
legend=Legend|
type=line|
x=11.13,22.85,45.70,68.55,91.41,114.26,137.11,160.55,182.81,228.52,274.22,365.62,548.44,731.25,1096.88,1279.69,1640.62,1992.19|
y1=37.12,35.48,36.96,36.63,36.96,36.80,36.80,35.14,35.48,33.49,33.82,33.49,28.05,21.45,12.21,9.17,4.12,2.47|
y1Title=Measured|
y2=,,,,24,26,32,34,34,34.5,36,35.5,34,16|
y2Title=From Datasheet (rough estimate)|
interpolate=monotone|
colors=seagreen,orchid|
}}

Source for torque curve from datasheet: https://www.omc-stepperonline.com/download/17HM19-2004S_Torque_Curve.pdf

Full data sheet of the motor: https://www.omc-stepperonline.com/download/17HM19-2004S.pdf

== Take Two, Weight Spinning ==

<Gallery>
Weightspinning.jpeg|Setup for torque measurement by a spinning weight
</Gallery>

The idea here is to measure the torque at a given RPM by testing how fast the stepper can accelerate to a higher RPM. This way the measurement is not limit to the length of a linear motion as in the previous chapter.

=== Lost step detection ===

With each round the rotor goes through a photo interruptor. The controller has an internal counter to keep track of the current angle with respect to an arbitrary reference. The home command puts the controller into a mode where it resets the counter if the rotor goes through the interruptor. After that, with each round it checks if the interruptor signal asserts during a given window around the reference. The window can be programmed and is currently set to +/- 4 full steps.

=== Measurement ===

We spin the motor to the RPM under test and try to accelerate it to the next higher RPM level. We use the interruptor signal to detect lost steps.
The acceleration directly corresponds to the torque the motor can generate at the given RPM.

We now have a detailed torque curve RPM vs. Ncm.

Do the same for deceleration

Repeat everything with the other set of weights.

The following series are all done with two 50g weights. The full setup corresponds roughly to a moving mass of 11kg when using a 16T pulley.

=== 1st Series ===

The following graph shows the max acceleration in RPM/s in steps of 200 RPM.

Driver config (just pasted here for reference):

reg 0x04 -> 0x00000000
reg 0xec -> 0x200100c3
reg 0x90 -> 0x00061802
reg 0x91 -> 0x0000000a
reg 0x80 -> 0x00003144
reg 0x93 -> 0x000001f4
reg 0xf0 -> 0x000401c8

{{
Graph:Chart|width=600|height=200|
xAxisTitle=RPM|
yAxisTitle=RPM/s|
type=line|
x=0.00,200.00,400.00,600.00,800.00,1000.00,1200.00,1400.00,1600.00,1800.00,2000.00,2200.00,2400.00,2600.00,2800.00,3000.00,3200.00|
y=7101.94,7611.49,6377.73,5601.97,3675.27,2408.02,1860.57,1763.62,1583.96,1071.46,935.91,891.38,776.37,751.01,664.83,612.14,581.51|
interpolate=monotone|
colors=seagreen,orchid|
}}

=== StealthChop ===

4 Series with StealthChop

tmcw(TMCR_CHOPCONF,
TMC_CHOPCONF_DEDGE |
(2 << TMC_CHOPCONF_TBL_SHIFT) |
(7 << TMC_CHOPCONF_HEND_SHIFT) |
(2 << TMC_CHOPCONF_HSTRT_SHIFT) |
(5 << TMC_CHOPCONF_TOFF_SHIFT));
tmcw(TMCR_IHOLD_IRUN,
( 6 << TMC_IHOLD_IRUN_IHOLDDELAY_SHIFT) |
(24 << TMC_IHOLD_IRUN_IRUN_SHIFT) |
( 3 << TMC_IHOLD_IRUN_IHOLD_SHIFT));
tmcw(TMCR_TPOWER_DOWN, 0x0a);
tmcw(TMCR_GCONF,
TMC_GCONF_DIAG0_INT_PUSHPULL |
TMC_GCONF_DIAG1_PUSHPULL |
TMC_GCONF_DIAG1_STALL |
TMC_GCONF_DIAG0_OTPW |
TMC_GCONF_EN_PWM_MODE
);
tmcw(TMCR_TPWMTHRS, 0);
tmcw(TMCR_PWMCONF,
TMC_PWMCONF_PWM_AUTOSCALE |
( 1 << TMC_PWMCONF_PWM_GRAD_SHIFT) |
(200 << TMC_PWMCONF_PWM_AMPL_SHIFT));

{{
Graph:Chart|width=600|height=200|
xAxisTitle=RPM|
yAxisTitle=RPM/s|
type=line|
x=0,200.00, 400.00, 600.00, 800.00, 1000.00, 1200.00, 1400.00,1600,1800,2000,2200,2400,2600,2800,3000|
y1=4652.11,8270.53,6688.88,4508.25,2932.28,2138.08,1581.30,1271.33,1328.75,1022.06|
y2=4771.72, 7918.49, 6734.86, 5036.72, 3401.45, 2294.83, 1554.91, 1694.32, 1295.62, 1284.12, 723.39, 704.20, 564.93, 578.95, 699.80, 502.95|
y3=4701.81, 7671.34, 6738.24, 5021.65, 3757.66, 2462.01, 1405.32, 1644.94, 1242.94, 1150.06, 902.61|
y4=4378.76, 7908.38, 6726.26, 5059.55, 3786.02, 2977.99, 1582.61, 1773.34, 1360.92, 1319.06, 700.13, 593.96, 497.86, 611.02, 609.19, 492.01|
interpolate=monotone|
colors=seagreen,orchid|
}}

=== SpreadCycle vs. StealthChop at 37V ===

{{
Graph:Chart|width=600|height=200|
xAxisTitle=RPM|
yAxisTitle=RPM/s|
type=line|
x=0,200.00, 400.00, 600.00, 800.00, 1000.00, 1200.00, 1400.00,1600,1800,2000,2200,2400,2600,2800,3000,3200|
y1=7101.94,7611.49,6377.73,5601.97,3675.27,2408.02,1860.57,1763.62,1583.96,1071.46,935.91,891.38,776.37,751.01,664.83,612.14,581.51|
y2=4771.72, 7918.49, 6734.86, 5036.72, 3401.45, 2294.83, 1554.91, 1694.32, 1295.62, 1284.12, 723.39, 704.20, 564.93, 578.95, 699.80, 502.95|
y1Title=SpreadCycle|y2Title=StealthChop|legend=Legend|
interpolate=monotone|
colors=seagreen,orchid|
}}

=== SpreadCycle vs. StealthChop at 24V ===

{{
Graph:Chart|width=600|height=200|
xAxisTitle=RPM|
yAxisTitle=RPM/s|
type=line|
x=0,200.00, 400.00, 600.00, 800.00, 1000.00, 1200.00, 1400.00,1600,1800,2000,2200,2400,2600,2800,3000,3200|
y1=7542.89,7479.90,6916.74,5115.56,3970.36,2537.81,1991.76,1270.71,974.54,1100.13,654.58,493.23,526.57,475.44|
y2=5023.15,6511.14,4549.33,2146.70,1382.23,1040.71,890.69,754.43,372.66,406.07|
y1Title=SpreadCycle|y2Title=StealthChop|legend=Legend|
interpolate=monotone|
colors=seagreen,orchid|
}}

=== SpreadCycle vs. StealthChop at 45V ===

{{
Graph:Chart|width=600|height=200|
xAxisTitle=RPM|
yAxisTitle=RPM/s|
type=line|
x=0,200.00, 400.00, 600.00, 800.00, 1000.00, 1200.00, 1400.00,1600,1800,2000,2200,2400,2600,2800,3000,3200|
y1=6833.09,6936.92,6967.79,5795.93,5090.94,4218.19,4093.83,2910.22,3110.80,2005.70,1814.99,1182.57,1083.50|
y2=4627.26,6868.87,6580.90,5164.92,3780.01,2877.61,2168.31,1452.74,1413.20,1641.69,865.66|
y1Title=SpreadCycle|y2Title=StealthChop|legend=Legend|
interpolate=monotone|
colors=seagreen,orchid|
}}

=== SpreadCycle at different Voltages ===
{{
Graph:Chart|width=600|height=200|
xAxisTitle=RPM|
yAxisTitle=RPM/s|
type=line|
x=0,200.00, 400.00, 600.00, 800.00, 1000.00, 1200.00, 1400.00,1600,1800,2000,2200,2400,2600,2800,3000,3200|
y1=7542.89,7479.90,6916.74,5115.56,3970.36,2537.81,1991.76,1270.71,974.54,1100.13,654.58,493.23,526.57,475.44|
y2=7101.94,7611.49,6377.73,5601.97,3675.27,2408.02,1860.57,1763.62,1583.96,1071.46,935.91,891.38,776.37,751.01,664.83,612.14,581.51|
y3=6833.09,6936.92,6967.79,5795.93,5090.94,4218.19,4093.83,2910.22,3110.80,2005.70,1814.99,1182.57,1083.50|
y1Title=24V|y2Title=37V|y3Title=45V|legend=Legend|
interpolate=monotone|
colors=seagreen,orchid,blue|
}}

=== StealthChop at different Voltages ===
{{
Graph:Chart|width=600|height=200|
xAxisTitle=RPM|
yAxisTitle=RPM/s|
type=line|
x=0,200.00, 400.00, 600.00, 800.00, 1000.00, 1200.00, 1400.00,1600,1800,2000,2200,2400,2600,2800,3000,3200|
y1=5023.15,6511.14,4549.33,2146.70,1382.23,1040.71,890.69,754.43,372.66,406.07|
y2=4771.72, 7918.49, 6734.86, 5036.72, 3401.45, 2294.83, 1554.91, 1694.32, 1295.62, 1284.12, 723.39, 704.20, 564.93, 578.95, 699.80, 502.95|
y3=4627.26,6868.87,6580.90,5164.92,3780.01,2877.61,2168.31,1452.74,1413.20,1641.69,865.66|
y1Title=24V|y2Title=37V|y3Title=45V|legend=Legend|
interpolate=monotone|
colors=seagreen,orchid,blue|
}}

== Series without weights, corresponds to ~1.4kg ==

== StealthChop at 40V ==

{{
Graph:Chart|width=600|height=200|
xAxisTitle=RPM|
yAxisTitle=RPM/s|
type=line|
x=0,200.00, 400.00, 600.00, 800.00, 1000.00, 1200.00, 1400.00,1600,1800,2000,2200,2400,2600,2800,3000,3200|
y1=20918.88,31064.29,49822.66,30495.68,19954.14,16975.80,15092.86,12889.57,7374.21,6677.21,6548.32,6316.87,5661.69,5542.80,3859.08,3112.40
y2=30349.05,52366.55,59085.26,38463.68,23076.22,16421.99,16383.62,12566.21,12533.29,7263.07,6329.07,5970.43,6619.73,4893.02,3537.95,3102.99,4084.08,2583.17
4.92,3780.01,2877.61,2168.31,1452.74,1413.20,1641.69,865.66|
interpolate=monotone|
colors=seagreen,orchid,blue|
}}

Stepper

2018-05-06T16:05:16Z

Sensille:

Stepper

2018-05-06T16:02:35Z

Sensille:

Stepper

2018-05-06T16:00:25Z

Sensille:

Stepper

2018-05-06T15:58:18Z

Sensille:

Stepper

2018-05-06T15:51:20Z

Sensille:

Stepper

2018-05-06T15:16:06Z

Sensille:

Stepper

2018-05-05T20:27:55Z

Sensille:

Stepper

2018-05-05T20:27:28Z

Sensille:

Stepper

2018-05-01T08:34:48Z

Sensille:

Stepper

2018-05-01T08:32:20Z

Sensille:

Stepper

2018-04-30T19:39:49Z

Sensille:

Stepper

2018-04-30T19:30:07Z

Sensille:

Stepper

2018-04-30T19:24:16Z

Sensille:

Controller

2018-03-21T21:12:47Z

Sensille:

Currently an Artix-7 FPGA is used as the controller. It has a serial interface with a command width of 80 bytes.

The first byte gives the command. The command has a variable width, with a maximum length of 80 bits. Most commands just get enqueued into an internal FIFO with 64 entries. The bits are clocked in right to left, so the lowest bit of the command comes last.

The internal clock frequency is 20MHz.

Commands:

=== Ramp ===
- ramp(8'h9a,36'<acceleration>, 36'<clock count>)

For the given number of clocks increment the internal acceleration register by the value given in the command.
Acceleration can also be negative.

=== Start ===
- start(8'hb5)

Start the engine. All commands in the fifo will be executed.

=== Configure Rev ===
- configure clocks/rev (8'ha3, 24'<step per revolution>)

Set number of steps for one revolution. With a 0.9deg stepper and 256 microstepping set it to 1024000.
If the internal position counter reaches this value, it is reset to zero and a pulse on the REV pin is generated.

=== Sync Revcounter ===
- sync(8'h3d)

Run until the next rising edge of the home sensor. If reached, reset the internal position to 0.

Controller

2018-03-21T21:10:45Z

Sensille:

Currently an Artix-7 FPGA is used as the controller. It has a serial interface with a command width of 80 bytes.

The first byte gives the command. The command has a variable width, with a maximum length of 80 bits. Most commands just get enqueued into an internal FIFO with 64 entries.

The internal clock frequency is 20MHz.

Commands:

=== Ramp ===
- ramp(8'h9a,36'<acceleration>, 36'<clock count>)

For the given number of clocks increment the internal acceleration register by the value given in the command.
Acceleration can also be negative.

=== Start ===
- start(8'hb5)

Start the engine. All commands in the fifo will be executed.

=== Configure Rev ===
- configure clocks/rev (8'ha3, 24'<step per revolution>)

Set number of steps for one revolution. With a 0.9deg stepper and 256 microstepping set it to 1024000.
If the internal position counter reaches this value, it is reset to zero and a pulse on the REV pin is generated.

=== Sync Revcounter ===
- sync(8'h3d)

Run until the next rising edge of the home sensor. If reached, reset the internal position to 0.

Controller

2018-03-21T21:05:31Z

Sensille:

Currently an Artix-7 FPGA is used as the controller. It has a serial interface with a command width of 80 bytes.

The first byte gives the command. The command has a variable width, with a maximum length of 80 bits. Most commands just get enqueued into an internal FIFO with 64 entries.

The internal clock frequency is 20MHz.

Commands:

=== Ramp ===
- ramp('8h9a,'36h<acceleration>, '36h<clock count>)

For the given number of clocks increment the internal acceleration register by the value given in the command.
Acceleration can also be negative.

=== Start ===
- start('8hb5)

Start the engine. All commands in the fifo will be executed.

=== Configure Rev ===
- configure clocks/rev ('8ha3, '24h<step per revolution>)

Set number of steps for one revolution. With a 0.9deg stepper and 256 microstepping set it to 1024000.
If the internal position counter reaches this value, it is reset to zero and a pulse on the REV pin is generated.

=== Sync Revcounter ===
- sync('8h3d)

Run until the next rising edge of the home sensor. If reached, reset the internal position to 0.

Controller

2018-03-21T20:50:08Z

Sensille: Created page with "Currently an Artix-7 FPGA is used as the controller. It has a serial interface with a command width of 80 bytes."

Currently an Artix-7 FPGA is used as the controller. It has a serial interface with a command width of 80 bytes.

Main Page

2018-03-21T20:49:10Z

Sensille:

[[Stepper]]

[[Controller]]

Stepper

2018-03-21T20:45:45Z

Sensille: /* Take Two, Weight Spinning */

Stepper

2018-03-21T20:14:13Z

Sensille:

Stepper

2018-03-21T20:10:02Z

Sensille:

Stepper

2018-03-21T20:09:17Z

Sensille:

Used Stepper: 17HM19-2004S

Driver Voltage: 37V

Driver: TMC2130

Max RPM reached with the motor, unloaded: 3600RPM
This is the limit of the driver. It runs from the internal oscillator at 12.1MHz. Measure by giving a 9.765kHz pulse and read out register TSTEP as 0x277 (DEDGE=true).

Take One, Lifting Weights

Driver Configuration is basically the recommended default from the datasheet for a coil current of about 2A:
reg 0x6c -> 0x200100c3
reg 0x10 -> 0x00061c02
reg 0x91 -> 0x0000000a
reg 0x80 -> 0x00003144
reg 0x93 -> 0x000001f4
reg 0xf0 -> 0x000401c8

For very slow step rates stealthChop was disabled

Load Testing at 1/256 microstepping. Testing done lifting a weight by winding a rope on a cylinder with effective radius of 16.5mm.

<gallery>
Weightlifting.jpeg|Weight Lifting Setup
</gallery>

9.5kHz 2250g
19.5kHz 2150g
39kHz 2240g
58.5kHz 2220g
78kHz 2240g
97.5kHz 2230g
117kHz 2230g
137kHz 2130g
156kHz 2150g
195kHz 2030g
234kHz 2050g
312kHz 2030g
468kHz 1700g
624kHz 1300g
936kHz 740g
1092kHz 556g
1400kHz 250g
1700kHz 150g

{{
Graph:Chart|width=600|height=200|
xAxisTitle=RPM|
yAxisTitle=Torque in Ncm|
legend=Legend|
type=line|
x=11.13,22.85,45.70,68.55,91.41,114.26,137.11,160.55,182.81,228.52,274.22,365.62,548.44,731.25,1096.88,1279.69,1640.62,1992.19|
y1=37.12,35.48,36.96,36.63,36.96,36.80,36.80,35.14,35.48,33.49,33.82,33.49,28.05,21.45,12.21,9.17,4.12,2.47|
y1Title=Measured|
y2=,,,,24,26,32,34,34,34.5,36,35.5,34,16|
y2Title=From Datasheet (rough estimate)|
interpolate=monotone|
colors=seagreen,orchid|
}}

Source for torque curve from datasheet: https://www.omc-stepperonline.com/download/17HM19-2004S_Torque_Curve.pdf

Full data sheet of the motor: https://www.omc-stepperonline.com/download/17HM19-2004S.pdf

Stepper

2018-03-21T19:56:07Z

Sensille:

Used Stepper: 17HM19-2004S

Driver Voltage: 37V

Driver: TMC2130

Max RPM reached with the motor, unloaded: 3600RPM
This is the limit of the driver. It runs from the internal oscillator at 12.1MHz. Measure by giving a 9.765kHz pulse and read out register TSTEP as 0x277 (DEDGE=true).

Take One, Lifting Weights

Driver Configuration is basically the recommended default from the datasheet for a coil current of about 2A:
reg 0x6c -> 0x200100c3
reg 0x10 -> 0x00061c02
reg 0x91 -> 0x0000000a
reg 0x80 -> 0x00003144
reg 0x93 -> 0x000001f4
reg 0xf0 -> 0x000401c8

For very slow step rates stealthChop was disabled

Load Testing at 1/256 microstepping. Testing done lifting a weight by winding a rope on a cylinder with effective radius of 16.5mm.

<gallery>
Weightlifting.jpeg|Caption1
</gallery>

9.5kHz 2250g
19.5kHz 2150g
39kHz 2240g
58.5kHz 2220g
78kHz 2240g
97.5kHz 2230g
117kHz 2230g
137kHz 2130g
156kHz 2150g
195kHz 2030g
234kHz 2050g
312kHz 2030g
468kHz 1700g
624kHz 1300g
936kHz 740g
1092kHz 556g
1400kHz 250g
1700kHz 150g

{{
Graph:Chart|width=600|height=200|
xAxisTitle=RPM|
yAxisTitle=Torque in Ncm|
legend=Legend|
type=line|
x=11.13,22.85,45.70,68.55,91.41,114.26,137.11,160.55,182.81,228.52,274.22,365.62,548.44,731.25,1096.88,1279.69,1640.62,1992.19|
y1=37.12,35.48,36.96,36.63,36.96,36.80,36.80,35.14,35.48,33.49,33.82,33.49,28.05,21.45,12.21,9.17,4.12,2.47|
y1Title=Measured|
y2=,,,,24,26,32,34,34,34.5,36,35.5,34,16|
y2Title=From Datasheet (rough estimate)|
interpolate=monotone|
colors=seagreen,orchid|
}}

Source for torque curve from datasheet: https://www.omc-stepperonline.com/download/17HM19-2004S_Torque_Curve.pdf

Full data sheet of the motor: https://www.omc-stepperonline.com/download/17HM19-2004S.pdf

File:Weightspinning.jpeg

2018-03-21T19:54:54Z

Sensille: Setup to measure torque by spinning known weights.

Setup to measure torque by spinning known weights.