Spectrino: Soluções Touch-Free TinyML e IoT com Arduino Nano 33 BLE Sense e ESP8266

Componentes e Materiais

Arduino Nano 33 BLE Sense	×	1
Espressif ESP8266 ESP-01	×	1
Arducam Mini 2MP Plus	×	1
Display MAX7219 Sugere-se display 4 em 1, 32x8	×	1
Buzzer	×	1
Micro Servo Motor SG90 Servo genérico - usarei MG995 ou MG959	×	2
Carregador Micro-Lipo Adafruit	×	1
Bateria Polímero de Lítio Adafruit	×	1
Arduino MKR WiFi 1010	×	1
LED RGB Difuso Cátodo Comum	×	1
Sensor Ultrassônico HC-SR04 (Genérico)	×	1

Ferramentas e Máquinas Necessárias

• Kit 10 Fios Jumper, 5 cm

Aplicativos e Serviços Online

• Arduino Web Editor
• ThingSpeak API
• Edge Impulse Studio
• TensorFlow

Sobre este Projeto

Visão Geral

A pandemia introduziu uma restrição à interação social: o distanciamento. Considerando este fator de risco, países do mundo todo estiveram em níveis variados de quarentena, e muitos shoppings tiveram que fechar devido à redução significativa no número de consumidores. Isso levou a um nível muito alto de demissões de pessoal de shoppings, bem como desafios econômicos semelhantes para proprietários de negócios.

Isso causou níveis relativos de perda de empregos de baixa renda (menos de $40.000 em ganhos anuais) em 2 de julho de 2020 nos EUA devido à COVID-19. Acomodação e Serviços de Alimentação, Comércio Varejista e Entretenimento somam coletivamente ~4.000.000 dos empregos perdidos estimados.

O desafio econômico enfrentado por diferentes indústrias, onde Alimentação, Consumo e Varejo aparecem no Top 6 de indústrias com maior número de funcionários demitidos (totalizando estimados 20.000+ empregos). Assumindo "Internacional" para incluir todas as áreas não-EUA consideradas nesta pesquisa, a contagem global de demissões atinge estimados 103.000+ empregos.

Complicação

Considerando os dados, a equipe determinou um grande desafio: há incerteza de risco quanto à densidade populacional em diferentes lojas, para shoppings que ainda estão abertos. Além disso, embora o uso de máscaras e evitar toque seja obrigatório em muitos lugares, ainda há violações. Isso torna mais difícil para o pessoal do shopping e proprietários, que não podem trabalhar remotamente, navegar com segurança neste novo normal. Isso levanta a pergunta: como podemos garantir, com um nível decente de certeza, que em qualquer momento uma loja específica no shopping é segura para entrar?

Todos estamos lutando contra a pandemia de COVID-19. E agora estamos em uma situação onde temos que nos adaptar às condições prevalentes com mais medidas de segurança. Enquanto a vida volta ao normal com mais medidas de segurança para evitar infecção viral, adicionar segurança em locais públicos e áreas lotadas também prevalece nas cidades. Mas houve muitas situações onde temos que quebrar as medidas de segurança e interagir com um elemento inseguro para atender às necessidades. Aqui, o projeto lida com a prevenção da propagação da COVID-19 através de interações por toque ou toques.

Um experimento foi conduzido para ver a propagação de qualquer vírus através do toque. Os resultados foram avaliados da seguinte forma:

Por isso, decidi automatizar os dispositivos mais comumente usados em habitações e sociedades para garantir comunicação mãos-livres com dispositivos.

As seguintes soluções foram desenvolvidas para fazer este protótipo:

• Sistema de Interfone Inteligente usando TinyML no Arduino 33 BLE Sense: Solução touch-free usando Visão Computacional e modelo TinyML para detectar pessoa na porta e tocar a campainha sem a pessoa tocar o botão.
• Sistema de Monitoramento de Temperatura usando IoT e sistema de alerta: Em meio à pandemia, a segurança tornou-se aspecto importante. O sistema de monitoramento de temperatura utiliza dashboard IoT ThingSpeak e detecta pessoas ao entrar e mede sua temperatura. Esta temperatura é exibida em dashboard IoT para tendências e análise de dados em tempo real. Em detecção de temperatura anormal, alertas são gerados para que a pessoa passe por segunda inspeção.
• Sistema de Elevador Touch-Free usando Reconhecimento de Fala TinyML no Arduino BLE 33 Sense: Usamos elevadores várias vezes ao dia, e sempre tenho medo de tocar botões contaminados tocados por outras pessoas. Este modelo de reconhecimento de fala identificará quando a pessoa deseja subir ou descer e realizará a ação.
• Sistema de Detecção de Máscara baseado em TinyML e monitoramento IoT: Este método usará modelo de visão computacional no Arduino BLE 33 Sense para detectar se a pessoa está usando máscara ou não e enviará dados para dashboard IoT para monitoramento e imposição de restrições conforme horários inseguros.
• Sistema inteligente de monitoramento e estabelecimento de filas em supermercado/shopping usando TinyML, IoT e visão computacional: Este modelo detectará pessoa na frente do supermercado e permitirá entrada de 50 pessoas por vez. Aguardará 15 minutos para que as pessoas lá dentro completem compras e permitirá próximo grupo de 50. Feito com visão computacional e TinyML no Arduino 33 BLE Sense. Dados projetados em dashboard IoT para rastreamento em tempo real.
• Sistema de Monitoramento de Pessoas em Corredor de Shopping e Sanitização baseada em Contaminação: Esta solução usa Algoritmo de Detecção de Pessoa implantado em área do shopping/supermercado e se a contaminação de pessoas na área passar do limite, auto-sanitiza a área com luz UV. Período e tempos de sanitização projetados em dashboard IoT para equipe do supermercado analisar.

Configuração (Requisitos para o projeto)

Hardware Necessário:

1) Arduino Nano 33 BLE Sense

O Arduino Nano 33 BLE Sense é uma evolução do Arduino Nano tradicional, mas com processador muito mais poderoso, o nRF52840 da Nordic Semiconductors, CPU ARM® Cortex™-M4 de 32 bits rodando a 64 MHz. Permite programas maiores que o Arduino Uno (tem 1MB de memória de programa, 32x maior), e muito mais variáveis (RAM 128x maior). O processador principal inclui recursos incríveis como emparelhamento Bluetooth® via NFC e modos de consumo de energia ultra baixo.

Inteligência Artificial Embarcada

A principal característica desta placa, além da impressionante seleção de sensores, é a possibilidade de rodar aplicações de Edge Computing (IA) nela usando TinyML. Você pode criar seus modelos de machine learning usando TensorFlow™ Lite e enviá-los para sua placa usando o Arduino IDE.

2) ESP8266 ESP-01

O ESP8266 ESP-01 é um módulo Wi-Fi que permite microcontroladores acessarem uma rede Wi-Fi. Este módulo é um SOC (System On a Chip) autocontido que não necessariamente precisa de um microcontrolador para manipular entradas e saídas como faria normalmente com um Arduino, porque o ESP-01 age como um pequeno computador. Dependendo da versão do ESP8266, é possível ter até 9 GPIOs. Assim, podemos dar acesso à internet a um microcontrolador como o Wi-Fi shield faz para o Arduino, ou simplesmente programar o ESP8266 para não só acessar rede Wi-Fi, mas atuar como microcontrolador também. Isso torna o ESP8266 muito versátil.

3) Arducam Mini 2MP Plus

ArduCAM-2MP-Plus é versão otimizada do ArduCAM shield Rev.C, câmera SPI de alta definição 2MP, que reduz complexidade da interface de controle da câmera. Integra sensor de imagem CMOS 2MP OV2640, e fornece tamanho miniatura, interface de hardware fácil de usar e biblioteca de código aberto.

4) Arduino MKR WiFi 1010:

O Arduino MKR WiFi 1010 é o ponto de entrada mais fácil para design básico de aplicações IoT e pico-network. Seja construindo rede de sensores conectada ao seu roteador de escritório ou casa, ou criando dispositivo BLE enviando dados para celular, o MKR WiFi 1010 é sua solução única para muitos cenários básicos de IoT.

Ferramentas de Software:

1) Arduino Web Editor

Arduino Create é uma plataforma online integrada que permite a Makers e Desenvolvedores Profissionais escrever código, acessar conteúdo, configurar placas, e compartilhar projetos. Vá de uma ideia a projeto IoT finalizado mais rápido que nunca. Com Arduino Create você pode usar IDE online, conectar múltiplos dispositivos com Arduino IoT Cloud, navegar coleção de projetos no Arduino Project Hub, e conectar remotamente às suas placas com Arduino Device Manager. Também pode compartilhar suas criações, com guias passo a passo, esquemáticos, referências, e receber feedback de outros.

2) Edge Impulse Studio:

A tendência de rodar ML em microcontroladores é chamada às vezes de Embedded ML ou Tiny ML. TinyML tem potencial para criar pequenos dispositivos que tomam decisões inteligentes sem precisar enviar dados para a nuvem — ótimo do ponto de vista de eficiência e privacidade. Mesmo modelos poderosos de deep learning (baseados em redes neurais artificiais) estão alcançando microcontroladores. No último ano, grandes avanços foram feitos para tornar modelos de deep learning menores, mais rápidos e rodáveis em hardware embarcado através de projetos como TensorFlow Lite for Microcontrollers, uTensor e Arm's CMSIS-NN; mas construir dataset de qualidade, extrair features certas, treinar e deployar esses modelos ainda pode ser complicado.

Usando Edge Impulse você pode agora coletar rapidamente dados de sensores do mundo real, treinar modelos ML nesses dados na nuvem, e depois deployar o modelo de volta ao seu dispositivo Arduino. A partir daí você pode integrar o modelo em seus sketches Arduino com uma única chamada de função. Seus sensores ficam muito mais inteligentes, podendo dar sentido a eventos complexos no mundo real. Os exemplos built-in permitem coletar dados do acelerômetro e microfone, mas é fácil integrar outros sensores com poucas linhas de código.

3) ThingSpeak:

ThingSpeak™ é um serviço de analytics IoT que permite agregar, visualizar, e analisar streams de dados ao vivo na nuvem. ThingSpeak fornece visualizações instantâneas de dados postados por seus dispositivos. Com a capacidade de executar código MATLAB® no ThingSpeak, você pode realizar análise online e processar dados conforme chegam. ThingSpeak é frequentemente usado para prototipagem e proof-of-concept de sistemas IoT que requerem analytics.

Começando com Implementações

1º Projeto: Sistema de Elevador Touch-Free usando Reconhecimento de Fala TinyML no Arduino BLE 33 Sense

Ao nos deslocarmos, usamos elevadores várias vezes ao dia! Um botão comumente usado é contaminado por todos que já tocaram o elevador antes. Decidi criar solução touch-free para elevadores que usa comandos de voz e sem uso de IoT ou rede Wi-Fi, colabora e realiza a ação. Soluções de elevadores touch-free foram implementadas usando controle por gestos ou sensores ultrassônicos, mas o problema é que precisam ser ativados a curta distância, aumentando risco de toque. Também, esses sensores são altamente sensíveis e ativam mesmo se pequenos objetos passarem. Propus criar solução mais precisa usando detecção de voz no Arduino 33 BLE Sense. Este modelo recebe dois comandos, "up" ou "down" e envia dados ao servo para pressionar os respectivos botões no painel. A ideia de enviar dados ao servo para acionar interruptores é porque a maioria das sociedades tem sistemas de botões e display pré-construídos, e não querendo atrapalhar esses sistemas pré-existentes, isso foi criado para adicionar sistema de hardware externo para controlar as funções.

Treinando o Modelo para interpretar comandos "up" e "down" no Edge Impulse Studio

a) Acumulando Dados Brutos com Conjuntos de Treino e Teste. Acumulei dados de 1:30min com duração de cada dado "up" e "down" de 2seg.

b) Criando Impulso baseado nos Parâmetros Necessários: Defini tamanho de incremento de janela para 300ms e treino baseado em Rede Neural Keras dedicada para dados de microfone e acelerômetro.

c) Conversão de Dados Brutos para Dados Processados. Logo abaixo dos dados brutos, vemos features dos dados brutos e dados processados vistos como resultados DSP baseados em coeficientes cepstrais.

d) Treinando Dados de Entrada para Gerar Features Processadas. Gravei dados com baixa e alta frequência baseados nos mesmos dados para treinar o impulso melhor e tornar o reconhecimento de voz preciso treinando com todos os tipos de voz. Obtemos saída de feature em curva "S" com diferenciação central nos eixos x, y e z.

e) Finalmente, Desenhando Arquitetura de Rede Neural no Classificador Neural Network do Edge Impulse e treinando a Rede.

A arquitetura da Rede Neural desenhada para a entrada de dados é:

• Camada de Entrada
• Camada Reshape
• Camada 1D convo pool (30 neurônios, kernel 5)
• Camada 1D convo pool (10 neurônios, kernel 5)
• Camada Flatten

O modelo performou bem com Acurácia Média de 91,2% e loss 0,29. Treinado em 100 ciclos (epochs). A matriz de confusão parece clara e precisa com a maioria dos dados correspondendo às classes rotuladas.

Após o modelo treinado, testei com Dados de Teste e Dados Ao Vivo e o modelo obteve acurácia de 75% baseada em 24 segundos de dados de teste.

Finalmente, após o modelo treinado e obter acurácia decente com a lógica, deployei o modelo como Biblioteca Arduino e deployando no Arduino 33 BLE Sense.

Deploy no Arduino 33 BLE Sense

Até este momento, a única placa Arduino com microfone embutido é o Arduino Nano 33 BLE Sense, então é o que usaremos. Se estiver usando outra placa Arduino e anexando seu próprio microfone, precisará implementar.

O Arduino Nano 33 BLE Sense também tem LED embutido, que usamos para indicar que uma palavra foi reconhecida e também controlar o servo para realizar a função.

Lógica de resposta ao comando:

// Se ouvirmos comando, acende LED apropriado e liga servo apropriado
if (found_command[0] == 'up') {
  last_command_time = current_time;
  digitalWrite(LEDG, LOW); // Verde para up, ligando LED por comando LOW
  servo_7.write(0); // Rotaciona servo para 0 graus para clicar botão do elevador quando diz "up"
  delay(100);
  digitalWrite(LEDG, HIGH); // Desliga LED após piscar comando
  servo_7.write(180); // servo retorna posição original 180 graus
}
// Se ouvirmos comando, acende LED apropriado e liga servo apropriado
if (found_command[0] == 'down') {
  last_command_time = current_time;
  digitalWrite(LEDG, LOW);
  servo_7.write(0); // Rotaciona servo para 0 graus para clicar botão do elevador quando diz "down"
  delay(100);
  digitalWrite(LEDG, HIGH);
  servo_7.write(180);
}

Após treinar dados, obtemos dataset tflite treinado. Estamos usando microfone embutido no Arduino Nano 33 BLE Sense e o modelo usa média de ~24-28KB dos 256KB flash no Arduino Nano. Este modelo é comparativamente leve comparado a modelo de reconhecimento de imagem e processa informação em taxa muito maior.

Lógica do modelo de reconhecimento de fala:

• Dados Capturados
• Captura Amostras de Áudio do Microfone
• Converte dados de áudio bruto em espectrogramas
• Tflite Interpreter Roda o Modelo
• Usa saída de inferência para decidir se comando foi ouvido
• Se comando "down" ouvido, servo move pressionando tecla down no painel do elevador
• Se comando "up" ouvido, servo move pressionando tecla up no painel do elevador

Diagrama de Circuito do Projeto:

O Arduino Nano 33 BLE Sense utiliza microfone embutido para coletar dados brutos. Como inferência no Arduino leva tempo, adicionei delay de 100ms para processar dados com precisão. Entre duas amostras de gravação, um LED azul embutido pisca indicando resposta a ser ouvida/dita entre os dois flashes do LED.

Esta é uma simulação do Arduino 33 BLE Sense demonstrando piscar do LED entre dois intervalos bem-sucedidos de entrada de Microfone.

Baseado na entrada de comando, o servo rotaciona conforme necessário.

Existem alternativas para automação de elevador touch-free como sensores ultrassônicos ou de gestos, mas ambos têm falhas, por isso decidi fazer sistema de elevador controlado por voz.

Falhas em Sensores Ultrassônicos: Sensores ultrassônicos são altamente sensíveis a movimento. Se qualquer objeto em movimento no corredor entrar no alcance, estes são ativados. Não são precisos o suficiente, às vezes processam informação errada.

Falhas em Sensores Controlados por Gestos: Estes sensores são mais precisos que ultrassônicos mas precisam ser ativados a distância menor. Isso aumenta risco de toque entre mãos e painel do elevador.

No entanto, painel de elevador controlado por voz é mais preciso que as duas soluções acima e pode ser ativado de distância maior que sensores ultrassônicos e de gestos.

Isso mostra distância necessária para ativar sensor de gesto. Como esta distância é muito pequena, taxa de contaminação é alta.

2º Projeto: Sistema de Interfone Inteligente usando Reconhecimento Facial e TinyML

CDC atualizou seu site e emitiu comunicado dizendo que contato indireto de superfície contaminada com novo coronavírus — conhecido como transmissão fômite — é forma potencial de contrair o vírus.

Pesquisa descobriu que o novo coronavírus pode durar até três dias em superfícies plásticas e metálicas e em papelão por 24 horas. No entanto, muitas coisas precisam acontecer para uma pessoa contrair Covid-19 tocando superfície contaminada.

Primeiro, pessoa deve entrar em contato com quantidade suficiente do vírus para causar infecção. Por exemplo, para ser infectado com vírus da gripe, milhões de cópias do vírus precisam alcançar rosto de uma pessoa de uma superfície, mas apenas alguns milhares são necessários quando vírus vai direto aos pulmões, relata New York Times.

Se pessoa toca superfície com grandes traços do vírus, teria que pegar quantidade suficiente e então tocar olhos, nariz ou boca — por isso especialistas em saúde pública dizem ser tão importante evitar tocar superfícies com frequência e evitar tocar objetos contaminados ou frequentemente tocados.

O vírus COVID-19 está se espalhando pelo Mundo. Mesmo quando finalmente diminuir, pessoas terão desenvolvido sensibilidade sobre tocar coisas em público. Como a maioria dos interfones são projetados para exigir pressionar botão para fazer chamada, decidi que soluções de interfone sem toque eram necessárias que não exigem pessoas tocarem nada.

Para resolver questão de sistemas baseados em toque, é necessário reduzir locais de contato e toque. Em sistema tradicional de interfones, consistem em sistemas baseados em interruptores, quando pressionados tocam a campainha. Para reformar sistema baseado em toque que aumenta risco de contaminação de superfícies, decidi construir sistema de reconhecimento facial touch-free deployado no Arduino 33 BLE Sense, baseado em tinyML e Tensorflow Lite.

Neste sistema de interfone inteligente, usei algoritmo de detecção de pessoa deployado no Arduino 33 BLE Sense que identifica pessoas e, consequentemente, toca a campainha com display de matriz LED exibindo "Person".

Implementação do Sistema de Interfone Inteligente

Softwares usados no design deste modelo:

• TensorFlow Lite
• Arduino Web Editor

Neste modelo de detecção de pessoa, usei modelo pré-treinado TensorFlow de detecção de pessoa adequado ao projeto. Este modelo pré-treinado consiste em três classes, sendo a terceira com conjunto de dados indefinido:

"unused",
"person",
"notperson"

No nosso modelo temos o Arducam Mini 2mp plus para captar imagens e estes dados de imagem com taxa decente de fps são enviados ao Arduino Nano 33 BLE Sense para processamento e classificação. Como o Microcontrolador fornece 256KB RAM, alteramos tamanho da imagem para 96x96 padrão para processamento e classificação. A rede Arduino Tensorflow Lite consiste em framework de deep learning:

• Depthwise Conv_2D
• Conv_2D
• AVERAGE Pool_2D
• Camada Flatten

Este framework é usado para treinar modelo de detecção de pessoa.

A função mais importante definida ao processar saídas no Microcontrolador via Arduino_detection_responder.cpp:

// Processa resultados de inferência.
uint8_t person_score = output->data.uint8[kPersonIndex];
uint8_t no_person_score = output->data.uint8[kNotAPersonIndex];
RespondToDetection(error_reporter, person_score, no_person_score);

Na definição da função, o person_score, no_person_score foram definidos na taxa de classificação dos dados.

Lógica funciona da seguinte forma:

├── Sistema Interfone Autônomo
├── Arducam Mini 2mp plus
│ ├── Dados visuais enviados ao Arduino
├── Arduino 33 BLE Sense
│ ├── se person-score > no_person_score
│ │ ├── Ativa buzzer
│ │ ├── Exibe "Person" na Matriz LED
│ │ └── ...Repete loop

Seguindo a lógica acima, o Arducam Mini 2mp plus continuamente captura dados visuais e envia ao Arduino 33 BLE Sense para processar e classificar. Uma vez dados brutos convertidos a processados, são classificados conforme dados treinados. Se pessoa detectada, Arduino envia sinal ao buzzer para ativar e MAX7219 para exibir "person".

Funcionamento e Lógica no Código

Bibliotecas incluídas no main.ino para funcionamento do modelo:

#include <TensorFlowLite.h>
#include "main_functions.h"
#include "detection_responder.h"
#include "image_provider.h"
#include "model_settings.h"
#include "person_detect_model_data.h"
#include "tensorflow/lite/micro/kernels/micro_ops.h"
#include "tensorflow/lite/micro/micro_error_reporter.h"
#include "tensorflow/lite/micro/micro_interpreter.h"
#include "tensorflow/lite/micro/micro_mutable_op_resolver.h"
#include "tensorflow/lite/schema/schema_generated.h"
#include "tensorflow/lite/version.h"

Trecho do loop definido e executado no main.ino:

void loop() {
  // Obtém imagem do provider.
  if (kTfLiteOk != GetImage(error_reporter, kNumCols, kNumRows, kNumChannels,
      input->data.uint8)) {
    TF_LITE_REPORT_ERROR(error_reporter, "Image capture failed.");
  }

  // Roda modelo nesta entrada e garante sucesso.
  if (kTfLiteOk != interpreter->Invoke()) {
    TF_LITE_REPORT_ERROR(error_reporter, "Invoke failed.");
  }

  TfLiteTensor* output = interpreter->output(0);

  // Processa resultados de inferência.
  uint8_t person_score = output->data.uint8[kPersonIndex];
  uint8_t no_person_score = output->data.uint8[kNotAPersonIndex];
  RespondToDetection(error_reporter, person_score, no_person_score);
}

Trecho arduino_image_provider.cpp para inferência de imagem capturada. Imagens convertidas para tamanho padronizado 96x96 interpretável na placa Arduino. Utiliza biblioteca Arducam mini 2mp OV2640.

#if defined(ARDUINO) && !defined(ARDUINO_ARDUINO_NANO33BLE)
#define ARDUINO_EXCLUDE_CODE
#endif

#ifndef ARDUINO_EXCLUDE_CODE
#include <SPI.h>
#include <Wire.h>
#include <memorysaver.h>
#include <ArduCAM.h>
#include <JPEGDecoder.h>

#if !(defined OV2640_MINI_2MP_PLUS)
#error Please select the hardware platform and camera module in the Arduino/libraries/ArduCAM/memorysaver.h
#endif

#define MAX_JPEG_BYTES 4096
#define CS 7

ArduCAM myCAM(OV2640, CS);
uint8_t jpeg_buffer[MAX_JPEG_BYTES] = {0};
uint32_t jpeg_length = 0;

TfLiteStatus InitCamera(tflite::ErrorReporter* error_reporter) {
  TF_LITE_REPORT_ERROR(error_reporter, "Attempting to start ArduCAM");
  Wire.begin();
  pinMode(CS, OUTPUT);
  digitalWrite(CS, HIGH);
  SPI.begin();
  myCAM.write_reg(0x07, 0x80);
  delay(100);
  myCAM.write_reg(0x07, 0x00);
  delay(100);
  myCAM.write_reg(ARDUCHIP_TEST1, 0x55);
  uint8_t test = myCAM.read_reg(ARDUCHIP_TEST1);
  if (test != 0x55) {
    TF_LITE_REPORT_ERROR(error_reporter, "Can't communicate with ArduCAM");
    delay(1000);
    return kTfLiteError;
  }
}

Código Arduino_detection_responder.cpp controla saída principal do modelo. Considera score de classificação definido no main.ino e conforme confiança do person_score, fornece saídas.

// Liga LED verde quando pessoa detectada, vermelho quando não
if (person_score > no_person_score) {
  digitalWrite(LEDG, LOW); // se pessoa detectada na porta, buzzer liga
  digitalWrite(LEDR, HIGH); // matriz led na casa exibe "person"
  digitalWrite(5, LOW);
  myDisplay.setTextAlignment(PA_CENTER);
  myDisplay.print("Person");
  delay(100);
} else {
  digitalWrite(LEDG, HIGH);
  digitalWrite(LEDR, LOW);
}

TF_LITE_REPORT_ERROR(error_reporter, "Person score: %d No person score: %d",
  person_score, no_person_score);
}

Funcionamento do Firmware:

Este modelo compreende o seguinte firmware:

• Arduino 33 BLE Sense - Processa dados, classifica, envia comandos conforme lógica.
• Buzzer - Alerta quando pessoa na porta.
• Arducam Mini 2mp plus - Acúmulo contínuo de dados de imagem brutos.
• Carregador lithium ion Adafruit - Entrega carga através da bateria lítio.
• Bateria lithium ion - Fonte de energia.
• Display MAX7219 4 em 1 - Exibe "person" na tela.

Recursos Adicionais: Usando sistema de interfone existente, é possível adicionar servo para pressionar botão e ver quem está na porta como mostrado na imagem:

Este pode ser setup adicional no sistema de interfone para ligar vídeo quando pessoa detectada. Porém, este sistema adicional deve ser deployado no sistema de interfone existente.

Código adicional ao existente:

if (person_score > no_person_score) {
  digitalWrite(LEDG, LOW);
  digitalWrite(LEDR, HIGH);
  digitalWrite(5, LOW);
  myDisplay.setTextAlignment(PA_CENTER);
  myDisplay.print("Person");
  servo_8.write(0); // liga interfone rotacionando servo
  delay(500);
  servo_8.write(180); // desliga interfone rotacionando servo
  delay(100);
} else {
  digitalWrite(LEDG, HIGH);
  digitalWrite(LEDR, LOW);
}

Adicionei função que rotaciona servo para ligar interfone existente e retorna à posição original.

3º Projeto: Automação Autônoma IoT de Detecção de Temperatura de Pessoas

O sensor de temperatura para Arduino é elemento fundamental quando queremos medir temperatura de processo ou do corpo humano.

O sensor de temperatura com Arduino deve estar em contato ou próximo para receber e medir nível de calor. É assim que termômetros funcionam.

Estes dispositivos são extremamente usados para medir temperatura corporal de pessoas doentes, pois temperatura é um dos primeiros fatores que mudam no corpo humano quando há anormalidade ou doença.

Uma das doenças que altera temperatura corporal é COVID-19. Principais sintomas:

• Tosse
• Cansaço
• Dificuldade para respirar (casos graves)
• Febre

Febre é sintoma cuja característica principal é aumento da temperatura corporal. Nesta doença, precisamos monitorar constantemente estes sintomas.

O mercado varejista foi muito impactado pela pandemia. Após shoppings e supermercados reabrirem, é necessário garantir segurança de todos clientes que entram. Para isso, técnicas manuais de verificação de temperatura foram implementadas. Isso aumenta mão de obra e também risco de contato entre quem verifica temperatura e quem tem temperatura verificada.

Esta imagem mostra contato próximo ou menor distanciamento social entre as duas pessoas.

Segundo defeito em sistema manual de verificação de temperatura: Para temperaturas verificadas, dados destes registros não são armazenados ou sincronizados com dispositivo externo para monitoramento.

Considerando todos estes contras, desenvolvi solução IoT baseada em Arduino deployada no Arduino MKR WiFi 1010. Temperaturas são medidas usando módulo de temperatura Adafruit AMG8833. Sempre que pessoa detectada no portão, sensores ultrassônicos enviam informação ao Arduino MKR WiFi 1010 para dar comando ao módulo AMG8833 para capturar dados de temperatura. O módulo captura dados com precisão e dados são projetados em dashboard IoT em tempo real. Se leitura anormal de temperatura detectada, alarme dispara para que segurança e staff do shopping investiguem imediatamente. Dados coletados recebem timestamp e podem ser vistos no dashboard ThingSpeak no gráfico temperatura vs Tempo para cada dado.

Similarmente, pode ser rastreado em quais dias e faixa horária o supermercado/shopping mostra leituras anormais de temperatura e mais medidas de segurança implementadas.

No portão de verificação, sensores ultrassônicos HC-SR04 podem ser instalados que detectam entrada de pessoa e enviam comando ao Arduino MKR WiFi 1010 se pessoa detectada em alcance de 20cm. O microcontrolador passa mesmo comando ao módulo AMG8833 para ler temperatura da pessoa. Este processo completo leva tempo desde sensor ultrassônico detectar pessoa, até enviar comando ao módulo de temperatura. Portanto, para sincronizar com delay, módulo de temperatura fica um pouco afastado do sensor ultrassônico.

Sempre que pessoa entra, portão abre (No protótipo, usamos servo como portão, mas em implementação futura, servo será substituído por motor de portão pesado controlado via driver de motor, onde Arduino enviará comandos). Leitura de temperatura da pessoa é tomada e enviada ao dashboard ThingSpeak IoT em tempo real via Arduino WiFi 1010. Para isso, conexão Wi-Fi ativa necessária no shopping, geralmente disponível. Segundo pesquisa, temperatura corporal de pessoa com febre é aproximadamente 38,1°C (104°F). Se módulo detecta temperatura acima deste limite, servo gira 180 graus e buzzer liga para alertar sobre a pessoa. Segurança e staff podem chegar a tempo.

Lógica de funcionamento:

├── Detecção Temperatura Pessoa
├── HC-SR04 Sensor Ultrassônico
│ ├── Detecção Pessoa
│ │ ├── Se (Distância Pessoa = 20), envia comando
├── Arduino MKR WiFi 1010
│ ├── Se sensor ultrassônico envia comando;
│ │ ├── Abre portão - Servo(0)
│ │ ├── Ativa AMG8833 para leituras
│ │ ├── Envia Leituras para Dashboard ThingSpeak
│ │ │ ├── Se Temperatura > 38.1°C
│ │ │ │ ├── Fecha portão - servo(180)
│ │ │ │ ├── Ativa Buzzer
│ │ └── ...Repete loop

Diagrama de Circuito do Modelo de Temperatura:

Esta simulação mostra tipo de dado capturado pela Câm Termal AMG8833 e enviado ao Arduino MKR WiFi 1010 para transferir comandos

Esta simulação mostra distância capturada por Sensor Ultrassônico e comando enviado ao Arduino MKR WiFi para ativar sensor térmico AMG8833

Em vez de sistema de abertura de porta baseado em servo, implementarei sistema de comando usando driver de motor para automação de porta deslizante:

Configurando Dashboard IoT:

Usando Setup Dashboard IoT ThingSpeak:

ThingSpeak™ é serviço de analytics IoT que permite agregar, visualizar, analisar streams de dados ao vivo na nuvem. Fornece visualizações instantâneas de dados postados por dispositivos. Com capacidade de executar código MATLAB® no ThingSpeak, pode realizar análise online e processar dados conforme chegam. Usado para prototipagem e proof-of-concept de sistemas IoT que requerem analytics.

Como ThingSpeak foi fácil de configurar e usar, preferi este dashboard. Esta interface permite compartilhar dashboard com departamento de segurança ou staff do shopping para monitorar continuamente pessoas visitando o shopping, e impor restrições em certos horários quando risco de temperatura maior.

Imagem mostra criação de visualizações em diferentes canais. Criei gráfico Temperatura vs Tempo na seção visualização. Dados coletados pelo sensor AMG8833 recebem timestamp e são plotados no gráfico para ver tempo de cada captura.

Dados podem ser vistos em tempo real no Dashboard Público: ThingSpeak Temperature Dashboard

Integração visualização data chart:

<iframe width="450" height="260" style="border: 1px solid #cccccc;" src="https://thingspeak.com/channels/1121969/charts/1?bgcolor=%23ffffff&color=%23d62020&dynamic=true&results=600&timescale=10&type=line"></iframe>

Este gráfico pode ser incorporado em dashboard único com leituras de gráficos de outros shoppings/supermercados na área e, assim, visitante único pode verificar qual shopping performa melhor em segurança e preferir ir onde guidelines seguidas e pessoas entrando não diagnosticadas com febre. Isso pode ajudar Governo a estabelecer segurança e confiança nas pessoas junto com reabertura de shoppings e setor varejista

Código do projeto pode ser visto no Github ou Arduino Web Editor: Temperature-Model-code

Lógica no código:

#include <Wire.h>
#include <Adafruit_AMG88xx.h>
#include <Servo.h>
#include ESP32_Servo.h
#include <WiFi.h>
#include <WiFiMulti.h>

Servo servo1;
int trigPin = 9;
int echoPin = 8;
long distance;
long duration;

WiFiMulti WiFiMulti;

const char* ssid = "JioFiber-tcz5n"; // Seu SSID - nome dummy, insira seu wifi ssid
const char* password = "**********"; // Senha não mencionada, insira sua ao rodar script

const char* host = "api.thingspeak.com/1121969";
String api_key = "8LNG46XKJEJC89FE"; // Sua API Key fornecida pelo thingspeak

Adafruit_AMG88xx amg;

Aqui defini algumas Bibliotecas e Firmware junto com setup necessário para host WiFi e API-Key para dashboard temperatura no thingspeak

Próxima parte: Setup componentes antes do loop principal:

void setup() {
  Serial.begin(9600);
  servo1.attach(7);
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
}

{
  Connect_to_Wifi();
  Serial.println(F("AMG88xx test"));

  bool status;
  status = amg.begin();
  if (!status) {
    Serial.println("Could not find a valid AMG88xx sensor, check wiring!");
    while (1);
  }

  Serial.println("-- Thermistor Test --");
  Serial.println();
  delay(100); // let sensor boot up
}

Próxima parte é Void Loop onde função completa é executada. Inicialmente defini portão aberto para permitir entrada de cada pessoa. AMG8833 coleta dados e lê temperatura das pessoas entrando. Se temperatura maior que limite esperado, portão fecha e alarme (buzzer) liga para alertar e não permitir entrada da pessoa

void loop() {
  ultra();
  servo1.write(0);
  if(distance <= 20){
    Serial.print("Thermistor Temperature = ");
    Serial.print(amg.readThermistor());
    Serial.println(" *C");

    Serial.println();
    // chama função para enviar dados ao Thingspeak
    Send_Data();
    delay(50);

    if(amg.readThermistor() > 38.1) // se pessoa com febre detectada, não permite entrar
      // pessoa com febre tem temp corporal média 38.1 graus celsius
      servo1.write(180);
      digitalWrite(6, HIGH); // Liga buzzer para alarmar pessoas
  }
}

Última parte: enviando dados ao Dashboard ThingSpeak:

Como tenho apenas um campo no canal, todos dados enviados para esse campo. Dados capturados amg.readThermistor() enviados ao dashboard.

void Send_Data() {
  Serial.println("Prepare to send data");
  WiFiClient client;
  const int httpPort = 80;

  if (!client.connect(host, httpPort)) {
    Serial.println("connection failed");
    return;
  } else {
    String data_to_send = api_key;
    data_to_send += "&field1=";
    data_to_send += String(amg.readThermistor());
    data_to_send += "\r\n";

    client.print("POST /update HTTP/1.1\n");
    client.print("Host: api.thingspeak.com\n");
    client.print("Connection: close\n");
    client.print("X-THINGSPEAKAPIKEY: " + api_key + "\n");
    client.print("Content-Type: application/x-www-form-urlencoded\n");
    client.print("Content-Length: ");
    client.print(data_to_send.length());
    client.print("\n\n");
    client.print(data_to_send);

    delay(200); // delay reduzido para coleta tempo real
  }
  client.stop();
}

GO TO MARKET & PRATICABILIDADE

• Shoppings e Supermercados podem usar para identificar dados anormais de temperatura e observar em certo dia/hora.
• Implementar estratégias usando estes dados para garantir Segurança e Conformidade.
• Reduzir Mão de Obra e automatizar Processo de Monitoramento de Temperatura
• Oferecer Dashboard aos visitantes para monitorar se shopping é seguro e visitar no horário mais seguro.
• Produto garante visitantes que shopping é local seguro, aumentando vendas e visitas seguindo guidelines governamentais
• Empresas oferecendo soluções IoT podem investir para produção em massa e distribuição.
• Quanto mais supermercados usando, mais acesso a dados para governo e mais escolha para clientes selecionarem local mais seguro na região.
• Solução comparativamente acessível vs monitoramento manual: reduz custo mão de obra + reduz taxa infecção vs monitoramento manual onde pessoa medindo temperatura precisa ficar próxima do visitante.

4º Projeto: Sistema de Monitoramento e Estabelecimento de Filas TinyML & IoT no Arduino 33 BLE Sense

Assim como shopping e setor varejo reabriram, gerenciamento de filas em shoppings/supermercados tornou-se grande problema. Devido à pandemia, restringir certa quantidade de pessoas dentro do shopping deve ser seguido para garantir conformidade de segurança. Mas isso é feito manualmente aumentando trabalho. Também dados de número de pessoas dentro do shopping em dado momento não disponíveis aos visitantes. Se estes dados fossem disponibilizados, aumentaria percentual de pessoas visitando.

Tentar manter loja/serviço durante crise Corona é desafio. Atender clientes mantendo eles e funcionários seguros é complicado, mas filas digitais ajudam muito. Tecnologias por trás de filas virtuais não são totalmente novas; o chamado para distanciamento social destaca alguns dos muitos benefícios.

Maioria países introduziu medidas legais para combater COVID-19. Para garantir satisfação do cliente aderindo novas regulamentações, uma coisa é certa: filas longas e lobbies lotados precisam acabar. Filas digitais (também chamadas virtuais ou remotas) permitem negócios atenderem clientes tempestivamente enquanto ficam fora de perigo.

Geralmente, você encontrará um ou mais dos seguintes tipos de soluções de gerenciamento de filas em ambiente varejista:

• Filas estruturadas: Formam em posição fixa, predeterminada. Ex: caixas de supermercado ou filas de segurança aeroporto.
• Filas não estruturadas: Formam natural e espontaneamente em locais/direções variadas. Ex: filas de táxi e espera por consultores em lojas especializadas.
• Filas baseadas em quiosque: Clientes inserem info básica em quiosque, permitindo staff responder. Quiosques usados em bancos, instalações médicas/governamentais.
• Filas móveis: Em vez de fila física, clientes usam smartphones. Não precisam esperar na loja, monitoram Dashboard IoT para ver tempo de espera na loja.

Filas longas, estruturadas ou não, frequentemente impedem clientes walk-in de entrar. Além disso, limitam produtividade e causam estresse excessivo para clientes e staff.

Gerenciamento eficaz de filas afeta diretamente experiência do cliente?

Aspecto interessante sobre experiência de esperar na fila: tempos de espera percebidos frequentemente não correspondem aos tempos reais. Podemos atribuir período falsamente como "mais longo" que normal ou julgar outro "mais curto" apesar de exceder média. Em grande parte, isso tem a ver com como preenchemos tempo esperando.

"Tempo ocupado (caminhando até esteira de bagagem) parece mais curto que tempo desocupado (parado na esteira). Pesquisa sobre filas mostrou que, em média, pessoas superestimam quanto tempo esperaram na fila em cerca de 36 por cento."

Principal razão que cliente tem medo de visitar supermercado é problema de dados insuficientes. Visitantes não sabem densidade de pessoas dentro do shopping. Maior número pessoas dentro, maior risco de visitar. Calcular manualmente número pessoas entrando/saindo e atualizar em tempo real não é possível. Visitante também não sabe qual dia/hora melhor para visitar. Também não sabe tempo de espera de cada shopping para ir a outro supermercado próximo se espera menor. Resultado: menor conversão de pessoas e menos visitantes. Se visitantes têm acesso a dados populacionais, têm senso de confiança e aumenta vendas. Por isso, desenvolvi solução Arduino TinyML e IoT para disponibilizar estes dados aos visitantes e aumentar conversão seguindo guidelines de segurança.

Esta solução baseia-se em visão computacional e algoritmo de detecção de pessoa baseado em framework tensorflow.

Funciona da seguinte forma:

Solução implementada nos portões do shopping/supermercado. Arducam mini 2mp captura dados de imagem e envia ao Arduino 33 BLE Sense para processar e classificar. Se pessoa detectada, Arduino incrementa contagem de pessoas dentro do shopping em 1. Como pessoa detectada, motor servo rotaciona, abrindo entrada para permitir pessoa dentro. Para cada pessoa permitida, dados enviados ao dashboard ThingSpeak IoT aberto para visitantes verem.

Quando contagem pessoas excede limite de 50 (limite alterável conforme tamanho supermercado), portão fecha e tempo de espera 15min definido até clientes dentro saírem. Tempo espera exibido em display matriz LED para clientes na fila saberem duração.

Pessoas também acompanham número pessoas dentro da loja. Número pessoas permitidas entrar de uma vez: 50 pessoas.

Unidade física de fila deste produto ajuda estabelecer filas enquanto Dashboard IoT projeta contagem total clientes entrando e saindo. Atualmente este é dado do dashboard mas estou trabalhando em lógica para exibir tempo espera necessário para cliente entrar no shopping. Lógica é simples: depende de número pessoas dentro do shopping. Total pessoas entrando no dashboard menos total pessoas saindo no dashboard. Resultado = total pessoas dentro da loja. Próxima operação: total pessoas fora da loja subtraído pelo limite (limite que loja acomoda). Se resultado inteiro negativo, tempo espera = multiplicação do inteiro negativo pelo negativo do tempo médio pessoa gasta dentro da loja. Se resultado positivo, tempo espera = zero.

Implementação do Sistema Físico de Filas

Softwares usados no design deste modelo:

• TensorFlow Lite
• ThingSpeak
• Arduino Web Editor

Mesmo modelo pré-treinado TensorFlow de detecção de pessoa com três classes: "unused", "person", "notperson". Arducam Mini 2mp plus para captação de imagem, dados enviados ao Arduino Nano 33 BLE Sense para processamento/classificação. Microcontrolador com 256KB RAM, imagem redimensionada para 96x96. Framework deep learning: Depthwise Conv_2D, Conv_2D, AVERAGE Pool_2D, Flatten layer.

Função importante no Arduino_detection_responder.cpp:

uint8_t person_score = output->data.uint8[kPersonIndex];
uint8_t no_person_score = output->data.uint8[kNotAPersonIndex];
RespondToDetection(error_reporter, person_score, no_person_score);

Usando estas funções definidas, darei certas saídas baseadas na confiança do person-score e no_person_score.

Lógica do detection responder:

├── Detecção Pessoa e Responder - Entrada
├── Arducam mini 2MP Plus
│ ├── Dados Imagem e Vídeo para Arduino
├── Arduino BLE 33 Sense
│ ├── processamento e classificação dados entrada
│ │ ├── Se pessoa detectada, abre portão - servo(180)
│ │ ├── Se nenhuma pessoa detectada, fecha portão - servo(0)
│ │ ├── Envia contagem pessoas entradas para Dashboard ThingSpeak via ESP8266-01
│ │ │ ├── Se contagem pessoas excedeu 50
│ │ │ │ ├── Fecha portão & aguarda 15min para pessoas dentro saírem
│ │ │ │ ├── Exibe tempo espera em Display Matriz LED
│ │ └── ...Repete loop

├── Detecção Pessoa e Responder - Saída
├── Arducam mini 2MP Plus
│ ├── Dados Imagem e Vídeo para Arduino
├── Arduino BLE 33 Sense
│ ├── processamento e classificação dados entrada
│ │ ├── Se pessoa detectada, abre portão - servo(180)
│ │ ├── Se nenhuma pessoa detectada, fecha portão - servo(0)
│ │ ├── Envia contagem pessoas saídas para Dashboard ThingSpeak via ESP8266-01
│ │ └── ...Repete loop

Seguindo lógica, Arducam mini 2mp plus captura continuamente dados de imagem e envia ao Arduino 33 BLE Sense para processar/classificar. Modelo tamanho total 125KB. Se pessoa detectada, Arduino envia comando ao servo para rotacionar 180 graus. Se não detectada, servo rotaciona 0 graus e portão fecha. Cada detecção, contagem incrementa 1. Se contagem excede 50, não mais pessoas permitidas e espera 15min definida.

Tempo espera continuamente exibido e atualizado no display matriz LED.

Contagem também exibida no dashboard ThingSpeak via ESP8266-01.

Através do Dashboard, indivíduo facilmente visualiza número pessoas dentro em dado dia/hora.

No portão de saída, mesma lógica. Se pessoa detectada, portão abre; se não, fecha. Cada detecção, contagem incrementa 1. Exibida no dashboard ThingSpeak.

Assim monitora pessoas entrando e saindo.

Como dois modelos para entrada/saída deployados em microcontroladores diferentes, calcular tempo médio espera baseado em dados de microcontroladores diferentes é difícil, mas usa função lógica simples.

x = Nº pessoas que entraram
Y = Nº pessoas que saíram
X - Y = Nº pessoas dentro do shopping
Z = Limite de pessoas permitidas dentro
Z - (X - Y) = count {número pessoas (negativo) que cruzaram limite ou estão abaixo}
Se "count" negativo, tempo espera = count * (negativo do tempo médio pessoa gasta no shopping)
Se "count" positivo, tempo espera = zero

Desta forma, algoritmo de cálculo tempo médio fila imposto.

Funcionamento do Firmware:

Modelo compreende firmware:

• Arduino 33 BLE Sense - Processa dados, classifica, envia comandos.
• MG959 / MG995 Servo - Servo pesado (fonte externa pode ser aplicada) - Abre/fecha portões conforme comando.
• Arducam Mini 2mp plus - Acúmulo contínuo dados imagem brutos.
• Carregador lithium ion Adafruit - Entrega carga através bateria lítio.
• Bateria lithium ion - Fonte energia.
• ESP8266-01 - Envia dados ao dashboard ThingSpeak via rede WiFi.
• Display MAX7219 4 em 1 - Exibe tempo espera na tela.

Funcionamento e Lógica no Código:

Bibliotecas no main.ino:

#include <TensorFlowLite.h>
#include "main_functions.h"
#include "detection_responder.h"
#include "image_provider.h"
#include "model_settings.h"
#include "person_detect_model_data.h"
#include "tensorflow/lite/micro/kernels/micro_ops.h"
#include "tensorflow/lite/micro/micro_error_reporter.h"
#include "tensorflow/lite/micro/micro_interpreter.h"
#include "tensorflow/lite/micro/micro_mutable_op_resolver.h"
#include "tensorflow/lite/schema/schema_generated.h"
#include "tensorflow/lite/version.h"

Loop no main.ino:

void loop() {
  if (kTfLiteOk != GetImage(error_reporter, kNumCols, kNumRows, kNumChannels,
      input->data.uint8)) {
    TF_LITE_REPORT_ERROR(error_reporter, "Image capture failed.");
  }
  if (kTfLiteOk != interpreter->Invoke()) {
    TF_LITE_REPORT_ERROR(error_reporter, "Invoke failed.");
  }
  TfLiteTensor* output = interpreter->output(0);
  uint8_t person_score = output->data.uint8[kPersonIndex];
  uint8_t no_person_score = output->data.uint8[kNotAPersonIndex];
  RespondToDetection(error_reporter, person_score, no_person_score);
}

Trecho arduino_image_provider.cpp para inferência imagem capturada. Imagens convertidas para 96x96 padronizado. Usa biblioteca Arducam mini 2mp OV2640.

#if defined(ARDUINO) && !defined(ARDUINO_ARDUINO_NANO33BLE)
#define ARDUINO_EXCLUDE_CODE
#endif

#ifndef ARDUINO_EXCLUDE_CODE
#include <SPI.h>
#include <Wire.h>
#include <memorysaver.h>
#include <ArduCAM.h>
#include <JPEGDecoder.h>

#if !(defined OV2640_MINI_2MP_PLUS)
#error Please select the hardware platform and camera module in the Arduino/libraries/ArduCAM/memorysaver.h
#endif

#define MAX_JPEG_BYTES 4096
#define CS 7

ArduCAM myCAM(OV2640, CS);
uint8_t jpeg_buffer[MAX_JPEG_BYTES] = {0};
uint32_t jpeg_length = 0;

TfLiteStatus InitCamera(tflite::ErrorReporter* error_reporter) {
  TF_LITE_REPORT_ERROR(error_reporter, "Attempting to start ArduCAM");
  Wire.begin();
  pinMode(CS, OUTPUT);
  digitalWrite(CS, HIGH);
  SPI.begin();
  myCAM.write_reg(0x07, 0x80);
  delay(100);
  myCAM.write_reg(0x07, 0x00);
  delay(100);
  myCAM.write_reg(ARDUCHIP_TEST1, 0x55);
  uint8_t test = myCAM.read_reg(ARDUCHIP_TEST1);
  if (test != 0x55) {
    TF_LITE_REPORT_ERROR(error_reporter, "Can't communicate with ArduCAM");
    delay(1000);
    return kTfLiteError;
  }
}

Parte final onde modelo controlado completamente é Arduino_detection_responder.cpp.

Trecho da lógica completa. Quando score confiança pessoa maior que score não-pessoa, portão abre e assume pessoa detectada. Servo movido a 0 graus para abrir portão. Na detecção, contagem incrementa 1 (iniciou em 0). Contagem indica número pessoas entrando. Valor num contagem enviado ao dashboard ThingSpeak representando pessoas entrando. Quando contagem atinge 50; portão fecha e espera 15min imposta na fila. Portão fecha e espera imposta cada vez que 50 pessoas entram. Lógica de múltiplos de 50 definida.

if (person_score > no_person_score) {
  digitalWrite(LEDG, LOW);
  digitalWrite(LEDR, HIGH);
  servo_8.write(0); // servo move 0 graus para abrir porta shopping quando pessoa detectada para entrada sem toque
  count++
} else {
  digitalWrite(LEDG, HIGH);
  digitalWrite(LEDR, LOW);
  servo_8.write(180); // servo move 180 graus quando nenhuma pessoa detectada
}

TF_LITE_REPORT_ERROR(error_reporter, "Person score: %d No person score: %d",
  person_score, no_person_score);
}

// Agora deixamos entrar 50 pessoas na loja, definimos delay 15min espera para outros esperando fora entrarem
// Exibindo tempo espera na tela a cada 1min

if(count = y*50) // quando pessoas detectadas em múltiplos de 50, instrui começar exibir tempo espera para outros esperarem até 15 min
  myDisplay.setTextAlignment(PA_CENTER);
  myDisplay.print("Waiting 15min");
  delay(60000);

Configurando Dashboard ThingSpeak:

Como recursos no Dashboard Thingspeak são limitados, não implementarei algoritmo predição tempo agora mas estou trabalhando em lógica para comunicar e escrever dados do Dashboard para microcontrolador para realizar algoritmo cálculo tempo.

No Dashboard ThingSpeak, adicionei dois campos: um para entrada e outro para saída.

Coordenadas da loja/shopping para qual sistema filas exibido, também adicionadas como mapa.

Dados exibidos primeiro campo coletados através lógica responder entrada e segundo campo através lógica responder saída.

Dashboard ThingSpeak disponível para staff da loja verificar número pessoas entrando/saindo em tempo real. Dados também observados para análise em dado dia/hora para verificar e impor restrições se limite pessoas na loja excede esperado em dado dia.

Dashboard pode ser visto aqui: IoT Dashboard

Questão: modelo detecção pessoa pode ser substituído por sensores ultrassônicos/infravermelho? Falhas: não exatamente precisos, para contagem pessoa tempo real podem dar leituras erradas. Também adicionam hardware extra enquanto em soluções Go to Market, algoritmo detecção pessoa pode ser implementado em câmeras existentes e reduzir custo hardware. Dados destas câmeras enviados ao Arduino BLE Sense para classificação central e processamento dados.

GO TO MARKET & PRATICABILIDADE

• Shoppings/Supermercados usam para identificar contagem pessoas entrando/saindo em tempo real.
• Implementar estratégias usando dados para garantir Segurança e Conformidade com algoritmos eficientes gestão filas.
• Reduzir Mão de Obra e automatizar Processo Gestão Filas
• Oferecer Dashboard visitantes para monitorar densidade pessoas dentro shopping e visitar no horário mais seguro.
• Produto garante visitantes que shopping é local seguro, aumentando vendas/visitas seguindo guidelines governamentais
• Empresas oferecendo soluções IA e IoT podem investir para produção massa e distribuição.
• Mais supermercados usando, mais acesso dados governo e mais escolha clientes selecionarem local mais seguro na região junto com tempo fila requerido para cada loja monitorado. Leva a ampla gama opções supermercados comparando tempo fila e segurança.
• Solução comparativamente acessível vs sistema filas manual e atualização manual info Dashboard.
• Utilizar footage CCTV tempo real para impor gestão filas em shopping/loja através detecção pessoa em termos tendências temporais e análise espacial densidade pessoa no shopping.
• Permitir Lojas tomarem decisões data-driven melhores que garantam sua segurança e filas eficientes baseadas em sistema filas autônomo.

Github Code: Arduino Autonomous TinyML and IoT based queuing system.

Adição ao Algoritmo Existente de Detecção de Pessoa - Sistema de Detecção de Máscara

Modelo Detecção Máscara baseado em TinyML:

Dra. Kierstin Kennedy, chefe de medicina hospitalar na Universidade do Alabama em Birmingham, disse: "Máscaras protegem contra qualquer doença infecciosa transmitida por gotículas. Ex: gripe, coqueluche, pneumonia."

Adicionando que usar máscara de pano tem benefícios além de retardar propagação COVID-19, e controle de fonte pode reduzir transmissão de muitas outras infecções respiratórias facilmente espalhadas — tipo que tipicamente tornam pessoas infecciosas antes de exibirem sintomas, como influenza.

Até ameaça desta pandemia neutralizada, pessoas devem abraçar proteção máscaras permitem fornecer àqueles ao redor.

Não é sobre você — é sobre todos que você entra em contato.

Não é incomum ser portador assintomático do novo coronavírus — significa que mesmo sem sintomas, você pode potencialmente transmitir vírus a alguém que pode ficar gravemente doente ou morrer.

Adherindo a isto, decidi aumentar necessidade de usar máscaras junto com sistemas touch-free para aumentar segurança em shoppings/supermercados. Junto com algoritmo detecção pessoa, decidi fazer modelo custom detecção máscara facial que detecta máscaras e exibe dados no dashboard ThingSpeak IoT para aumentar awareness entre staff e visitantes para que saibam tendências temporais quando mais pessoas sem máscaras. Através disso há aumento de senso de aviso e awareness para usar máscaras. Staff da loja pode monitorar tendências e aumentar restrições baseadas em estatísticas data-driven.

Decidindo Lógica e Dataset do Modelo

Esta é lógica geral usada na maioria algoritmos detecção máscara facial. Como deployamos modelo no Arduino 33 BLE Sense, processo deploy variará.

Duas etapas na construção modelo Detecção Máscara Facial:

• Treinamento: Carregar dataset detecção máscara do disco, treinar modelo (usando Keras/TensorFlow) neste dataset, serializar detector máscara para disco
• Deploy: Uma vez detector máscara treinado, carregar detector, realizar detecção facial, classificar cada face como mask ou no_mask

Dataset usado no treino:

Dataset consiste em 3500 imagens mas para reduzir tamanho modelo e alimentar imagens precisas, usei 813 imagens para aumentar acurácia diminuindo volume. Modelo médio 676K e utiliza ~440.3K RAM. Como versão otimizada do original, acurácia 87,47% vs 98,15% não otimizado.

Softwares usados no design:

• TensorFlow Lite
• ThingSpeak
• Arduino Web Editor

Design do modelo no EdgeImpulse Studio:

Modelos deep learning poderosos (baseados em redes neurais artificiais) agora alcançam microcontroladores. No último ano, grandes avanços feitos para tornar modelos menores, mais rápidos e rodáveis em hardware embarcado através TensorFlow Lite for Microcontrollers, uTensor e Arm's CMSIS-NN; mas construir dataset qualidade, extrair features certas, treinar e deployar modelos ainda complicado.

Usando Edge Impulse pode coletar rapidamente dados sensores mundo real, treinar modelos ML nesses dados na nuvem, deployar modelo de volta ao dispositivo Arduino. Integrar modelo em sketches Arduino com única chamada função. Sensores ficam mais inteligentes, entendendo eventos complexos mundo real. Exemplos built-in permitem coletar dados acelerômetro e microfone, mas fácil integrar outros sensores com poucas linhas código.

Passo 1 - Aquisição Dados no Edge Impulse Studio:

Usando dataset 3500 imagens, filtrei para melhores imagens e alimentei 813 imagens no Treino e 487 no Teste. Rotulei classes como mask e no_mask.

Criei design impulso mais adequado ao tipo modelo. Para acurácia ótima, recomendado tamanho imagem padrão 96x96 que funciona melhor no Arduino 33 BLE Sense. Tipo entrada imagens, selecionei "images" no bloco processamento. Para bloco transfer learning, tipo recomendado para aprendizado imagem é Transfer Learning (Images) - fine tune modelo pré-treinado imagem nos seus dados. Bom desempenho mesmo com datasets imagem relativamente pequenos.

Próximo passo: salvar parâmetros baseados em profundidade cor. Selecionei RGB porque no dataset para detecção máscara, cor também feature importante classificação em vez de grayscale. Nesta página, também vemos features brutas com features processadas da imagem.

Após Geração Features, obtive gráfico classificação ou feature explorer onde vejo classes baseadas em classificações. Pontos azuis = imagens com máscara, laranja = sem máscara.

Nesta geração features, obtive classificação justa com gráfico classificação distinto.

Finalmente, Plot Transfer Learning:

Defini ciclos treino/epochs como 30 para maior acurácia com val_loss mínimo. Acontece que se treinar modelo em muitos ciclos, gráfico acurácia começa decrementar após certo número epochs e val_loss aumenta. Por isso limitei epochs a 30 que provou perfeito. Learning rate 0.0005 (default) mais apropriado. Usei modelo MobileNetV2 0.35 (camada final: 16 neurônios, 0.1 dropout) porque modelo comparativamente leve e preciso.

Após completar 30 epochs e 10 epochs melhor performance, obtive acurácia 1.00 e loss ~0 (0.0011). Saída final durante treino:

Saving best performing model... Converting TensorFlow Lite float32 model... Converting TensorFlow Lite int8 quantized model with float32 input and output...
Epoch 9/10 21/21 - 5s - loss: 0.0011 - accuracy: 1.0000 - val_loss: 0.0727 - val_accuracy: 0.9755
Epoch 10/10 21/21 - 5s - loss: 0.0012 - accuracy: 1.0000 - val_loss: 0.0728 - val_accuracy: 0.9755 Finished training

Saída final: acurácia 92,6% e loss 0,19.

Usando dados teste, testei acurácia: 98,15%.

Como modelo pronto, deployei como Biblioteca Arduino com firmware Arduino 33 BLE Sense: obtive pasta zip biblioteca e comecei mudanças conforme requisitos.

Para confirmação final, classifiquei dados ao vivo para garantir classificação correta. Resultados perfeitos como esperado:

Alterando código conforme saída requerida no modelo:

Trecho main.ino do modelo mask_detection:

Defini bibliotecas Arduino necessárias para funcionamento modelo e base framework Tensorflow lite, desenhei modelo.

Loop de algumas funções principais definidas nas bibliotecas. main.ino centraliza funções e loop com código central.

void loop() {
  if (kTfLiteOk != GetImage(error_reporter, kNumCols, kNumRows, kNumChannels,
      input->data.uint8)) {
    TF_LITE_REPORT_ERROR(error_reporter, "Image capture failed.");
  }
  if (kTfLiteOk != interpreter->Invoke()) {
    TF_LITE_REPORT_ERROR(error_reporter, "Invoke failed.");
  }
  TfLiteTensor* output = interpreter->output(0);
  uint8_t mask_score = output->data.uint8[kmaskIndex];
  uint8_t no_mask_score = output->data.uint8[kno-maskIndex];
  RespondToDetection(error_reporter, mask_score, no_mask_score);
}

Dados processados deste modelo podem ser vistos aqui: Arduino_mask_detect_model_data.h

Para fornecer imagem, usarei Arducam mini 2mp plus para entrada dados visual. Trecho image_provider.h:

#include "image_provider.h"
/* ... */
#if defined(ARDUINO) && !defined(ARDUINO_ARDUINO_NANO33BLE)
#define ARDUINO_EXCLUDE_CODE
#endif

#ifndef ARDUINO_EXCLUDE_CODE
#include <SPI.h>
#include <Wire.h>
#include <memorysaver.h>
#include <ArduCAM.h>
#include <JPEGDecoder.h>

#if !(defined OV2640_MINI_2MP_PLUS)
#error Please select the hardware platform and camera module in the Arduino/libraries/ArduCAM/memorysaver.h
#endif

Código Arduino_detection_responder.cpp realiza inferência e entrega saída principal. Quando pessoa com máscara detectada, abre portão; se sem máscara, fecha portão.

// Liga LED verde quando máscara detectada, vermelho quando não
if (mask_score > no_mask_score) {
  digitalWrite(LEDG, LOW);
  digitalWrite(LEDR, HIGH);
  servo_8.write(0); // servo move 0 graus para abrir porta shopping quando pessoa detectada para entrada sem toque
  count++
} else {
  digitalWrite(LEDG, HIGH);
  digitalWrite(LEDR, LOW);
  servo_8.write(180); // servo move 180 graus quando nenhuma pessoa detectada
  count2++
}

count e count2 são variáveis inteiras incrementando cada vez máscara detectada ou não. Contagens exibidas no Dashboard ThingSpeak IoT:

Gráfico exibe contagem máscara e sem máscara ao longo do tempo. Dashboard thingspeak configurado no código Arduino:

#include <WiFi.h>
#include <WiFiMulti.h>
WiFiMulti WiFiMulti;
const char* ssid = "Yourssid";
const char* password = "Wifipass";
const char* host = "api.thingspeak.com/channels/1118220";
String api_key = "9BRPKINQJJT2WMWP";

Código completo responder: Arduino_detection_responder.cpp

Github Code: Arduino Mask Detection

Dashboard ThingSpeak: IoT Dashboard

5º Projeto - Detecção de Pessoas em Corredores de Supermercado e Sistema de Auto-Sanitização

Assim como shoppings/supermercados/setor varejo reabriram, risco contaminação vírus aumentou. Principal risco em supermercados/lojas. Lojas podem ser roupas, alimentos, eletrônicos, vírus deposita e permanece nestas superfícies por longo tempo.

Dados iniciais sugerem novo coronavírus vive em superfícies por vários dias

Novo coronavírus é novo — ainda muito para aprender sobre facilidade propagação via superfícies contaminadas. Mas evidências iniciais indicam sobrevivência superfície similar a SARS, coronavírus relacionado identificado 2002. Dependendo superfície, vírus vive por algumas horas ou até vários dias.

Novo coronavírus sobrevive mais tempo em plástico e aço inoxidável — potencialmente até três dias. Também vive em papelão até 24 horas.

Descubra o que isso significa para coisas que você toca durante o dia:

• Roupas
• Alimentos
• Compras
• Pacotes
• Eletrônicos

Pandemia coronavírus deu nova vida a técnica décadas que zapa vírus/bactérias: luz ultravioleta.

Hospitais usam há anos para reduzir propagação superbactérias resistentes a drogas e desinfetar suítes cirúrgicas. Mas agora interesse em usar tecnologia em espaços como escolas, prédios comerciais, restaurantes para reduzir transmissão coronavírus quando espaços públicos reabrirem.

Efeitos sanitizantes luz UV vistos com outros coronavírus, incluindo SARS. Estudos mostram pode ser usado contra outros coronavírus. Estudo encontrou pelo menos 15 min exposição UVC inativou SARS, tornando impossível replicação vírus. Autoridade Trânsito Metropolitano NY anunciou uso luz UV em carros metrô, ônibus, centros tecnologia, escritórios. Academia Nacional Ciências diz embora não evidência concreta eficácia UV no vírus causador COVID-19, funcionou em outros vírus similares, então provavelmente combaterá este também.

Seguindo informação, Shoppings/Supermercados começaram impor soluções baseadas sanitização UV manual. Isso consome muito tempo e dados indisponíveis. Em processo manual, não se sabe qual área exposta a toque humano mais ou qual área maior risco contaminação.

Para automatizar processo e fornecer análise espacial tempo real dados coletados e taxa contaminação área.

Imagens demonstram distribuição população no shopping. Claramente visto Figura B, densidade perto escada rolante comparativamente alta vs segundo andar. Manualmente rastrear dados continuamente mudando em tempo real e sanitizar áreas/corredores conforme taxa contaminação não é tarefa manual.

Por isso, decidi fazer solução robusta automatizando processo com TinyML Visão Computacional & IoT deployado no Arduino 33 BLE Sense.

Framework estruturado deste sistema:

Modelos deployados individualmente nos Corredores e Áreas dos shoppings/supermercados próximo à área que deve ser sanitizada. Como modelo utiliza algoritmo detecção pessoa, posicionamento feito conforme.

Neste modelo, para acúmulo dados vídeo, Arducam mini 2MP Plus usado. Arducam Mini 2MP Plus continuamente coleta dados visuais e envia ao Arduino Nano 33 BLE Sense para processamento/classificação. Arduino classifica dados e processa comandos. Se pessoa detectada, contagem pessoas incrementa 1 na detecção cada pessoa perto do Corredor.

Limite certo para contagem pessoas definido dependendo taxa contaminação baseada tipo objeto naquela área. Taxa contaminação e limite para corredor alimentos, roupas, esportes, eletrônicos é diferente.

Considerando limite médio, se 25 pessoas detectadas, área segura. Se contagem aumenta 50, área rumo contaminação e visitantes alertados. Se contagem aumenta 100, área declarada contaminada e pessoas avisadas cuidado ao tocar objetos. Finalmente se limite cruza 150, área autônomamente sanitizada usando Luz UV.

Alertas gerados baseados em Cores LED. Verde = seguro, Azul = alerta, Vermelho = Aviso! Alertas baseados em LED instalados áreas individualmente.

Implementação do Sistema Autônomo de Sanitização

Softwares usados no design:

• TensorFlow Lite
• ThingSpeak
• Arduino Web Editor

Mesmo modelo pré-treinado TensorFlow detecção pessoa com classes "unused", "person", "notperson". Arducam Mini 2mp plus para captação imagem, dados enviados Arduino Nano 33 BLE Sense processamento/classificação. Microcontrolador 256KB RAM, imagem 96x96. Framework: Depthwise Conv_2D, Conv_2D, AVERAGE Pool_2D, Flatten layer.

Função importante Arduino_detection_responder.cpp:

uint8_t person_score = output->data.uint8[kPersonIndex];
uint8_t no_person_score = output->data.uint8[kNotAPersonIndex];
RespondToDetection(error_reporter, person_score, no_person_score);

Lógica detection responder:

├── Detecção Pessoa e Sanitização
├── Arducam mini 2MP Plus
│ ├── Dados Imagem e Vídeo para Arduino
├── Arduino BLE 33 Sense
│ ├── processamento e classificação dados entrada
│ │ ├── Se pessoa detectada, incrementa contagem 1
│ │ ├── Se nenhuma pessoa detectada, não faz nada
│ │ ├── Envia contagem pessoas para Dashboard ThingSpeak via ESP8266-01
│ │ │ ├── Se contagem pessoas até 25
│ │ │ │ ├── Indica área segura piscando luz verde
│ │ │ ├── Se contagem até 50
│ │ │ │ ├── Indica pessoas alerta piscando luz azul
│ │ │ ├── Se contagem até 100
│ │ │ │ ├── Indica área contaminada piscando luz vermelha
│ │ │ ├── Se contagem entre 150-175
│ │ │ │ ├── Sanitiza área ativando luz UV
│ │ │ │ ├── Reseta contagem pessoa para 0 já que área sanitizada
│ │ └── ...Repete loop

Conforme lógica, Arducam Mini 2MP Plus captura continuamente dados visuais e envia ao Arduino Nano 33 BLE Sense para processar/classificar. Modelo tamanho 125KB. Uma vez imagem processada, Arduino classifica dados. Se pessoa detectada, contagem pessoas aumenta 1. Contagem continuamente enviada ao dashboard ThingSpeak via ESP8266-01. Contagem permite staff supermercado com dados visitantes área em qualquer momento. Staff pode gerar decisões data-driven para ação se contagem visitantes significativamente alta.

Indo para saída: se contagem 1-25, área declarada segura piscando LED verde. Se 26-50, alerta visitantes piscando LED AZUL. Se 51-100, área declarada contaminada piscando LED VERMELHO. Quando contagem ultrapassa limite, aqui 150, luz UV ligada até 165ª pessoa passar área. Área sanitizada. Contagem pessoas resetada para 0 já que área sanitizada.

Funcionamento do Firmware:

Modelo compreende firmware:

• Arduino 33 BLE Sense - Processa dados, classifica, envia comandos.
• Arducam Mini 2mp plus - Acúmulo contínuo dados imagem brutos.
• Carregador lithium ion Adafruit - Entrega carga através bateria lítio.
• Bateria lithium ion - Fonte energia.
• ESP8266-01 - Envia dados dashboard ThingSpeak via WiFi.
• LED RGB - Pisca sinais baseados status contaminação.
• Luz UV - Sanitiza Área (protótipo: LED exibido. Solução real: luz UV consome muita energia, fonte externa necessária).

Funcionamento e Lógica no Código:

Bibliotecas no main.ino:

#include <TensorFlowLite.h>
#include "main_functions.h"
#include "detection_responder.h"
#include "image_provider.h"
#include "model_settings.h"
#include "person_detect_model_data.h"
#include "tensorflow/lite/micro/kernels/micro_ops.h"
#include "tensorflow/lite/micro/micro_error_reporter.h"
#include "tensorflow/lite/micro/micro_interpreter.h"
#include "tensorflow/lite/micro/micro_mutable_op_resolver.h"
#include "tensorflow/lite/schema/schema_generated.h"
#include "tensorflow/lite/version.h"

Resultado principal modelo depende lógica em detection_responder.cpp. Trecho mostra limite generalizado contaminação objeto definido contagem 101.

void RespondToDetection(tflite::ErrorReporter* error_reporter,
  uint8_t person_score, uint8_t no_person_score) {
  static bool is_initialized = false;
  if (!is_initialized) {
    pinMode(LEDR, OUTPUT);
    pinMode(LEDG, OUTPUT);
    pinMode(LEDB, OUTPUT);
    is_initialized = true;
  }

  // LEDs RGB no Arduino Nano 33 BLE Sense acesos quando pino LOW, apagados HIGH
  digitalWrite(LEDG, HIGH);
  digitalWrite(LEDR, HIGH);
  digitalWrite(LEDB, LOW);
  delay(100);
  digitalWrite(LEDB, HIGH);

  if (person_score > no_person_score) {
    digitalWrite(LEDG, LOW);
    digitalWrite(LEDR, HIGH);
    count++
  } else {
    digitalWrite(LEDG, HIGH);
    digitalWrite(LEDR, LOW);
  }

  TF_LITE_REPORT_ERROR(error_reporter, "Person score: %d No person score: %d",
    person_score, no_person_score);
}

if (constrain(count, 1, 50)) {
  digitalWrite(LEDGREEN, LOW); // LED verde = área não contaminada
}
if (constrain(count, 51, 75)) {
  digitalWrite(LEDBLUE, LOW); // LED azul = alerta >50 pessoas
}
if (constrain(count, 76,100)) {
  digitalWrite(LEDRED, LOW); // LED vermelho = aviso área contaminada
}
if (constrain(count, 101, 110)) {
  digitalWrite(UV, LOW); // Luz UV sanitiza após 100 pessoas tocarem objetos
}
if (count > 111) {
  (count = 0); // reseta contagem pessoa 0 após área sanitizada por UV
}
/* cc - Dhruv Sheth */

Trecho executado pelo ESP8266-01 para enviar dados ao campo ThingSpeak:

void Send_Data() {
  WiFiClient client;
  const int httpPort = 80;

  if (!client.connect(host, httpPort)) {
    Serial.println("connection failed");
    return;
  } else {
    String data_to_send = api_key;
    data_to_send += "&field1=";
    data_to_send += String(count);
    data_to_send += "\r\n";

    client.print("POST /update HTTP/1.1\n");
    client.print("Host: api.thingspeak.com\n");
    client.print("Connection: close\n");
    client.print("X-THINGSPEAKAPIKEY: " + api_key + "\n");
    client.print("Content-Type: application/x-www-form-urlencoded\n");
    client.print("Content-Length: ");
    client.print(data_to_send.length());
    client.print("\n\n");
    client.print(data_to_send);

    delay(10); // delay reduzido para coleta tempo real
  }
  client.stop();
}

Limite para cada Corredor dentro shopping definido diferente conforme taxa contaminação modelo. Dados alterados conforme necessidade shoppings/supermercados. Limites também alterados conforme tendências temporais e densidade populacional área.

Limite Corredor Roupas:

if (constrain(count, 1, 50)) { digitalWrite(LEDGREEN, LOW); }
if (constrain(count, 51, 75)) { digitalWrite(LEDBLUE, LOW); }
if (constrain(count, 76,100)) { digitalWrite(LEDRED, LOW); }
if (constrain(count, 101, 110)) { digitalWrite(UV, LOW); }
if (count > 111) { (count = 0); }

Limite Corredor Eletrônicos: Vírus permanece menos nestas superfícies, limite maior.

if (constrain(count, 1, 75)) { digitalWrite(LEDGREEN, LOW); }
if (constrain(count, 76, 180)) { digitalWrite(LEDBLUE, LOW); }
if (constrain(count, 181,225)) { digitalWrite(LEDRED, LOW); }
if (constrain(count, 225, 240)) { digitalWrite(UV, LOW); }
if (count > 111) { (count = 0); }

Limite Alimentos e Comestíveis: Risco contaminação maior, limite menor.

if (constrain(count, 1, 25)) { digitalWrite(LEDGREEN, LOW); }
if (constrain(count, 25, 50)) { digitalWrite(LEDBLUE, LOW); }
if (constrain(count, 51,75)) { digitalWrite(LEDRED, LOW); }
if (constrain(count, 76, 90)) { digitalWrite(UV, LOW); }
if (count > 91) { (count = 0); }

Configurando Dashboard IoT Thingspeak:

No dashboard thingspeak, 4 campos adicionados para 4 corredores configurados:

• Food-aisle
• Sports-aisle
• Clothes-aisle
• Electronics-aisle

Coordenadas localização shopping vistas na visualização canal exibidas cumulativamente em dashboard único através do qual dados cada supermercado/shopping na localidade acessados.

Dashboard IoT: IoT Dashboard

Campos e canais corredores exibidos juntos em único Dashboard ThingSpeak IoT.

Imagem mostra plot densidade população em região dada na loja do shopping.

Atualmente usando Dashboard ThingSpeak para plotar dados formato gráfico. Mas, usando mesmos dados e visualizações Tableau, possível plotar dados no mapa de planta do Supermercado.

Dados facilmente acessíveis a outros visitantes entrando supermercado e poderão interpretar decisões data-driven como visitar loja com menor densidade populacional.

O que torna produto único:

Atualmente, sistema sanitização UV implementado base manual e sanitização realizada monitorando áreas manualmente. Robôs UV autônomos deployados em shoppings para coletar dados planta e mapear áreas, sanitizando autonomamente. Estas soluções não capazes de sanitizar cada corredor/área no shopping junto com população fluindo pessoas. Sanitização limitada a parte inferior destes corredores, partes superiores não sanitizadas. Soluções comparativamente caras e não capazes de monitoramento contínuo dados e sanitização respectiva taxa contaminação. Significa que não monitoram número pessoas passaram por certa área/corredor e não sanitizam áreas conforme contaminação.

Go to Market e Viabilidade:

• Shoppings/Supermercados usam para identificar contagem pessoas e densidade em certa área loja e impor auto-sanitização dentro shoppings.
• Implementar estratégias usando dados para garantir Segurança e Conformidade com algoritmos eficientes monitoramento densidade populacional.
• Reduzir Mão de Obra e automatizar Processo Sanitização.
• Oferecer Dashboard visitantes para monitorar densidade pessoas em certa área dentro shopping e visitantes têm visão loja com menor densidade populacional e tomam decisões baseadas nisto. Visitantes também veem tendências temporais sanitização vendo mudança abrupta gráfico densidade pessoa em área quando sanitização realizada. (Como cada sanitização em área, contagem pessoa resetada para 0 porque local sanitizado)

• Produto garante visitantes que shopping é local seguro, aumentando vendas/visitas seguindo guidelines governamentais
• Empresas oferecendo soluções IA e IoT podem investir para produção massa e distribuição.
• Mais supermercados usando, mais acesso dados governo e mais escolha clientes selecionarem local mais seguro na região e qual loja continuamente sanitizada para estar em dia com segurança. Leva a ampla gama opções supermercados comparando tempo fila e segurança.
• Solução comparativamente acessível vs sistema robô UV autônomo e altamente escalável em termos dados e serviços com Dashboard IoT fornecido.
• Utilizar footage CCTV tempo real para impor sistema sanitização autônomo através detecção pessoa em termos tendências temporais e análise espacial densidade pessoa no shopping.
• Permitir Lojas tomarem decisões data-driven melhores que garantam sua segurança e filas eficientes baseadas em sistema filas autônomo.

Github Link: https://github.com/dhruvsheth-ai/self-sanitisation-person-detection

VÍDEO DO PROJETO

Obrigado por ver meu projeto!

Código

Automação Elevador usando comandos fala "up" - "down"

Arquivo .zip da Biblioteca Arduino

No preview (download only).

Sanitização Automática Corredor Shopping com Sistema Detecção Pessoa

https://github.com/dhruvsheth-ai/self-sanitisation-person-detetction

Sistema monitoramento temperatura baseado IoT

https://github.com/dhruvsheth-ai/temperature-arduino-iot

Algoritmo Detecção Máscara

https://github.com/dhruvsheth-ai/ble-mask-detection-optimised

Interfone Autônomo Pessoa baseado TinyML

https://github.com/dhruvsheth-ai/person-autonomous-intercom

Automação Elevador usando TinyML

https://github.com/dhruvsheth-ai/elevator-Automation-ARDUINO

Sistema Detecção Pessoa e Filas Entrada Shopping

Sistema Filas baseado TinyML detecção pessoa Entrada/Saída Shopping conectado via IoT Thingspeak dashboard monitoramento dados ao vivo

https://github.com/dhruvsheth-ai/Person-queuing-system-arduino33

Esquemáticos