Contador Inteligente de Pessoas Controlado via App Android

Componentes e Materiais

Arduino UNO	×	1
Módulo Bluetooth HC-06	×	1
Protoboard (genérico)	×	2
Fotorresistor (LDR)	×	3
Módulo Laser	×	3
Buzzer	×	1
Módulo LED RGB	×	1
LED (genérico)	×	3
Resistor 1k ohm	×	3
Resistor 221 ohm	×	3
Bateria	×	1
Fios jumper (genéricos)	×	1

Aplicações e Serviços Online

• Arduino IDE
• MIT App Inventor

Sobre este Projeto

Descrição

Em primeiro lugar, o contador de pessoas é um dispositivo que deteta o número de pessoas a atravessar uma entrada. Pensei em fazer um contador para proteger o meu quarto quando tivesse de ir de férias por duas semanas. Também queria usá-lo como alarme que avisa pessoas sem permissão para entrar. O laser é a melhor opção para contar algo com precisão com um LDR devido à sua velocidade, por isso decidi usar lasers com LDRs para a contagem. Há três entradas possíveis no meu quarto (duas portas e uma janela), então usei três lasers e três LDRs. No entanto, percebi que precisava de controlar o dispositivo remotamente se quisesse escolher qual laser de entrada está ativo ou se o alarme está ligado. Por isso, adicionei um módulo Bluetooth HC-06 para comunicar com o dispositivo através de uma app Android que criei. Além disso, a app mostra o número de pessoas que entram na entrada que se deseja observar.

Criação da App

Existem muitas formas de criar uma app Android, como converter código de HTML para Java ou programar a app com Python. No entanto, o MIT App Inventor é a forma mais fácil devido à sua estrutura de arrastar e soltar quando se quer fazer uma app Android, mas não esquecer que ainda não é compatível com iOS.

A app chama-se "People Counter!" e inclui dois ecrãs: Screen1 e Screen2.

Screen1 (Ecrã Inicial)

É o ecrã inicial para continuar para o ecrã principal, mas primeiro a password definida no MIT App Inventor deve ser introduzida corretamente. (A password padrão que defini é "counter".)

Screen2 (Ecrã Principal)

É o ecrã principal e o menu para controlar a placa Arduino e o resultado do contador de pessoas que é enviado pelo Arduino é exibido neste ecrã. Pode escolher qual laser está ligado ou se o alarme está ativo, além de ver o resultado do contador e reiniciá-lo a zero.

Como Fazer um Contador de Pessoas Usando Lasers e LDRs

Um laser (amplificação de luz por emissão estimulada de radiação) é um dispositivo que envia pacotes de luz numa linha muito reta até ao alvo. Um LDR (resistor dependente de luz) pode facilmente detetar o aumento na intensidade da luz se o laser estiver apontado diretamente para ele. Quando há um obstáculo entre o laser e o LDR, este deteta uma diminuição na intensidade da luz. Portanto, se conseguir contar cada diminuição no nível ótimo, terá um contador de pessoas. Segundo a minha experiência com o LDR, o intervalo do nível ótimo deve estar entre 150 e 350.

Conexões

• Arduino Uno - Módulos
• Pino 2 --------- Laser_Módulo_1
• Pino 3 -------- Laser_Módulo_2
• Pino 4 -------- Laser_Módulo_3
• Pino 5 -------- Buzzer
• Pino 6 -------- HC-06 Bluetooth Module (TX)
• Pino 7 --------- HC-06 Bluetooth Module (RX)
• Pino 8 --------- Control_Led_1
• Pino 12 --------- Control_Led_2
• Pino 13 ---------- Control_Led_3
• Pino 9 ------- RGB_Módulo (R)
• Pino 10 ------ RGB_Módulo (G)
• Pino 11 ------- RGB_Módulo (B)
• A0 ------------ LDR_1
• A1 ------------- LDR_2
• A2 ----------- LDR_3

Certifique-se de que os lasers estão apontados diretamente para os LDRs antes de finalizar todas as conexões.

Depois de testar o dispositivo e gravar um vídeo de teste, dividi o dispositivo em três partes para três entradas diferentes. Não tenho tido dúvidas sobre a segurança do meu quarto desde que os uso.

Código

PeopleCounter_with_Lasers.ino

///////////////////////////////////////////// 
// Criar um Contador de Pessoas com Lasers 
// num Dispositivo Android 
// por Kutluhan Aktar 
///////////////////////////////////////////// 
// O objetivo do projeto é fazer um contador de pessoas que deteta o número de pessoas que entram na sala usando lasers e LDRs e controlá-lo com uma app Android. 
// Ligue uma perna de um LDR ao GND com resistor de 1K ohm. 
// Certifique-se de que os lasers apontam diretamente para os LDRs. 
// Se quiser que os resultados do contador sejam precisos, defina corretamente o nível ótimo dos LDRs. 
// Conexões: 
// Arduino Uno 
// Laser_Módulo_1 // Pino 2 ------------------------ 
// Laser_Módulo_2 // Pino 3 ------------------------ 
// Laser_Módulo_3 // Pino 4 ------------------------ 
// Buzzer // Pino 5 ------------------------ 
// HC-06 Bluetooth Module // Pino 6 ------------------------TX 
// Pino 7 ------------------------RX 
// Control_Led_1 // Pino 8 ------------------------ 
// Control_Led_2 // Pino 12 ------------------------ 
// Control_Led_3 // Pino 13 ------------------------ 
// RGB_Módulo // Pino 9 ------------------------R 
// Pino 10 ------------------------G 
// Pino 11 ------------------------B 
// LDR_1 // A0 ------------------------ 
// LDR_2 // A1 ------------------------ 
// LDR_3 // A2 ------------------------ 

#include <SoftwareSerial.h> 
int LaserPin_1 = 2; 
int LaserPin_2 = 3; 
int LaserPin_3 = 4; 
int BuzzerPin = 5; 
int Control_RX = 6; 
int Control_TX = 7; 
int RedPin = 9; 
int GreenPin = 10; 
int BluePin = 11; 
int Control_Led_1 = 8; 
int Control_Led_2 = 12; 
int Control_Led_3 = 13; 
int LDR_1 = A0; 
int LDR_2 = A1; 
int LDR_3 = A2; 
int LDR_1_Read; 
int LDR_2_Read; 
int LDR_3_Read; 
int Counter = 0; 
volatile boolean Alarm_is_Activated = false; 
volatile boolean Alarm_Initial = false; 
volatile boolean Counter_Detect = false; 
SoftwareSerial Control(Control_RX, Control_TX); 
String Name = "Control"; 
int Password = 1111; 
String Uart = "9600,0,0"; 

void setup() { 
  Serial.begin(9600); 
  Control.begin(9600); 
  pinMode(LaserPin_1,OUTPUT); 
  pinMode(LaserPin_2,OUTPUT); 
  pinMode(LaserPin_3,OUTPUT); 
  pinMode(RedPin,OUTPUT); 
  pinMode(GreenPin,OUTPUT); 
  pinMode(BluePin,OUTPUT); 
  pinMode(Control_Led_1,OUTPUT); 
  pinMode(Control_Led_2,OUTPUT); 
  pinMode(Control_Led_3,OUTPUT); 
} 

void loop() { 
  get_Data_From_LDR(); 
  if(Control.available()){ 
    char c = Control.read(); 
    Serial.println(c); 
    Commands(c); 
  } 
  Set_Alarm(); 
  Set_Counter(); 
} 

void Commands(char i){ 
  switch(i){ 
    case '1' : Control.print(Counter); break; 
    case '2' : Alarm_is_Activated = true; break; 
    case '3' : Alarm_is_Activated = false; break; 
    case '4' : digitalWrite(LaserPin_1,HIGH); digitalWrite(Control_Led_1,HIGH); break; 
    case '5' : digitalWrite(LaserPin_1,LOW); digitalWrite(Control_Led_1,LOW); break; 
    case '6' : digitalWrite(LaserPin_2,HIGH); digitalWrite(Control_Led_2,HIGH); break; 
    case '7' : digitalWrite(LaserPin_2,LOW); digitalWrite(Control_Led_2,LOW); break; 
    case '8' : digitalWrite(LaserPin_3,HIGH); digitalWrite(Control_Led_3,HIGH); break; 
    case '9' : digitalWrite(LaserPin_3,LOW); digitalWrite(Control_Led_3,LOW); break; 
    case 'r' : Counter = 0; break; 
  } 
} 

void get_Data_From_LDR(){ 
  LDR_1_Read = analogRead(LDR_1); 
  LDR_2_Read = analogRead(LDR_2); 
  LDR_3_Read = analogRead(LDR_3); 
} 

void Set_Counter(){ 
  if(LDR_1_Read < 150 || LDR_2_Read < 150 || LDR_3_Read < 150){ 
    Counter_Detect = true; 
  } else{ 
    Counter_Detect = false; 
  } 
  if(Counter_Detect == true){ 
    Counter = Counter + 1; 
    delay(500); 
  } 
  if(Counter_Detect == false){ 
    Counter = Counter; 
  } 
} 

void Set_Alarm(){ 
  if(Alarm_is_Activated == true){ 
    if(LDR_1_Read < 150 || LDR_2_Read < 150 || LDR_3_Read < 150){ 
      Alarm_Initial = true; 
    } else{ 
      Alarm_Initial = false; 
    } 
    if(Alarm_Initial == true){ 
      tone(BuzzerPin,500); 
      Color_Change(255, 0, 0); delay(50); 
      Color_Change(0, 255, 0); delay(50); 
      Color_Change(0, 0, 255); delay(50); 
      Color_Change(255, 255, 0); delay(50); 
      Color_Change(80, 0, 80); delay(50); 
      Color_Change(0, 255, 255); delay(50); 
      Color_Change(255, 255, 255); delay(50); 
    } 
  } 
  if(Alarm_is_Activated == false || Alarm_Initial == false ){ 
    noTone(BuzzerPin); 
    Color_Change(0, 0, 0); 
  } 
} 

void Color_Change(int red, int green, int blue){ 
  red = 255 - red; 
  green = 255 - green; 
  blue = 255 - blue; 
  analogWrite(RedPin, red); 
  analogWrite(GreenPin, green); 
  analogWrite(BluePin, blue); 
} 

void Change_BluetoothModule_Defaults(){ 
  Control.print("AT+NAME"); 
  Control.println(Name); 
  Serial.print("Nome alterado: "); 
  Serial.println(Name); 
  delay(2000); 
  Control.print("AT+PSWD"); 
  Control.println(Password); 
  Serial.print("Password alterada: "); 
  Serial.println(Password); 
  delay(2000); 
  Control.print("AT+UART"); 
  Control.println(Uart); 
  Serial.print("Baud rate definido: "); 
  Serial.println(Uart); 
  delay(2000); 
  Serial.println("Tarefa concluída."); 
} 

Peças Personalizadas e Caixas

• Ficheiro de código da app People Counter! peoplecounter_J375iBnBF8.aia
• Ficheiro APK da app People Counter! peoplecounter_uBf7MU4A1c.apk

Esquemáticos