Já pensou em montar seu próprio controle para jogos utilizando um Arduino UNO?
Neste projeto, vamos mostrar como fazer um joystick com Arduino UNO utilizando o Shield Joystick Funduino. Além de controlar os movimentos nos eixos X e Y, o shield possui botões que podem ser configurados para executar diferentes comandos.
Para transformar os movimentos e cliques do joystick em comandos do teclado, vamos utilizar o Arduino IDE para realizar a leitura dos controles e o Thonny com Python para interpretar os dados enviados pela porta serial.
Esse projeto pode ser utilizado para controlar jogos, mas também serve como base para aplicações de robótica, automação e outros projetos interativos.
Conhecendo o Shield Joystick Funduino
Os shields para Arduino vêm se popularizando graças à praticidade que oferecem. Eles permitem adicionar novas funções à placa sem precisar montar todo o circuito utilizando diversos componentes separados.
Neste projeto, utilizaremos o Shield Joystick Funduino, que possui um joystick analógico para movimentação nos eixos X e Y, além de botões que podem ser utilizados para diferentes comandos.
O joystick analógico fornece valores diferentes conforme movimentamos a alavanca. O Arduino interpreta essas variações e consegue identificar se estamos movimentando o controle para a direita, esquerda, cima ou baixo.
Os botões funcionam como entradas digitais e podem ser associados às teclas que desejarmos.
Como encaixar o Shield no Arduino UNO
Antes de começar, tenha atenção à orientação do shield.
O Shield Joystick Funduino possui uma posição correta de encaixe. Os pinos precisam estar perfeitamente alinhados com os conectores do Arduino UNO.
Não force o encaixe. Confira a posição dos pinos antes de pressionar o shield contra a placa.
Quando estiver corretamente encaixado, todos os pinos deverão estar totalmente acoplados.
Programando o Joystick
Para este projeto, vamos utilizar dois programas:
- Arduino IDE: responsável por fazer a leitura dos movimentos e botões do joystick;
- Thonny com Python: responsável por receber os dados pela porta serial e transformá-los em comandos do teclado.
Dessa forma, o Arduino funciona como o responsável por capturar os comandos do joystick, enquanto o Python interpreta essas informações e envia as teclas correspondentes para o computador.
Programando o Arduino UNO
Conecte o Arduino UNO ao computador e abra a Arduino IDE.
Configure a placa e selecione a porta COM correspondente ao Arduino.
Depois, cole o código abaixo:
#define JOY_X A0
#define JOY_Y A1
#define JOY_SW 2
#define K1 3
#define K2 4
#define K3 5
#define K4 6
int lastX = -1, lastY = -1;
int lastSW = -1, lastK1 = -1, lastK2 = -1, lastK3 = -1, lastK4 = -1;
void setup() {
Serial.begin(9600);
while (!Serial) { ; }
pinMode(JOY_SW, INPUT_PULLUP);
pinMode(K1, INPUT_PULLUP);
pinMode(K2, INPUT_PULLUP);
pinMode(K3, INPUT_PULLUP);
pinMode(K4, INPUT_PULLUP);
}
void loop() {
int x = analogRead(JOY_X);
int y = analogRead(JOY_Y);
int sw = !digitalRead(JOY_SW);
int k1 = !digitalRead(K1);
int k2 = !digitalRead(K2);
int k3 = !digitalRead(K3);
int k4 = !digitalRead(K4);
if (x != lastX || y != lastY ||
sw != lastSW || k1 != lastK1 ||
k2 != lastK2 || k3 != lastK3 ||
k4 != lastK4) {
Serial.print(x);
Serial.print(",");
Serial.print(y);
Serial.print(",");
Serial.print(sw);
Serial.print(",");
Serial.print(k1);
Serial.print(",");
Serial.print(k2);
Serial.print(",");
Serial.print(k3);
Serial.print(",");
Serial.println(k4);
lastX = x;
lastY = y;
lastSW = sw;
lastK1 = k1;
lastK2 = k2;
lastK3 = k3;
lastK4 = k4;
}
delay(10);
}Como funciona o código do Arduino?
O programa começa definindo os pinos utilizados pelo joystick e pelos botões.
Os eixos X e Y são conectados às entradas analógicas:
#define JOY_X A0
#define JOY_Y A1Já os botões utilizam entradas digitais:
#define JOY_SW 2
#define K1 3
#define K2 4
#define K3 5
#define K4 6O Arduino realiza continuamente a leitura dessas entradas e envia os valores pela comunicação serial.
Os dados são enviados neste formato:
X,Y,SW,K1,K2,K3,K4Por exemplo:
512,512,0,0,0,0,0Dessa forma, o Python consegue identificar cada movimento e cada botão separadamente.
Configurando o Thonny e o Python
Agora vamos utilizar o Thonny para interpretar os dados recebidos pelo Arduino.
Caso alguma biblioteca não esteja instalada, você pode acessá-la pelo próprio Thonny em:
Ferramentas → Gerenciar pacotes
Pesquise pelo nome da biblioteca e clique em Instalar.
Para este projeto, utilizaremos:
PyserialPynput
Depois de instalar as bibliotecas necessárias, crie um novo arquivo no Thonny e cole o código abaixo:
import serial
import time
from pynput.keyboard import Key, Controller
PORT = "COM11"
BAUD = 9600
teclado = Controller()
arduino = serial.Serial(PORT, BAUD, timeout=1)
time.sleep(2)
arduino.reset_input_buffer()
print("Conectado. Aguardando eventos do joystick...\n")
THRESHOLD = 400
DEADZONE = 30
estado_anterior = {
'sw': 0, 'k1': 0, 'k2': 0, 'k3': 0, 'k4': 0,
'esquerda': 0, 'direita': 0, 'cima': 0, 'baixo': 0
}
ultimo_x = 512
ultimo_y = 512
def pressionar(tecla):
teclado.press(tecla)
def soltar(tecla):
teclado.release(tecla)
def tratar_botao(valor, tecla, nome):
if valor and not estado_anterior[nome]:
pressionar(tecla)
print(f"[PRESSIONOU] {nome}")
elif not valor and estado_anterior[nome]:
soltar(tecla)
print(f"[SOLTOU] {nome}")
estado_anterior[nome] = valor
def tratar_eixo(x, y):
global ultimo_x, ultimo_y
if abs(x - ultimo_x) < DEADZONE and abs(y - ultimo_y) < DEADZONE:
return
ultimo_x = x
ultimo_y = y
centro = 512
esq = x < (centro - THRESHOLD)
dir = x > (centro + THRESHOLD)
cim = y < (centro - THRESHOLD)
bai = y > (centro + THRESHOLD)
tratar_botao(esq, Key.left, 'esquerda')
tratar_botao(dir, Key.right, 'direita')
tratar_botao(bai, Key.up, 'cima')
tratar_botao(cim, Key.down, 'baixo')
try:
while True:
linha = arduino.readline().decode(
'utf-8',
errors='ignore'
).strip()
if not linha:
continue
linha = ''.join(
c for c in linha
if c.isdigit() or c == ','
)
partes = linha.split(',')
if len(partes) != 7:
continue
if any(p == '' for p in partes):
continue
x = int(partes[0])
y = int(partes[1])
sw = int(partes[2])
k1 = int(partes[3])
k2 = int(partes[4])
k3 = int(partes[5])
k4 = int(partes[6])
tratar_botao(sw, Key.space, 'sw')
tratar_botao(k1, 'z', 'k1')
tratar_botao(k2, 'x', 'k2')
tratar_botao(k3, 's', 'k3')
tratar_botao(k4, 'f', 'k4')
tratar_eixo(x, y)
except KeyboardInterrupt:
print("\nEncerrado.")
finally:
arduino.close()Configurando a porta COM
Existe um detalhe importante antes de executar o programa em Python.
No início do código, encontramos:
PORT = "COM11"Você precisa substituir COM11 pela mesma porta COM utilizada pelo Arduino na Arduino IDE.
Por exemplo:
PORT = "COM5"Outro ponto importante: feche o Monitor Serial da Arduino IDE antes de executar o programa no Thonny.
Isso acontece porque a comunicação serial só pode ser utilizada por um programa por vez. Se o Monitor Serial estiver aberto, o Python poderá não conseguir acessar os dados enviados pelo Arduino.
Configurando os botões
Uma das vantagens dessa montagem é poder escolher quais teclas do teclado serão acionadas pelos botões.
No exemplo deste projeto, configuramos:
- Joystick → Direcional;
- SW → Barra de espaço;
- K1 → Z;
- K2 → X;
- K3 → S;
- K4 → F.
Essa configuração aparece no código nestas linhas:
tratar_botao(sw, Key.space, 'sw')
tratar_botao(k1, 'z', 'k1')
tratar_botao(k2, 'x', 'k2')
tratar_botao(k3, 's', 'k3')
tratar_botao(k4, 'f', 'k4')Para utilizar o joystick em outro jogo ou aplicação, você pode alterar as teclas entre aspas conforme os comandos necessários.
Por exemplo:
tratar_botao(k1, 'a', 'k1')Nesse caso, o botão K1 passará a enviar a tecla A.
Como o Joystick Ccontrola o computador?
O funcionamento do projeto acontece em etapas.
Primeiro, o Shield Joystick Funduino detecta os movimentos e os cliques.
Depois, o Arduino UNO realiza a leitura desses sinais e envia os valores pela porta serial.
O Python, executado pelo Thonny, recebe essas informações, interpreta os valores e utiliza a biblioteca pynput para pressionar ou soltar as teclas correspondentes no computador.
O fluxo fica assim:
Joystick → Arduino UNO → Porta Serial → Python → Teclado do computador
Utilizando o Joystick em jogos
Depois de configurar as teclas de acordo com o jogo escolhido, execute o programa Python no Thonny.
Quando o Arduino for conectado corretamente, o programa deverá apresentar uma mensagem semelhante a:
Conectado. Aguardando eventos do joystick...A partir desse momento, os movimentos e botões do joystick serão convertidos nos comandos configurados.
Lembre-se de configurar as teclas de acordo com os comandos utilizados pelo jogo. Cada jogo pode utilizar uma combinação diferente de teclas.
Outras aplicações
Embora este projeto tenha sido desenvolvido para utilizar o joystick como controle de jogos, a mesma ideia pode ser aplicada em diversas outras situações.
Você pode utilizar o joystick para:
- Controlar robôs;
- Movimentar carrinhos;
- Criar interfaces de automação;
- Controlar braços robóticos.
A leitura dos eixos X e Y também permite criar sistemas em que a intensidade do movimento do joystick influencia diretamente o comportamento de um motor ou outro dispositivo.
Conclusão
Agora você já sabe como fazer seu próprio joystick com Arduino UNO utilizando o Shield Joystick Funduino.
Neste projeto, aprendemos a capturar os movimentos e botões utilizando o Arduino, enviar essas informações pela comunicação serial e utilizar Python para transformar os comandos em teclas do computador.
A combinação entre Arduino UNO e Python amplia bastante as possibilidades do projeto. Além de criar um controle para jogos, você pode utilizar a mesma estrutura como base para projetos de robótica, automação e sistemas interativos.
Agora é só escolher a aplicação, configurar as teclas necessárias e começar a utilizar seu próprio joystick.
Projeto realizado por Emanuel Sousa – Graduando em Engenharia Mecatrônica
Deixe um comentário