Existem inúmeras formas de controlar diretamente algum projeto que usa Arduino, por exemplo, usando botões, potenciômetro, criando uma interface no celular e entre outros… Porém, as formas mais interessantes costumam ser um problema, já que são difíceis de implementar e possuem um custo relativamente alto, quando comparado com as outras formas.

Mesmo assim, existe um jeito muito interessante e que apenas reutiliza um joystick que você não usa mais. E é o que nós vamos ver hoje. Claro que, para quem não tem um, isso representa um custo.

Caso você queira aprender sobre como funciona um controle por dentro, eu recomendo esse post.

Técnica Utilizada

Existe uma forma de controlar um controle de playstation que não exige que ele seja aberto. Essa forma usa os próprios pinos que saem do cabo. E existe uma biblioteca pronta que faz todo o trabalho chato pra você. O material para fazer desse jeito pode ser encontrado aqui.

Entretanto, meu intuito é fazer um projeto que seja possível entender 100% do processo e que também seja simples de executar. Sendo assim, eu vou usar um joystick de computador (imagem abaixo) e pretendo usar os componentes internos diretamente. Dessa forma, independente do controle que você utilize, será possível entender e reproduzir com o seu controle.

controle de pc joystick

Ao contrário do que aparece normalmente, esse joystick que eu vou usar possui os componentes ligados diretamente aos fios que saem do cabo. Exceto os botões, que passam por um CI que processa os dados (igual o restante dos controles). Porém, eu resolvi soldá-los diretamente aos fios que saem do controle. Então, de certa forma, não é necessário abrir meu controle. Só para intuito de esclarecimento, vou mostrar alguns pinos do conector (imagem abaixo).

joystick pc pinos

A ordem é de cima para baixo e da esquerda para direita:

Pino 1 – 5V que liga em uma ponta de todos os potenciômetros e em uma ponta dos botões

Pino 2 – Terminal 1 do botão 1

Pino 3 – Potenciômetro Eixo Lateral

Pino 4 – Terminal 2 do botão 1 e botão 2

Pino 6  – Potenciômetro Eixo Frontal

Pino 10 – Terminal 1 do botão 2

Pino 11 – Potenciômetro Slider Lateral

Pino 13 – Potenciômetro Slider Topo

Materiais

Os materiais são os mais simples possíveis:

  • Um controle de videogame ou computador que não é usado mais
  • Alguns fios para conexão
  • Um Arduino
  • 3 LEDs (de preferência de cores diferentes)
  • 3 resistores de 220Ω
    • Ou apenas 3 resistores para limitar a corrente dos LEDs
  • (Opcional) Um resistor de 470Ω
    • Veja se você precisa dele na montagem

Montagem

Informações prévias

O objetivo da montagem é fazer com que dois botões do meu controle acionem 2 LEDs (cada um aciona um) e um potenciômetro – que é responsável pelo movimento da haste central – controlará o brilho do último LED. Possivelmente, você está usando um controle que possui um analógico, e caso você não saiba, o analógico é um potenciômetro, então utilize ele para controlar o brilho do LED. Sendo assim, eu vou usar os pinos 1, 2, 3, 4 e 10 (veja o tópico da “Tecnica Utilizada” para entender o que eu vou fazer).

Como saber se você precisa do resistor de 470Ω? É simples: você não precisa se você tiver acesso a todos os terminais do seu potenciômetro, mas, caso apenas 2 terminais estejam disponíveis (que é meu caso), você vai precisar. Isso, porque com dois terminais o potenciômetro funciona como uma resistência variável simples e fica inviável fazer medições, então precisamos transformá-lo em um divisor de tensão, que é o caso dos 3 terminais. O valor de 470Ω é aleatório e pode ser substituído por outro. Por causa dessa diferença, farei dois circuitos, um para cada caso. No circuito, eu vou simbolizar os botões como se fossem um pushbutton comum, mas a ligação é a mesma, e o mesmo vale para o potenciômetro.

Circuito

Circuito 1 – Usando resistor de 470Ω

Circuito joystick com resistor 470ohms

Circuito 2 – Sem usar o resistor de 470Ω

Circuito joystick sem resistor

Como eu disse anteriormente, o potenciômetro está atuando como divisor de tensão, sendo a tensão de entrada 5v e a tensão de saída está sendo lida no pino A0. Enquanto isso os botões estão ligados, de um lado no GND e do outro nos pinos 2 e 3. Ou seja, quando os botões forem pressionados, os pinos 2 e 3 vão ler sinal de nível baixo (0v). Por último, os LEDs basicamente vão ser controlados pelos pinos 4,5 e 6 e a outra ponta deles está ligada ao GND. Uma observação importante é que o LED que nós controlaremos o brilho deve ser ligado a um pino com PWM (um pino que possua um ~ na frente).

Programação

Antes de fazer o nosso programa final, nós precisamos saber qual é a faixa de valores que o pino analógico 0 irá ler. Para isso, é preciso fazer um programa que imprima esses valores no monitor serial. Aprenda como fazer leituras analógicas neste post.

1
2
3
4
5
6
7
8
void setup() {
  Serial.begin(9600);
  pinMode(A0, INPUT);
}
void loop() {
  Serial.println(analogRead(A0));
  delay(100);
}

Basta rodar o código acima, abrir o monitor serial, movimentar o analógico (potenciômetro) e anotar os valores que aparecerão no monitor serial. No meu caso foi cerca de: movimentando a haste para um lado deu 780 e para o outro aproximou de 0. Feito isso, agora vamos para o código final.

Explicação detalhada

Primeiro temos que definir os pinos:

1
2
3
4
5
int bot1 = 2;
int bot2 = 3;
int led1 = 4;
int led2 = 5;
int led3 = 6;

Agora, na nossa inicialização, vamos definir os pinos dos LEDs como saídas, o pino analógico A0 como entrada e os pinos dos botões como entradas também, porém ativando o pull-up interno para garantir que a entrada dos botões não fique flutuando quando o botão não for pressionado, isto é, não ficar lendo valores aleatórios que não deveria. Entenda sobre resistência pull-up neste post.

1
2
3
4
5
6
7
8
void setup() {
  pinMode(bot1, INPUT_PULLUP);
  pinMode(bot2, INPUT_PULLUP);
  pinMode(led1, OUTPUT);
  pinMode(led2, OUTPUT);
  pinMode(led3, OUTPUT);
  pinMode(A0, INPUT);
}

Na nossa função loop, será preciso fazer a leitura de A0. Portanto, basta criar uma variável (o recomendável é uma int) recebendo a leitura do pino A0.

1
int pot = analogRead(A0);

Antes de entrar na lógica do brilho do LED, vamos programar os botões. A ideia é simples: se o botão 1 for pressionado então o led1 deve ser acionado e, caso contrário, deve ser apagado. O mesmo vale para o botão 2 que controla o led2.

1
2
3
4
5
6
7
8
9
10
if(digitalRead(bot1) == 0){
  digitalWrite(led1, HIGH);
}else{
  digitalWrite(led1, LOW);
}
if(digitalRead(bot2) == 0){
  digitalWrite(led2, HIGH);
}else{
  digitalWrite(led2, LOW);
}

Para controlar o brilho do LED, nós usaremos um PWM e o comando para isso funciona numa escala de 0 a 255. Já que os valores do nosso potenciômetro – os valores anotados anteriormente – ultrapassam essa faixa, é preciso remapear a nossa escala para a escala de 0 a 255. Portanto, vou utilizar o comando map para isso, que, de certa forma, faz uma regra de 3.

1
int brilho = map(pot, 0,780,0,255);

Depois disso, basta pegar esse valor remapeado e acionar o LED com ele (Entenda melhor lendo o post sobre isso).

1
analogWrite(led3, brilho);

Código completo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
int bot1 = 2;
int bot2 = 3;
int led1 = 4;
int led2 = 5;
int led3 = 6;

void setup() {
  pinMode(bot1, INPUT_PULLUP);
  pinMode(bot2, INPUT_PULLUP);
  pinMode(led1, OUTPUT);
  pinMode(led2, OUTPUT);
  pinMode(led3, OUTPUT);
  pinMode(A0, INPUT);
}

void loop() {
  int pot = analogRead(A0);
  if(digitalRead(bot1) == 0){
    digitalWrite(led1, HIGH);
  }else{
    digitalWrite(led1, LOW);
  }
  if(digitalRead(bot2) == 0){
    digitalWrite(led2, HIGH);
  }else{
    digitalWrite(led2, LOW);
  }
  int brilho = map(pot, 0,780,0,255);
  analogWrite(led3, brilho);
}

Assista o resultado do projeto no vídeo no início do post. Enfim, agora você já pode controlar seus robôs usando um joystick antigo.

Como é um Joystick por dentro