Title: 16. Exemplos
Course: AI Projects for Students (PT) > Section: IA COM rPI 5

16. Exemplos

16.1     Construa o Seu Próprio Sistema de Segurança "Detetor Parental"

Visão Geral do Projeto: Alguma vez se perguntou quem entra sorrateiramente no seu quarto quando não está por perto? Neste projeto, irá construir um sistema de segurança inteligente — frequentemente chamado de "Detetor de Pais" — para descobrir exatamente quem esteve no seu quarto.

Conseguirás isto combinando um Raspberry Pi, um sensor de movimento e uma câmara para ativar e gravar automaticamente imagens de vídeo de quaisquer intrusos.

Passo 1: Reúne o Teu Hardware

Para construir esta câmara de segurança automatizada, será necessário três componentes principais de hardware:

·        Um Raspberry Pi: Este atua como o cérebro do seu projeto, processando os sinais e executando o código.

·        Um Sensor de Movimento Passivo por Infravermelhos (PIR): Este componente atua como os "olhos" do seu sistema, detetando alterações no calor infravermelho para detetar quando uma pessoa se aproxima.

·        Um Módulo de Câmara Raspberry Pi: Este é o dispositivo que capta as provas de vídeo do intruso.

Passo 2: Compreender e ajustar o sensor PIR

Antes de ligar qualquer coisa com fios, precisa de configurar as definições físicas do próprio sensor PIR. Se olhar para a parte de trás do módulo PIR, verá dois componentes laranja com pequenos soquetes em forma de cruz que encaixam perfeitamente numa chave de fendas Philips.

Estes mostradores laranja chamam-se potenciómetros e permitem-lhe ajustar manualmente o comportamento do sensor:

·        Sensibilidade: Determina quanto movimento é necessário para ativar o sensor.

·        Tempo (Atraso): Determina quanto tempo o sensor permanece "acionado" após detetar movimento antes de reiniciar.

Configuração Inicial: Para que este projeto funcione melhor, use a sua chave de fendas para definir o potenciômetro de sensibilidade ao máximo absoluto e o potenciômetro de tempo ao mínimo absoluto. Podes sempre ajustar e variar estas definições mais tarde se achares que o sensor está demasiado sensível ou fica ligado por muito tempo.

Passo 3: Ligue os componentes em segurança

Agora é altura de ligar o seu hardware ao Raspberry Pi. Regra Crucial: Certifique-se sempre de que o seu Raspberry Pi está completamente desligado e desligado antes de ligar o hardware.

1. Ligue a Câmara: Insira cuidadosamente o cabo de fita do Módulo de Câmara na porta dedicada da câmara do Raspberry Pi.

2. Ligue o Sensor PIR: O sensor PIR precisa de enviar os seus dados de movimento para o Raspberry Pi. Vais ligar o pino de saída de dados do sensor PIR diretamente ao pino rotulado GPIO 4 na tua placa Raspberry Pi. (Também terá de ligar os pinos de alimentação (VCC) e terra (GND) aos respetivos pinos de 5V e GND do Pi).

Passo 4: Escrever o Software de Segurança (Python)

Quando o seu hardware estiver ligado, ligue o seu Raspberry Pi. Abra o ambiente de programação chamado Thonny, crie um novo ficheiro e guarde-o imediatamente como parent_detector.py.

Para fazer o nosso hardware funcionar, precisamos de importar bibliotecas específicas. Vamos usar o MotionSensor da biblioteca gpiozero para gerir o sensor PIR e a classe Camera da biblioteca picamzero para controlar o Módulo Camera.

A Lógica do Código:

1. Monitorização Contínua: Usamos um ciclo while True:, que é um ciclo infinito que mantém o programa a verificar o movimento para sempre.

2. Espera por Ação: O programa usa pir.wait_for_motion() para pausar o código até que o sensor detete movimento. Assim que o movimento é detetado, imprime uma mensagem no ecrã.

3. Gravação: A câmara começa a captar vídeo usando a função cam.start_recording().

4. Parar: Não queremos gravar uma sala vazia para sempre. O código usa pir.wait_for_no_motion() para esperar que o intruso saia, e depois para o ficheiro de vídeo em segurança usando cam.stop_recording().

Resolver um Bug Crítico (O Problema de Sobrescrever): Se simplesmente dissermos à câmara para guardar o ficheiro como intruder.mp4, cada vez que uma nova pessoa entra na sala, o vídeo antigo será completamente sobrescrito e eliminado. Para garantir que mantemos um registo em vídeo de todos (pais ou irmãos irritantes), precisamos de um nome de ficheiro dinâmico. Podemos usar a biblioteca de tempo do Python para descobrir automaticamente a data e hora atuais e injetá-las no nome do ficheiro do vídeo.

Comece com este código e as suas ferramentas de IA favoritas para testar este código:

Escreve isto no teu ficheiro de parent_detector.py:

1. a partir da importação gpiozero do MotionSensor

 2. da câmara importada picamzero

 3. Tempo de importação

 4.

 5. # 1. Inicializar Hardware

 6. # Configurar o sensor PIR na GPIO 4

 7. pir = MotionSensor(4)

 8.

 9. # Criar um objeto Câmara para controlar o módulo

10. cam = Câmara()

11.

12. imprimir ("Sistema de Segurança Armado. À espera de intrusos...")

13.

14. # 2. Circuito Principal de Segurança

15. embora Verdadeiro:

16.     # O programa pausa aqui até ser detetado movimento

17.     pir.wait_for_motion()

18.     print("AVISO: Movimento detetado!")

19.

20.     # 3. Gerar um Nome de Ficheiro Único

21.     # Isto cria uma cadeia como "20231025-143000" (AnoMêsDia-HoraMinutoSegundo)

22. carimbo temporal = hora.strftime("%Y%m%d-%H%M%S")

23. nome do ficheiro = f"intruder_{timestamp}.mp4"

24.

25.     # Começar a gravar provas em vídeo no novo ficheiro

26. print(f"A gravar vídeo: {nome do ficheiro}")

27. cam.start_recording(nome do ficheiro)

28.

29.     # 4. Esperar que a sala volte a ficar vazia

30.     pir.wait_for_no_motion()

31. imprimir ("Movimento parado.")

32.

33.     # Parar a gravação para finalizar e guardar o ficheiro de vídeo em segurança

34.     cam.stop_recording()

35.     print("Sistema a regressar ao modo de espera.")

Agora que o seu código está totalmente escrito e o seu hardware está ligado de forma segura, é altura de testar se o detetor parental funciona realmente no mundo real! Primeiro, clique no botão Executar dentro do seu ambiente de programação Thonny para iniciar o script. Quando o programa estiver a funcionar e à espera, acene deliberadamente com a mão diretamente à frente do detetor de movimento PIR para simular um intruso a entrar na sala. Olhe imediatamente para o ecrã do seu computador; deve ver as palavras "Movimento detetado!" impressas na área da consola, confirmando que o sensor conseguiu ativar a câmara para iniciar a gravação.

Depois de acionar o alarme, é necessário testar o mecanismo de desligamento. Saia do campo de visão do sensor, mantenha-se completamente imóvel ou cubra suavemente a cúpula branca do sensor com a mão. Espere alguns segundos até que a consola lhe indique que o movimento parou e que o sistema está a regressar ao modo de espera. Isto indica que o programa finalizou e fechou o ficheiro de vídeo em segurança. Finalmente, abre o gestor de ficheiros do teu Raspberry Pi e navega até à mesma pasta onde guardaste o teu script de parent_detector.py . Agora deve ver um ficheiro de vídeo .mp4 novo à sua espera, com a data e hora únicas no nome, tal como programámos. Clique duas vezes neste ficheiro recém-criado para ver as provas gravadas, verificar a qualidade do vídeo e garantir que o ângulo da câmara capta perfeitamente a porta!

Fotos adicionais:

Fonte: https://www.electronicwings.com/raspberry-pi/pir-motion-sensor-interfacing-with-raspberry-pi

Fonte: https://thepihut.com/products/pir-camera-case-for-raspberry-pi-4-3

16.2   Reconhecimento de Estimativa de Postura YOLO

Neste guia, vamos configurar algumas com o OpenCV e a família de modelos de estimativa de pose YOLO no Raspberry Pi 5. Vamos analisar alguns dos diferentes modelos YOLO disponíveis, bem como otimizá-los para obter FPS mais suaves, e também como usar os dados de keypointpoints gerados pelo modelo para implementar a estimativa de pose no seu próximo projeto. Este tem sido um dos guias mais divertidos que fizemos nos últimos tempos, por isso vamos a isso!

Para acompanhar este guia, vai precisar de:

·        Raspberry Pi 5 - Um modelo de 4GB ou 8GB funciona aqui. Embora tecnicamente isto pudesse ser feito num Pi 4, é muito mais lento do que o Pi 5 e não seria uma experiência agradável, e por essas razões, não testámos num Pi 4

·        Pi Camera - Estamos a usar o Módulo de Câmara V3

·        Cabo Adaptador - O Pi 5 vem com um cabo de câmara CSI de tamanho diferente e a sua câmara pode vir com o mais antigo e mais grosso, por isso vale a pena confirmar. O Módulo da Câmara V3 VAI precisar de um

·        Solução de Arrefecimento - Estamos a usar o cooler ativo (a visão por computador vai realmente levar o teu Pi ao limite)

·        Fonte de Alimentação

·        Cartão Micro SD - Pelo menos 16GB de tamanho

·        Monitor e Cabo Micro-HDMI para HDMI

·        Rato e Teclado

Montagem de Hardware

Em termos de montagem de hardware, aqui é bastante leve. Liga o lado mais grosso do cabo à câmara e o lado mais fino ao Pi 5. Estes conectores têm uma aba – levanta-os e depois insere o cabo na ranhura. Quando estiver bem alinhado, empurra a aba para baixo para prender o cabo no lugar.

Fica atento, pois estes conectores só funcionam numa orientação e podem ser frágeis, por isso evita dobrá-los muito (um pouco é aceitável).

Instalação do Pi OS

Antes de mais, precisamos de instalar o Pi OS no cartão micro SD. Usando o Raspberry Pi Imager , selecione o Raspberry PI 5 como Dispositivo, o Raspberry Pi OS (64 bits) como sistema operativo e o seu cartão microSD como dispositivo de armazenamento.

O mesmo procedimento do PiRacer.

Configuração de um Ambiente Virtual e Instalação de Bibliotecas

Com a introdução do Bookworm OS em 2023, somos agora obrigados a usar Ambientes Virtuais (ou venv), pois são um espaço isolado no Pi onde podemos experimentar sem o risco de prejudicar o resto do nosso Pi OS ou projetos. Temos todos os comandos e instruções necessários neste guia.

Para criar um ambiente virtual, abra uma nova janela de terminal e digite:

python3 -m venv --system-site-packages yolo_pose

Depois de criar o venv, podemos entrar nele escrevendo:

fonte yolo_pose/bin/ativar

Depois disso, verá o nome no ambiente virtual à esquerda do texto verde – isto significa que estamos a trabalhar corretamente dentro dele. Se alguma vez precisares de voltar a entrar neste ambiente (por exemplo, se fechares a janela do terminal vais sair do ambiente), basta escreveres novamente o comando de origem acima.

Agora que trabalhamos num ambiente virtual, podemos começar a instalar os pacotes necessários. Primeiro, certifique-se de que o PIP (o gestor de pacotes Python) está atualizado, introduzindo as seguintes três linhas:

Atualização Sudo Apt

sudo apt install python3-pip -y

pip install -U pip

Depois instala o Pacote Ultralytics com:

Instalar Ultralytics[exportar]

O pessoal simpático da Ultralytics tem sido um dos principais desenvolvedores e mantenedores dos modelos YOLO mais recentes. Este pacote deles vai fazer grande parte do trabalho pesado e vai instalar o OpenCV, bem como toda a infraestrutura necessária para corrermos o YOLO.

Este processo também instala uma grande quantidade de outros pacotes e, como resultado, é propenso a falhas. Se a tua instalação falhar (vai mostrar uma parede inteira de texto vermelho), basta digitar novamente a linha de instalação do Ultralytics e deverá recomeçar. Em casos raros, pode ser necessário repetir a linha de instalação algumas vezes.

Depois de terminar a instalação, reinicie o Raspberry Pi. Se quiseres ser um utilizador avançado, podes fazê-lo escrevendo no shell:

Reinício

Temos mais uma coisa a fazer, que é preparar o Thonny para usar o ambiente virtual que acabámos de criar. O Thonny é o programa do qual vamos correr todo o nosso código e precisamos de o fazer funcionar com o mesmo VENV para que tenha acesso às bibliotecas que instalámos.

Da primeira vez que abrir o Thonny pode estar no modo simplificado, e verá um "mudar para modo normal" no canto superior direito. Se isto estiver presente, clica e reinicia o Thonny fechando-o.

Agora entre no menu de opções do interpretador selecionando Executar > Configurar Interpretador.  Na opção executável em Python, há um botão com 3 pontos. Seleciona-o e navega até ao executável Python no ambiente virtual que acabámos de criar.

Isto estará localizado em home/pi/yolo_pose/bin e, neste ficheiro, terá de selecionar o ficheiro chamado "python3". Carrega em ok e agora vais trabalhar neste venv.

Sempre que abrir o Thonny, ele funciona automaticamente a partir deste ambiente. Podes mudar o ambiente onde estás a trabalhar selecionando-o no menu suspenso sob o executável Python no mesmo menu de opções do interpretador. Se quiser sair do ambiente virtual, selecione a opção bin/python3.

Estimativa de Postura Corrente

Agora que temos as nossas bibliotecas instaladas e o Thonny está a trabalhar no ambiente virtual, podemos executar o nosso script de estimativa de pose. Extrai a pasta zip do projeto (descarrega do nosso servidor) para um local conveniente, como o ambiente de trabalho. Lá dentro encontrará o primeiro guião que vamos usar, "pose demo.py". Abre-o, Thonny, e carrega no grande botão verde de corrida. Na primeira vez que executares isto, pode instalar algumas coisas extra necessárias (todas automaticamente), e após alguns segundos deves ver uma janela de pré-visualização com a estimativa da tua pose a correr.

Algumas coisas deviam estar a acontecer aqui. Primeiro, o YOLO tentará detetar humanos e, se reconhecer um, desenhará uma caixa à sua volta com a classificação de confiança no topo. O importante é que ele colocará pontos onde considera que estão alguns pontos essenciais do seu corpo (estes são chamados pontos-chave), e irá traçar linhas entre esses pontos para estimar a pose e a orientação da pessoa. No canto superior direito estará também os FPS a que isto está a correr (que vamos melhorar daqui a pouco).

E é isso! Com estes poucos passos, já temos a nossa estimativa da pose de corrida do Pi!

Mudanças nos Modelos YOLO

Até agora temos corrido o YOLO11, e uma das vantagens deste pacote Ultralytics é que podemos simplesmente trocar uma única linha no código para mudar completamente o modelo. Podemos usar isto para correr um modelo YOLO11 mais avançado, ou até um modelo mais antigo. Tudo o que precisas de mudar é esta frase aqui na configuração:

# Carregue o nosso modelo YOLO11

modelo = YOLO("yolo11n-pose.pt")

Esta linha está atualmente a usar o modelo nano, que é o modelo mais pequeno, menos potente, mas mais rápido do YOLO11, e podemos alterar esta linha para usar um dos diferentes tamanhos em que este modelo existe, alterando a única letra após "11", como mostrado à direita. Se mudares esta linha para outro tamanho de modelo e a executares, o script descarrega automaticamente o novo modelo (que pode estar na casa das centenas de Mb para os modelos maiores).

A diferença entre estes modelos é um compromisso entre desempenho na estimativa de pose e FPS. Quanto maior o modelo, melhor será a estimar as partes do corpo que podem não ser vistas pela câmara, bem como ângulos mais complexos e frames com mais pessoas, no entanto, pode esperar que só seja processado 1 frame a cada 10 segundos! Vamos aumentar este valor no próximo passo.

O nanomodelo, por outro lado, é o que corre mais rápido, conseguindo cerca de 1,5 FPS sem otimização, mas não tem o poder de processamento dos modelos maiores. Para a estimação da pose, podes usar o nanomodelo na maior parte do tempo, pois normalmente é suficientemente bom para as tuas necessidades, mas se precisares de algo um pouco mais potente, continua a aumentar o tamanho do modelo para se adequar às tuas necessidades.

Nesta linha, também podemos alterar a versão do YOLO a correr. Podes voltar a um modelo mais antigo se quiseres, ou podes usar um modelo mais recente. Este guia acabará por ficar desatualizado e, se a Ultralytics lançar o YOLO13, deverá simplesmente conseguir alterar a linha para a seguinte para começar a usar a versão mais recente do YOLO:

# Carregue o nosso modelo YOLO11

modelo = YOLO("yolo13n-pose.pt")

Aumento da Velocidade de Processamento

Há duas coisas que podemos fazer para aumentar o FPS no Pi e a forma mais eficaz é converter o modelo para um formato chamado NCNN. Este é um formato de modelo mais otimizado para funcionar em processadores baseados em ARM como os Raspberry Pi. Abra o script chamado "ncnn conversion.py" e encontrará o seguinte:

da importação de ultralytics  YOLO

# Carregar um modelo YOLO11n PyTorch

modelo = YOLO("yolo11n-pose.pt")

# Exportar o modelo para o formato NCNN

modelo.export(format="ncnn", imgsz=640) # cria 'yolov11n-pose_ncnn_model'

Para usar este script, especifique primeiro o modelo que pretende converter. Isto usa as mesmas convenções de nomenclatura que discutimos na secção anterior. Depois, o formato do modelo "ncnn" é especificado como formato de saída, assim como a resolução. Por agora, mantém isto no padrão de 640. Na primeira vez que executares este script, ele vai descarregar mais algumas coisas adicionais de que precisa, mas deverá demorar apenas alguns segundos a executar a conversão propriamente dita.

Quando isso estiver concluído, na pasta onde os scripts estão vais encontrar uma nova pasta chamada algo como "yolo11n-pose_ncnn_model". Copie o nome deste ficheiro e volte ao nosso script de demonstração anterior.

Agora tens de dizer ao script para usar este modelo que criámos, mudando a linha do modelo para o nome da pasta que acabou de criar. Deveria parecer algo assim:

# Carregue o nosso modelo YOLO11

modelo = YOLO("yolo11n-pose_ncnn_model")