Números Aleatórios e Arduino: Simulador de Mega Sena

Introdução

A mega da virada passou, assim como o ano de 2020, e acredito que infelizmente você não foi um dos vencedores (#chateado). E que tal se o Arduino pudesse te ajudar nessa missão de gerar números para, quem sabe, você vir ser um dos premiados?

Hoje iremos aprender um pouco mais sobre como gerar números aleatórios e como aprender isto pode nos ajudar a criar projetos bastante legais, como este simulador de números da Mega Sena, que você poderá utilizar caso deseje fazer aquela aposta e não tem muita criatividade na hora de compor os números.

Como um conhecimento adicional, neste tutorial você aprenderá como criar caracteres personalizados para um display LCD, que poderá fazer com que seu projeto tenha um charme a mais.

Primeiro começaremos discutindo um pouco sobre a diferença de um número aleatório para um número pseudo aleatório.

Número aleatório e Pseudoaleatório

Pense você por um instante em como gerar um número aleatório escrevendo um programa no Arduino? (Após pensar continue lendo abaixo)

Provavelmente a solução que você deve pensou envolve o tempo, mas aqui usaremos algo bem mais simples: as portas analógicas.

Você já experimentou fazer a leitura de uma porta analógica sem que nada esteja conectada a ela? Provavelmente o que você viu algo como na imagem abaixo:

Isto basicamente é o ruído captado, que é completamente aleatório. sendo assim, uma boa forma de criar uma função de gerar números aleatórios com o Arduino é utilizar esses dados aleatórios de ruído para gerar os números aleatórios.

Por sorte, a biblioteca principal da Arduino IDE já implementou uma função para gerar números aleatório, e essa função é a random(), onde você pode passar um ou dois parâmetros. Caso você passe um parâmetro, você estará limitando os números pseudo-aleatórios de zero até o limite máximo que você passou no parâmetro. Quando você passa dois parametros, você está escolhendo o limite inferior e superior para que a função sempre passe valores entre os dois valores.

Eu disse que está gerando números pseudo-aleatórios é que se você utilizar a função random() sozinha não irá funcionar corretamente, porque ela irá gerar em toda execução os mesmos números, porque não indicamos de onde iremos tirar a aleatorização.

Para indicar de onde iremos utilizar a aleatorização, esta função é a randomSeed(). Esta função basicamente embaralha os números da função random(), e faz com que os números que eram pseudo-aleatórios passem a ser aleatórios.

Como ordenar estes números aleatórios recebidos?

Talvez você nunca precisou lidar com ordenação de dados, mas esse é um estudo muito importante na ciência da computação e surgiram vários métodos para realizar um ordenamento.

Neste exemplo de hoje iremos ordenar apenas 6 números recebidos, desta forma, o método escolhido não fará muita diferença no sentido de eficiência computacional, mas saber dominar os métodos de ordenamento é bastante importante para implementar sistemas grandes.

Pense na sua loja online preferida (Eletrogate), ao você pesquisar por exemplo: “Sensor”, você verá que existem mais de 469 resultados, e possível ordenar de várias formas.

Como ordem alfabética, mais recentes, mais vendidos, etc.

E se o seu método de ordenamento for ruim? Mal implementado? Isso fará com que haja uma demora excessiva na ordenação, e talvez isso faça com que prejudique a qualidade do seu site.

Pense agora em um sistema como o Google, que em uma pesquisa busca até 153 mil resultados que podem ser ordenados. Neste caso, o algoritmo de ordenamento será crucial.

Para entender um pouco sobre métodos de ordenação, uma excelente introdução ao assunto pode ser vista aqui (clique).

Como usaremos apenas 6 números, o método adotado será o de Inserção.

Entender o método de ordenação por inserção é algo bem simples. Ele é um método onde você inicia em uma das pontas do vetor de números (conjunto de números), e ele faz a ordenação como fazemos com cartas de baralho. A idéia é partir de que o primeiro elemento já está ordenado, e partimos dele. Sendo assim, todos os demais elementos serão inseridos em relação aos elementos já ordenados.

Para entender melhor, deixo aqui um vídeo divertido que explica muito bem este método.

Basicamente ele sempre ordena da esquerda para direita, onde, ele pega o próximo elemento do vetor ordenado e o ordena dentro deste vetor comparando um a um se é maior. Após a inserção, ele vai para o próximo elemento e assim o faz até o vetor estar completamente ordenado.

Assim, quando conseguirmos gerar os 6 números, basta colocar neste algoritmo para ele realizar a ordenação.

Materiais Necessários para o Projeto Números Aleatórios e Arduino: Simulador de Mega Sena

Para fazer este novo tutorial iremos precisar de apenas:

• 1x Uno R3 + Cabo Usb Para Arduino
• 1x Display LCD 20×4 com Backlight Azul com I2C
• 1x Jumpers – Macho/Femea – 20 Unidades de 20cm

Executando o Projeto

Para deixar o projeto com uma cara muito bonita, iremos plotar o conhecido logo da Mega Sena na display.

Para fazer isto, iremos criar caracteres personalizados para o nosso Display.

O Arduino permite criarmos até 8 caracteres personalizados (limite máximo da plataforma) para o display. Para criar é bem simples, basta ir neste site aqui e desenhar o caractere, e ele já retorna o código Arduino.

Como exemplo, vou criar um coração.

https://maxpromer.github.io/LCD-Character-Creator/

Para fazer a logo, eu dividi a logo da mega sena em 8 caracteres que poderão ser criado, e guia para desenhar pode ser consultado aqui embaixo:

Caso queira criar essas imagens, basta pegar um desenho qualquer, levar até o Photoshop ou algum software de manipulação de imagem, e reduzir a imagem para 20×16 pixels.

Diagrama e código

Monte o diagrama abaixo e carregue o código para sua placa Arduino. Caso deseja, edite o código para ter um resultado diferente.

Para este exemplo precisaremos instalar a biblioteca LiquidCrystal I2C. Para isso, basta ir em “Ferramentas > Gerenciar bibliotecas”, e pesquisar por: “LiquidCrystal I2C” e instale a biblioteca do autor “Frank de Brabander”.

Eu estou utilizando a versão 1.1.2, caso dê algum erro, instale esta versão e teste.

O código a ser carregado é o código abaixo.

#include <LiquidCrystal_I2C.h> // Biblioteca do LCD I2C
#include <Wire.h>  // Biblioteca para ativar o I2C

#define QntdNum 6 // Quantidade de numeros sorteados

LiquidCrystal_I2C lcd(0x27,20,4); 

void setup() {
  randomSeed(analogRead(A0)); // Usando o pino A0 para embaralhar os numeros para ficarem aleatórios
  criaCaracteres(); // Chamando a função para criar os caracteres
  desenhaLogo(0,1); // Chamando a função para desenhar o logo com base na posição passada por parametro
  lcd.setCursor(6,1); // Setando o cursor para a posição para escrever a mensagem
  lcd.print("Simulador");
  lcd.setCursor(6,2);
  lcd.print("Mega Sena");
  desenhaLogo(16,1); // Chamando a função para desenhar o logo com base na posição passada por parametro
  Serial.begin(9600); // Inicia a comunicação serial para receber a informação também na comunicação serial.
  delay(4000); // Espera 4 segundos na tela inicial
  lcd.clear();
  Serial.println("Numeros da sorte: ");
  lcd.print(" Numeros da sorte: ");
  delay(50);
  
  
}

void loop() {
  int NumSorte[QntdNum], i = 0; // Inicia o vetor que irá receber os números aleatórios e uma variável para pular para o próximo espaço do vetor
  lcd.setCursor(1, 2);
  while (1) {
    do {
      NumSorte[i] = random(1, 60); // Recebe um numero aleatório no range definido.
    } while (VerificaRepetidos(NumSorte, i)); // Chama a função para verificar se existe numero repetido, e passa também quantos numeros existem no vetor
    //Caso o numero seja repetido, ele recebe outro numero e verifica de novo se é repetido, e repete até que não seja repetido.
    i++; // Pula para o próximo espaço do vetor.
    if (i == QntdNum) { // Verifica se o vetor está completo com a quantidade de numeros definidos
      insertionSort(NumSorte, QntdNum); //Chama a função para ordenar o vetor.
      for (int j = 0; j < QntdNum; j++) { // Imprime no LCD e serial cada numero individualmente separando por espaço
        Serial.print(NumSorte[j]);
        Serial.print(" ");
        lcd.print(NumSorte[j]);
        lcd.print(" ");
        delay(50);
      }
      Serial.println();   
      while(1){}; //Trava o programa
    }
  }
}



bool VerificaRepetidos(int* Numeros, int k) {  // Função que verifica se o número passado é repetido em relação aos outros
  for (int i = 0; i < k; i++) {
    if (Numeros[k] == Numeros[i]) return (true);
  }
  return (false);
}

void insertionSort(int arr[], int n) // O algoritmo de ordenação por inserção, que funciona como visto na vídeo.
{
  int aux, i, j;
  for (i = 1; i < n; i++) {
    aux = arr[i];
    j = i - 1;
    while (j >= 0 && arr[j] > aux) {
      arr[j + 1] = arr[j];
      j--;
    }
    arr[j + 1] = aux;
  }
}

void criaCaracteres(){ // Função que cria os caracteres com base nos desenhos que fizemos
  byte c1[] = {
  0x00,
  0x00,
  0x00,
  0x01,
  0x03,
  0x07,
  0x03,
  0x00
};
byte c2[] = {
  0x04,
  0x0E,
  0x0E,
  0x1E,
  0x1E,
  0x1E,
  0x1E,
  0x00
};
byte c3[] = {
  0x04,
  0x0E,
  0x0A,
  0x0B,
  0x0B,
  0x08,
  0x0F,
  0x00
};
byte c4[] = {
  0x00,
  0x00,
  0x00,
  0x10,
  0x1C,
  0x06,
  0x1C,
  0x00
};
byte c5[] = {
  0x00,
  0x03,
  0x06,
  0x03,
  0x00,
  0x00,
  0x00,
  0x00
};
byte c6[] = {
  0x00,
  0x1E,
  0x02,
  0x12,
  0x1A,
  0x0A,
  0x0E,
  0x00
};
byte c7[] = {
  0x00,
  0x0F,
  0x0F,
  0x0F,
  0x0F,
  0x0E,
  0x0E,
  0x04
};
byte c8[] = {
  0x00,
  0x18,
  0x1C,
  0x18,
  0x10,
  0x00,
  0x00,
  0x00
};
lcd.init();
  lcd.clear();
  lcd.backlight();
  lcd.createChar(0, c1);
  lcd.createChar(1, c2);
  lcd.createChar(2, c3);
  lcd.createChar(3, c4);
  lcd.createChar(4, c5);
  lcd.createChar(5, c6);
  lcd.createChar(6, c7);
  lcd.createChar(7, c8);
  
}

void desenhaLogo(int linha, int coluna){ // Função para desenhar a logo com base nos caracteres personalizados.
  lcd.setCursor(linha,coluna);
  lcd.write(0);
  lcd.write(1);
  lcd.write(2);
  lcd.write(3);
  lcd.setCursor(linha,coluna+1);
  lcd.write(4);
  lcd.write(5);
  lcd.write(6);
  lcd.write(7);
}

E o resultado obtido foi este abaixo:

Conclusão

Neste post aprendemos muitas coisas, que permitiram a gente criar um projeto legal. Hoje aprendemos a utilizar e criar números aleatórios, a como ordenar dados e como criar caracteres personalizados.

Você fez o seu simulador de números e talvez vai usar ele para fazer sua aposta? Tire uma foto e marque a gente no instagram @eletrogate , vai ser um prazer ver e interagir com você.

Gostou do post? Deixe sua avaliação.

Utilize a parte dos comentários para deixar dúvidas, sugestões e elogios.

Forte abraço e até a próxima!

Tenha a Metodologia Eletrogate na sua Escola! Conheça nosso Programa de Robótica Educacional.

Sobre o Autor

Gustavo Nery Cursando Engenharia de Controle e Automação pela UFMG. Apaixonado por eletrônica, computação e tecnologias na área de sistemas embarcados. Nos tempos livres me divido entre desenvolver pesquisa na universidade, adquirir novos conhecimentos e estar com a família.