DX8 mixing voor tank besturing

HackWar

HackWar

Naast mijn RC hobby met vliegtuigen en helikopters, ben ik ook met een robot platform bezig. Dit platform wordt aangedreven door 2 dc brushed motors. Daaraan zit vervolgens weer een tandwiel met rupsbanden. De motoren worden aangestuurd door twee parallax Hb-25 controllers. Daarmee kan ik de motoren aansturen alsof het servos zijn. De regelaars hangen weer aan de orange rx die aan mijn DX8 gekoppeld is. Power voor de rx komt uit de Arduino. Power voor de regelaars/motoren komt uit een Lipo accu.

Nu krijg ik de mixing net niet helemaal goed. Ik wil met 1 stick kunnen rijden. Dit is zoals ik het nu heb:

Mid stick geen throttle, dus idle.
Throttle naar voren, beide motoren vol gas vooruit.
Throttle naar beneden, beide motoren 50% achteruit.
Rudder naar links, M1 achteruit M2 vooruit. Naar rechts is het precies andersom.

Dit werkt prima, behalve als ik achteruit rijd en ga sturen, dan gebeurt precies het tegenovergestelde van wat ik wil. Links is dan rechts en vice versa.

Misschien ook niet de meest handige oplossing, dus suggesties zijn welkom. Is het überhaupt wel goed te krijgen met een aircraft tx?

agunesy3.jpg
 
Je hebt mixers gebruikt om dit mogelijk te maken. Volgens mij gaat er iets niet goed met dat mixen. Bij achteruit draaien wordt het stuursignaal verkeerd gemixt.
Mijn vermoeden is dus dat je bij de mixer instellingen ergens een + in een - moet veranderen. Misschien moet je wel meer dan één instelling veranderen en zelfs de servo reverse gebruiken, dat kan ik helaas niet "voorspellen".
 
Dat heb ik geprobeerd maar dan gaat het vooruit weer niet goed. Ik heb nu geprobeerd om het met de 2e stick erbij (ailerons) te fixen, maar dat geeft hetzelfde probleem. Linker motor zit op AUX1 en rechter op AUX2.

ze3y8epa.jpg

3e9anu4y.jpg

hy7esube.jpg

e3a4yhu9.jpg
 
Deze zender ken ik niet maar wel de oudere Futaba zenders dus wat ik nu ga schrijven zou verouderd kunnen zijn.
Wat ik denk is dat je bij de mixers 1 en 3 één van de waarden van -75% zal moeten wijzigen in +75%. Het "probleem" is namelijk links blijft link en rechts blijft rechts of je nu vooruit of achteruit rijdt. Bij het instellen van een normale mix functie mix je de kanalen in de zelfde richting als de originelen.
Of het werkelijk kanaal 1 en 3 moeten zijn weet ik ook niet zeker maar ik hoop dat je begrijpt wat ik bedoel. Het is erg lastig en je kan er uren mee bezig zijn om het goed te krijgen maar ik weet vrijwel zeker dat het mogelijk is.
Het is wat onduidelijk als ik het zelf lees maar ik weet ook niet hoe ik het anders moet opschrijven. :oops:
 
Het probleem ontstaat omdat je iets probeert te doen wat in de basis onmogelijk is. Mixers tellen signalen op, dus als jij je mixers zo ingesteld hebt dat "aileron links" bewerkt dat de rechter motor harder gaat draaien dan de linker, dan blijven ze dat doen ongeacht of je er nog een voor- of achteruit deel bij optelt. Kortom, je tank draait dan linksom zowel voor- als achteruit, maar bij achteruit voel je dat aan als "verkeerd". In feite vergelijk je het met een voertuig met sturende wielen wat er eigenlijk niets mee te maken heeft.
Ik ken de Spectrum zenders niet, maar op mijn zender zou ik zoeken naar een mogelijkheid om bij het passeren van de middenstand met de gasknuppel de mixers 1 en 3 uit te schakelen en een tweede set met omgekeerde werking in te schakelen.

Max.
 
Laatst bewerkt:
max z zei:
...bewerkt dat de rechter motor harder gaat draaien dan de linker.....
Klik om te vergroten...

Ik las het nog eens en dit klopt niet helemaal. Het hele verhaal blijft wel overeind.

Ik probeer het nu met een plaatje: de blauwe bolletjes zijn je motoren als gevolg van de throttle, via mix2 en mix4, de rode bolletjes zijn het eindresultaat voor de linker track nadat er door mix1 bij een uitslag van de aileron knuppel naar rechts een stukje "bijgemixt" is, de groene bolletjes het resultaat van mix3 voor de rechter track, bij dezelfde rechterbocht.
Als je nu het eindresultaat vergelijkt voor de situaties 1, 2 en 3 (stop, vooruit en achteruit), dan zie je dat de tank in alle gevallen rechtsom roteert.
Wat jij zou willen is dat bij het passeren van de neutrale lijn door de blauwe bolletjes (mix2 en mix4), de rode en groene pijlen van richting omkeren (mix1 en mix3). Nog afgezien van een onbepaalde toestand bij het draaien bij nul voorwaartse of achterwaartse snelheid, kan dit m.i. niet bereikt worden zonder extra mixers en de mogelijkheid deze aan en uit te kunnen schakelen met de throttle.

p.s. ik heb de 50% maximale achteruit snelheid maar even buiten beschouwing gelaten.

edit: mixernummers aangepast

full


Groet,
Max.
 
Laatst bewerkt door een moderator:
Precies zo zit het Max, met die tekening wordt het een stuk duidelijker. :thumbsup: Nu kan ik ook beter uitleggen wat ik bedoel.
Bij stap 3 gaat het rode pijltje van mix1 naar boven en de groene van mix3 naar beneden. Daarom klopt links en rechts niet meer. Maar als je dat deel van de mixer omdraait klopt links en rechts weer en is het probleem opgelost. Bij mix1 moet je dan bijvoorbeeld van de + een - maken en bij mix3 van de - een +. Het kan natuurlijk ook omgekeerd zijn maar daar kom je door proberen snel genoeg achter.
De vraag is alleen of je dat wel kan omkeren, ik denk van wel maar weet het niet 100% zeker.
 
Wow, thanks! Ik ga er mee aan de slag. Fijn al die hulp op het forum :)

Als het gelukt is post ik wel even een filmpje.
 
Helaas, dat gaat niet werken. Als je een deel van mixer 1 en mixer 3 omkeert, ga je steeds dezelfde kant op, of je nu naar links of naar rechts stuurt.
Zoals ik al probeerde uit te leggen moet je de hele mix1 en mix3 omkeren (alle plussen worden minnen en omgekeerd), als de uitkomst van mix2 en mix4 "door de nul gaat", (de throttle dus). En dat gaat alleen door er nog twee mixers bij te maken die omgekeerd aan mix1 en mix3 zijn. Door de gasknuppel moet je dan een software-schakelaar laten bedienen die bij de neutraalstand van de knuppel omschakelt, en mix1/mix3 uitschakelt en mix5/mix6 inschakelt.

Ik ken de mogelijkheden van de Spectrum niet, maar de meeste mixers kunnen alléén optellen/aftrekken, niet vermenigvuldigen. In wiskunde termen:

T= gasknuppel stand (afwijking van de neutraalstand)
A= aileronknuppel stand (ditto)
F= de mixer waarde, bijvoorbeeld -70% = -0,7

wat je nu hebt is T+F*A (linker track) en T-F*A (rechter track)

wat je zou willen is T+T*F*A (linker track) en T-T*F*A (rechtr track), hier wordt bij vooruit rijden de invloed van de aileronknuppel steeds minder naarmate je gasknuppel de neutraalstand nadert, keert bij die neutraalstand van teken om en wordt bij het achteruitrijden weer meer naarmate je harder rijdt. Dit benadert m.i. het meeste een voertuig met sturende wielen, maar is helaas met onze zenders niet te realiseren (misschien bij Frsky/Taranis wel?).

Groet,
Max.
 
een v-tail mix werkt toch ook? die is voorgeprogrammeerd in spektrum zenders (mijn dx7s iniedergeval wel) dan ben je toch meteen klaar? alleen de 50% snelheid naar achteren ga je overheen, zou je misschien geen expo op je "elevator" kunnen zetten?
 
De V-tail mixer werkt zoals het nu al is, het probleem blijft daarmee hetzelfde. Het probleem is dat de mixer andersom moet mixen als de tank achteruit rijdt. Volgens mij zou dat mogelijk moeten zijn maar ik kan het niet uitproberen omdat ik zo'n zender niet heb. Met mijn Futaba FC18 maar ook mijn 7C denk ik dat het kan want ik kan de mixers zo instellen dat de servo vanuit het midden de zelfde kant op gaat als ik de knuppel naar links of naar rechts beweeg.
Dat doe ik door de mixfunctie naar beide kanten dezelfde richting op te laten gaan. Dus niet + naar rechts en - naar links maar naar beide kanten + of naar beide kanten -.
Zo kan ik een servo met bijvoorbeeld de rolroer functie netjes naar links en naar rechts laten draaien. Mix ik dan bijvoorbeeld het richtingroer mee dan kan ik die gewoon +100% en -100% mee mixen. Beweeg ik dan de rolroeren dan gaat het richtingroer evenveel en in de zelfde richting mee.
Zet ik de mixer op +100% en de andere kant op ook op +100% dan zal het richtingroer altijd naar rechts gaan of ik nu naar links of naar rechts stuur met de rolroeren.
 
Ernst, naar mijn mening is het appels met peren vergelijken. Probeer maar eens in jouw voorbeeld je rolroerservo te vervangen door één van de track-regelaars, en je richtingroer door de andere, en beredeneer dan wat de uitkomst is in termen van vooruit, achteruit, links draaien en rechts draaien en combinaties daarvan. Ik kan het niet beter uitleggen dan ik al gedaan heb.

@Hackwar: ik zie dat je leuke dingen gaat doen met arduino, kun je daar niet een stuurfunctie in programmeren volgens de 2e set formules die ik hierboven aangaf? Als dat mogelijk is heb ik nog wel een paar ideeën daarover, maar die zal ik dan wel spuien.

Groeten,
Max.
 
Je hebt gelijk denk ik Max, de functie om de aileron alleen te reversen bij een bepaalde throttle stand ga ik niet geprogrammeerd krijgen in de zender, daar was ik al bang voor.

Bovendien is er nog een tweede 'probleem'. Geen enkele DC motor loopt exact gelijk aan een andere ondanks dat ze van hetzelfde type zijn. Ze bevatten helaas geen encoder dus ook dit had ik met een offset of trim op de zender moeten oplossen.

Al met al lijkt het mij inderdaad beter om de input vanuit de zender zonder mixes eerst door te sturen naar de Arduino en daar softwarematig de mixes te programmeren. En ik denk dat ik ook op zoek moet naar shaft/wheel encoders.
 
HackWar zei:
Al met al lijkt het mij inderdaad beter om de input vanuit de zender zonder mixes eerst door te sturen naar de Arduino en daar softwarematig de mixes te programmeren.
Klik om te vergroten...

In dat geval spui ik mijn ideeën toch nog maar even. In de eerste plaats lijkt het me beter om het sturen te bewerkstelligen door alléén de binnenbocht-track te vertragen, en de buitenbocht op dezelfde snelheid te houden. Dan kan het stuurgedrag niet beïnvloed worden doordat één van de regelaars tegen het maximum aanloopt, en het heeft nog een ander voordeel, zoals later zal blijken.

Dus:
Algemeen: alle stuursignalen lopen van -1 (1 ms) via 0 (1,5 ms) naar +1 (2 ms).
Stel L=linkertrack, R=rechtertrack, T=gas, A=stuur

Ik heb me nooit verdiept in het programmeren van arduino, maar in algemene termen wordt het dan;
if A<0 then L=T+f*T*A, else L=T
if A>0 then R=T-f*T*A, else R=T
Nu is de hoeksnelheid waarmee je tank van richting verandert proportioneel met de gasstand, en dat geeft een nagenoeg constante draaicirkel bij alle standen van het gas. En dat lijkt mij wenselijk, want als je tank een onafhankelijke draaisnelheid heeft ben je bij weinig gas al 90 graden de hoek om als je nog maar een klein stukje vooruit gereden bent, en bij veel gas is dat pas als je veel verder bent. M.a.w. de bocht wordt scherper als je gas terugneemt.
De draaicirkel is dus nu constant zolang je stuurinput constant is, en hangt alleen af van de factor f. In het extreme geval van f=0 is er geen besturing meer mogelijk, dus een oneindig grote draaicirkel. Bij f=1 kun je door maximaal te sturen de éne track laten draaien terwijl de andere stilstaat, een hele kleine draaicirkel dus. Bij f=2 wordt het nog beter, als je voluit stuurt loopt je éne track vooruit en de andere achteruit, kortom je draait de tank op de plaats op het moment dat je gas geeft:

A=1, f=2
if A<0 then L=T+f*T*A, else L=T : L=T
if A>0 then R=T-f*T*A, else R=T : R=T-2*T*1=T-2T=-T

Andere kant op sturen: A=-1
if A<0 then L=T+f*T*A, else L=T : L=T+2*T*(-1)=T-2T=-T
if A>0 then R=T-f*T*A, else R=T : R=T

Extreem scenario: je stuurt voluit naar rechts, er gebeurt nog niets
Je geeft gas, de tank gaat rechtsom draaien, eventueel tot volgas.
Je laat het stuur naar de neutraalstand komen, de linker track blijft vol vooruit draaien, de rechter track komt geleidelijk tot stilstand en gaat ook vooruit draaien. Bij A=0 (neutraalstand) draaien ze weer even hard, en de tank scheurt rechtuit weg. :):):)

Groeten
Max.
 
Het heeft wel even geduurd en ik heb de reacties van Max wel een paar keer moeten lezen maar nu denk ik dat ik het begrijp. Ik ben ook met mijn eigen zender aan het spelen geweest en inderdaad mijn idee klopt niet. Het gaat goed één kant op maar de andere kant op gaat het fout. Dan moet in de + weer in een - veranderen. Het is dus toch een behoorlijk stuk lastiger dan ik zo dacht.
 
ik heb laatst toevallig iets gevonden over arduino:
pwm (servo) signalen uitlezen doe je met pulseIn([pin], HIGH, 25000);
pin is je input pin die je met een draadje aansluit op je ontvanger.
HIGH betekent dat je de duur van de puls wilt meten, niet de duur van het dal tussen de pulsen door.
25000 is een time-out waarde die bij de tutorial stond die ik ooit is heb gevonden en werkt voor mij prima.

je krijgt je servo signalen binnen als getal tussen 1000 en 2000.
je gebruikt in je loop dus bijvoorbeeld:

int throttle = pulseIn(2, HIGH, 25000);
int steering = pulseIn(3, HIGH, 25000);

om dus je gas van bijvoorbeeld pin 2 te lezen en je stuur van pin 3.

volgens mij heeft max een hele mooie formule gemaakt om het signaal te mixen :P die ik ook niet aan zou durven passen :D
het resultaat daarvan sturen we weer naar buiten met de functie writeMicroseconds()

let wel op dat je het eerst moet initialiseren, een output toe moet wijzen enz (let op welke i/o pins je als pwm kan gebruiken!)
dat doe je zo:

declareren (variabele een plek in het geheugen geven):
Servo linker_motor_uit;
Servo rechter_motor_uit;

(met uit bedoel ik uitgaand signaal)
nu moeten we ze initialiseren, een pin toewijzen. ik gebruik voor het gemak pin 5 en 6 in dit voorbeeld, omdat ik een arduino nano heb en deze 2 PWM pins naast elkaar zitten.
dus nu het initialiseren (instellen) van de outputs:
void setup()
{
linker_motor_uit.attach(5, 1000, 2000);
rechter_motor_uit.attach(6, 1000, 2000);
}

van de linker motor verbinden we dan de signaaldraad van de ESC met pin 5, van de rechter motor/ESC met pin 6.
het kan ook zonder de 1000 en 2000 maar zo geef je meteen minimale en maximale waarden mee om je ESC niet in de war te brengen, want dat zijn tenslotte de min/max signalen die ze kunnen begrijpen.

nu kun je de formule van max toepassen en het signaal naar buiten sturen.
na de formule van max hebben we de waarde voor de linker motor in deze variabele zitten:
int linker_motor = (formule van max);
en voor rechts:
int rechter_motor = (formule van max);

nu schrijven we ze aan het eind van de loop weg naar de outputs en dat doen we zo:
linker_motor_uit.writeMicroseconds(linker_motor);
rechter_motor_uit.writeMicroseconds(rechter_motor);

zo sturen we de waarde naar de juiste pins, en bij het declareren van de (servo) pins hebben we al een min/max opgegeven om eventuele uitschieters uit de berekening te halen.

oh en max: neutraal = 1.5 ms en ziet de arduino niet als 0 maar als 1500 (in microseconden, us) dus we moeten 1500 als neutraal zien.
 
Leuk om te zien dat dit project meer mensen enthousiast maakt :D ;)

Ik heb al aardig wat projecten met de Arduino gedaan dus het programmeren zelf zal de uitdaging niet zijn. De Servo library vind ik persoonlijk niet lekker werken met de HB-25 motor controller. Vandaar dat ik inderdaad ook gewoon zelf de pulsIn gebruik.

@Max: klopt de formule wel helemaal? Het lijkt erop dat de bocht juist krapper wordt naarmate de throttle toeneemt, dat lijkt precies het omgekeerde effect. Ik heb zelf nog wat zitten sleutelen, en het is nog niet af, maar het doet al redelijk wat.

Vanavond nog maar even verder sleutelen. Voor de geïnteresseerde coders:

Code: 
const int PIN_THROTTLE = 22;
const int PIN_STEERING = 24;

const int PIN_MOTOR_L_OUT = 23;
const int PIN_MOTOR_R_OUT = 25;

int throttle;
int steering;
float throttleLeftTrack = 1500;
float throttleRightTrack = 1500;

float multiplier = 1;


void setup() {
  pinMode(PIN_THROTTLE, INPUT);
  pinMode(PIN_STEERING, INPUT);

  pinMode(PIN_MOTOR_L_OUT, OUTPUT);
  pinMode(PIN_MOTOR_R_OUT, OUTPUT);
  Serial.begin(57600);
}

void loop() {
  throttle = pulseIn(PIN_THROTTLE, HIGH, 25000);
  
  //LEFT MAX: 1900,  NEUTRAL:1500, RIGHT MIN: 1100
  steering = pulseIn(PIN_STEERING, HIGH, 25000);
  setThrottleEngines();
}

void setThrottleEngines(){
  float tmpThr = (throttle - 1500)/400.00;
  float tmpSteer = (steering - 1500)/400.00;
    
  if(steering>1520 || steering<1480){
    if(tmpThr>0){
      throttleLeftTrack = throttle - (((multiplier * (1-tmpThr) * tmpSteer))*400);
      throttleRightTrack = throttle + (((multiplier * (1-tmpThr) * tmpSteer))*400);
    }else{
      throttleLeftTrack = throttle - (((multiplier * (-1-tmpThr) * tmpSteer))*400);
      throttleRightTrack = throttle + (((multiplier * (-1-tmpThr) * tmpSteer))*400);
    }
  }else{
    int newInt = throttle-1500;
    int newTthrottleLeftTrack = throttle-newInt;
    Serial.println(newTthrottleLeftTrack);
    throttleRightTrack = throttle;
  }
  delay(100);
  
  pulseOut(PIN_MOTOR_L_OUT, (int)throttleLeftTrack);
  pulseOut(PIN_MOTOR_R_OUT, (int)throttleRightTrack);
  
 // Serial.print("MOTOR L:");
  //Serial.println(throttleLeftTrack);
}

void pulseOut(int pin, int us)
{
    digitalWrite(pin, HIGH);
    us = max(us - 20, 1);
    delayMicroseconds(us);
    digitalWrite(pin, LOW);
}
 
de servo library heeft toch helemaal geen input functies?
pulseIn werkt wel maar is wel langzaam als je veel pins wilt uitlezen vanwege de time-out.

ik ben laatst ergens een andere library tegengekomen die een stuk sneller is, heb hem zelf alleen niet getest
 
Je hebt gelijk, ik bedoel het aansturen van de motor controller. De servo library heeft de timing niet helemaal juist. Als ik zelf pulsen stuur werkt het perfect.
 
Laatst bewerkt door een moderator:
HackWar zei:
@Max: klopt de formule wel helemaal? Het lijkt erop dat de bocht juist krapper wordt naarmate de throttle toeneemt, dat lijkt precies het omgekeerde effect.
Klik om te vergroten...

Ik ben niet vertrouwd met arduino code, maar klopt dit:
HackWar zei:
if(steering>1520 || steering<1480){
if(tmpThr>0){
throttleLeftTrack = throttle - (((multiplier * (1-tmpThr) * tmpSteer))*400);
throttleRightTrack = throttle + (((multiplier * (1-tmpThr) * tmpSteer))*400);
Klik om te vergroten...
wel met dit?:

if A<0 then L=T+f*T*A, else L=T
if A>0 then R=T-f*T*A, else R=T
 
You must log in or register to reply here.
Back
Top