Base de Câmera com Rastreamento de Movimento Automatizado com Arduino e Controle de Servo

Componentes e Materiais

Arduino UNO	×	1
Capacitor 100 µF	×	1
LED (genérico)	×	5
Sensor de Movimento PIR (genérico)	×	5
Resistor 220 Ω	×	5
Servos (Tower Pro MG996R)	×	1

Sobre o Projeto

Tive esta ideia para resolver um problema que estava tendo com minhas câmeras de segurança domésticas. Tenho uma câmera específica posicionada em uma parede entre dois cômodos; no entanto, você só consegue ver um cômodo por vez, a menos que faça login no software da câmera para rotacioná-la manualmente. Se alguém entrasse no cômodo oposto, a câmera nunca gravaria a ação. Para resolver este problema, decidi criar uma base detectora/rastreadora de movimento na qual eu pudesse prender a câmera para que ela se reposicionasse automaticamente para onde o movimento foi detectado.

COMO FUNCIONA:

Este dispositivo usa 5 sensores de movimento PIR para detectar qualquer movimento dentro de um raio de 180º. Uma vez detectado o movimento, um motor servo rotaciona a base da câmera para apontar naquela direção. Há também 5 luzes LED de "status" posicionadas dentro da base que acenderão sempre que um dos sensores PIR detectar movimento.

VEJA EM AÇÃO!

FIAÇÃO:

A fiação para este projeto é simples e direta; no entanto, devido ao fato de haver 5 de tudo exceto o motor servo, o número de fios começa a somar bastante. Confira o diagrama de circuito e esquemáticos no final desta página para mais detalhes, mas aqui estão os fundamentos.

As luzes LED de status...

Usei uma mini protoboard para manter as luzes LED separadas do resto da circuitaria, a fim de permitir remoção mais fácil se necessário. Cada LED responde a um sensor PIR diferente e acenderá sempre que detectar movimento. Simplesmente conecte cada LED a uma entrada digital separada (9-13) no Arduino, e aterre-os através de um resistor de 220 Ω.

Os sensores de movimento PIR...

Usei o modelo HC-SR501 de sensores PIR para este projeto. Cada sensor PIR precisa ser conectado a uma entrada digital (2-6) no Arduino, alimentação 5V e terra. Se você estiver usando o mesmo sensor PIR que eu, pode (com cuidado) remover a tampa e os pinos estão marcados embaixo. Você conectará cada sensor PIR ao LED correspondente no código enviado posteriormente.

O motor servo...

O motor servo é preso ao suporte onde a câmera fica, e rotaciona a câmera para alinhar com o sensor PIR ativo. Usando o pinout do seu motor, conecte um pino à alimentação, outro pino à entrada digital 7 do Arduino, e o último pino à terra. Antes de alimentar o Arduino, certifique-se de conectar um capacitor de 100µF entre a alimentação e terra do motor para ajudar a proteger a placa dos picos de energia que ocorrem quando o motor se move.

Uma coisa a notar sobre motores servo é que nem todos têm amplitude total de 180º. Após alguns testes, descobri que o meu só movia cerca de 160º, então modifique o código adequadamente se o seu motor for diferente. Você saberá que o motor está tentando ir longe demais quando ele faz um ruído de rangido na última posição do sensor PIR.

CONSTRUÇÃO:

Usei um rotulador de CD Memorex antigo para o alojamento do servo e a superfície para a câmera sentar. Não tirei uma foto "antes", então a imagem abaixo é a única restante que pude encontrar online. A peça traseira era um disco plástico plano e resistente que eventualmente saiu em uma peça (após uma pequena persuasão da minha chave de fenda), então funcionou muito bem como lugar para sentar minha câmera. Também veio com 4 "pés" de borracha removíveis, que ajudam a dar um pouco mais de aderência à câmera quando o motor move.

Usei meu alicate na parte preta no centro para removê-la… e por isso quero dizer, quebrá-la em tantas partes quanto possível antes que se vá :) Em seguida, fiz alguns furos na base com meu Dremel e prendi o motor servo com alguns parafusos.

Por fim, usei outro parafuso para prender o motor servo à peça onde a câmera vai sentar. Encontrei um problema onde o peso da câmera estava fazendo a base inclinar, então resolvi isso fazendo um cilindro de papelão alto o suficiente para caber frouxamente entre o motor e a câmera. Agora ainda se move livremente, mas tem mais suporte com seu peso distribuído uniformemente.

Aqui está como tudo fica depois que os sensores PIR foram instalados e toda a circuitaria concluída. Você notará que usei várias protoboards para completar meu projeto. A razão para isso é que tornou extremamente fácil encaixá-las dentro da base, bem como escolher qual remover durante a solução de problemas e expansão posterior.

Para completar o projeto, pintei com spray todas as partes visíveis do papelão de preto para que parecesse mais uniforme com o suporte preto acima.

Aqui está o produto final após a pintura...

Código

• O Código Principal

O Código Principal Arduino

Os sensores PIR calibrarão por 15 segundos após ligar o Arduino. Recomenda-se que você saia da sala durante este processo para que os sensores obtenham uma imagem real da sala sem nenhum movimento.

/*************************************************
 *** Base de Câmera Motorizada com Seguimento de Movimento ***
 *** por Lindsay Fox ***
 *************************************************/
// Motor Servo
#include <Servo.h>
Servo camServo; // nome do motor servo controlando a base da câmera
int currentPIRposition = 0; // define ângulo atual do servo
// Luzes LED de status
int LEDpin[] = {9,10,11,12,13}; // números dos pinos LED
int currentLEDpin = 9; // o pino LED atual; começa com o primeiro na sequência acima
// Sensores PIR
int PIRpin[] = {2,3,4,5,6}; // números dos pinos PIR
int currentPIRpin = 2; // o pino PIR atual; começa com o primeiro na sequência acima
int PIRprevState[] = {1,1,1,1,1}; // estado anterior do PIR (0 = LOW, 1 = HIGH)
int PIRposition[] = {157,117.75,78.5,39.25,0}; // atribui ângulos para motor servo (0-157 distribuídos igualmente entre 5 sensores PIR)
boolean PIRstatus; // Define status do sensor PIR como true ou false

///// SETUP //////////////////////////////////////
void setup() {
  Serial.begin(9600);
  camServo.attach(7); // atribui pino do servo
  for (int p = 0; p < 5; p++) {
    // define todos sensores PIR como INPUTS
    pinMode(PIRpin[p], INPUT);
  }
  for (int l = 0; l < 5; l++) {
    // define todos LEDs como OUTPUTS
    pinMode(LEDpin[l], OUTPUT);
  }
  /////// CALIBRAR SENSORES PIR ///////
  Serial.print("Calibrando Sensores PIR ");
  for(int c = 0; c < 15; c++) {
    // calibra sensores PIR por 15 segundos (mude de 10-60 seg dependendo dos seus sensores)
    Serial.print(".");
    delay(1000); // espera 1 segundo
  }
  Serial.println("Sensores PIR Prontos");
  camServo.write(78.5); // move o servo para posição central para começar
}

///// LOOP PRINCIPAL //////////////////////////////////
void loop() {
  for (int PIR = 0; PIR < 5; PIR++) {
    // inicia este loop para cada sensor PIR
    currentPIRpin = PIRpin[PIR]; // define pino PIR atual para número atual no loop 'for'
    currentLEDpin = LEDpin[PIR]; // define pino LED atual para número atual no loop 'for'
    PIRstatus = digitalRead(currentPIRpin);
    if (PIRstatus == HIGH) {
      // se movimento detectado no sensor PIR atual
      digitalWrite(currentLEDpin, HIGH); // liga LED correspondente
      if(PIRprevState[PIR] == 0) {
        // se estado anterior do sensor PIR é LOW
        if (currentPIRposition != currentPIRpin && PIRprevState[PIR] == 0) {
          // se PIR HIGH é diferente da posição atual PIR, move para nova posição
          camServo.write(PIRposition[PIR]);
          Serial.print("Ângulo atual: ");
          Serial.println(PIRposition[PIR]);
          delay(50);
          currentPIRposition = currentPIRpin; // redefine posição PIR atual para pino [PIR] ativo
          PIRprevState[PIR] = 1; // define estado anterior PIR para HIGH
        }
        PIRprevState[PIR] = 1; // define estado anterior PIR para HIGH se a posição atual é a mesma do pino PIR atual
      }
    }
    else {
      // digitalWrite(currentLEDpin, LOW); // o led visualiza o estado do pino de saída do sensor
      PIRprevState[PIR] = 0; // define estado anterior PIR para LOW
    }
  }
}

Esquemáticos

(Esquemáticos não fornecidos no original)