Aprender

Um jogo da cobrinha em duas matrizes de LEDs 8x8

Avançado

Ou veja todas as aulas.

  • 526componentes na bancada
  • 46placas rodando agora
  • 1.00xtempo real, em todas as placas
Arduino Uno: cobrinha em duas matrizes de LEDsao vivo0.000 s 0.00x
Aperte Rodar e depois empurre o analógico para começar
O exemplo Cobrinha em duas matrizes: dois módulos MAX7219 para um campo de 8x16 e um joystick analógico. Empurre o analógico para começar.

A cobrinha é aquele jogo dos celulares antigos: uma linha de pontos rasteja pela tela, come uma maçã, cresce e morre ao bater numa parede ou nela mesma. É um passo além do Simon, porque exige uma imagem em movimento, uma direção, um corpo que cresce e leitura de entrada entre os quadros.

O circuito acima roda o jogo num Arduino Uno com dois módulos de matriz de LEDs 8x8 MAX7219, um acima do outro, formando um campo de oito pontos de largura por dezesseis de altura. Um joystick analógico controla a direção. Aperte Rodar e a cobrinha fica esperando, com três pontos de comprimento e uma maçã em algum lugar do campo. Empurre o analógico, ou pressione-o, e a cobrinha parte. Se você deixar quieto, ela rasteja direto até a parede de baixo em cerca de três segundos e meio; o monitor serial mostra "bitten". Aperte o analógico para jogar de novo.

O que você precisa

  • Um Arduino Uno
  • Dois módulos de matriz de LEDs 8x8 MAX7219
  • Um módulo de joystick analógico (dois potenciômetros e um botão de pressão)
  • Uma protoboard e jumpers

Ligação

Componente e pinoVai paraNota
DIN das duas matrizesPino 11Dados compartilhados
CLK das duas matrizesPino 13Clock compartilhado
CS da matriz de cimaPino 10Cada módulo tem seu próprio chip select
CS da matriz de baixoPino 9
VCC e GND das matrizes5 V e GNDO MAX7219 precisa de 4 V ou mais
VRX do analógicoA0Esquerda e direita
VRY do analógicoA1Cima e baixo
SW do analógicoPino 2Pressione para começar ou recomeçar
VCC e GND do analógico5 V e GND

O display

Um MAX7219 guarda oito bytes, um por linha da matriz, e varre eles sozinho, então o Uno só escreve um byte quando algo muda. Os dois módulos compartilham dados e clock, e cada um tem seu próprio chip select. O que o Uno envia com um pino CS em nível baixo vai só para aquele módulo.

Isso custa um pino a mais do que encadear os módulos (DOUT de um no DIN do próximo, como o jogo de empilhar faz), e aqui vale a pena: um passo da cobrinha muda dois pontos, a cabeça nova e o rabo velho, geralmente na mesma metade. Com um select para cada, um passo reescreve um módulo e deixa o outro em paz.

O exemplo usa mokxi_max7219.h, um driver pequeno que vem com o Mokxi: setPixel(), clear() e show(). Numa placa de verdade a escolha usual é a biblioteca LedControl do Gerenciador de Bibliotecas, que o Mokxi também tem como LedControl.h, com setLed(module, row, col, state) fazendo o mesmo papel de setPixel().

O corpo, a maçã e as paredes

The snake is a ring buffer: an array of 128 cell numbers, one per dot on the field, with an index for the head. A cell number is row times 8 plus column. Each step works out the next cell from the heading, writes it at the head, and lights it. If the snake did not just eat, it also turns off the tail cell, so the snake moves without being redrawn. Two dots change per step, and the other 126 are left as they are.

Comer é uma comparação: se a célula da cabeça nova é a célula da maçã, o comprimento aumenta um, o tempo do passo cai 8 ms (de 240 ms, até ficar abaixo de 90) e uma nova maçã é colocada numa célula livre. Morrer são duas verificações: a célula nova está fora do campo, ou já faz parte do corpo. Aqui as paredes são paredes de verdade, não dão a volta, então você pode perder.

A posição da maçã vem de um gerador de números aleatórios bem pequeno (um LFSR de 16 bits). O estado dele é misturado com millis() quando o jogador reinicia, então cada partida é diferente.

Dirigindo com um joystick analógico

Um joystick analógico informa uma posição, dois números de 0 a 1023, mas uma cobrinha precisa de uma direção. Então o sketch lê o analógico como um empurrão: o eixo mais distante do centro vence, e só se passar de 160 unidades além da zona morta. Solte e o analógico volta à posição de repouso, e a cobrinha segue em frente.

Uma curva direto de volta para o próprio pescoço da cobrinha é recusada. Sem essa regra, um toque rápido de baixo para cima acabaria o jogo na hora.

O analógico é lido a cada poucos milissegundos entre os passos, não só uma vez por passo. Senão, um toque que começa e termina dentro de um único passo de 240 ms passaria despercebido.

Lendo o analógico como uma direção
static void steer() {
  int16_t x = stick.dx();
  int16_t y = stick.dy();
  int8_t wantX = 0, wantY = 0;
  int16_t ax = x < 0 ? -x : x;
  int16_t ay = y < 0 ? -y : y;
  if (ax > ay) {
    if (ax > THROW) wantX = x > 0 ? 1 : -1;
  } else if (ay > THROW) {
    wantY = y > 0 ? 1 : -1;
  }
  if (wantX == 0 && wantY == 0) return;
  waiting = false;                    // the first push starts the game
  if (wantX != 0 && dx != 0) return;  // no reversing into the neck
  if (wantY != 0 && dy != 0) return;
  dx = wantX;
  dy = wantY;
}

Erros comuns

Metade do campo fica apagada. Geralmente o fio CS daquele módulo está frouxo ou num pino errado, ou o VCC dele está em 3,3 V. O MAX7219 precisa de 4 V ou mais.

A cobrinha vira sozinha no momento em que o jogo começa. Um analógico de verdade não repousa exatamente em 512, então compare com a posição de repouso lida na ligação, não com 512, e adicione uma zona morta. Ler dois pinos analógicos em sequência num Uno tem uma segunda pegadinha: a primeira leitura depois de trocar de canal pode carregar o valor do canal anterior, então descarte ela.

O jogo acaba antes de você encostar nele. Num campo de dezesseis linhas de altura, uma cobrinha que anda a cada 240 ms chega na parede em cerca de três segundos. É por isso que o sketch espera o primeiro empurrão.

Usar delay() para o tempo do passo. Um delay de 240 ms significa que o analógico não é lido por 240 ms. Use millis() e leia o analógico no intervalo.

Um array de corpo pequeno demais. Dimensione ele para o campo inteiro, 128 células, para uma cobrinha comprida nunca escrever além do fim.

Abra este circuito no editor. Arduino Uno: cobrinha em duas matrizes de LEDs, ligado como roda no topo desta página. Troque um componente ou um valor e rode de novo.

Abrir o circuito

Perguntas

Como faço um jogo da cobrinha numa matriz de LEDs 8x8 com Arduino?

Controle a matriz com um MAX7219 e a LedControl, guarde a cobrinha como um array de células, mova a cabeça uma célula por passo, apague o rabo se a cobrinha não acabou de comer e termine o jogo quando a cabeça sai da grade ou cai no corpo.

Posso jogar cobrinha numa matriz 8x8 só?

Pode. Mude o campo para 8 linhas e tire o segundo módulo. É um jogo curto em 64 pontos, por isso este usa dois módulos para 128.

Posso usar um OLED ou um TFT no lugar?

Pode. A lógica é a mesma; só as chamadas de desenho mudam. O Mokxi tem uma versão em TFT também, num ILI9341 de 240x320, linkada logo abaixo desta página.

Posso usar botões em vez de um joystick?

Pode. Quatro botões em pinos INPUT_PULLUP, cada um definindo dx e dy, com a mesma verificação de não reverter.

Monte isto de verdade

Abra o editor, mude um valor e veja o número mudar junto. Nada para instalar, e não precisa de conta.