Controlador de jogo Arduino com luzes que respondem ao seu jogo Unity :: 24 etapas

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

Primeiro, escrevi isso em palavras. Esta é a primeira vez que uso instructable so sempre que digo: escreva código assim, saiba que estou me referindo à imagem no topo dessa etapa.

Neste projeto eu uso 2 arduino para executar 2 bits separados de código, uma vez que tive alguns problemas para fazê-lo funcionar com apenas um

Estes são o Uno e o Leonardo

no total, isso é o que você precisa para implementar este projeto.

· 7 botões de pressão

· 23 fios de jumper

· 1 arduino Leonardo + cabo usb

· 4 resistores · 4 leds

· 1 cabo arduino uno + usb

· 2 placas de ensaio

Etapa 1: conectando os botões de controle ao Arduino

O que você precisa para conectar esta parte:

· 7 botões de pressão

· 14 fios de jumper

· 1 arduino Leonardo + cabo usb

· Breadboard

Os botões são muito simples de conectar, mas podem rapidamente se tornar uma bagunça para exibir em forma de imagem.

· Primeiro coloque os botões nas posições que marquei na imagem acima.

· Em segundo lugar, você deseja conectar um jumper do slot de aterramento no arduino Leonardo na linha negativa da placa de ensaio.

· Agora você conecta jumpers de qualquer lugar na linha negativa à linha que está alinhada com o pino direito de seu botão. isso irá fornecer energia para ele.

· Em seguida, você deseja conectar um fio jumper de uma linha que está alinhada com o pino esquerdo do seu botão de pressão aos slots de entrada digital do Leonardo. Para os botões aqui, usei o slot 2 - 3 - 4 - 5 - 6 - 7- 8

Eu só mostrei o fio indo para a entrada 8 na imagem porque fica uma imagem muito bagunçada para mostrar todos os fios se cruzando.

Etapa 2: Codificando o Arduino Leonardo:

Então, para dizer a você o motivo pelo qual estou usando o Leonardo para isso. É porque ele tem um determinado chip que o Uno não possui, isso faz com que o computador o reconheça como um dispositivo de entrada USB. Muito parecido com um teclado. O que nos permite fazer algo que torna nossas vidas como programadores deste projeto muito mais fáceis. Emulação de teclado. Vamos enganar o computador fazendo-o pensar que estamos pressionando certas teclas do teclado quando, na verdade, estamos pressionando botões em nosso controlador.

Agora vou explicar o código passo a passo.

Em primeiro lugar, no topo, incluímos Keyboard.h. Isso nos permitirá usar as funções do teclado que usaremos em nosso código.

Etapa 3:

Em seguida, precisamos definir os slots de entrada digital que vamos usar no

Leonardo para cada botão.

Também nomeei cada um deles com base na chave que vou imitar.

Passo 4:

A partir daí, entramos na função de configuração. Isso diz ao

arduino o que faz na inicialização.

primeiro escrevemos o Serial.begin que irá abrir a porta serial e definir a taxa de dados para 9600 bps

e definimos que todos são nomeados pinos como entradas.

Etapa 5:

E, finalmente, escrevemos nossa função de loop que irá verificar se

botões estão sendo pressionados e dizem ao arduino como responder a isso.

Primeiro escrevemos Keyboard.begin, que dirá ao Arduino que ele precisa cuidar de nós usando as funções do teclado

Etapa 6:

Então, para cada botão, escrevemos uma instrução if / else que funciona assim

Então, o que eu disse ao Arduino aqui é: se meu botão esquerdo está sendo pressionado no controlador, faz o computador pensar que estamos pressionando a tecla "a" e se não for o caso, faz com que ele pense que soltamos a tecla.

Basicamente, você repete esse bloco de código para cada botão do controlador. com mudanças para cada variável e as chaves que a variável precisa para emular

Etapa 7:

As teclas que dissemos ao computador para pressionar aqui são W - A - S - D, que

são basicamente o padrão para movimento em jogos de PC e E - Q - e a barra de espaço que neste código é reconhecida como ‘‘que são os botões que eu uso para pegar - dispensar e disparar em meu jogo. Sinta-se à vontade para alterá-las para quaisquer teclas que você achar que funcionam melhor para o seu jogo / controlador.

Então, por último, pedimos ao arduino para interromper a verificação de qual Keyboard.end

Etapa 8: Movimento de codificação na unidade:

Em primeiro lugar, deixe-me dizer que estou fazendo isso para um jogo 2d, então

os exemplos que você verá são feitos para isso. Significa principalmente onde eu uso o vetor2, se você estiver trabalhando em 3D, você usará o vetor3. porque você precisaria se preocupar com uma dimensão extra de movimento em 3D.

Agora, o motivo pelo qual usei a emulação de teclado no lado do arduino é porque o Unity tem algo integrado para reconhecer as teclas do teclado que podemos usar.

Se você abrir seu projeto no Unity, vá para Editar -> Configurações do projeto -> Entrada. Você pode ver no seu inspetor que ele inicializa o gerenciador de entrada. Onde, se você clicar em Axes, poderá ver um monte de nomes de entrada abertos que são normalmente usados para controladores de PC como os que estamos fazendo agora. As 2 entradas que vamos usar são Horizontal e Vertical, que verifique para você adivinhou W-A-S-D.

Primeiro você quer fazer um objeto em sua hierarquia de cenas de unidade que será o seu jogador. No meu caso, sendo esse rapazinho divertido. Isso pode ser o que você precisar, mas para o propósito do meu jogo eu fiz esse cara.

Etapa 9:

Você quer dar a este jogador 2 coisas. Um colisor de caixa 2d e

um Rigidbody 2d e edite-os para ficarem como a imagem acima.

Etapa 10:

Em seguida, você deseja ir para a pasta de projetos e criar um

Script C #. Que chamei de PlayerMovement.

Neste script, você definirá 2 variáveis. Um float público que chamo de moveSpeed. O que determinará o quão rápido você vai. E um Rigidbody2D privado que chamo de RigidPlayer. Que vai olhar para o corpo rígido de seus jogadores.

Não se esqueça de ir ao seu editor de unidade, clicar no seu player, adicionar este novo script arrastando-o para o inspetor e definir um valor numérico para moveSpeed.

Etapa 11:

agora em seu Start () você quer fazer uma coisa e isso é

certifique-se de que seu RigidPlayer pode encontrar seu rigidbody pagador 2d. Você faz isso com a seguinte linha de código:

Etapa 12:

Em seguida, passamos para o update (). Aqui é para onde estamos indo

para fazer o jogador se mover.

fazemos isso com uma instrução if bastante simples que olhará para as chaves negativas e positivas de Horizontal (AD) e Vertical (SW) e aplicará isso como um número para forçar que colocaremos nosso corpo rígido 2d para empurrar nosso jogador uma direção. Esse número será multiplicado pela variável moveSpeed.

Etapa 13:

Por último, você quer ter certeza de que o seu player pare de se mover quando

você não pressiona nada. Você gosta disso:

Agora, se você quiser usar seus três outros botões para qualquer coisa, faça isso com esta instrução if: if (Input. GetKeyDown (Keycode. Space))

para a barra de espaço e em vez de espaço coloque a letra das outras teclas que você escolheu usar para as outras teclas.

Etapa 14: conectando luzes ao Arduino

·

O que você precisa para conectar esta parte:

· 9 fios de jumper

· 4 resistores

· 4 leds

· 1 cabo arduino uno + usb

· Breadboard

A ligação das luzes será feita através do Uno.

Vai ficar parecido com a imagem acima:

Você conecta os resistores ao lado comprido dos LEDs. E então você conecta um jumper de um número de pino digital no uno aos resistores. neste caso eu usei slots de pino digital 9 - 10 -11 -12 esses números serão relevantes quando chegarmos ao código para as luzes.

A partir daí, você deseja conectar um jumper do slot de aterramento em seu arduino Uno ao ponto em sua placa, como pode ser visto com o fio preto na imagem acima.

Então você deseja que 4 jumpers levem para a extremidade curta de cada LED

Etapa 15: codificando o Arduino Uno

Tudo bem, primeiro vamos definir nossas variáveis novamente

Então, primeiro quais entradas digitais estamos usando para nossas luzes. E vamos fazer um char chamado myCol [20]

Etapa 16:

Então, na configuração, queremos fazer o Serial.begin novamente. Coloque todos os nossos LEDs na saída e desligue todos eles na inicialização.

Etapa 17:

E, finalmente, você deseja escrever sua função de loop.

Isso fará com que o Arduino leia todos os dados recebidos por meio de serial até que um dos dois eventos aconteça. Um caractere de alimentação de linha é detectado; isso é identificado por lf, que é definido como 10 e é o primeiro argumento ou uma certa quantidade de bytes foi lida. Este é o terceiro argumento e, para este exemplo, é definido como apenas um byte. Os dados são armazenados na variável myCol, que é definida como char e com um limite de 20. Em readBytesUntil, este é o segundo argumento. Ou outra maneira de explicar isso é Serial.readBytesUntil (terminatorCharacter, buffer, byteLimit);

E as declarações if farão com que certas luzes se acendam quando a unidade der o sinal. Neste caso eu tenho 4 luzes de cores diferentes, então eu faço a unidade enviar g para o LED verde acender, b para o LED azul acender, r para o LED vermelho acender ey para o LED amarelo acender.

Etapa 18: Codificação do lado da unidade das luzes:

Oke 2 coisas primeiro antes de entrarmos nisso.

1. Em seu programa de codificação Arduino, vá para Ferramenta -> Porta -> e verifique para mim em qual COM o seu uno está. No meu caso é COM3 (isso será importante no código)

2. na unidade Vá em Editar -> Configurações do projeto -> Player e, em seguida, no inspetor, clique em outras configurações, vá para o Nível de compatibilidade da API e mude da sub-rede. NET 2.0 para apenas. NET 2.0

Ok, está feito. Vamos entrar nisso.

Clique com o botão direito na sua hierarquia e clique em Criar vazio.

Este será um objeto de jogo vazio que existirá apenas em seu jogo para conter um script para nós. Eu chamei este objeto de Init.

Etapa 19:

Em seguida, vá para a guia de projetos e crie um novo script C #

e chamá-lo de envio.

A primeira coisa a fazer é escrever essas linhas nas seções de uso de seu código:

using System. IO. Ports;

using System. Threading;

isso faz com que possamos usar a variável SerialPort

Etapa 20:

neste script vamos fazer as seguintes variáveis. Agora, observe que tenho COM3 lá, isso pode ser diferente para você, conforme discutimos no início desta etapa. Se for, substitua o 3 pelo número que ele disse para você.

Etapa 21:

No início, dizemos que o script a ser usado é OpenConnection

função que vamos escrever daqui a pouco

a atualização é mais um teste do que qualquer coisa, mas se você quiser incluí-la, é para testar as mensagens enviadas para a unidade. Você pode ignorar isso honestamente.

Etapa 22:

Ok agora para esta função OpenConnection. Este é apenas um grande

if / else declaração que mantém a conexão aberta, apenas copie-a como está escrita e você ficará bem.

Etapa 23:

Agora lembre-se do código do Arduino que eu fiz verificar para

sinais de que a unidade vai enviar para ele.

bem, é aqui que isso acontece. No meu caso, conectei 4 luzes, então escrevi 4 funções extremamente simples. Tudo o que fazem é quando são chamados, enviam uma carta para o Arduino. Quando o Arduino pega essa letra, ele acende a luz correspondente a essa letra.

Etapa 24:

Você deve estar se perguntando como faço para chamar isso de

função? Bem, você faz isso com uma linha simples em qualquer um dos outros scripts c # que você usa para o seu jogo. Sending. NameFunctionhere ();. Por exemplo, no meu jogo, o jogador tem a tarefa de coletar 4 orbes coloridas. Então eu escrevi um pequeno script que garante que quando ele chegar perto de um e apertar o botão certo, ele o pegue e mande o sinal para o arduino que neste caso o orbe amarelo foi captado. Para que ele saiba, ok eu tenho que ligar o LED amarelo:

Você pode colocar essa linha de código em qualquer lugar que quiser. Se você quiser que ele acenda quando o jogo começar, coloque-o na função de início. Quer que acenda quando ele morrer coloque em sua função para a morte do jogador. Experimente um pouco. Eu escolhi fazer das luzes uma espécie de elemento de interface do usuário fora do jogo para manter o controle dos orbes que você conseguiu coletar sem bagunçar a tela.