Na semana passada, eu construí um cubo de LED Como fazer um Arduino pulsante LED Cubo que parece que veio do futuro Como fazer um pulsante Arduino LED Cubo que parece que veio do futuro Se você já se interessou por alguns projetos iniciantes do Arduino, mas estão à procura de algo um pouco permanente e em um nível totalmente diferente de incrível, então o humilde 4 x 4 x 4 LED cubo é ... Leia Mais - 64 LEDs que você pode programar para fazer shows fantásticos de luzes futuristas - e eu espero que você também tenha feito, porque é um ótimo projeto para motivar você e expandir seu conjunto de habilidades do Arduino. Deixei-te com algumas aplicações básicas para te fazer pensar, mas hoje vou apresentar mais alguns bits de software que fiz para o cubo, juntamente com explicações de código. O objetivo disso é dar a você alguns espetáculos de luzes mais bonitos, mas também aprender sobre algumas das limitações da programação do cubo e aprender alguns novos conceitos de programação no processo.
Isso é uma codificação bastante avançada; você realmente precisa ter lido todos os meus tutoriais anteriores do Arduino e nosso guia Arduino para iniciantes antes de personalizar o código fornecido.
App 1: Mini Cobra
Em vez de executar uma seqüência de padrões de serpente, eu queria programar uma cobra - uma artificial que faria suas próprias escolhas aleatórias, e seria completamente imprevisível. Está limitado a apenas 2 segmentos, o que explicarei mais adiante e você poderá ver a demonstração abaixo. Baixe o código completo aqui.
Ao lidar com o espaço 3D, você precisa de 3 coordenadas para um único ponto: X, Y e Z.
No entanto, em nosso cubo, os planos X e Z são representados por pinos de LED, enquanto o Y é mapeado diretamente para os planos do catodo. Para facilitar o trabalho com essas coordenadas e descobrir o movimento em torno do cubo, criei um novo tipo de dados (usando struct) para representar um único ponto no cubo - que chamei de “xyz”. Consiste em apenas dois inteiros: “xz” e “y”. Com essa estrutura, eu também poderia representar uma direção, indicada abaixo em nosso sistema de coordenadas especial (xz, y):
Movimento Y (para cima, para baixo) : (xz, y + 1), (xz, y-1)
Movimento Z (para frente, para trás) : (xz-1, y), (xz + 1, y)
Movimento X (esquerda, direita) : (xz + 4, y), (xz-4, y)
Por exemplo, para mover o LED na posição (0, 0) um para a esquerda, aplicamos (xz + 4, y) e terminamos com (0, 4) .
Existem certos limites que são colocados no movimento - a saber, que as coordenadas Y só podem ser 0 a 3 possíveis (0 sendo a camada inferior, 3 sendo o topo) e as coordenadas XZ podem ser apenas 0 a 15 . Um limite adicional é colocado no movimento Z para evitar “saltar” da parte de trás para a frente do cubo e vice-versa. Neste caso, usamos a função de módulo para testar múltiplos de 4 e negar essa tentativa de movimento. Essa é a lógica representada na função valid (), que retorna um verdadeiro se a direção proposta for aceitável e falsa de outra forma. Eu adicionei uma função adicional para verificar uma direção inversa - isto é, se a cobra está indo em uma direção, nós não queremos que ela volte para trás em si mesma, mesmo que seja de outra forma um local válido para mover - e função move (), que pega uma coordenada, uma direção e retorna a nova coordenada.
As funções de tipo de dados XYZ, válido (), move () e inverso () podem ser encontradas no arquivo xyz.h nos downloads. Se você está se perguntando por que isso foi colocado em um arquivo separado em vez do arquivo de programa principal, é devido a algumas complicadas regras de compilador do Arduino que impedem que as funções retornem tipos de dados personalizados ; eles devem ser colocados em seu próprio arquivo e, em seguida, importados no início do arquivo principal.
De volta ao arquivo principal de tempo de execução, uma série de direções armazena todos os movimentos possíveis que a serpente pode fazer; podemos simplesmente escolher um membro aleatório para obter uma nova direção. Variáveis também são criadas para armazenar a localização atual (agora), a direção anterior e o local anterior. O resto do código deve ser bastante óbvio para você; apenas para fazer loops e ligar e desligar os LEDs. No loop principal, nós verificamos se a direção proposta é válida, e se formos, então, nós seguiremos esse caminho. Se não, escolhemos uma nova direção.
A única coisa a destacar no loop principal são algumas verificações para corrigir um bug que eu encontrei envolvendo multiplexação: se o novo local estava no mesmo plano de cátodo ou mesmo pino de ânodo, desligar o LED anterior resultaria em ambos saírem. É também neste ponto que eu percebi que ir além de uma cobra de 2 segmentos seria impossível com a minha implementação atual: tente acender 3 LEDs em um arranjo de canto. Você não pode, porque com 2 camadas e 2 pinos LEDs ativados, 4 LEDs ligariam, não 3. Este é um problema inerente ao nosso projeto de cubo multiplexado limitado, mas não se preocupe: nós simplesmente precisamos usar o poder da persistência de visão para reescrever o método de desenho.
Persistência de visão significa que quando a luz atinge nossos olhos sequencialmente - mais rápido do que podemos processá-la - parece ser uma única imagem. No nosso caso, em vez de desenhar todas as quatro camadas ao mesmo tempo, devemos desenhar a primeira, desativá-la, desenhar a segunda e desativá-la: mais rápido do que podemos dizer que qualquer alteração está acontecendo. Este é o princípio pelo qual os redatores de mensagens trabalham, como este:
Novo método de desenho usando a persistência da visão
Primeiro, então, uma nova rotina de sorteio. Eu criei uma matriz bidimensional de bits de 4 x 16 (true ou false) para ser uma representação literal do estado do cubo de LED. A rotina de desenho implementará a persistência da visão simplesmente iterando sobre isso e liberando cada camada para o cubo por um breve momento. Ele continuará se desenhando no estado atual até que o tempo de atualização tenha decorrido, quando então passaremos o controle de volta ao loop principal (). Eu salvei esta seção do código neste arquivo LED_cube_POV, então se você quer simplesmente pular para programar seus próprios jogos e tal, então sinta-se livre para usar isso como uma base.
App 2: Jogo da Vida
Por enquanto, vamos desenvolver isso em uma versão básica do Game Of Life de Conway. Para aqueles de vocês que não estão familiarizados (tente usar o Google para encontrar uma fantástica animação de ovos de páscoa), o Game of Life é um exemplo de autômatos celulares que criam um padrão fascinante de comportamento emergente, dado apenas algumas regras simples.
http://www.youtube.com/watch?v=XcuBvj0pw-E
Isto é, por exemplo, como as formigas parecem se mover com inteligência e mente colmeia, apesar do fato biológico de que elas realmente seguem apenas regras hormonais básicas. Aqui está o código completo para download: pressione o botão reset para reiniciar. Se você estiver recebendo o mesmo padrão várias vezes, tente manter pressionado o botão de descanso por mais tempo.
http://www.youtube.com/watch?v=iBnL8pulJ
Aqui estão as regras do Jogo da Vida:
- Qualquer célula viva com menos de dois vizinhos vivos morre, como se causada por subpopulação.
- Qualquer célula viva com dois ou três vizinhos vivos vive para a próxima geração.
- Qualquer célula viva com mais de três vizinhos vivos morre, como se estivesse em superlotação.
- Qualquer célula morta com exatamente três vizinhos vivos torna-se uma célula viva, como se fosse reproduzida.
Execute o código. Você notará dentro de 5 a 10 “gerações”, os autômatos provavelmente terão que descansar, estabilizando em uma certa posição; às vezes, esse padrão estável mudará de local e mudará para o quadro. Em casos raros, eles podem até ter morrido completamente. Esta é uma limitação de ter apenas LEDs 4x4x4 para trabalhar, mas é um bom exercício de aprendizagem de qualquer maneira.
Para explicar o código:
- Você pode não estar familiarizado com a função memcpy () . Eu usei isso para salvar o estado do jogo anterior, como matrizes não podem ser atribuídas apenas como variáveis normais - você tem que realmente copiar através do espaço de memória (neste caso, 64 bits).
- A função howManyNeighbours () deve ser autoexplicativa, mas caso não seja - esse método usa uma única coordenada e percorre cada vizinho possível (a mesma matriz de direções que usamos anteriormente no aplicativo snake), para verificar se elas são válidas . Em seguida, ele verifica se esses LEDs vizinhos estavam "ligados" no estado de jogo anterior e conta quantos há.
- A principal função deste aplicativo Game of Life é o progressGame (), que aplica as regras dos autômatos ao estado atual do jogo.
Melhorias : Eu passei muito tempo nisso até agora, mas você pode querer tentar adicionar em uma verificação que automaticamente redefine a placa após 5 ou mais gerações do mesmo padrão. então por favor me avise! Eu também sugiro tentar adicionar a metodologia POV ao jogo da cobra para, com sorte, tornar possível uma cobra mais longa.
É isso de mim hoje. Eu posso revisitar mais alguns aplicativos de cubo LED Arduino em um momento posterior, mas espero que você esteja em condições de modificar meu código e criar suas próprias regras de jogo: deixe-nos saber o que você faz nos comentários, para que todos possamos baixar suas criações! Como sempre, estarei aqui para responder suas perguntas e defender minhas horrendas habilidades de codificação.
Crédito da imagem: coordenadas cartesianas - usuário Wikimedia Sakurambo