混合2轴模拟输入以控制差动电动机驱动的算法

我正在寻找有关如何使用uC（在我的情况下为ATMega328p）正确混合2个模拟操纵杆信号（X轴和Y轴）以控制双差动电机驱动器（“类似油箱的”驱动器）的信息，但是同样适用于任何具有ADC输入和PWM输出的uC）：

我有一个模拟摇杆，可提供2个模拟值：

（方向）X：0至1023
（油门）Y：0至1023

静止位置是（方向和节气门中立）512,512
节气门前进/方向左为0,0
全前进-全右为1023,0，依此类推
。

电机由2个H桥驱动器控制，每个都有2个PWM引脚（正向，反向）控制，例如：
左电机：-255至255
右电机：-255至255
（正值启用正向PWM引脚，负启用反向PWM引脚，0均禁用）

目的是将操纵杆模拟信号混合以达到以下响应：

a）节气门前进，空档方向=车辆向前行驶
b）节气门前进，左方向=车辆向前行驶并向左转弯
c）油门空档，左方向=车辆向左转弯

...以及类似的其他组合。当然，输出应为“模拟”，即应允许从例如选项a）到b）到c）的逐步过渡。

这个概念是：

“适当的”混合尚有争议：-)。

问题是您必须决定在单个锅中的纯信号下轨道移动的速度以及包含另一个锅中的信号时该怎么做。例如，如果您将FB（前进后退电位计）完全向前推动，并且如果两个电动机都以全速前进，那么您如何处理添加的少量LR（左右）电位计。要获得旋转，您必须使一条轨道的速度快于另一条轨道的速度。因此，如果您已经在两个电动机上都以最大前进速度运行，则必须降低一个或其他轨道的速度才能转弯。但是，如果您一直静止不动，本来可以加速一条或另一条轨道来达到相同的结果。

因此，所有这些，这是我脑海中一个简单的即席启动解决方案，看来是个不错的开始。

如果锅在机械上是独立的，那么两者可以同时处于100％的位置。
如果两者都在操纵杆类型的排列上，如果Yaxis = 100％并且Xaxi​​s = 0％，则添加一些B通常会减少A。可以在上述情况不成立的情况下构造操纵杆，但这是不寻常的。
假定操纵杆的类型是当X = 100％时增加Y％会减少X。可以做出其他假设。

FB =前后锅。零位居中，+ Ve用于锅的向前运动

LR =左右锅。居中零位。+右为锅。

K最初是比例因子1。
如果任何结果超过100％，则将K调整为结果= 100％，并且对其他电动机也使用相同的K值。

• 例如，如果左马达结果= 125，右马达结果= 80，则为。
  当125 x 0.8 = 100时，设置K = 0.8。然后。
  左= 125 x 0.8 = 100％。右= 80 x 0.8 = 64％。

然后：

• 左电机= K x（前_后+左_右）

• 右马达= K x（前_后-左_右）

健全性检查：

• LR = 0（居中），FB =正转->两个电机均正转运行。

• LR =左全速，FB = 0->
  左电动机向后全速运行，
  右电动机正向全速运行。
  车辆逆时针旋转。

• FB为100％，Lr = 0％。向右添加LR的10％。
  L = FB + LR = 100％-+ 10％R = FB-LR = 100％--10％

如果最大轴<100％，则缩放直到= 100％。
然后按相同数量缩放其他轴。

这是一种解决方案，不需要复杂的if / else链，在完全向前移动或原位旋转时不降低动力，并允许平滑的曲线以及从移动到旋转的过渡。

这个想法很简单。假设（x，y）操纵杆值为正方形平面上的笛卡尔坐标。现在，想象一个较小的方形平面在其中旋转45º。

操纵杆坐标会在较大的正方形中为您提供一个点，而在较小的正方形中叠加的相同点将为您提供电动机值。您只需要将坐标从一个正方形转换为另一个正方形，即可将新的（x，y）值限制在较小正方形的边上。

有很多方法可以进行转换。我最喜欢的方法是：

1. 将初始（x，y）坐标转换为极坐标。
2. 将它们旋转45度。
3. 将极坐标转换回笛卡尔坐标。
4. 将新坐标重新缩放为-1.0 / + 1.0。
5. 将新值固定为-1.0 / + 1.0。

假设初始（x，y）坐标在-1.0 / + 1.0范围内。内部正方形的边将始终等于l * sqrt(2)/2，因此步骤4只是将值乘以sqrt(2)。

这是一个示例Python实现。

import math

def steering(x, y):
    # convert to polar
    r = math.hypot(x, y)
    t = math.atan2(y, x)

    # rotate by 45 degrees
    t += math.pi / 4

    # back to cartesian
    left = r * math.cos(t)
    right = r * math.sin(t)

    # rescale the new coords
    left = left * math.sqrt(2)
    right = right * math.sqrt(2)

    # clamp to -1/+1
    left = max(-1, min(left, 1))
    right = max(-1, min(right, 1))

    return left, right

该方法的原始思想（具有更复杂的转换方法）来自本文。

下面是Russel McMahon答案描述的混合算法实现示例：

http://www.youtube.com/watch?v=sGpgWDIVsoE

//Atmega328p based Arduino code (should work withouth modifications with Atmega168/88), tested on RBBB Arduino clone by Modern Device:
const byte joysticYA = A0; //Analog Jostick Y axis
const byte joysticXA = A1; //Analog Jostick X axis

const byte controllerFA = 10; //PWM FORWARD PIN for OSMC Controller A (left motor)
const byte controllerRA = 9;  //PWM REVERSE PIN for OSMC Controller A (left motor)
const byte controllerFB = 6;  //PWM FORWARD PIN for OSMC Controller B (right motor)
const byte controllerRB = 5;  //PWM REVERSE PIN for OSMC Controller B (right motor)
const byte disablePin = 2; //OSMC disable, pull LOW to enable motor controller

int analogTmp = 0; //temporary variable to store 
int throttle, direction = 0; //throttle (Y axis) and direction (X axis) 

int leftMotor,leftMotorScaled = 0; //left Motor helper variables
float leftMotorScale = 0;

int rightMotor,rightMotorScaled = 0; //right Motor helper variables
float rightMotorScale = 0;

float maxMotorScale = 0; //holds the mixed output scaling factor

int deadZone = 10; //jostick dead zone 

void setup()  { 

  //initialization of pins  
  Serial.begin(19200);
  pinMode(controllerFA, OUTPUT);
  pinMode(controllerRA, OUTPUT);
  pinMode(controllerFB, OUTPUT);
  pinMode(controllerRB, OUTPUT);  

  pinMode(disablePin, OUTPUT);
  digitalWrite(disablePin, LOW);
} 

void loop()  { 
  //aquire the analog input for Y  and rescale the 0..1023 range to -255..255 range
  analogTmp = analogRead(joysticYA);
  throttle = (512-analogTmp)/2;

  delayMicroseconds(100);
  //...and  the same for X axis
  analogTmp = analogRead(joysticXA);
  direction = -(512-analogTmp)/2;

  //mix throttle and direction
  leftMotor = throttle+direction;
  rightMotor = throttle-direction;

  //print the initial mix results
  Serial.print("LIN:"); Serial.print( leftMotor, DEC);
  Serial.print(", RIN:"); Serial.print( rightMotor, DEC);

  //calculate the scale of the results in comparision base 8 bit PWM resolution
  leftMotorScale =  leftMotor/255.0;
  leftMotorScale = abs(leftMotorScale);
  rightMotorScale =  rightMotor/255.0;
  rightMotorScale = abs(rightMotorScale);

  Serial.print("| LSCALE:"); Serial.print( leftMotorScale,2);
  Serial.print(", RSCALE:"); Serial.print( rightMotorScale,2);

  //choose the max scale value if it is above 1
  maxMotorScale = max(leftMotorScale,rightMotorScale);
  maxMotorScale = max(1,maxMotorScale);

  //and apply it to the mixed values
  leftMotorScaled = constrain(leftMotor/maxMotorScale,-255,255);
  rightMotorScaled = constrain(rightMotor/maxMotorScale,-255,255);

  Serial.print("| LOUT:"); Serial.print( leftMotorScaled);
  Serial.print(", ROUT:"); Serial.print( rightMotorScaled);

  Serial.print(" |");

  //apply the results to appropriate uC PWM outputs for the LEFT motor:
  if(abs(leftMotorScaled)>deadZone)
  {

    if (leftMotorScaled > 0)
    {
      Serial.print("F");
      Serial.print(abs(leftMotorScaled),DEC);

      analogWrite(controllerRA,0);
      analogWrite(controllerFA,abs(leftMotorScaled));            
    }
    else 
    {
      Serial.print("R");
      Serial.print(abs(leftMotorScaled),DEC);

      analogWrite(controllerFA,0);
      analogWrite(controllerRA,abs(leftMotorScaled));  
    }
  }  
  else 
  {
  Serial.print("IDLE");
  analogWrite(controllerFA,0);
  analogWrite(controllerRA,0);
  } 

  //apply the results to appropriate uC PWM outputs for the RIGHT motor:  
  if(abs(rightMotorScaled)>deadZone)
  {

    if (rightMotorScaled > 0)
    {
      Serial.print("F");
      Serial.print(abs(rightMotorScaled),DEC);

      analogWrite(controllerRB,0);
      analogWrite(controllerFB,abs(rightMotorScaled));            
    }
    else 
    {
      Serial.print("R");
      Serial.print(abs(rightMotorScaled),DEC);

      analogWrite(controllerFB,0);
      analogWrite(controllerRB,abs(rightMotorScaled));  
    }
  }  
  else 
  {
  Serial.print("IDLE");
  analogWrite(controllerFB,0);
  analogWrite(controllerRB,0);
  } 

  Serial.println("");

  //To do: throttle change limiting, to avoid radical changes of direction for large DC motors

  delay(10);

}