Comprensione del missaggio dei canali: 4 passaggi (con immagini)

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:04

Se hai mai guidato uno chassis con telecomando, ci sono buone probabilità che tu abbia usato il mixaggio, anche se non lo sapevi. In particolare, se hai utilizzato un singolo joystick o gimble per controllare un veicolo che utilizza lo sterzo a pattino o lo sterzo differenziale, hai usato la miscelazione.

Il missaggio è semplicemente il modo in cui i dati del joystick vengono utilizzati per determinare quanta potenza deve essere fornita a ciascun lato dello chassis.

Se apri un joystick, generalmente vedrai due potenziometri all'interno. Uno per misurare la tua posizione attuale lungo l'asse Y (su e giù) e l'altro per misurare dove ti trovi lungo l'asse X (da lato a lato).

Anche se non ho una formazione formale sull'argomento, ho dovuto fare il missaggio nel codice prima e recentemente ho voluto immergermi un po' più a fondo nell'argomento.

Innanzitutto voglio notare che la maggior parte dei trasmettitori RC ha capacità di mixaggio, così come molti controller del motore. Queste informazioni saranno molto utili se devi eseguire tu stesso il missaggio nel codice. Diciamo ad esempio se stai usando un Arduino per leggere dati non mischiati da un ricevitore RC, o stai leggendo dati analogici dai vasi in un joystick, o se stai leggendo le coordinate da un joystick digitale su un'app mobile.

Diamo un'occhiata ad alcuni diversi approcci di miscelazione.

Passaggio 1: metodo di miscelazione »Nessuno

Per prima cosa diamo un'occhiata a cosa succede se non usi affatto la miscelazione. Se invii semplicemente i dati da un asse a un lato del telaio e l'altro asse all'altro lato, il tuo veicolo non risponderà nel modo desiderato.

Ad esempio, se spingi il joystick completamente in avanti, l'asse Y è al massimo e l'asse X è a 0. Quindi guideresti in tondo invece di andare dritto.

Passaggio 2: Metodo Metodo »Ruota

Un collega una volta mi ha fatto notare che, in un pizzico, puoi ruotare il trasmettitore di 45 gradi per un mix da poveri. Se pensi ai valori dei due potenziometri in un joystick come l'asse x e y su una griglia (con entrambi gli assi che vanno da -100 a +100) questo ha molto senso perché stai andando a +100 su entrambi gli assi mentre spingi il joystick verso l'alto e verso destra. Quindi, se questo mappa direttamente ai tuoi due canali del telaio (i lati sinistro e destro del tuo robot) farebbe avanzare il tuo robot.

Quindi il primo metodo di miscelazione che abbia mai provato è stato quello di ruotare matematicamente le coordinate xey di 45 gradi attorno al punto centrale della griglia.

Funziona bene, tuttavia non posso andare avanti con il 100% di potenza perché quando ruoti, il movimento complessivo è vincolato a un cerchio all'interno della griglia, il che significa che non puoi mai davvero entrare in quell'angolo in alto a destra.

Ciò comporta anche il mancato utilizzo degli angoli della griglia. Questo non è un problema se stai usando un joystick/gimple che limita il tuo movimento in modo che quelle aree non vengano mai raggiunte comunque, ma altrimenti vorrai che quella parte della griglia faccia qualcosa in modo che i tuoi movimenti sembrino completamente proporzionali.

Se sei uno studente visivo come me, questo concetto potrebbe essere più facile da capire guardando il video all'inizio di questo tutorial.

Diamo un'occhiata ad alcuni esempi di codice.

NOTE SUI MIEI ESEMPI DI CODICE: Sto tralasciando il modo in cui ottieni i valori joystick_x e joystick_y poiché cambierebbe a seconda del tuo progetto. Inoltre mapperò/vincolo a ±100, ma potrebbe essere necessario mappare a 1000 - 2000 per PWM o 0 - 255 per uscita analogica ecc. Limito sempre … per ogni evenienza.

Esempio di Arduino:

//ruota matematicamente

doppio rad = -45*M_PI/180; int leftThrottle = joystick_x * cos(rad) - joystick_y * sin(rad); int rightThrottle = joystick_y * cos(rad) + joystick_x * sin(rad); //constrain leftThrottle = constrain(leftThrottle, -100, 100); rightThrottle = constrain(rightThrottle, -100, 100);

Esempio JavaScript:

//ruota matematicamentevar rad = -45*Math. PI/180; leftThrottle = joystick_x * Math.cos(rad) - joystick_y * Math.sin(rad); rightThrottle = joystick_y * Math.cos(rad) + joystick_x * Math.sin(rad);//constrainleftThrottle = constrain(leftThrottle, -100, 100);rightThrottle = constrain(rightThrottle, -100, 100); //helper functionvar constrain = function(num, min, max){ return Math.min(Math.max(num, min), max); };

Passaggio 3: Metodo Metodo » Semplice

Successivamente abbiamo un'equazione molto semplice che ho raccolto per la prima volta da uno dei video SparkFun di Shawn Hymel's Adventures in Science in cui stava lavorando a un progetto molto simile a quello a cui stavo lavorando.

Questa equazione ti consente di raggiungere la massima velocità quando vai avanti ma, proprio come il metodo di rotazione, ignora le aree d'angolo della griglia. Questo perché in alcuni casi il massimo è 100 e in alcuni casi il massimo è 200. Quindi useresti una funzione di vincolo per ignorare qualsiasi cosa dopo 100.

E comunque non chiamo questo semplice spregiativamente… c'è una bellezza nella semplicità.

Esempio di Arduino:

int leftThrottle = joystick_y + joystick_x;

int rightThrottle = joystick_y - joystick_x; //constrain leftThrottle = constrain(leftThrottle, -100, 100); rightThrottle = constrain(rightThrottle, -100, 100);

Esempio JavaScript:

var canale sinistro = joystick_y + joystick_x;

var rightChannel = joystick_y - joystick_x;//constrain leftChannel = constrain(leftChannel, -100, 100); rightChannel = constrain(rightChannel, -100, 100); //vincolo var funzione di supporto = function(num, min, max){ return Math.min(Math.max(num, min), max); };

Passaggio 4: Metodo Metodo »Proporzionale

Sono saltato fuori dal metodo semplice sperando di ottenere il meglio dall'equazione di entrambi i mondi. L'idea qui è di essere completamente proporzionale in tutte le direzioni anche in diagonale, nonostante il fatto che ti muovi per una distanza maggiore, ha lo stesso raggio di quando ti muovi verticalmente, che è una distanza minore.

Finisci con una scala da -200 a +200 in tutte le direzioni nei miei esempi, lo mappo a ±100 perché rappresenta la percentuale di potenza che va a ciascun canale, tuttavia vorrai mapparlo su qualsiasi cosa funzioni nel tuo uso- custodia per il controller del motore. Ad esempio, se stai inviando un segnale PWM, potresti mapparlo da 1000 a 2000 o se stai inviando un segnale analogico potresti mapparlo su 0-255 e impostare la direzione come booleana, ecc.

Esempio di Arduino:

int leftThrottle = joystick_y + joystick_x;

int rightThrottle = joystick_y - joystick_x;// in alcuni casi il massimo è 100, in alcuni casi è 200// teniamo conto della differenza in modo che il massimo sia sempre 200 int diff = abs(abs(joystick_y) - abs(joystick_x));acceleratore sinistro = Acceleratore sinistro < 0 ? LeftThrottle - diff: leftThrottle + diff;rightThrottle = rightThrottle < 0 ? RightThrottle - diff: rightThrottle + diff; //Mappa da ±200 a ±100 o qualsiasi intervallo di cui hai bisognoleftThrottle = map(leftThrottle, 0, 200, -100, 100);rightThrottle = map(rightThrottle, 0, 200, -100, 100); //constrainleftThrottle = constrain(leftThrottle, -100, 100);rightThrottle = constrain(rightThrottle, -100, 100);

Esempio JavaScript:

var leftThrottle = joystick_y + joystick_x;var rightThrottle = joystick_y - joystick_x;// in alcuni casi il massimo è 100, in alcuni casi è 200, // teniamo conto della differenza in modo che il massimo sia sempre 200var diff = Math.abs(Math.abs(joystick_y) - Math.abs(joystick_x));leftThrottle = leftThrottle < 0 ? LeftThrottle - diff: leftThrottle + diff;rightThrottle = rightThrottle < 0 ? rightThrottle - diff: rightThrottle + diff; //Map da ±200 indietro a ±100 o qualunque cosa ti servaleftThrottle = map(leftThrottle, -200, 200, -100, 100);rightThrottle = map(rightThrottle, -200, 200, -100, 100); //constrain leftThrottle = constrain(leftThrottle, -100, 100);rightThrottle = constrain(rightThrottle, -100, 100);//alcune funzioni di supportovar constrain = function(num, min, max){ return Math.min(Math. max(num, min), max); }; var map = function(num, inMin, inMax, outMin, outMax){ var p, inSpan, outSpan, mappato; inMin = inMin + inMax; numero = numero + inMax; inMax = inMax + inMax; inSpan = Math.abs(inMax-inMin); p = (num/inSpan)*100; outMin = outMin + outMax; outMax = outMax + outMax; outSpan = Math.abs(outMax - outMin); mappato = outSpan*(p/100) - (outMax/2); ritorno mappato;};