Algorytm mieszania 2-osiowego wejścia analogowego w celu sterowania różnicowym napędem silnikowym

Szukam informacji o tym, jak zaimplementować prawidłowe miksowanie 2 analogowych sygnałów joysticka (oś X i Y) do sterowania podwójnym napędem różnicowym (napęd „zbiornikowy”) za pomocą sterownika uC (w moim przypadku ATMega328p), ale to samo powinno dotyczyć dowolny uC z wejściami ADC i wyjściami PWM):

Mam analogowy drążek, który daje 2 wartości analogowe:

(kierunek) X: od 0 do 1023
(przepustnica) Y: od 0 do 1023

Pozycja spoczynkowa to (neutralny kierunek i przepustnica) 512,512
Przepustnica do przodu / kierunek w lewo to 0,0
Całkowite do przodu-pełne prawo to 1023,0
itp.

Silniki są sterowane przez 2 sterowniki mostka H, ​​dla każdego z 2 pinów PWM (do przodu, do tyłu), tak:
Lewy silnik: od -255 do 255
Prawy silnik: od -255 do 255
(wartości dodatnie włączają pin PWM do przodu, ujemny włącza wsteczny Pin PWM, 0 wyłącza oba)

Celem jest zmiksowanie sygnałów analogowych joysticka w celu uzyskania następującej odpowiedzi:

a) Przepustnica do przodu, kierunek neutralny = pojazd poruszający się do przodu
b) Przepustnica do przodu, kierunek lewy = pojazd poruszający się do przodu i skręca w lewo
c) Przepustnica neutralna, kierunek lewy = pojazd skręca w lewo W MIEJSCU, który jest prawym silnikiem całkowicie do przodu, lewy silnik całkowicie do tyłu

... i podobnie w przypadku innych kombinacji. Oczywiście wyjście powinno być „analogowe”, co oznacza, że ​​powinno umożliwiać stopniowe przejście z na przykład z opcji a) do b) do c).

Koncepcja jest następująca:

„Właściwe” miksowanie jest otwarte na debatę :-).

Problem polega na tym, że musisz podejmować decyzje o tym, jak szybko ścieżka porusza się pod czystymi sygnałami z jednej puli i co zrobić, gdy uwzględniane są sygnały z drugiej puli. Na przykład, jeśli popchniesz FB (potencjometr do przodu i do tyłu całkowicie do przodu, a jeśli oba silniki pracują na pełnych obrotach do przodu, jak sobie poradzisz z dodaniem niewielkiej ilości puli LR (lewy prawy). uzyskać obrót, musisz mieć jeden tor poruszający się szybciej niż drugi. Jeśli więc biegniesz już z maksymalną prędkością do przodu na obu silnikach, musisz zmniejszyć jedną lub drugą prędkość toru, aby skręcić. Ale jeśli stałeś nieruchomo, przyspieszyłby jeden lub drugi utwór, aby osiągnąć ten sam wynik.

Tak więc wszystko, co powiedziałem, oto proste rozwiązanie wyjściowe z mojej głowy, które wydaje się dobrym początkiem.

Jeśli doniczki są mechanicznie niezależne, oba mogą być na 100% jednocześnie.
Jeśli oba są ustawione w układzie joysticka, jeśli Yaxis = 100% i Xaxis = 0%, wówczas dodanie części B zwykle zmniejsza A. A Joystick można skonstruować tam, gdzie powyższe nie jest prawdą, ale są one niezwykłe.
Załóżmy, że joystick jest tego typu, że zwiększenie Y%, gdy X = 100% zmniejszy X. Można przyjąć inne założenia.

FB = pula z przodu i z tyłu. Centrum zero, + Ve dla ruchu doniczki do przodu

LR = lewa prawa pula. Centrum zero. + Ve za pulę po prawej stronie.

K jest początkowo współczynnikiem skali 1.
Jeśli jakikolwiek wynik przekracza 100%, dostosuj K, więc wynik = 100% i użyj tej samej wartości K również dla innego silnika.

• np. jeśli wynik dla lewego silnika = 125, a wynik dla prawego silnika = 80, to.
  Jako 125 x 0,8 = 100, ustaw K = 0,8. Następnie.
  Lewy = 125 x 0,8 = 100%. Racja = 80 x 0,8 = 64%.

Następnie:

• Lewy silnik = K x (Front_Back + Left_Right)

• Prawy silnik = K x (Front_Back - Left_Right)

Kontrole poczytalności:

• LR = 0 (wyśrodkowany), FB = pełny fwd -> Oba silniki pracują całkowicie do przodu.

• LR = całkowicie lewy, FB = 0 ->
  Lewy silnik obraca się całkowicie do tyłu,
  prawy silnik obraca się całkowicie do przodu.
  Pojazd obraca się przeciwnie do ruchu wskazówek zegara.

• FB wynosiła 100%, Lr = 0%. Dodaj 10% LR po prawej stronie.
  L = FB + LR = 100% - + 10% R = FB-LR = 100% - - 10%

Jeśli największa oś <100%, skaluj do = 100%.
Następnie przeskaluj drugą oś o tę samą wartość.

Oto rozwiązanie, które nie wymaga skomplikowanych łańcuchów if / else, nie zmniejsza mocy podczas pełnego ruchu do przodu lub obracania się w miejscu i pozwala na płynne zakrzywienie i przejście od przejścia do wirowania.

Pomysł jest prosty. Załóżmy, że wartości (x, y) joysticka są współrzędnymi kartezjańskimi na płaszczyźnie kwadratowej. Teraz wyobraź sobie mniejszą kwadratową płaszczyznę obróconą w niej o 45º.

Współrzędne joysticka dają punkt na większym kwadracie, a ten sam punkt nałożony na mniejszy kwadrat daje wartości silnika. Trzeba tylko przekonwertować współrzędne z jednego kwadratu na drugi, ograniczając nowe wartości (x, y) do boków mniejszego kwadratu.

Istnieje wiele sposobów konwersji. Moja ulubiona metoda to:

1. Konwertuj początkowe współrzędne (x, y) na współrzędne biegunowe.
2. Obróć je o 45 stopni.
3. Przekształć współrzędne biegunowe z powrotem na kartezjańskie.
4. Przeskaluj nowe współrzędne do -1,0 / + 1,0.
5. Zablokuj nowe wartości na -1.0 / + 1.0.

Zakłada się, że początkowe współrzędne (x, y) mieszczą się w zakresie -1.0 / + 1.0. Bok wewnętrznego kwadratu zawsze będzie równy l * sqrt(2)/2, więc krok 4 polega na pomnożeniu wartości sqrt(2).

Oto przykładowa implementacja języka 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

Oryginalny pomysł na tę metodę - o znacznie bardziej skomplikowanej metodzie transformacji - pochodzi z tego artykułu .

Poniżej znajduje się przykład implementacji algorytmu mieszania opisany przez odpowiedź Russela McMahona:

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);

}