Olá!

Estou planejando construir uma maquina de pinball, e no momento planejo implementar dois displays para mostrar a pontuação adquirida pelo jogador e outro pra mostrar frases como por exemplo: game over, bônus, bola perdida... etc.

O display dos pontos será Display 8 Dígitos Max7219 Led 7 Segmentos. Para mostrar as frases vou usar dez unidades do  Display Matriz Led Verm 3mm 8x8 Com Chip Max7219 assim posso adicionar alguns efeitos.

Planejareis os efeitos de texto em outro momento.

Agora preciso encontrar um meio de armazenar a pontuação do jogador, mostrando a mesma no display de 8 digitos. A ideia é espalhar pela area da pinball alguns alvos e quando for atingidos pela bolinha, os ponto serão exibidos no display.

Exibir os pontos no display não parece problema.

Gostaria mesmo que eles fossem somados. A bolinha acertou o alvo 100 o display mostra 100 e quando ela atingir o alvo 50 o mostrador deverá mostrar 150 e assim sucessivamente somando os valores de cada alvo.

Estou usando o arduino mega.

Um abraço a todos!

Exibições: 1600

Responder esta

Respostas a este tópico

Amigo,  isso é o básico do basico. É elementar. Se vc der conta de programar um sketch pro arduino,  tenho certeza que essa tarefa de somar pontos será insignificante,  daria muito menos trabalho do que fazer exibir mensagens nos displays que vc pretende usar. 

Nem vou me atrever a responder como se faz a soma de pontos. Considere um desafio pessoal e tente aprender a fazer,  buscando no google por exemplo,  mas sem perguntar como faz. Mas se vc não der conta de fazer nem ao menos isso, talvez vc deva reconsiderar esse projeto,  talvez tentando fazer algo mais simples de início 

Flávio, vou tentar te ajudar de uma forma que você mesmo possa encontrar uma solução pra seu problema, pois é você quem deverá percorrer o seu caminho.

Sugiro que comece a fazer um esquema lógico do seu pimball (fluxograma).

Crie uma variável para acumular os pontos do jogador (acumulador) que tenha capacidade de comportar o maior número mostrado pelo display, no caso como disse que serão 8 digitos:

00.000.000 a 99.999.999

Portanto use preferencialmente um unsigned long que ocupa 4 bytes e pode acumular de 0 a 4.294.967.295 (2^32 - 1).

unsigned long pontos = 0;

Existem outras variáveis que comportam esta gama de valores, todas ocupam os mesmos 4 bytes mas tem outras peculiaridades:

O long pode acumular de -2,147,483,648 to 2,147,483,647.

O float  pode acumular de -3.4028235E+38 a 3.4028235E+38mas se não for acrescentar pontos em decimais não gaste memória e tempo de processamento com um float.

No loop faça a varredura das entradas que são ligadas aos alvos, e caso eles sejam acionados incremente (some) na variável de pontuação do jogador o valor atribuído ao alvo atingido.

if (x=1) pontos = pontos + 50;

Lógico que vai ter que fazer todo o tratamento das entradas, para evitar a contagem múltipla de pontos em uma única batida no alvo. Assim como a contagem e controle dos créditos, sequências especiais de acionamento dos alvos, recordes e outras possibilidades.

Abraço.

 

 

Olá...

Estudei um pouquinho... tenho noções do que seja um fluxograma e desenhei esse que compartilho com os colegas.

Preciso aprender mais a respeito de variáveis e conseguirei acumular e mostrar os pontos do jogador em minha máquina pinball.

Agradeço aos colegas  imhugo e Wiechert pelas contribuição. Obrigado por acompanhar e pelas respostas rápidas!

Oi pessoal,

estou tentando escrever o código, observei alguns códigos usando esse display de 8 dígitos e pelo que pude aprender atá agora, cheguei ao seguinte código....

Ahh.... ele tá cheio de falhas eu sei. Por isso espero qe os senores possam me apontar os caminhos para que possa torná-lo funcional. Um forte abraço!

segue o código:

/*
■===================================■
| Sistemas de pontos PinBall |
■===================================■
Sistema que mostrará os pontos acumulados por
uma jogador em uma mesa de Pinball

■===================================■
| Flavio da Silva Ribeiro |
■===================================■
*/
//------------------------------------
// Carrega a biblioteca LedControl
//------------------------------------
#include <LedControl.h>
//------------------------------------
LedControl lc=LedControl (20,21,22,1) // Definicoes dos pinos e quantidade de modulos no circuito
//------------------------------------
//Declara os portos de entradas e saídas
//------------------------------------
int alvo1 = 2; //Pino onde se encontra o botão, entrada
int alvo2 = 3; //Pino onde se encontra o botão, entrada
int alvo3 = 4; //Pino onde se encontra o botão, entrada
int alvo4 = 5; //Pino onde se encontra o botão, entrada
int alvo5 = 6; //Pino onde se encontra o botão, entrada
int alvo6 = 7; //Pino onde se encontra o botão, entrada
int alvo7 = 8; //Pino onde se encontra o botão, entrada
int alvo8 = 9; //Pino onde se encontra o botão, entrada
int alvo9 = 10; //Pino onde se encontra o botão, entrada
int alvo10 = 11; //Pino onde se encontra o botão, entrada
//------------------------------------
//Função principal
//------------------------------------
void setup()
{
pinMode(alvo1, INPUT); // Configura a entrada 50 pontos
pinMode(alvo2, INPUT); // Configura a entrada 50 pontos
pinMode(alvo3, INPUT); // Configura a entrada 50 pontos
pinMode(alvo4, INPUT); // Configura a entrada 100 pontos
pinMode(alvo5, INPUT); // Configura a entrada 100 pontos
pinMode(alvo6, INPUT); // Configura a entrada 500 pontos
pinMode(alvo7, INPUT); // Configura a entrada 10 pontos
pinMode(alvo8, INPUT); // Configura a entrada 200 pontos
pinMode(alvo9, INPUT); // Configura a entrada 300 pontos
pinMode(alvo10, INPUT); // Configura a entrada 400 pontos

void setup()
{
lc.shutdown(0,false); // Inicializa o modulo
lc.setIntensity(0,8); // Ajuste do brilho do display (0 min, 15 max)
lc.clearDisplay(0); // Apaga o display
}

}
//------------------------------------
//Função cíclica
//------------------------------------
void loop()
{
unsigned long pontos = 0
{
printNumber(pontos); // Envia 0 (zero) para o display

}
delay(500);
if (alvo1, HIGH) pontos = pontos + 50
if (alvo2, HIGH) pontos = pontos + 50
if (alvo3, HIGH) pontos = pontos + 50
if (alvo4, HIGH) pontos = pontos + 100
if (alvo5, HIGH) pontos = pontos + 100
if (alvo6, HIGH) pontos = pontos + 500
if (alvo7, HIGH) pontos = pontos + 10
if (alvo8, HIGH) pontos = pontos + 200
if (alvo9, HIGH) pontos = pontos + 300
if (alvo10, HIGH) pontos = pontos + 400
}
void printNumber(unsigned long pontos)
{
}

amigo, já que está começando, comece pequeno.

Mande exibir os valores no monitor serial e use apenas um botão (alvo). Cada vez que vc aperta o botão, faça incrementar a pontuação que é exibida no serial monitor.

Depois que vc aprender a montar esse sketch simples, isto é, aprender a escrever os códigos corretamente (usando ponto e vírgula no final de cada linha, por exemplo), aí sim vc estará pronto pra dar mais um passo, como por exemplo incluir um segundo botão que lhe forneça uma pontuação diferente. E depois vc parte pro aprendizado de manipulação de displays de led.

Perceba que o aprendizado deve ocorrer de degrau em degrau. Se vc se recusar a fazer isso e já quiser partir pro projeto final logo de cara, vc deixará de aprender etapas importantes no processo.

Vai por mim, amigo. Pega as vídeo aulas do laboratório de garagem (aquelas apresentadas pelo Maurício Ortega) e vai aprendendo as coisas aula por aula.

Já se vc for uma daquelas pessoas que gostam de ter tudo mastigado, esperando que as pessoas façam os códigos pra vc, esqueça o que eu estou sugerindo. Nesse caso, acredito também que existam colegas aqui dispostos a fazer os códigos pra vc, sempre prontos a dar as coisas mastigadas.

Oi  imhugo,

mais uma vez obrigado pela atenção. Você descreveu dois tipos de usuários do fórum: aquele que só se interessa por códigos prontos e não se esforça para aprender e um segundo tipo que analisa as sugestões e procura assimilar e se apropriar dos conteúdos construindo seus próprios códigos.

Seguramente acredito que me situo no segundo grupo. Reconheço minha ignorância em programação e isso está muito claro. Mas essas linhas são um avanço considerando que fiz tudo isso com base em informações de outros códigos sem copiar códigos inteiros.

Quando publiquei o código aqui, o fiz na esperança dos amigos ir sugerindo correções, assim como você citou a ausência do ponto e virgula no final de cada linha.

suas sugestões são muito importantes desde as primeiras no primeiro tópico. Vamos ver no que dá.

Um abraço a todos!

 

Oi,

Como prometi estudei muito aprendi pouco, perguntei bastante no chat aqui do Lab e com a ajuda do amigos em especial o amigo RENATO FALARZ que me ajudou muito no código tirando minhas duvidas desde as mais bobas.

Segui o conselho do pessoal e estou fazendo experiencias como Monitor Serial.

Esse foi o melhor resultado até agora:

#define botao 2
boolean botao_pressionado = false;
int contador_botao;
int contagem;

void setup()
{
Serial.begin(9600);
pinMode(botao,INPUT);
digitalWrite(botao,HIGH);
}

void loop()
{
if(digitalRead(botao) == 0 && botao_pressionado == false){ contagem++; botao_pressionado = true;
Serial.print("valor da contagem: ");
Serial.print(contagem);
}
if(botao_pressionado == true){ contador_botao++;
}
if(contador_botao >= 9000){ botao_pressionado = false; contador_botao = 0;
}
}

1) qual sua intenção ao colocar  no sketch a variável "contador_botao"?

2) vc por acaso não presenciou um fenômeno onde, ao pressionar o botão, a contagem ocorre mais vezes além do que deveria ocorrer? Se sim, pesquise sobre a técnica de "debounce"

Acabei de fazer ua leitura muito esclarecedora a respeito de:

Programação Arduino: Configuração de Botão e Debounce

sendo assim vou repassar o link para que outros possam fazer também essa leitura!

Arduino ideias

Um abraço!

RSS

© 2024   Criado por Marcelo Rodrigues.   Ativado por

Badges  |  Relatar um incidente  |  Termos de serviço