Mesa de pebolim Raspberry Pi IoT: 11 etapas

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

Bem-vindo à minha versão de uma mesa de pebolim hackeada, como parte de um projeto de estudante para novas tecnologias de mídia e comunicação. Eu basicamente cresci em torno de mesas de pebolim e sinuca, então achei que seria ótimo tentar conectar um desses dispositivos à internet.

A configuração principal é usar uma mesa de pebolim existente conectada a um Raspberry Pi que pode fazer todas as seguintes tarefas:

• Usa pinos GPIO para conduzir os LEDs / receptores IR e os módulos matriciais 8x8
• Executa um site do Flask usando nginx
• Executa um banco de dados MySQL / MariaDB para armazenamento de dados

Para ser capaz de recriar este projeto, você precisará das seguintes habilidades:

Processo interno:

• Noções básicas sobre HTML / CSS / Javascript para o cliente do site
• Noções básicas sobre Python com Flask / Flask-SocketIO / Jinja2 para o lado do servidor do site
• Conhecimento básico de MySQL
• Saiba como executar um servidor web

Protótipo

• Conhecimento básico de como fazer a fiação de um circuito elétrico
• De solda
• Noções básicas sobre como escrever um script em Python
• Trabalhando com Linux (Raspbian)
• Ter muita paciência porque haverá muita depuração envolvida

Etapa 1: os materiais

Aqui está a lista com todas as peças necessárias para a mesa:

• Raspberry Pi Modelo 3 (com revestimento)
• T-Cobbler para conectar o Pi à placa de ensaio
• Mesa de pebolim (usei uma mesa muito antiga semelhante a esta. Devo estar disposto a fazer furos nela)
• MAX7219 Módulo Matrix de pontos Arduino (2)
• Emissores de LED IV (2+ porque quebram, semelhante a este)
• Receptores IR (2+ porque eles também quebram, semelhantes a este)
• Placa de ensaio básica sem solda
• Muitos e muitos fios (depende do tamanho da mesa de pebolim)
• conectores machos (30+)
• conectores fêmeas (10+)
• Resistores de 100-220 Ohms (4+)
• materiais de solda
• tiras de arame
• Suportes de LED
• alguma madeira / parafusos no caso de você querer retransmitir a bola na sarjeta

O custo total deste projeto depende inteiramente do custo de sua mesa de pebolim (caro). Para além da mesa os materiais custam no máximo 150 euros.

Etapa 2: o circuito elétrico

Antes de tentar soldar, monte todos os componentes que eu recomendo testar primeiro em uma placa de ensaio. É mais fácil substituir componentes com defeito antes de passar horas soldando-os.

No início eu tentei implementar a matriz de LED 8x8 com um registrador de deslocamento 74HC595 (primeira imagem) e matriz de transistores, mas devido aos muitos fios e saída muito baixa, mudei para o módulo matricial de pontos MAX7219 porque leva apenas 5 fios e é diretamente acionado por um ônibus SPI.

O circuito que usei foi desenhado com Fritzing. Observe que os LEDS IR e receptores podem ser conectados a qualquer um de seus pinos GPIO gratuitos.

Os receptores IR e o LED devem estar diretamente um em frente ao outro e a parte superior do LED deve estar apontada para o receptor. Porque queremos simular um feixe direto que pode ser quebrado pelo movimento da bola, caso em que haverá uma mudança de estado da linha DATA do receptor de 0 para 1.

Etapa 3: Codificando os Sensores

Eu codifiquei a maior parte deste projeto usando o Pycharm porque ele permite uma implantação fácil de SSH em seu Raspberry Pi usando um interpretador remoto. Não vou entrar em detalhes sobre como esse programa funciona, mas muitas informações podem ser encontradas no site do pycharm.

Ainda estou trabalhando no projeto, mas assim que tudo estiver feito, o projeto inteiro estará disponível no meu perfil do github

O código para os sensores consiste em 3 classes que são executadas em um thread de segundo plano no meu servidor Flask (que será explicado mais tarde):

1. A classe do objetivo (link) - Este arquivo inicia todos os componentes separados, que podem ser chamados inserindo o dispositivo / barramento SPI correto e o número do pin
2. A Classe Matrix (link) - Esta é a classe principal para ligar o módulo MAX7219
3. O LED e a classe do receptor (link) - Esta é a classe principal para ligar o feixe de infravermelho usando Threads separados para reduzir a carga da CPU do RPi

O LED e o receptor funcionam em uma frequência de 38kHz e os receptores sempre esperam um pulso de 50% para cima e 50% para baixo para funcionar corretamente.

Etapa 4: Preparando e Colocando os Sensores

Agora vamos preparar o LED IR e o receptor. Na imagem da tabela você pode encontrar os locais onde o RPi e os sensores devem ser colocados.

Mas primeiro precisamos preparar a fiação:

1. Certifique-se de medir a quantidade de fio necessária do RPi / localização da placa de ensaio até a localização do sensor
2. Solde os pinos do receptor IR em uma extremidade do fio (COM / GND / V +)
3. Solde as peças do conector macho na outra extremidade do fio

Agora vamos preparar a mesa:

1. Faça um desenho básico (com base na imagem) sobre onde perfurar. É muito importante que os 2 orifícios estejam alinhados um ao outro, pois esta será a localização do feixe.
2. Faça os furos
3. Se você tiver alguns suportes de LED (link), você pode colocá-los dentro do orifício para torná-lo mais resistente
4. Insira + fita o LED + receptor em ambos os lados
5. Amarre os fios + prenda-os na madeira para que não se cruzem muito
6. Insira os pinos machos na placa de ensaio de acordo com o circuito fornecido anteriormente

Etapa 5: preparação e colocação do módulo de matriz

Em seguida, vamos conectar os 2 módulos de matriz de LED

Observação:

Como usei uma velha mesa de pebolim, já havia buracos subindo em direção à parte superior por causa das piteiras. Se você não tiver esses, você precisará criá-los.

Para preparar os fios:

1. Meça o fio da placa de ensaio em direção à parte superior da mesa
2. Solde alguns conectores fêmeas na primeira extremidade do fio
3. Solde alguns conectores machos na outra extremidade do fio

Colocando a matriz:

1. Traga a matriz através do orifício no topo
2. Amarre + prenda os fios dentro da madeira para evitar que se cruzem
3. Insira os pinos machos na placa de ensaio de acordo com o circuito fornecido anteriormente

Em algum ponto, irei adicionar um pequeno passo DIY para adicionar um invólucro para o módulo de matriz, mas por enquanto eles estão nus.

Etapa 6: Tornando-se IoT

Se você deseja apenas se registrar e exibir as pontuações, pode terminar o projeto escrevendo um pequeno script python em execução que executa um loop até que uma das pontuações chegue a 9 e é reiniciado.

No entanto, se você deseja conectar sua mesa à Internet, as próximas etapas devem ser úteis.

Nas próximas etapas, abordaremos o seguinte:

• Configurando o Raspberry Pi
• Fazendo um banco de dados para armazenamento
• Criação do site
• Colocando online

Neste ponto, se você estiver familiarizado com o git, recomendo fazer um repositório no GitHub / GitLab para manter o controle de seus arquivos. Caso contrário, você pode criar uma pasta com a mesma estrutura da imagem.

O projeto completo estará disponível em breve no GitHub. No entanto, um arquivo rar temporário com todos os arquivos necessários está disponível.

Etapa 7: conectando o Raspberry Pi

Em seguida, vamos configurar o ambiente raspberry pi, para fazer isso você precisa executar as seguintes etapas:

• Conecte-se por SSH ao seu Rasberry Pi (você pode usar PuTTY)
• Crie uma pasta (exemplo de projeto mkdir) e mova para esta pasta usando o comando cd
• Crie um ambiente Python virtual nesta pasta usando o comando python3 -m venv --system-site-packages env
• Ative o intérprete virtual com o comando source / env / bin / activate
• Instale os pacotes de requirements.txt com o comando python -m pip install package-name
• Transfira os arquivos do arquivo project_example.rar fornecido anteriormente por SSH na pasta do seu projeto

Agora você deve ser capaz de executar o projeto completo em seu Raspberry Pi. Aconselho você a usar um IDE Python como o PyCharm, que permite que você use você para depurar do seu interpretador remoto através de SSH e carregar diretamente as alterações, se necessário.

Etapa 8: Configurando o banco de dados

Agora você precisa configurar um banco de dados muito básico, baseado neste modelo.

A maneira mais fácil de fazer isso é criar seu banco de dados no ambiente de trabalho MySQL, onde você também pode fazer alguns testes.

Uma vez feito isso, você pode exportar um dump de seu banco de dados e carregá-lo em seu RPi e, em seguida, executá-lo com sudo mariadb <pathtofile / file.sql

Etapa 9: Criação do site

Em seguida, você pode analisar (e usar) o código fornecido no arquivo project_example.rar.

O arquivo principal é o Flask.py que é o pão com manteiga deste projeto:

• Executa um aplicativo Flask-SocketIO que lida com o back-end do site
• Cria uma conexão entre o banco de dados e o Flask
• Fornece validação de login e registro de usuário
• Fornece o código necessário sobre como jogar um jogo usa socketio para atualizar o site em tempo real durante o jogo
• Coloca os resultados do jogo no banco de dados

Nas pastas estáticas e templates, você pode encontrar o HTML / CSS / JS que fornece a parte de frontend do site. Sinta-se à vontade para modificá-los de acordo com suas preferências.

Etapa 10: Conectando-se à World Wide Web

Para conectar nosso site à web, usaremos nginx e uwsgi. No exemplo do projeto, você pode encontrar os arquivos necessários na pasta conf.

Em primeiro lugar, você precisa atualizar o seguinte nestes arquivos:

• No uwsgi-flask.ini, você precisa alterar o caminho do parâmetro virtualenv para o seu interpretador
• No project1-flask.service, você precisa atualizar a parte [Service] do arquivo com suas credenciais e caminhos para os arquivos associados
• No arquivo nginx, você precisa atualizar o servidor e a localização / caminho para o soquete associado

Em seguida, você precisa substituir o arquivo nginx webserver padrão com a localização do seu arquivo de configuração nginx, abaixo está um exemplo de comandos do Linux para fazer isso

• me @ my-rpi: ~ / project1 $ sudo cp conf / nginx / etc / nginx / sites-available / project1
• me @ my-rpi: ~ / project1 $ sudo rm / etc / nginx / sites-enabled / defaul t
• me @ my-rpi: ~ / project1 $ sudo ln -s / etc / nginx / sites-available / project1 / etc / nginx / sites-enabled / project1
• me @ my-rpi: ~ / project1 $ sudo systemctl restart nginx.service

Finalmente, você precisa adicionar os serviços personalizados à pasta systemd, este é um exemplo de como fazer isso:

• me @ my-rpi: ~ / project1 $ sudo cp conf / project1 - *. service / etc / systemd / system /
• me @ my-rpi: ~ / project1 $ sudo systemctl daemon-reload
• me @ my-rpi: ~ / project1 $ sudo systemctl start project1- *
• me @ my-rpi: ~ / project1 $ sudo systemctl status project1- *

Se você quiser que o servidor web inicie na inicialização do seu raspberry pi, você precisará usar o comando sudo systemctl enable project1 - *. Service.

Se feito corretamente, após a reinicialização do sistema, seu site deve estar sendo executado no seu endereço IP. Se você quiser editar um desses arquivos de configuração, você sempre precisa parar o serviço, recarregar os arquivos e usar o comando daemon-reload seguido de um start, caso contrário, as alterações não terão efeito.

Etapa 11: Concluindo

Enquanto digita a parte final deste instrutível, este pequeno projeto escolar ainda é um trabalho em andamento.

Passei incontáveis horas fazendo isso em 2,5 semanas. Apesar de tudo ter corrido um pouco, ainda estou orgulhoso do que conquistei. Durante a fase de montagem, encontrei inúmeros bugs / erros / sensores com falha, então não desanime se tudo não estiver funcionando na primeira tentativa.

A melhor coisa que você pode fazer é pedir ou procurar ajuda na internet, há muitas pessoas com muito mais conhecimento que estão ansiosas para ajudá-lo.

Por último, mas não menos importante, gostaria de agradecer aos meus professores da New Media and Communication Technology por me darem muitos conselhos e me ajudarem a terminar este projeto.