Octopod: Solução Inteligente de Automação IoT para Casa e Indústria

Componentes e Materiais

Arduino UNO	1
Arduino MKR WiFi 1010 (ou qualquer ESP8266/ESP32; usei NodeMCU ESP8266 por indisponibilidade)	1
Maxim Integrated MAX32630FTHR (pode usar MAX32620FTHR, Arduino 1010 ou qualquer ESP8266; precisa WiFi externo)	1
Raspberry Pi Zero Wireless (pode usar Pi 2/3 normal)	1
Sensor Temperatura e Umidade DHT11 (4 pinos)	1
Sensor de Gás Seeed Grove MQ2	1
Sensor Umidade do Solo SparkFun (com terminais de parafuso)	1
Sensor de Movimento PIR (genérico)	1 (opcional)
Leitor RFID (genérico)	1
Relé (genérico, 2 canais preferencialmente)	1
LED RGB Difuso Cátodo Comum	1
Módulo Câmera Raspberry Pi	1
Servos Tower Pro MG996R	1
Buzzer	2
Módulo Bluetooth HC-05	1 (opcional)
LED (genérico)	4
Adaptador de Parede / Power Bank	2
Cartão de Memória (>4GB, preferencialmente Classe 10, necessário para Raspberry Pi OS)	1

Ferramentas Necessárias

• Pistola de Cola Quente (genérica)
• Impressora 3D (genérica, opcional)
• Ferramentas Manuais (alicate de bico, tesoura, estilete, etc.)

Aplicativos e Serviços Online

• Blynk
• OpenCV

Sobre o Projeto

Existem muitos projetos de automação IoT, mas confie: nada se compara a este! O Octopod é feito com NodeMCU (MAX32620FTHR ou Arduino MKR 1010), Arduino Uno e Raspberry Pi 3. Permite tornar sua casa inteligente. Envia diversos dados como temperatura, umidade e qualidade do gás dentro de casa/escritório/indústria. Envia notificação ao detectar qualquer movimento e avisa quando precisa regar plantas. Também controla eletrodomésticos via app Blynk no smartphone. Permite até iluminação de ambiente (mood lighting)!

O Octopod tem uma minúscula câmera que envia feed ao vivo. Esta câmera usa inteligência artificial (OpenCV) para detectar humanos em seu campo de visão e envia suas fotos por e-mail. Além disso, possui sistema de fechadura de porta por RFID! Incrível, certo?

Como Tudo Funciona

O NodeMCU conecta a vários sensores, módulo relé e LEDs RGB. Conecta ao app Blynk no smartphone via WiFi, enviando todos os dados e permitindo controle da casa.

O Raspberry Pi também conecta ao WiFi, permitindo ver feed ao vivo via Pi Camera. Instalamos bibliotecas OpenCV no Pi e configuramos para detectar humanos em seu campo de visão e enviar suas imagens por e-mail.

A unidade de porta inteligente usa módulo RFID. Quando RFID autorizado aproxima-se, abre a porta automaticamente.

PASSO 1: Programando o Octopod Principal

Adicionei comentários em quase todas as linhas para que você não apenas copie, mas entenda. Resumo do que acontece quando o código roda:

Incluindo Bibliotecas

Usa 2 bibliotecas principais: Blynk (compatibilidade com app Blynk) e DHT11 (converte dados brutos do sensor em temperatura/umidade). Baixe nos links do código, depois Arduino IDE → Sketch → Include Library → Add .ZIP Library.

#include <ESP8266WiFi.h>
#include <BlynkSimpleEsp8266.h>
#include <DHT.h>
#define BLYNK_PRINT Serial

Código Blynk para conectar NodeMCU à internet e autenticar no app:

char auth[] = "Sua Chave Auth Blynk";
char ssid[] = "Seu SSID WiFi";
char pass[] = "Sua Senha WiFi";

Definindo Pinos e Variáveis

#define DHTPIN 2       // Pino digital do sensor temp/umidade
#define soilPin 4      // Pino digital do sensor umidade solo
#define gasPin A0      // Pino analógico do sensor gás
#define pirPin 12      // Pino digital do sensor PIR
int pirValue, soilValue;
int PIRpinValue, SOILpinValue; // Valores vindos do app Blynk (pinos virtuais V0, V1)

BLYNK_WRITE()

Diz ao app Blynk que pinos V0 e V1 controlam se Detecção de Movimento e Teste Umidade Solo estão LIGADOS.

BLYNK_WRITE(V0) { PIRpinValue = param.asInt(); }
BLYNK_WRITE(V1) { SOILpinValue = param.asInt(); }

void sendSensor()

Lê DHT11, torna dados utilizáveis, envia para pinos virtuais V5 (umidade) e V6 (temperatura).

void sendSensor() {
  int h = dht.readHumidity();
  int t = dht.readTemperature();
  if (isnan(h) || isnan(t)) {
    Serial.println("Falha ao ler sensor DHT!");
    return;
  }
  Blynk.virtualWrite(V5, h);
  Blynk.virtualWrite(V6, t);
}

void getPirValue() & void getSoilValue()

Lê valor digital dos sensores, verifica estado via if-else. Se sensor no estado requerido, envia notificação pelo app Blynk.

void getPirValue() {
  pirValue = digitalRead(pirPin);
  if (pirValue) {
    Serial.println("Movimento detectado");
    Blynk.notify("Movimento detectado");
  }
}
void getSoilValue() {
  soilValue = digitalRead(soilPin);
  if (soilValue == HIGH) {
    Serial.println("Regar Plantas");
    Blynk.notify("Regar Plantas");
  }
}

void setup()

Inicia serial em 9600 baud, autoriza código no app Blynk, inicia leitura DHT, tuíta que projeto está online, define pinos PIR e Solo como entrada, configura timer para chamar sendSensor a cada segundo.

void setup() {
  Serial.begin(9600);
  Blynk.begin(auth, ssid, pass);
  dht.begin();
  Blynk.tweet("OCTOPOD IS ONLINE!");
  pinMode(pirPin, INPUT);
  pinMode(soilPin, INPUT);
  timer.setInterval(1000L, sendSensor);
}

void loop()

Executa Blynk.run() e timer.run(). Verifica estado dos pinos virtuais V0 e V1 e lê sensores conforme necessário.

void loop() {
  Blynk.run();
  timer.run();
  if (PIRpinValue == HIGH) getPirValue();
  if (SOILpinValue == HIGH) getSoilValue();
}

PASSO 2: Programando a Fechadura Inteligente RFID

Código simples. Duas versões: uma com Bluetooth (avisa via terminal serial quando porta abre), outra sem (serial para monitor do computador). Prefiro versão simples sem Bluetooth.

1. Arduino IDE: Sketch → Include Library → Manage Libraries → busque "MFRC522" e instale. File → Examples → Custom Libraries → MFRC522 → dumpInfo Sketch. No início mostra conexão dos pinos. Rode código, abra monitor serial, aproxime cartão RFID do módulo MFRC522 por 5 segundos. Anote UID do cartão. Repita para outros cartões/chaveiros.
2. Baixe código desejado. Abra e vá à linha: if (content.substring(1) == "XX XX XX XX") — substitua X's pelo UID do cartão que deve abrir a porta. Carregue o código.

No código, no if-else: se UID corresponde, move servo (abre porta), pisca LEDs, toca buzzer. Senão, pisca LEDs diferentes e toca buzzer de erro.

PASSO 3: Configuração Raspberry Pi - Detecção Humana com IA

Guia para criar Câmera de Segurança Inteligente. Câmera envia e-mail ao detectar objeto. Se na mesma rede WiFi, acessa feed ao vivo digitando IP do Raspberry Pi. Mostro como criar do zero.

Requisitos

• OpenCV (Open Source Computer Vision Library)
• Raspberry Pi 3B
• Raspberry Pi Camera V2

Pressupostos

• Raspberry Pi 3 com Raspbian Stretch instalado. Se não tem, faça upgrade (download + instruções). Recomendo instalação limpa do Raspbian Stretch!
• Acesso físico ao Pi para abrir terminal e executar comandos. Acesso remoto via SSH ou VNC também funciona.

Passo 1: CONECTANDO CÂMERA AO RASPBERRY PI 3

1. Abra módulo câmera. Cuidado com eletricidade estática — toque objeto aterrado antes de retirar da bolsa antiestática.
2. Instale cabo da câmera no conector entre portas Ethernet e HDMI, conectores prateados voltados para HDMI.
3. Inicie o Raspberry Pi.
4. Execute sudo raspi-config. Se opção "camera" não listada, rode sudo apt-get update e sudo apt-get upgrade.
5. Rode sudo raspi-config novamente — opção "camera" deve aparecer (em interfacing options). Habilite, selecione "Finish" e reinicie: sudo reboot.

Passo 2: INSTALAÇÃO OPENCV

Se primeira vez instalando OpenCV ou começando com Raspbian Stretch, este tutorial é ideal.

Passo #1: Expandir filesystem

Nova instalação do Raspbian Stretch? Expanda filesystem para usar todo espaço do micro-SD:

sudo raspi-config

Selecione "Advanced Options" → "Expand filesystem" → "A1. Expand File System" → Enter → "OK" → reboot. Se cartão 8GB, pode estar usando ~50% espaço. Delete LibreOffice e Wolfram para liberar espaço:

sudo apt-get purge wolfram-engine
sudo apt-get purge libreoffice*
sudo apt-get clean
sudo apt-get autoremove

Recupera quase 1GB!

Passo #2: Instalar dependências

sudo apt-get update && sudo apt-get upgrade
sudo apt-get install build-essential cmake pkg-config
sudo apt-get install libjpeg-dev libtiff5-dev libjasper-dev libpng12-dev
sudo apt-get install libavcodec-dev libavformat-dev libswscale-dev libv4l-dev
sudo apt-get install libxvidcore-dev libx264-dev
sudo apt-get install libgtk2.0-dev libgtk-3-dev
sudo apt-get install libatlas-base-dev gfortran
sudo apt-get install python2.7-dev python3-dev

Passo #3: Baixar código fonte OpenCV

cd ~
wget -O opencv.zip https://github.com/Itseez/opencv/archive/3.3.0.zip
unzip opencv.zip
wget -O opencv_contrib.zip https://github.com/Itseez/opencv_contrib/archive/3.3.0.zip
unzip opencv_contrib.zip

Versões opencv e opencv_contrib devem coincidir (3.3.0).

Passo #4: Python 2.7 ou Python 3? Instalar pip

wget https://bootstrap.pypa.io/get-pip.py
sudo python get-pip.py
sudo python3 get-pip.py

Recomendo virtualenv e virtualenvwrapper para ambientes isolados:

sudo pip install virtualenv virtualenvwrapper
sudo rm -rf ~/.cache/pip

Atualize ~/.profile adicionando ao final:

# virtualenv and virtualenvwrapper
WORKON_HOME=$HOME/.virtualenvs
source /usr/local/bin/virtualenvwrapper.sh

Recarregue: source ~/.profile (faça isso cada vez que abrir terminal).

Crie ambiente virtual Python:

mkvirtualenv cv -p python2
# ou para Python 3:
mkvirtualenv cv -p python3

Para acessar depois: source ~/.profile && workon cv. Verifique se vê (cv) no prompt.

Passo #5: Compilar e Instalar OpenCV

workon cv
cd ~/opencv-3.3.0/
mkdir build
cd build
cmake -D CMAKE_BUILD_TYPE=RELEASE \
  -D CMAKE_INSTALL_PREFIX=/usr/local \
  -D INSTALL_PYTHON_EXAMPLES=ON \
  -D OPENCV_EXTRA_MODULES_PATH=~/opencv_contrib-3.3.0/modules \
  -D BUILD_EXAMPLES=ON ..

Verifique saída do CMake: seção Python 2 e Python 3 deve mostrar paths válidos para Interpreter, Libraries, numpy, packages no ambiente cv. Se não vê cv, você NÃO está no ambiente virtual — execute workon cv e rode cmake novamente.

Configurar swap space antes de compilar

Edite /etc/dphys-swapfile:

# CONF_SWAPSIZE=100
CONF_SWAPSIZE=1024

Ative novo swap:

sudo /etc/init.d/dphys-swapfile stop
sudo /etc/init.d/dphys-swapfile start

Nota: swap grande pode corromper microSD. Recomendo voltar para 100MB após compilar.

Compile OpenCV (usa 4 núcleos):

make -j4

Se der erro, recompile com 1 núcleo: make clean && make.

Instale:

sudo make install
sudo ldconfig

Passo #6: Finalizar instalação OpenCV no Pi

Para Python 2.7: verifique /usr/local/lib/python2.7/site-packages/cv2.so. Crie symlink no ambiente virtual:

cd ~/.virtualenvs/cv/lib/python2.7/site-packages/
ln -s /usr/local/lib/python2.7/site-packages/cv2.so cv2.so

Para Python 3: arquivo sai como cv2.cpython-35m-arm-linux-gnueabihf.so — renomeie para cv2.so e crie symlink:

cd /usr/local/lib/python3.5/site-packages/
sudo mv cv2.cpython-35m-arm-linux-gnueabihf.so cv2.so
cd ~/.virtualenvs/cv/lib/python3.5/site-packages/
ln -s /usr/local/lib/python3.5/site-packages/cv2.so cv2.so

Passo #7: Testar instalação OpenCV 3

source ~/.profile
workon cv
python
>>> import cv2
>>> cv2.__version__
'3.3.0'

Sucesso! Remova diretórios opencv para liberar espaço: rm -rf opencv-3.3.0 opencv_contrib-3.3.0 (cuidado: só após confirmar instalação).

Restaure swap para 100MB:

# CONF_SWAPSIZE=100
# CONF_SWAPSIZE=1024
sudo /etc/init.d/dphys-swapfile stop
sudo /etc/init.d/dphys-swapfile start

PASSO 4: Configurando Programa Python

Verifique câmera: raspistill -o image.jpg salva imagem no diretório atual.

Baixe arquivos Python e modelos: Google Drive.

Ative ambiente virtual: source ~/.profile && workon cv.

Navegue ao diretório e instale dependências:

cd Smart-Security-Camera
pip install -r requirements.txt

Configure e-mail em mail.py (vim mail.py → i para editar):

fromEmail = 'meuemail@gmail.com'
fromEmailPassword = 'senha1234'
toEmail = 'outroemail@gmail.com'

O mail.py loga no SMTP Gmail e envia e-mail com imagem do objeto detectado. Salve (esc + ZZ).

Modifique main.py se quiser:

email_update_interval = 600 // envia e-mail apenas uma vez neste intervalo
video_camera = VideoCamera(flip=True)
object_classifier = cv2.CascadeClassifier("models/fullbody_recognition_model.xml")

Execute: python main.py.

Veja stream ao vivo acessando IP do Pi no navegador (mesma rede). Descubra IP com ifconfig (procure inet address). Acesse :5000 no browser.

Nota: Para ver stream em rede diferente, use ngrok: ./ngrok http 5000 e acesse link gerado. Stream não inicia automaticamente no boot — adicione em /etc/rc.local.

Ao receber primeiro e-mail, Google pode bloquear apps menos seguros. Clique em "permitir less secure apps" e ative. Próximo objeto detectado enviará e-mail.

PASSO 4: Configuração Interface App Blynk

Um dos passos mais fáceis e divertidos. Vamos lá?

1. Baixe app Blynk (App Store / Google Play). Cadastre-se / login.
2. New Project → nomeie → Device: NodeMCU → Connection: WiFi → Create.
3. Receberá Auth Key por e-mail. Copie e adicione ao código.
4. Clique + para adicionar widgets (pode precisar comprar energia).
5. Adicione 3 Gauges: Temperature (Virtual Pin V6, range 0-50°C, label °C, reading rate Push). Repita para Humidity (V5) e Gas (V7).
6. Adicione zeRGBa: R → GP15, G → GP3, B → GP1.
7. Adicione 4 Buttons, mude cores, configure conforme imagens.
8. Adicione SuperChart: 3 data streams (Temperature, Humidity, Gas) com cores, pinos, range, sufixo.
9. Adicione abas. Segunda aba: Twitter, Notifications, Email, Eventor. Twitter: usuário/senha. Notifications: ligue "Notify when hardware goes off". Email: seu e-mail. Eventor: configure gatilhos (veja imagens).
10. Pronto. Clique play para usar interface. Pode personalizar como quiser!

PASSO 5: Construindo Estrutura do Octopod

Aviso - Processo mais demorado!

Nota: Pode pular e imprimir em 3D o gabinete que forneci!

Passo opcional mas mais importante! Pode usar caixa de sapato e evitar trabalho. Mas o trabalho duro torna o projeto único. Ideia surgiu fazendo lição de matemática — forma inspirada em octógono. Na verdade, um octógono 3D!

Fazendo a Estrutura

• Desenhe retângulo 9cm x 9.5cm no papelão (dimensões ajustáveis). Junte ponta a ponta desenhando 4 retângulos similares (8 se papelão longo).
• Faça cortes parciais (tipo vinco) entre retângulos e recorte peça inteira. Repita até ter 4 peças longas.
• Com transferidor, desenhe ângulo 135° e recorte. Faça 16 ângulos iguais.
• Cole ângulos entre peças pequenas com cola quente. Repita em todas juntas.
• Una 2 estruturas abertas para fechar (formato octógono).
• Cole outras 2 perpendicularmente, formando forma 3D.
• Corte 4 peças 9 x 9.5 cm e cole nos espaços vazios.
• Restarão 8 triângulos abertos. Corte 8 triângulos de papel vegetal/acrílico para fechar, mas não cole ainda.

Pintura

Vá para área aberta! Use máscara e luvas. Passe uma demão na estrutura. YouTube tem dicas para acabamento perfeito. Seque 4-5 horas, passe 2ª demão. 3 demões são bons.

Pronto! Peça única de arte.

PASSO 6: Fazendo Gabinete da Fechadura

Simples: caixa de sapato + 2-3 demões de tinta spray. Para design, faça padrão xadrez com fita adesiva.

PASSO 7: Montando o Octopod

Tornei simples com diagrama esquemático. Consulte imagem ou arquivo, faça conexões. Explico brevemente:

• NodeMCU em protoboard grande. Fonte de alimentação protoboard também conectada. NodeMCU, sensores, LEDs e outros componentes alimentados pela fonte.
• Conexões sensores:
  • DHT11 → D4 / GP2
  • MQ2 → A0 / adc00
  • Sensor Umidade Solo → D2 / GP4
  • PIR → D6 / GP1
  • RGB: R → D8 / GP15, G → Rx / GP3, B → Tx / GP1
  • Relé: Ln1 → D0 / GP16, Ln2 → D5 / GP14
• Alimente com Power Bank ou Adaptador de Parede na fonte protoboard.
• Raspberry Pi com Camera: faça furo pequeno em uma parede do papelão e cole/grude a câmera.
• Insira eletrônica por triângulo aberto e feche com recortes de papel vegetal. Deixe 1-2 abertos para manutenção. Deixe pontas do sensor umidade do solo para fora.

Tudo pronto! Ligar energia e colocar Octopod na mesa de jantar ou mesa de convidados. Para ver feed ao vivo do Raspberry Pi, abra navegador e digite IP do Pi. Divirta-se!

PASSO 8: Montando a Fechadura

Após carregar código no Arduino, faça conexões conforme imagem ou arquivo fritzing. Simples. Faça 2 furos na caixa de sapato para LEDs e deixe servo exposto. Travas mecânicas com servo existem no mercado, mas servo funciona bem. Experimento apenas — não use como fechadura real! Cole RFID em uma parede da caixa e também protoboard pequena e Arduino. Use adaptador de parede ou power bank. Ligue Arduino e pronto!

CONCLUSÃO

Projeto muito divertido! Fiquei feliz com resultado. Luzes ficaram ótimas, vale a pena fazer mesmo que apenas uma como abajur. Não agradeço o suficiente aos criadores do Blynk e OpenCV — excelentes softwares que tornaram isso possível! Dúvidas? Pergunte nos comentários. Obrigado! Vote em nós!

- Saksham

Blog Arduino | Instructable Completo

ATUALIZAÇÃO

Trabalhando na integração com Amazon Alexa, quase pronto. Subirei código em 2-3 dias!

Código

• octopod.ino
• octopod_door.ino
• octopod_door_bluetooth.ino

octopod.ino (Arduino) — Código principal para Arduino MKR 1010 (NodeMCU no meu caso)

Se usar MAX32620FTHR, baixe bibliotecas, mude board nas configurações e pinos conforme tabela:

ESP       MAX
AO  ---   GPIO2
A1  ---   GPIO1

Soil Sensor MAX
analog sensor --- GPIO3

Gas Sensor (MQ2) MAX
sensor  ---   GPIO4

PIR Sensor MAX
sensor  ---   GPIO0

Relay MAX
1  ---   M0
2  ---   M1

/***************************************************************************
 OCTOPOD: PROJETO DE AUTOMAÇÃO RESIDENCIAL INTELIGENTE POR SAKSHAM
 Baixe biblioteca Blynk mais recente: https://github.com/blynkkk/blynk-library/releases/latest
 Baixe biblioteca DHT Sensor mais recente: https://github.com/adafruit/DHT-sensor-library
***************************************************************************/
#include <ESP8266WiFi.h>
#include <BlynkSimpleEsp8266.h>
#include <DHT.h>
#define BLYNK_PRINT Serial

char auth[] = "Sua Chave Auth Blynk";
char ssid[] = "Seu SSID WiFi";
char pass[] = "Sua Senha WiFi";

#define DHTPIN 2
#define soilPin 4
#define gasPin A0
#define pirPin 12

int pirValue, soilValue;
int PIRpinValue, SOILpinValue;

#define DHTTYPE DHT11
//#define DHTTYPE DHT22
//#define DHTTYPE DHT21
DHT dht(DHTPIN, DHTTYPE);
BlynkTimer timer;

BLYNK_WRITE(V0) { PIRpinValue = param.asInt(); }
BLYNK_WRITE(V1) { SOILpinValue = param.asInt(); }

void sendSensor() {
  int h = dht.readHumidity();
  int t = dht.readTemperature();
  if (isnan(h) || isnan(t)) {
    Serial.println("Falha ao ler sensor DHT!");
    return;
  }
  Blynk.virtualWrite(V5, h);
  Blynk.virtualWrite(V6, t);
}

void getPirValue() {
  pirValue = digitalRead(pirPin);
  if (pirValue) {
    Serial.println("Movimento detectado");
    Blynk.notify("Movimento detectado");
  }
}

void getSoilValue() {
  soilValue = digitalRead(soilPin);
  if (soilValue == HIGH) {
    Serial.println("Regar Plantas");
    Blynk.notify("Regar Plantas");
  }
}

void setup() {
  Serial.begin(9600);
  Blynk.begin(auth, ssid, pass);
  dht.begin();
  Blynk.tweet("OCTOPOD IS ONLINE!");
  pinMode(pirPin, INPUT);
  pinMode(soilPin, INPUT);
  timer.setInterval(1000L, sendSensor);
}

void loop() {
  Blynk.run();
  timer.run();
  if (PIRpinValue == HIGH) getPirValue();
  if (SOILpinValue == HIGH) getSoilValue();
}

octopod_door.ino (Arduino) — Fechadura Automática RFID (SEM BLUETOOTH)

/***********************************************************************************************************
 OCTOPOD: PROJETO AUTOMAÇÃO RESIDENCIAL INTELIGENTE POR SAKSHAM
 CÓDIGO FECHADURA RFID ARDUINO
 Biblioteca: MFRC522
************************************************************************************************************/
#include <SPI.h>
#include <MFRC522.h>
#include <Servo.h>

#define SS_PIN 10
#define RST_PIN 9
#define LED_G 5
#define LED_R 4
#define BUZZER 2

MFRC522 mfrc522(SS_PIN, RST_PIN);
Servo myServo;

void setup() {
  Serial.begin(9600);
  SPI.begin();
  mfrc522.PCD_Init();
  myServo.attach(3);
  myServo.write(0);
  pinMode(LED_G, OUTPUT);
  pinMode(LED_R, OUTPUT);
  pinMode(BUZZER, OUTPUT);
  noTone(BUZZER);
  Serial.println("Aproxime seu cartao do leitor...");
  Serial.println();
}

void loop() {
  if (!mfrc522.PICC_IsNewCardPresent()) return;
  if (!mfrc522.PICC_ReadCardSerial()) return;

  Serial.print("UID tag :");
  String content = "";
  for (byte i = 0; i < mfrc522.uid.size; i++) {
    Serial.print(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " ");
    Serial.print(mfrc522.uid.uidByte[i], HEX);
    content.concat(String(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " "));
    content.concat(String(mfrc522.uid.uidByte[i], HEX));
  }
  Serial.println();
  Serial.print("Message : ");
  content.toUpperCase();
  if (content.substring(1) == "XX XX XX XX") { // Altere para UID do cartão autorizado
    Serial.println("Acesso autorizado");
    Serial.println();
    delay(500);
    digitalWrite(LED_G, HIGH);
    tone(BUZZER, 500);
    delay(300);
    noTone(BUZZER);
    myServo.write(180);
    delay(5000);
    myServo.write(0);
    digitalWrite(LED_G, LOW);
  } else {
    Serial.println(" Acesso negado");
    digitalWrite(LED_R, HIGH);
    tone(BUZZER, 300);
    delay(1000);
    digitalWrite(LED_R, LOW);
    noTone(BUZZER);
  }
}

octopod_door_bluetooth.ino (Arduino) — Fechadura Automática RFID (Versão Bluetooth)

/***********************************************************************************************************
 OCTOPOD: PROJETO AUTOMAÇÃO RESIDENCIAL INTELIGENTE POR SAKSHAM
 CÓDIGO FECHADURA RFID ARDUINO (Bluetooth)
 Biblioteca: MFRC522
************************************************************************************************************/
#include <SoftwareSerial.h>
SoftwareSerial BTserial(0, 1); // RX | TX
#include <SPI.h>
#include <MFRC522.h>
#include <Servo.h>

#define SS_PIN 10
#define RST_PIN 9
#define LED_G 5
#define LED_R 4
#define BUZZER 2

MFRC522 mfrc522(SS_PIN, RST_PIN);
Servo myServo;

void setup() {
  BTserial.begin(9600);
  BTserial.println("Aguardando conexoes...");
  SPI.begin();
  mfrc522.PCD_Init();
  myServo.attach(3);
  myServo.write(0);
  pinMode(LED_G, OUTPUT);
  pinMode(LED_R, OUTPUT);
  pinMode(BUZZER, OUTPUT);
  noTone(BUZZER);
  BTserial.println("Aproxime seu cartao do leitor...");
  BTserial.println();
}

void loop() {
  if (!mfrc522.PICC_IsNewCardPresent()) return;
  if (!mfrc522.PICC_ReadCardSerial()) return;

  BTserial.print("UID tag :");
  String content = "";
  for (byte i = 0; i < mfrc522.uid.size; i++) {
    BTserial.print(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " ");
    BTserial.print(mfrc522.uid.uidByte[i], HEX);
    content.concat(String(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " "));
    content.concat(String(mfrc522.uid.uidByte[i], HEX));
  }
  BTserial.println();
  BTserial.print("Message : ");
  content.toUpperCase();
  if (content.substring(1) == "33 3E A7 E5" || content.substring(1) == "E5 36 6B 49") {
    BTserial.println("Acesso autorizado");
    BTserial.println();
    delay(500);
    digitalWrite(LED_G, HIGH);
    tone(BUZZER, 500);
    delay(300);
    noTone(BUZZER);
    myServo.write(180);
    delay(5000);
    myServo.write(0);
    digitalWrite(LED_G, LOW);
  } else {
    BTserial.println(" Acesso negado");
    digitalWrite(LED_R, HIGH);
    tone(BUZZER, 300);
    delay(1000);
    digitalWrite(LED_R, LOW);
    noTone(BUZZER);
  }
}

Peças Personalizadas e Gabinetes

Design básico para fazer gabinete de papelão/madeira como eu:
octopod_v2_ukTmIJ0uMl.f3d

Gabinete próprio para impressão 3D:
octo_2_v3_sii4tuCF7d.f3d

Esquemáticos

Configuração de pinos pode diferir com Arduino MKR 1010

Sem Bluetooth
Para Bluetooth: Rx (HC-05) → Tx (Arduino), Tx (HC-05) → Rx (Arduino), 5V a 5V, GND a GND

ESP       MAX
AO  ---   GPIO2
A1  ---   GPIO1

Soil Sensor MAX
analog sensor --- GPIO3

Gas Sensor (MQ2) MAX
sensor  ---   GPIO4

PIR Sensor MAX
sensor  ---   GPIO0

Relay MAX
1  ---   M0
2  ---   M1