FlyPT 6DOF/Stewart/Hexapod Interface for linear and rotating actuators

Its completely at his discretion of course what he wishes to do and how far to take it but if he wishes it I have no doubts he can accomplish it . I just crave a little diversity which is lacking here imo. Of course every other developer isn't interested in or even know of motion software so its a rare thing. I think with all the "Simtools" stuff going on here though it gets lost this site is not just for Simtools but also open to other ideas and contributions which is a great thing.

For 6dof only though I think things like axis assignments should not be hard. And the tuning center just scales telemetry which can be done with simple multiplication. I agree it would be nice to have compatibility with all games Simtools does but since its plugins aren't sharable we could ask plugin developers if they would also contribute to other software too. Maybe we could even turn some kind of open telemetry server idea into a community effort some day . In any case he has a Simtools plugin already for compatibility when necessary.

Hello @pmvcda . I tried the version 1.8.1 with Asseto Corsa direct link (no Simtools). It sent two of my actuator to their max (before the limit switch) and did nothing else. I did not time to move the car. I reset everything and tried again. Same thing.

Then, I tried with Simtools, for Elite and I got this:



I went back to version 1.7.3 and all went fine (exept for the Lock to lowest position).

Hey @pmvcda

may I ask how you create the pose for the platform? I assume that for every frame you create the platform at the origin and then apply translations and rotations using the motion data. Is that correct?

I am asking, because I am considering different orders in which those transformations (to create the pose) are being applied. Initially I thought: 1. translations, 2.rotations (rotations dependent on translations)

...then I realised some problems with false cues and changed to 1. rotations, 2. translations (translations dependent on translations). And again, I realised different problems with different false cues.

I came up with an unorthodox solution as I discussed with @hexpod using an intermediate pose, but I am still unsure. So can you do me the favour and describe in what order you apply these transformations? That could help me a lot.

Dirty

Your bit range is 8 bit?
I thought it should be 10 bits for the SMC.
In your topic, you had 10 for bit range.
Please try

I'm using two solutions:
1st rotation
2nd translation in world coordinates

Or:
1st rotation
2nd translation in top platform coordinates

You can select witch one to use.
Transform swap checked is translation in platform coordinates
unchecked translation in world coordinates

Compound is hard to to.
I have it in a build, but it's drifting.

The drift is caused, because I have to work with deltas, not absolute positions.
I see @hexpod asked for this.
I may take a look if I can make it better.

For translation/rotation, see above post.
I will try to make it better.
The filters, are basic stuff.
No problem in sharing (my current c# filter class):

Code:

// ========================
// Filter class - by the FlyPT
// Last revision 15-03-2019
// ========================

using System;

class ClassFilter
{
    // ================
    // Public constants
    // ================
    public const sbyte NONE = 0;
    public const sbyte EMALOWPASS = 1;
    public const sbyte EMAHIGHPASS = 2;
    public const sbyte EMABANDPASS = 3;
    public const sbyte EMABANDSTOP = 4;
    public const sbyte DEMALOWPASS = 5;
    public const sbyte DEMAHIGHPASS = 6;
    public const sbyte DEMABANDPASS = 7;
    public const sbyte DEMABANDSTOP = 8;
    public const sbyte TEMALOWPASS = 9;
    public const sbyte TEMAHIGHPASS = 10;
    public const sbyte TEMABANDPASS = 11;
    public const sbyte TEMABANDSTOP = 12;
    public const sbyte EMAWASHOUT = 13;
    public const sbyte DEMAWASHOUT = 14;
    public const sbyte TEMAWASHOUT = 15;


    // =============================================
    // Public properties and respective private ones
    // =============================================
    private sbyte _type = NONE;
    public sbyte type
    {
        get
        {
            return _type;
        }
        set
        {
            // Use values we had in the previous filter to avoid spike when we change filter type
            switch (_type)
            {
                case EMALOWPASS:
                    emaStoredHighPassValue = emaStoredLowPassValue;
                    demaStoredLowPassValue = emaStoredLowPassValue;
                    demaStoredHighPassValue = emaStoredLowPassValue;
                    temaStoredLowPassValue = emaStoredLowPassValue;
                    temaStoredHighPassValue = emaStoredLowPassValue;
                    break;
                case EMAHIGHPASS:
                    emaStoredLowPassValue = emaStoredHighPassValue;
                    demaStoredLowPassValue = emaStoredHighPassValue;
                    demaStoredHighPassValue = emaStoredHighPassValue;
                    temaStoredLowPassValue = emaStoredHighPassValue;
                    temaStoredHighPassValue = emaStoredHighPassValue;
                    break;
                case EMABANDPASS:
                case EMABANDSTOP:
                case EMAWASHOUT:
                    demaStoredLowPassValue = emaStoredLowPassValue;
                    demaStoredHighPassValue = emaStoredHighPassValue;
                    temaStoredLowPassValue = emaStoredLowPassValue;
                    temaStoredHighPassValue = emaStoredHighPassValue;
                    break;

                case DEMALOWPASS:
                    emaStoredLowPassValue = demaStoredLowPassValue;
                    emaStoredHighPassValue = demaStoredLowPassValue;
                    demaStoredHighPassValue = demaStoredLowPassValue;
                    temaStoredLowPassValue = demaStoredLowPassValue;
                    temaStoredHighPassValue = demaStoredLowPassValue;
                    break;
                case DEMAHIGHPASS:
                    emaStoredLowPassValue = demaStoredHighPassValue;
                    emaStoredHighPassValue = demaStoredHighPassValue;
                    demaStoredLowPassValue = demaStoredHighPassValue;
                    temaStoredLowPassValue = demaStoredHighPassValue;
                    temaStoredHighPassValue = demaStoredHighPassValue;
                    break;
                case DEMABANDPASS:
                case DEMABANDSTOP:
                case DEMAWASHOUT:
                    emaStoredLowPassValue = demaStoredLowPassValue;
                    emaStoredHighPassValue = demaStoredHighPassValue;
                    temaStoredLowPassValue = demaStoredLowPassValue;
                    temaStoredHighPassValue = demaStoredHighPassValue;
                    break;

                case TEMALOWPASS:
                    emaStoredLowPassValue = temaStoredLowPassValue;
                    emaStoredHighPassValue = temaStoredLowPassValue;
                    demaStoredLowPassValue = temaStoredLowPassValue;
                    demaStoredHighPassValue = temaStoredLowPassValue;
                    temaStoredHighPassValue = temaStoredLowPassValue;
                    break;
                case TEMAHIGHPASS:
                    emaStoredLowPassValue = temaStoredHighPassValue;
                    emaStoredHighPassValue = temaStoredHighPassValue;
                    demaStoredLowPassValue = temaStoredHighPassValue;
                    demaStoredHighPassValue = temaStoredHighPassValue;
                    temaStoredLowPassValue = temaStoredHighPassValue;
                    break;
                case TEMABANDPASS:
                case TEMABANDSTOP:
                case TEMAWASHOUT:
                    emaStoredLowPassValue = temaStoredLowPassValue;
                    emaStoredHighPassValue = temaStoredHighPassValue;
                    demaStoredLowPassValue = temaStoredLowPassValue;
                    demaStoredHighPassValue = temaStoredHighPassValue;
                    break;
            }
            _type = value;
        }
    }


    // ==================
    // Private parameters
    // ==================
    private double alpha1 = 1;
    private double alpha2 = 1;
    public double emaStoredLowPassValue = 0;
    public double emaStoredHighPassValue = 0;
    private double demaStoredLowPassValue = 0;
    private double demaStoredHighPassValue = 0;
    private double temaStoredLowPassValue = 0;
    private double temaStoredHighPassValue = 0;


    // ==================
    // Class constructors
    // ==================
    public ClassFilter()
    {
        _type = NONE;
        numberOfSamples(1, 1000);
    }
    public ClassFilter(sbyte type_of_filter)
    {
        _type = type_of_filter;
        numberOfSamples(1, 1000);
    }
    public ClassFilter(sbyte type_of_filter, UInt16 numberOfSamples1, UInt16 numberOfSamples2)
    {
        _type = type_of_filter;
        numberOfSamples(numberOfSamples1, numberOfSamples2);
    }

    // =================================================
    // Changing the number of samples used in the filter
    // =================================================
    public void numberOfSamples(UInt16 numberOfSamples1, UInt16 numberOfSamples2)
    {
        alpha1 = 2 / (1 + (double)numberOfSamples1);
        alpha2 = 2 / (1 + (double)numberOfSamples2);

    }
    public double numberOfSamples1(int numberOfSamples1)
    {
        alpha1 = 2 / (1 + (double)numberOfSamples1);
        return alpha1;
    }
    public double numberOfSamples2(int numberOfSamples2)
    {
        alpha2 = 2 / (1 + (double)numberOfSamples2);
        return alpha2;
    }


    // ===============================================
    // Call filter depending on current type of filter
    // ===============================================
    public double filter(double value)
    {
        switch (_type)
        {
            case NONE: return value;

            case EMALOWPASS: return emaLowPass(value);
            case EMAHIGHPASS: return emaHighPass(value);
            case EMABANDPASS: return emaBandPass(value);
            case EMABANDSTOP: return emaBandStop(value);

            case DEMALOWPASS: return demaLowPass(value);
            case DEMAHIGHPASS: return demaHighPass(value);
            case DEMABANDPASS: return demaBandPass(value);
            case DEMABANDSTOP: return demaBandStop(value);

            case TEMALOWPASS: return temaLowPass(value);
            case TEMAHIGHPASS: return temaHighPass(value);
            case TEMABANDPASS: return temaBandPass(value);
            case TEMABANDSTOP: return temaBandStop(value);

            case EMAWASHOUT: return emaWashout(value);
            case DEMAWASHOUT: return demaWashout(value);
            case TEMAWASHOUT: return temaWashout(value);

            default: return value;
        }
    }


    // =================
    // EMA based filters
    // =================
    private double emaLowPass(double value)
    {
        emaStoredLowPassValue += alpha1 * (value - emaStoredLowPassValue);
        return emaStoredLowPassValue;
    }
    private double emaHighPass(double value) // HIGH = VALUE-LOW
    {
        emaStoredHighPassValue += alpha2 * (value - emaStoredHighPassValue);
        return value - emaStoredHighPassValue;
    }
    private double emaBandPass(double value) // BAND = LOW_FOR_HIGH - LOW
    {
        emaStoredLowPassValue += alpha1 * (value - emaStoredLowPassValue);
        emaStoredHighPassValue += alpha2 * (value - emaStoredHighPassValue);
        return emaStoredHighPassValue - emaStoredLowPassValue;
    }
    private double emaBandStop(double value) // STOP = VALUE - LOW_FOR_HIGH + LOW
    {
        emaStoredLowPassValue += alpha1 * (value - emaStoredLowPassValue);
        emaStoredHighPassValue += alpha2 * (value - emaStoredHighPassValue);
        return value - (emaStoredHighPassValue - emaStoredLowPassValue);
    }


    // =========================================
    // DEMA based filters  DEMA = 2*EMA-EMA(EMA)
    // =========================================
    private double demaLowPass(double value)
    {
        emaStoredLowPassValue += alpha1 * (value - emaStoredLowPassValue);
        demaStoredLowPassValue += alpha1 * (emaStoredLowPassValue - demaStoredLowPassValue);
        return 2 * emaStoredLowPassValue - demaStoredLowPassValue;
    }
    private double demaHighPass(double value) // HIGH = VALUE-LOW
    {
        emaStoredHighPassValue += alpha2 * (value - emaStoredHighPassValue);
        demaStoredHighPassValue += alpha2 * (emaStoredHighPassValue - demaStoredHighPassValue);
        return value - (2 * emaStoredHighPassValue - demaStoredHighPassValue);
    }
    private double demaBandPass(double value) // BAND = LOW_FOR_HIGH - LOW
    {
        emaStoredLowPassValue += alpha1 * (value - emaStoredLowPassValue);
        demaStoredLowPassValue += alpha1 * (emaStoredLowPassValue - demaStoredLowPassValue);
        emaStoredHighPassValue += alpha2 * (value - emaStoredHighPassValue);
        demaStoredHighPassValue += alpha2 * (emaStoredHighPassValue - demaStoredHighPassValue);
        return 2 * (emaStoredHighPassValue -  emaStoredLowPassValue) - demaStoredHighPassValue  + demaStoredLowPassValue;
    }
    private double demaBandStop(double value) // STOP = VALUE - LOW_FOR_HIGH + LOW
    {
        emaStoredLowPassValue += alpha1 * (value - emaStoredLowPassValue);
        demaStoredLowPassValue += alpha1 * (emaStoredLowPassValue - demaStoredLowPassValue);
        emaStoredHighPassValue += alpha2 * (value - emaStoredHighPassValue);
        demaStoredHighPassValue += alpha2 * (emaStoredHighPassValue - demaStoredHighPassValue);
        return value - (2 * (emaStoredHighPassValue - emaStoredLowPassValue) - demaStoredHighPassValue + demaStoredLowPassValue);
    }


    // ===========================================================
    // TEMA based filter TEMA = 3*EMA - 3*EMA(EMA) + EMA(EMA(EMA))
    // ===========================================================
    private double temaLowPass(double value)
    {
        emaStoredLowPassValue += alpha1 * (value - emaStoredLowPassValue);
        demaStoredLowPassValue += alpha1 * (emaStoredLowPassValue - demaStoredLowPassValue);
        temaStoredLowPassValue += alpha1 * (demaStoredLowPassValue - temaStoredLowPassValue);
        return 3 * (emaStoredLowPassValue - demaStoredLowPassValue) + temaStoredLowPassValue;
    }
    private double temaHighPass(double value) // HIGH = VALUE-LOW
    {
        emaStoredHighPassValue += alpha2 * (value - emaStoredHighPassValue);
        demaStoredHighPassValue += alpha2 * (emaStoredHighPassValue - demaStoredHighPassValue);
        temaStoredHighPassValue += alpha2 * (demaStoredHighPassValue - temaStoredHighPassValue);
        return value - (3 * (emaStoredHighPassValue - demaStoredHighPassValue) + temaStoredHighPassValue);
    }
    private double temaBandPass(double value) // BAND = LOW_FOR_HIGH - LOW
    {
        emaStoredLowPassValue += alpha1 * (value - emaStoredLowPassValue);
        demaStoredLowPassValue += alpha1 * (emaStoredLowPassValue - demaStoredLowPassValue);
        temaStoredLowPassValue += alpha1 * (demaStoredLowPassValue - temaStoredLowPassValue);
        emaStoredHighPassValue += alpha2 * (value - emaStoredHighPassValue);
        demaStoredHighPassValue += alpha2 * (emaStoredHighPassValue - demaStoredHighPassValue);
        temaStoredHighPassValue += alpha2 * (demaStoredHighPassValue - temaStoredHighPassValue);
        return 3 * (emaStoredHighPassValue - demaStoredHighPassValue - emaStoredLowPassValue + demaStoredLowPassValue) + temaStoredHighPassValue - temaStoredLowPassValue;
    }
    private double temaBandStop(double value) // STOP = VALUE - LOW_FOR_HIGH + LOW
    {
        emaStoredLowPassValue += alpha1 * (value - emaStoredLowPassValue);
        demaStoredLowPassValue += alpha1 * (emaStoredLowPassValue - demaStoredLowPassValue);
        temaStoredLowPassValue += alpha1 * (demaStoredLowPassValue - temaStoredLowPassValue);
        emaStoredHighPassValue += alpha2 * (value - emaStoredHighPassValue);
        demaStoredHighPassValue += alpha2 * (emaStoredHighPassValue - demaStoredHighPassValue);
        temaStoredHighPassValue += alpha2 * (demaStoredHighPassValue - temaStoredHighPassValue);
        return value - (3 * (emaStoredHighPassValue - demaStoredHighPassValue - emaStoredLowPassValue + demaStoredLowPassValue) + temaStoredHighPassValue - temaStoredLowPassValue);
    }


    // ==============
    // Washout filter
    // ==============
    public double emaWashout(double value)
    {
        return emaLowPass(emaHighPass(value));
    }
    public double demaWashout(double value)
    {
        return demaLowPass(demaHighPass(value));
    }
    public double temaWashout(double value)
    {
        return temaLowPass(temaHighPass(value));
    }
}

@BlazinH,

I'm just enjoying myself.
This is leisure (well, I might put a donation button on the program, had people saying they would donate, and I'm not an idiot.... I think).

I'm not sure where I go with the software. The idea is not to replace SimTools.
But,
I have many ideas and I will put them in practice as time allows.

I'm already working in a new program to replace the current interface.
And I hope people like it. Might give some ideas for future updates in SimTools.

Don't want to say much, not because I want to make mystery, but because I'm not sure when I have it ready to show or if it will work as I expect.
The day I post the program, it will be already working, at least in a basic way. And yes, it will have direct input from games.

Stay tuned!

Thanks pmvcda. It's been a while since I've been this excited about an announcement here so I'm really looking forward to seeing what you come up with . I'm mostly into racing so a 6dof has not been a priority for me thus far but since I have a lot of what is needed already its time to start one me thinks (rotational).

I do love Simtools but I have a lot more left to share.

I'm getting the same error with latest build. Error no data from sim tools ?

Found the problem, making a new build.

Version 1.8.2

Bug corrected (I think)
Download in first post.

Sorry about the error in bit rate of my other pics. I use arrows to test Asseto Corsa and I put hexapod interface over to change value. But, arrows does drive the car in asseto, but it also change the value of the last parameter I used in hexapod. Still, version 1.8.1 was not working at 10 bits.

Version 1.8.2 does.
Direct link to asseto corsa does work too, but I have to put the gain at 0.1 because of the too strong signal. Yaw with washout works really well. I will definitively test it more.
Lock at lowest position uses the main gain. At 0.1, it does not go really far down.

yes yes! you have it already. only "small" issue I see is that in "local mode" your center of gravity moves laterally and should move according to "local Platform" translations.

If the Surge "lifts" the platform because of Pitch, the CoG should follow

https://youtu.be/WmtAohWiYn4

Am I right?

erased

The HPF brings back the platform but not the slider so it’s blocking the cue data

Any solution how to overcome ?

I'm looking at it right now.

@pmvcda , Can you see this Center of rotation issue here?

The axis representation is corrected in the last version.
Or do you mean that rotation should be made around the point affected by translation?

EDIT:
Well it's around that point, but not on the axis.

It can be it is my wrong usage of SimTools scaling which blocs the data and not the FLYpt slider/model discrepancy issue.

Sorry I missed this fix. Seems all fine in the last one.
Congrats!