Advanced Search

No, sadly not!
I tried various other things too, but nope.
I am going back to do a completely new install from scratch of Linux, etc. which requires a SSD shuffle between computers.
...

I think it might be more effective to create a dedicated component, rather than force carousel to fit.

But I think that Carousel will probably just keep the "motor-fwd" bit set high until the carousel is in the correct position, so the trick is to find a way to release the pressure and lower the carousel once the actuating cylinder hits end-of-stroke.
Is there a sensor for that?

The crude way to make this work might be to use motor-fwd to enable a siggen component that sends a suitably-timed series of pulses.

Aciera wrote:

one advantage of using switchable kinematics is that all joints can be homed normally on startup.

Trying to digest all this and a couple questions occurred to me...

Is this the part of the component/programming that changes the position of the joints?:

• CASE 1
  • pos->tran.x = j[0];
  • pos->v = j[2];
• Case 2
  • pos->tran.x = j[2];
  • pos->v = j[0];

More specifically, when the kinematics switch is made is the above what causes the X and V axes DRO's to switch?

Why does X has a 'tran' and V doesn't?  I saw that stuff in userkins.comp, but I can't find an explanation of the programming language/syntax.

 

endian wrote:

Yes Rod .. it is solution but it is creating constant delay between control position -> DFIR -> current position of tool ....
 

It will not add any delay as it should be applied as the acceleration is calculated or read per servo cycle. Just not sure how you need to use it. 
the size of the buffer is configurable.
Any other published moving average solution wanted to use loops which are a source of delay so I devised this..
One of the cleverest algorithms I have ever coded...

I don't think they do consultancy, but you are very close to the Mesa Electronics HQ.

You don't say what the inputs to and2.2 are. That is probably important.

A problem you will have is that spindle.0.index-enable is a bidirectional HAL pin, so can't be directly connected to the output of an and2 block.

You can probably work around this with linuxcnc.org/docs/stable/html/man/man9/tristate_bit.9.html

But, are you sure that your spindle encoder driver doesn't offer e direct, bidirectional, index-enable pin?

There is an example of an index-simulator HAL component here:
forum.linuxcnc.org/24-hal-components/388...ation?start=0#223508

It's written for a stepper spindle, but should work just as well (or just as badly) for an absolute encoder assuming that the encoder has an integer "counts" output.


I was going to suggest watching one bit of the binary counts value and tristate-bit. But that wouldn't zero the counts on index.

There _is_ a way to do it with a sample-hold to capture the counts at index, then subtracting that from the raw counts, that would need a bitslice, mux_generic (set up for signed int), edge, and tristate-bit HAL component.
It's do-able but at that point the custom HAL component makes more sense.

@grandixximo 
Do you have any idea what might be causing the delay in the DRO? 
It seems like the drives arent going into OP right away. The delay is always different. Sometimes the DRO is instantly filled with the encoder read (but converted to axis position) values, sometimes it takes up to 10 seconds. 

Could this also be part of the whole issue? The drives PRE-OP to OP delay. 

Hi all,I'm using a Mesa 7i95T and I need a bitfile with the following configuration:

• sserial on P1 (to read a MESA 7i87 for analog sensors)
• 1x rcpwmgen for RC servo control (MG995, 50Hz, 1-2ms pulse width)
• as many stepgens as possible with the remaining pins (ideally 5)

Currently I'm usingwhich has a standard pwmgen, but rcpwmgen would be much cleaner for direct RC servo control without needing external offset/scale calculations. Is there an existing bitfile that covers this, or could you compile one?Thanks in advance!

It is an older 15kw Tosvert that i repaired some time ago, dont think its in the modbus era. So traditional i/o it is. The servo drives only have 2-3inputs for internal use, like fault reset, homing switch and e-stop.

Yes Rod .. it is solution but it is creating constant delay between control position -> DFIR -> current position of tool ....

next stuff what Gemini tells me at Cloud of points topic is - 

* Look-Ahead Buffer CompressionConventional S-curves fail when the "Look-ahead" buffer is too small. If the planner only sees 10 points ahead, it doesn't know it can maintain $F500$ through the next 100 points.The Fix: Use a Compressor or Point Filter.In your trajectory planner settings, ensure the look-ahead is set to at least 100–200 segments.The Approximation: If three points are almost in a straight line, the planner should "ignore" the middle point. This turns a "Cloud of Points" back into a "Set of Vectors," which is much easier for S-curve math to handle.

(before noticed DRIF)
* The "Look-up Table" (LUT) Approximation
If the analytical math (solving cubic equations) is too slow for your CPU, you can use a pre-computed trapezoidal acceleration profile and apply a Finite Impulse Response (FIR) Filter.

The Method: Calculate a standard, "harsh" Trapezoidal move first. Then, run that velocity profile through a "Moving Average" filter.

The Result: The "sharp corners" of the trapezoid become smooth "S" shapes.

* Constraint Decoupling (Axis vs. Path)Latency often spikes when the planner tries to synchronize 3+ axes using 3rd-order math.The Fix: Instead of calculating a full 3D vector S-curve, calculate the S-curve for the Master Path (the total distance) and then linearly project that to X, Y, and Z.The Trade-off: This is slightly less "optimal" for machine time, but it reduces the math complexity by $66\%$, significantly dropping your latency.

* Frequency Domain Filtering (Advanced)
If you are writing the code for the planner, you can use a Low-pass filter on the commanded acceleration.
Generate the "rough" motion.
Pass it through a 2nd order low-pass filter (Butterworth or similar).
This effectively "limits jerk" by removing the high-frequency components (the "thumps") of the motion.

what I can see aproximation or longer thread timing are the only known solutions... but I am not expert in this topic 

endian wrote:

In professional controllers (Fanuc/Siemens), this is solved by having a dedicated DSP (Digital Signal Processor) or an FPGA that does nothing but the motion math, leaving the main CPU to handle the G-code.

As far as I know, that’s not entirely right.
For the nano-smoothing function (NURBS interpolation for cloud of points), Fanuc uses non-realtime buffered calculations on the CPU to prepare the trajectory (look-ahead buffer). Then, data from the interpolator is sent to the DSP, where the planner calculates the speeds in real time.

Hi,
Some time ago I opened a topic about separating CiA402 logic from EtherCAT and validating it in a more modular way.

forum.linuxcnc.org/ethercat/58434-separa...ter-drive-stub-valid

Since then I kept working on that idea and turned it into something more complete that is now actually runnable and easier to test.

What problem I was trying to solve:
While studying and experimenting with CiA402 setups (and reading quite a few forum threads), I kept running into the same kind of issues:
often ending up debugging everything at once (motion + HAL + EtherCAT + drive)
not knowing if a problem comes from logic, wiring or hardware
drive-internal homing causing unexpected behavior or following errors
difficulty understanding what the controlword / statusword is really doing at runtime


So the goal here is not to replace anything, but to make those problems easier to isolate and understand.

What this does differently
The main idea is to separate things a bit more clearly:
keep LinuxCNC motion as-is
isolate CiA402 semantics (state machine, CSP, homing, etc.)
keep hardware/backend separate (EtherCAT, etc.)
This way it's possible to:
test CiA402 behavior without hardware first
see what's happening internally instead of guessing
debug logic without mixing it with transport issues

You can run it directly (no EtherCAT required):
git clone github.com/MarcosDuqueCesar/linuxcnc-cia402-layer
cd linuxcnc-cia402-layer
find comp -name "*.comp" -exec halcompile --install {} \;
linuxcnc ini/examples/runtime_validate_xyz.ini
scripts/diag.sh

This runs a full CiA402 pipeline using a stub backend.
You can observe things like:
controlword behavior
statusword transitions
mode switching (CSP / HOMING)
basic sequencing / watchdog behavior

Debugging focus:
One thing I tried to improve is visibility.
Instead of guessing, you can see internal state and get a better idea if the issue is:
logic / sequencing
HAL wiring
or backend / hardware

About homing:
This is one area that motivated the work.
In some setups, using drive-internal homing can lead to following errors if the LinuxCNC side is not kept consistent with what the drive is doing.
Here, homing is treated as a separate semantic part instead of being embedded inside the driver logic, so it's easier to observe and reason about.

Current status:
simulation: working
CiA402 logic: validated in runtime
hardware integration: not yet tested
This is intentional so far — the focus was to understand and validate the CiA402 behavior first without requiring hardware.

Scope:
This does not replace:
real-time tuning
EtherCAT setup complexity
Those are still necessary.
This is mainly about structuring and understanding CiA402 behavior.

Feedback:
If anyone is working with CiA402 in LinuxCNC, I’d really appreciate feedback.
Especially from real hardware setups, to validate the adapter/binding side.
Thanks

 was struggling with the forum editor formatting, so the first post didn’t come out right.

by way of explanation the moving average uses a simple circular buffer and calculates the sum of readings. Once the buffer is filled, the next reading overwrites the first reading in the buffer. So by deducting that value before it is overwritten and adding the new value as its written, the sum is maintained without any loops. The moving average is simply the sum / buffer size. There is no reason why it could not be called again recursively to calculate the second moving average.

C73 on a 7I96 (there is no C73 on a 7I96S)  is 22 uF 10V or 16V size 1210