Algorithms

Do
 ta = Abs((vmax - v0) / a) ' Acceleration time.
 da = (v0 * ta) + (0.5 * a * ta * ta) ' Acceleration distance.
 tf = Abs((vmax - vf) / a) ' Deceleration time.
 df = (vf * tf) + (0.5 * a * tf * tf) ' Deceleration distance.
 If (da + df > dist) Then  ' if the accel and decel distances are bigger than the total distance...
   If (v0 = vf) Then  ' Only if v0 is equal than vf then we can calculate the time it will take to reach the middle position
     taux = (Sqr((a * dist) + (v0 * v0)) - v0) / a
     vmax = v0 + a * taux
   Else  ' Super slow way to search for the right speed (moreover it only decreases by 1 so it won't find exactly the right speed)
     vmax = vmax - 1  ' reduce the maximum allowed speed... it would be better to use a binary search than that,... but the best thing would be to use a mathematical calculation to find it...
   End If
 End If
Loop While (da + df > dist) ' We are doing this until the condition is met.

distance_with_v = x1 - x0 - s_Acc - s_Dec

if Distance_with_v < 0 then
   Relation_Acc_Dec = s_Acc / (s_Acc + s_Dec)
   DistanceCorrecting_Accelaration = Distance_with_v * Relation_Acc_Dec 
      da = s_Acc - DistanceCorrecting_Accelaration
   DistanceCorrecting_Decelaration = Distance_with_v * (1 - Relation_Acc_Dec) 
      df = s_Dec - DistanceCorrecting_Decelaration
end if

ta = Abs((vmax - v0) / a)
   da = (v0 * ta) + (0.5 * a * ta * ta)
   tf = Abs((vmax - vf) / a)
   df = (vf * tf) + (0.5 * a * tf * tf)
   
   If (da + df > dist + 0.000000001) Then
    If (v0 = vf) Then
      taux = (Sqr((a * dist) + (v0 * v0)) - v0) / a
      vmax = v0 + a * taux
    Else
      DistTotal = xf - x0 - da - df
      RelAccDec = da / (da + df)
      dist_corr_acc = DistTotal * RelAccDec
      da = da + dist_corr_acc
      dist_corr_dec = DistTotal * (1 - RelAccDec)
      df = df + dist_corr_dec

      taux = (Sqr((a * dist) + (v0 * v0)) - v0) / a  ' Here time is not getting calculated as it should... and therefore the vmax is also wrong...
      vmax = v0 + (a * taux)
    End If
   End If

LimitIterations = 1000
    ' Search the amount of time and distance we use to accelerate from v0 to vmax.
    ta = Abs((vmax - v0) / a)
    da = (v0 * ta) + (0.5 * a * ta * ta)
    ' Search the amount of time and distance we use to brake from vmax to vf.
    tf = Abs((vmax - vf) / a)
    df = (vf * tf) + (0.5 * a * tf * tf)
   
    ' If da and df are bigger than the distance to run...
    If (da + df > dist + 0.000000001) Then
      ' adapt the acceleration and braking distances to the distance we must run.
      DistTotal = xf - x0 - da - df
      RelAccDec = da / (da + df)
      dist_corr_acc = DistTotal * RelAccDec
      da = da + dist_corr_acc
      dist_corr_dec = DistTotal * (1 - RelAccDec)
      df = df + dist_corr_dec

      ' Now that we know the correct distances it should be easy to find the needed time and therefore the reached vmax after the acceleration stage.
      taux = Sqr(da / (0.5 * a))  ' Normal formula that doesn't work when v0 > 0
      taux = (Sqr((2 * a * da) + (v0 * v0)) - v0) / a  ' Rare formula that nobody understands...
      vmax = v0 + (a * taux)  ' Easy way to calculate the vmax.

      ' Ugliest code in the world... if there is not a better option I'll end up making a binary search to minimize the cpu time (I've seen cases of 500 iterations and when one starts making these ugly things no one knows what can happen).
      Do
        ' refresh the values (time, distance...) to find the maximum allowed speed for that movement vmax...
        ta = Abs((vmax - v0) / a)
        da = (v0 * ta) + (0.5 * a * ta * ta)
        tf = Abs((vmax - vf) / a)
        df = (vf * tf) + (0.5 * a * tf * tf)
        If (da + df > dist + 0.000000001) Then
          vmax = vmax - 1   ' Decrease the vmax till it works... 
          iterations = iterations + 1
          If (iterations > LimitIterations) Then
            ErrorID = 1
            Exit Do
          End If
        Else
          Exit Do
        End If
      Loop
    End If

a = Vc/t
a = (Ve-Vo)/t
a = ( (Vo^2 + 2ad)^(1/2) - Vo )/t
at = ( (Vo^2 + 2ad)^(1/2) - Vo )
t = ( (Vo^2 + 2ad)^(1/2) - Vo )/a

taux = (Sqr((2 * a * da) + (v0 * v0)) - v0) / a
      vmax = v0 + (a * taux)

vmax = Sqr((v0 * v0) + 2 * a * (da))

Ralf Meier wrote:

I'm not sure that an asynchronous Motor is the right approach

Ralf Meier wrote:

If you want to stop the Motor during it's cycle (because of urgency or a fault) you don't need to calculate the distance - here it is necessary (my opinion) to realize a maximum of decelaration.

Ralf Meier wrote:

In this case the formula's should be corrected ... I think I have a Solution for this.

Ralf Meier wrote:

So : t = abs(v_x0_x1 - v_x1_x2) / a_x1

t = abs(v0 - vmax)/a

da = 0.5*a*ta^2

Joan M wrote:

Any idea on how to solve that problem?

Joan M wrote:

This remembers me the school days when we had to find the intersection of two vectors...