非對稱加減速軌跡規劃：C#實現與應用詳解

作者：iamrick 2025-05-08 03:00:00

非對稱加減速控制為運動控制系統提供了更高的靈活性和性能，使其能夠更好地適應復雜多變的工業應用場景。通過合理設置加速度和減速度參數，可以在速度、精度和能耗之間取得更好的平衡。

在運動控制系統中，軌跡規劃是確保設備平穩、高效運行的關鍵技術。傳統的對稱加減速模型（如梯形速度曲線）雖然實現簡單，但在很多實際應用場景中存在局限性。本文將詳細探討非對稱加減速軌跡規劃的實現方法，為您展示如何通過C#代碼靈活應用不同的加速度和減速度參數，以適應更復雜的控制需求。

為什么需要非對稱加減速？

在實際工程應用中，對稱加減速并不總能滿足我們的需求：

機械特性差異許多系統在加速和減速時的動力學特性不同
工藝要求某些加工工藝可能需要快速啟動但緩慢停止
能量優化不同的加減速比例可以優化能源消耗
運行時間縮短合理設置加減速參數可減少總運行時間
精度控制在精密定位應用中，慢減速有助于提高停止精度

從對稱到非對稱：理論基礎

對稱梯形速度曲線回顧

在對稱模型中，加速度和減速度大小相同，速度曲線呈現完美對稱的梯形。如下圖所示，加速時間等于減速時間：

速度
^
|    ___________
|   /|          |\
|  / |          | \
| /  |          |  \
|/___|__________|___\___> 時間
    ta         t-ta

非對稱梯形速度曲線

在非對稱模型中，加速度(a)和減速度(d)可以不同，通常以減速度為加速度的比例系數(k)表示：d = k×a，其中k可以大于或小于1。

速度
^
|    ___________
|   /|          |\
|  / |          | \
| /  |          |  \
|/___|__________|___\___> 時間
    ta          td

非對稱加減速的數學模型

非對稱加減速的軌跡規劃主要包括三個階段：加速、勻速、減速。關鍵等式如下：

加速階段：v(t) = a × t，其中t ∈ [0, ta]
勻速階段：v(t) = vmax，其中t ∈ [ta, ta+tc]
減速階段：v(t) = vmax - d × (t - ta - tc)，其中t ∈ [ta+tc, ta+tc+td]

位移計算：

加速階段位移：sa = 0.5 × a × ta2
勻速階段位移：sc = vmax × tc
減速階段位移：sd = vmax × td - 0.5 × d × td2

C#代碼實現：非對稱加減速控制器

下面是一個完整的C#實現示例，包含了非對稱加減速軌跡規劃的核心功能：

using Timer = System.Windows.Forms.Timer;

namespace AsymmetricMotion
{
    public partial class Form1 : Form
    {
        // 運動參數
        privatedouble totalDistance;      // 總運動距離
        privatedouble maxVelocity;        // 最大速度
        privatedouble acceleration;       // 加速度
        privatedouble deceleration;       // 減速度（可以與加速度不同）
        privatedouble accelerationRatio;  // 減速度與加速度的比例系數

        // 計算出的運動學參數
        privatedouble accelerationTime;    // 加速時間
        privatedouble constantSpeedTime;   // 勻速時間
        privatedouble decelerationTime;    // 減速時間
        privatedouble accelerationDistance; // 加速階段距離
        privatedouble constantSpeedDistance; // 勻速階段距離
        privatedouble decelerationDistance;  // 減速階段距離
        privatedouble totalTime;            // 總運動時間

        // 動畫相關
        privatedouble currentTime = 0;
        private Timer timerAnimation;
        privateconstint TimerInterval = 50;  // 刷新間隔(ms)
        privateconstdouble TimeStep = 0.05;  // 時間步進(s)

        // 繪圖相關
        privateconstint Margin = 50;
        privateconstint GraphHeight = 200;
        privateconstint AxisOffset = 30;

        public Form1()
        {
            InitializeComponent();
            this.DoubleBuffered = true;  // 啟用雙緩沖減少閃爍
            this.Width = 1024;
            this.Height = 600;

            // 初始化參數
            totalDistance = 2000;       // 總距離2000單位
            maxVelocity = 100;          // 最大速度100單位/秒
            acceleration = 20;          // 加速度20單位/秒2
            accelerationRatio = 0.5;    // 減速度是加速度的0.5倍
            deceleration = acceleration * accelerationRatio; // 計算減速度

            // 計算運動學參數
            CalculateMotionParameters();

            // 設置動畫定時器
            timerAnimation = new Timer();
            timerAnimation.Interval = TimerInterval;
            timerAnimation.Tick += UpdateAnimation;
            timerAnimation.Start();
        }

        /// <summary>
        /// 計算非對稱梯形速度曲線的關鍵參數
        /// </summary>
        private void CalculateMotionParameters()
        {
            // 計算加速時間和加速距離
            accelerationTime = maxVelocity / acceleration;
            accelerationDistance = 0.5 * acceleration * Math.Pow(accelerationTime, 2);

            // 計算減速時間和減速距離
            decelerationTime = maxVelocity / deceleration;
            decelerationDistance = 0.5 * deceleration * Math.Pow(decelerationTime, 2);

            // 檢查是否能達到最大速度
            double criticalDistance = accelerationDistance + decelerationDistance;

            if (criticalDistance > totalDistance)
            {
                // 無法達到最大速度，需要重新計算（三角形速度曲線）
                // 解方程：0.5*a*ta2 + 0.5*d*td2 = S 且 a*ta = d*td
                double ta = Math.Sqrt(2 * totalDistance / (acceleration * (1 + acceleration / deceleration)));
                double td = ta * acceleration / deceleration;

                accelerationTime = ta;
                decelerationTime = td;
                maxVelocity = acceleration * ta; // 實際最大速度

                accelerationDistance = 0.5 * acceleration * Math.Pow(accelerationTime, 2);
                decelerationDistance = totalDistance - accelerationDistance;
                constantSpeedTime = 0;
                constantSpeedDistance = 0;
            }
            else
            {
                // 可以達到最大速度，為梯形速度曲線
                constantSpeedDistance = totalDistance - accelerationDistance - decelerationDistance;
                constantSpeedTime = constantSpeedDistance / maxVelocity;
            }

            // 計算總時間
            totalTime = accelerationTime + constantSpeedTime + decelerationTime;
            this.Text = $"非對稱加減速控制 - 總時間: {totalTime:F2}秒";
        }

        /// <summary>
        /// 更新動畫狀態
        /// </summary>
        private void UpdateAnimation(object sender, EventArgs e)
        {
            currentTime += TimeStep;

            // 動畫完成后停止定時器
            if (currentTime > totalTime)
            {
                timerAnimation.Stop();
            }

            // 觸發重繪
            Invalidate();
        }

        /// <summary>
        /// 繪制函數
        /// </summary>
        protected override void OnPaint(PaintEventArgs e)
        {
            base.OnPaint(e);
            Graphics g = e.Graphics;
            g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias;

            int graphWidth = this.ClientSize.Width - 2 * Margin;

            // 繪制坐標軸
            DrawAxes(g, graphWidth);

            // 繪制速度曲線
            DrawVelocityCurve(g, graphWidth);

            // 繪制位移曲線
            DrawPositionCurve(g, graphWidth);

            // 繪制動畫指示器
            DrawCurrentTimeIndicator(g, graphWidth);

            // 顯示當前時間和關鍵參數
            DrawInformation(g);
        }

        /// <summary>
        /// 繪制坐標軸
        /// </summary>
        private void DrawAxes(Graphics g, int graphWidth)
        {
            using (Pen axisPen = new Pen(Color.Black, 2))
            {
                // 速度曲線坐標軸
                g.DrawLine(axisPen, Margin, Margin + GraphHeight, Margin + graphWidth, Margin + GraphHeight); // X軸
                g.DrawLine(axisPen, Margin, Margin, Margin, Margin + GraphHeight); // Y軸

                // 位移曲線坐標軸
                g.DrawLine(axisPen, Margin, Margin + GraphHeight * 2 + AxisOffset, Margin + graphWidth, Margin + GraphHeight * 2 + AxisOffset); // X軸
                g.DrawLine(axisPen, Margin, Margin + GraphHeight + AxisOffset, Margin, Margin + GraphHeight * 2 + AxisOffset); // Y軸

                // 坐標軸標簽
                g.DrawString("時間(s)", this.Font, Brushes.Black, Margin + graphWidth - 40, Margin + GraphHeight + 5);
                g.DrawString("速度", this.Font, Brushes.Black, Margin - 30, Margin);
                g.DrawString("時間(s)", this.Font, Brushes.Black, Margin + graphWidth - 40, Margin + GraphHeight * 2 + AxisOffset + 5);
                g.DrawString("位移", this.Font, Brushes.Black, Margin - 30, Margin + GraphHeight + AxisOffset);
            }
        }

        /// <summary>
        /// 繪制速度曲線
        /// </summary>
        private void DrawVelocityCurve(Graphics g, int graphWidth)
        {
            using (Pen curvePen = new Pen(Color.Blue, 2))
            {
                // 計算縮放因子
                double timeScale = graphWidth / totalTime;
                double velocityScale = GraphHeight / maxVelocity;

                // 上一個點的坐標
                Point lastPoint = new Point(
                    Margin,
                    Margin + GraphHeight
                );

                // 繪制速度曲線
                for (double t = 0; t <= totalTime; t += 0.01)
                {
                    double v = CalculateVelocity(t);
                    int x = Margin + (int)(t * timeScale);
                    int y = Margin + GraphHeight - (int)(v * velocityScale);

                    Point currentPoint = new Point(x, y);
                    g.DrawLine(curvePen, lastPoint, currentPoint);
                    lastPoint = currentPoint;
                }
            }
        }

        /// <summary>
        /// 繪制位移曲線
        /// </summary>
        private void DrawPositionCurve(Graphics g, int graphWidth)
        {
            using (Pen curvePen = new Pen(Color.Red, 2))
            {
                // 計算縮放因子
                double timeScale = graphWidth / totalTime;
                double positionScale = GraphHeight / totalDistance;

                // 上一個點的坐標
                Point lastPoint = new Point(
                    Margin,
                    Margin + GraphHeight * 2 + AxisOffset
                );

                // 繪制位移曲線
                for (double t = 0; t <= totalTime; t += 0.01)
                {
                    double p = CalculatePosition(t);
                    int x = Margin + (int)(t * timeScale);
                    int y = Margin + GraphHeight * 2 + AxisOffset - (int)(p * positionScale);

                    Point currentPoint = new Point(x, y);
                    g.DrawLine(curvePen, lastPoint, currentPoint);
                    lastPoint = currentPoint;
                }
            }
        }

        /// <summary>
        /// 繪制當前時間指示器
        /// </summary>
        private void DrawCurrentTimeIndicator(Graphics g, int graphWidth)
        {
            if (currentTime <= totalTime)
            {
                double timeScale = graphWidth / totalTime;
                int x = Margin + (int)(currentTime * timeScale);

                using (Pen indicatorPen = new Pen(Color.Green, 1) { DashStyle = System.Drawing.Drawing2D.DashStyle.Dash })
                {
                    // 速度圖上的指示線
                    g.DrawLine(indicatorPen, x, Margin, x, Margin + GraphHeight);

                    // 位移圖上的指示線
                    g.DrawLine(indicatorPen, x, Margin + GraphHeight + AxisOffset, x, Margin + GraphHeight * 2 + AxisOffset);

                    // 在指示線上標出當前時間
                    g.FillEllipse(Brushes.Green, x - 3, Margin + GraphHeight - 3, 6, 6);
                    g.DrawString($"{currentTime:F2}s", this.Font, Brushes.Green, x + 5, Margin + GraphHeight - 20);

                    // 在指示線上標出當前速度和位移
                    double v = CalculateVelocity(currentTime);
                    double p = CalculatePosition(currentTime);
                    g.DrawString($"速度: {v:F2}", this.Font, Brushes.Blue, x + 5, Margin + 10);
                    g.DrawString($"位移: {p:F2}", this.Font, Brushes.Red, x + 5, Margin + GraphHeight + AxisOffset + 10);
                }
            }
        }

        /// <summary>
        /// 顯示運動參數信息
        /// </summary>
        private void DrawInformation(Graphics g)
        {
            string info = $"總距離: {totalDistance}單位 最大速度: {maxVelocity:F2}單位/秒\n" +
                          $"加速度: {acceleration}單位/秒2 減速度: {deceleration}單位/秒2 (比例: {accelerationRatio:F2})\n" +
                          $"加速時間: {accelerationTime:F2}秒 勻速時間: {constantSpeedTime:F2}秒 減速時間: {decelerationTime:F2}秒 總時間: {totalTime:F2}秒";

            using (Font infoFont = new Font(this.Font.FontFamily, 10))
            {
                g.DrawString(info, infoFont, Brushes.Black, Margin, Margin + GraphHeight * 2 + AxisOffset + 40);
            }
        }

        /// <summary>
        /// 計算指定時間點的速度
        /// </summary>
        private double CalculateVelocity(double t)
        {
            // 加速階段
            if (t <= accelerationTime)
            {
                return acceleration * t;
            }
            // 勻速階段
            elseif (t <= accelerationTime + constantSpeedTime)
            {
                return maxVelocity;
            }
            // 減速階段
            elseif (t <= totalTime)
            {
                return maxVelocity - deceleration * (t - accelerationTime - constantSpeedTime);
            }
            // 停止狀態
            else
            {
                return0;
            }
        }

        /// <summary>
        /// 計算指定時間點的位移
        /// </summary>
        private double CalculatePosition(double t)
        {
            // 加速階段
            if (t <= accelerationTime)
            {
                return0.5 * acceleration * t * t;
            }
            // 勻速階段
            elseif (t <= accelerationTime + constantSpeedTime)
            {
                double accelerationDist = 0.5 * acceleration * accelerationTime * accelerationTime;
                double constantDist = maxVelocity * (t - accelerationTime);
                return accelerationDist + constantDist;
            }
            // 減速階段
            elseif (t <= totalTime)
            {
                double accelerationDist = 0.5 * acceleration * accelerationTime * accelerationTime;
                double constantDist = maxVelocity * constantSpeedTime;
                double decelerationTime = t - accelerationTime - constantSpeedTime;
                double decelerationDist = maxVelocity * decelerationTime - 0.5 * deceleration * decelerationTime * decelerationTime;
                return accelerationDist + constantDist + decelerationDist;
            }
            // 運動結束
            else
            {
                return totalDistance;
            }
        }

        private void btnReStart_Click(object sender, EventArgs e)
        {
            currentTime = 0;
            if (!timerAnimation.Enabled)
                timerAnimation.Start();
        }

        private void btnChangeRatio_Click(object sender, EventArgs e)
        {
            // 修改加減速比例
            if (double.TryParse(txtRatio.Text, out double newRatio) && newRatio > 0)
            {
                accelerationRatio = newRatio;
                deceleration = acceleration * accelerationRatio;

                // 重新計算運動參數
                CalculateMotionParameters();
                currentTime = 0;

                // 重啟動畫
                if (!timerAnimation.Enabled)
                    timerAnimation.Start();
            }
        }
    }
}

圖片

非對稱加減速的優化策略

能耗優化

通過調整加減速比例，可以優化系統能耗：

// 能耗優化示例
private double CalculateOptimalDecelerationRatio(double load, double efficiency)
{
    // 基于負載和效率計算最佳減速比例
    double baseRatio = 1.0;
    double loadFactor = 1.0 + (load / 100.0);
    double efficiencyFactor = Math.Max(0.5, efficiency / 100.0);

    return baseRatio * loadFactor * efficiencyFactor;
}

時間優化

在滿足精度要求的前提下，可以調整加減速參數以最小化運行時間：

// 最小時間優化示例
private void OptimizeForMinimumTime(double requiredAccuracy)
{
    // 加速度設置為最大允許值
    acceleration = maxAllowedAcceleration;

    // 減速度根據精度需求調整
    double accuracyFactor = Math.Log10(requiredAccuracy) + 6; // 簡化計算
    accelerationRatio = Math.Max(0.2, Math.Min(1.0, accuracyFactor / 5.0));
    deceleration = acceleration * accelerationRatio;

    // 重新計算運動參數
    CalculateMotionParameters();
}

振動抑制

在一些精密設備中，可以通過漸變的加減速曲線減少振動：

// S形加減速曲線計算（提供更平滑的速度過渡）
private double CalculateSCurveVelocity(double t)
{
    // 簡化的S曲線速度計算
    if (t <= accelerationTime)
    {
        // S形加速階段
        if (t < accelerationTime / 2)
            return acceleration * t * t / accelerationTime;
        else
            return acceleration * t - acceleration * (t - accelerationTime / 2) * (t - accelerationTime / 2) / accelerationTime;
    }
    // 其他階段類似處理...

    return0; // 簡化返回
}

結論與展望

隨著工業4.0和智能制造的發展，基于人工智能的自適應加減速算法將成為未來發展趨勢，系統將能夠根據運行狀態、負載變化和環境條件自動調整最佳加減速參數，進一步提高生產效率和產品質量。

希望本文對您理解和應用非對稱加減速控制有所幫助。您可以基于提供的C#示例進行擴展和完善，以滿足特定應用需求。

責任編輯：武曉燕來源：技術老小子

C#非對稱場景