Compreendendo a mixagem de canais: 4 etapas (com imagens)

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:39

Se você já dirigiu um chassi de controle remoto, há uma boa chance de que já tenha usado a mixagem, mesmo que não saiba. Especificamente, se você usou um único joystick ou gimble para controlar um veículo que usa direção deslizante ou direção diferencial, você usou a mistura.

A mixagem é simplesmente como os dados de seu joystick são usados para determinar quanta energia deve ser fornecida a cada lado do chassi.

Se você abrir um joystick, geralmente verá dois potenciômetros dentro dele. Um para medir sua posição atual ao longo do eixo Y (para cima e para baixo) e o outro para medir onde você está ao longo do eixo X (lado a lado).

Embora eu não tenha nenhum treinamento formal sobre o assunto, tive que fazer mixagem de código antes e, recentemente, quis me aprofundar um pouco mais no assunto.

Em primeiro lugar, quero observar que a maioria dos transmissores RC tem capacidade de mixagem, assim como muitos controladores de motor. Essa informação será mais útil se você tiver que fazer a mixagem sozinho em seu código. Digamos, por exemplo, se você estiver usando um Arduino para ler dados não misturados de um receptor RC, ou se estiver lendo dados analógicos dos potenciômetros em um joystick, ou se estiver lendo as coordenadas de um joystick digital em um aplicativo móvel.

Vamos dar uma olhada em algumas abordagens de mixagem diferentes.

Etapa 1: Método de mistura »Nenhum

Primeiro, vamos dar uma olhada no que acontece se você não usar a mixagem. Se você apenas enviar os dados de um eixo para um lado do chassi e do outro eixo para o outro lado, seu veículo não responderá da maneira que você deseja.

Por exemplo, se você empurrar o joystick totalmente para frente, o eixo Y está em aceleração total e o eixo X está em 0. Portanto, você estaria dirigindo em círculos em vez de ir em linha reta.

Etapa 2: Método Método »Girar

Certa vez, um colega de trabalho me disse que, em um piscar de olhos, você pode girar seu transmissor 45 graus para uma mistura de homem pobre. Se você pensar nos valores dos dois potenciômetros em um joystick como sendo o eixo xey em uma grade (com ambos os eixos abrangendo -100 a +100), isso faz muito sentido porque você está indo para +100 em ambos os eixos conforme você empurra o joystick para cima e para a direita. Portanto, se isso for mapeado diretamente para seus dois canais de chassi (os lados esquerdo e direito de seu robô), ele faria o robô avançar.

Portanto, o primeiro método de mixagem que tentei foi girar matematicamente as coordenadas xey 45 graus sobre o ponto central da grade.

Isso funciona bem, no entanto, não posso avançar com 100% de potência porque quando você está girando, o movimento geral é restrito a um círculo dentro da grade, o que significa que você nunca pode realmente chegar ao canto superior direito.

Isso também faz com que os cantos da grade não sejam utilizados. Isso não é um problema se você estiver usando um joystick / gimple que limita seu movimento para que essas áreas nunca sejam alcançadas, mas caso contrário, você vai querer que essa parte da grade faça algo para que seus movimentos pareçam completamente proporcionais.

Se você for um aprendiz visual como eu, este conceito pode ser mais fácil de entender assistindo ao vídeo no início deste manual.

Vejamos alguns exemplos de código.

NOTAS SOBRE OS MEUS EXEMPLOS DE CÓDIGO: Estou omitindo como você obtém os valores joystick_x e joystick_y, pois eles mudariam dependendo do seu projeto. Além disso, estarei mapeando / restringindo para ± 100, mas você provavelmente precisará mapear para 1000 - 2000 para PWM ou 0 - 255 para saída analógica etc. Eu sempre restrinjo … apenas no caso.

Exemplo de Arduino:

// girar matematicamente

duplo 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); // restringir leftThrottle = constrain (leftThrottle, -100, 100); rightThrottle = constrain (rightThrottle, -100, 100);

Exemplo de JavaScript:

// rotatevar matematicamente 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); // auxiliar functionvar constrain = function (num, min, max) {return Math.min (Math.max (num, min), max); };

Etapa 3: Método Método »Simples

Em seguida, temos uma equação muito simples que eu peguei em um dos vídeos do SparkFun de Aventuras na Ciência de Shawn Hymel, onde ele estava trabalhando em um projeto muito semelhante ao que eu estava trabalhando.

Esta equação permite que você obtenha velocidade total ao avançar, mas de forma muito parecida com o método de rotação, ela desconsidera as áreas dos cantos da grade. Isso ocorre porque em alguns casos o máximo é 100 e em alguns casos o máximo é 200. Portanto, você usaria uma função de restrição para desconsiderar qualquer coisa após 100.

E, a propósito, não chamo isso de simples depreciativo … há uma beleza na simplicidade.

Exemplo de Arduino:

int leftThrottle = joystick_y + joystick_x;

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

Exemplo de JavaScript:

var leftChannel = joystick_y + joystick_x;

var rightChannel = joystick_y - joystick_x; // restringir leftChannel = constrain (leftChannel, -100, 100); rightChannel = constrain (rightChannel, -100, 100); // auxiliar functionvar constrain = function (num, min, max) {return Math.min (Math.max (num, min), max); };

Etapa 4: Método Método »Proporcional

Eu embarquei no método simples na esperança de fazer o melhor com a equação dos dois mundos. A ideia aqui é ser totalmente proporcional em todas as direções, mesmo na diagonal, apesar do fato de que você está se movendo em uma distância maior, ela tem o mesmo alcance de quando você se move na vertical, que é uma distância menor.

Você acaba com uma escala de -200 a +200 em todas as direções em meus exemplos, mapeio para ± 100 porque representa a porcentagem de energia que vai para cada canal - no entanto, você vai querer mapeá-la para qualquer coisa que funcione em seu uso- caso para o seu controlador de motor. Por exemplo, se você estiver enviando um sinal PWM, poderá mapeá-lo para 1000 a 2000 ou se estiver enviando um sinal analógico, poderá mapeá-lo para 0-255 e definir a direção como booleana etc.

Exemplo de Arduino:

int leftThrottle = joystick_y + joystick_x;

int rightThrottle = joystick_y - joystick_x; // em alguns casos, o máximo é 100, em alguns casos é 200 // vamos fatorar a diferença para que o máximo seja sempre 200int diff = abs (abs (joystick_y) - abs (joystick_x)); leftThrottle = leftThrottle <0? leftThrottle - diff: leftThrottle + diff; rightThrottle = rightThrottle <0? rightThrottle - diff: rightThrottle + diff; // Mapeie de ± 200 a ± 100 ou qualquer intervalo que você agulhaftThrottle = map (leftThrottle, 0, 200, -100, 100); rightThrottle = map (rightThrottle, 0, 200, -100, 100); // constrainleftThrottle = constrain (leftThrottle, -100, 100); rightThrottle = constrain (rightThrottle, -100, 100);

Exemplo de JavaScript:

var leftThrottle = joystick_y + joystick_x; var rightThrottle = joystick_y - joystick_x; // em alguns casos, o máximo é 100, em alguns casos é 200, // vamos fatorar a diferença para que o máximo seja 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; // Mapeie de ± 200 de volta para ± 100 ou o que você agulharftThrottle = map (leftThrottle, -200, 200, -100, 100); rightThrottle = map (rightThrottle, -200, 200, -100, 100); // restrição leftThrottle = constrain (leftThrottle, -100, 100); rightThrottle = constrain (rightThrottle, -100, 100); // algumas funções auxiliaresvar restrição = function (num, min, max) {return Math.min (Math. max (num, min), max); }; var map = função (num, inMin, inMax, outMin, outMax) {var p, inSpan, outSpan, mapeado; inMin = inMin + inMax; num = num + inMax; inMax = inMax + inMax; inSpan = Math.abs (inMax-inMin); p = (num / inSpan) * 100; outMin = outMin + outMax; outMax = outMax + outMax; outSpan = Math.abs (outMax - outMin); mapeado = outSpan * (p / 100) - (outMax / 2); retorno mapeado;};