TRABALHO - ALGORITIMX UNITED

TRABALHO FINAL

     Esse projeto tem como objetivo exemplificar o funcionamento de sensores infravermelhos, e demonstrar a sua utilidade em diversas situações cotidianas. No vídeo abaixo simulamos um dispositivo que recebe um sinal infravermelho e realiza um comando através deste. No caso, acender um LED.

Componentes:

- Resistor 1K ohm

- 7 jumpers

- 1 LED

- Módulo IR Receiver

- Protoboard

- Arduino UNO 

CÓDIGO:

#include <IRremote.h>

int pinoReceptor = 11;

int pinoLED = 9;

int estadoLED = LOW;

IRrecv receptor(pinoReceptor);

decode_results resultado;

void setup()

{

  Serial.begin(9600);

  pinMode(pinoLED, OUTPUT);

  receptor.enableIRIn();

}

void loop() {

  if (receptor.decode(&resultado)) 

  {

    guardarCodigo(&resultado);

    if(estadoLED == LOW)

    {

      estadoLED = HIGH;

      digitalWrite(pinoLED, estadoLED);

      Serial.println("Acendendo o LED");

    }

    else

    {

      estadoLED = LOW;

      digitalWrite(pinoLED, estadoLED);

      Serial.println("Apagando o LED");

    }

       

    receptor.resume();

  }

  delay(1000);

}

INTEGRANTES DO GRUPO: 

 

Arthur Napoleão

Artur Dias

Henrick Bartolo

Matheus Rocha

Definindo destino de caixas a partir de seu tamanho

Grupo Algoolatras

Nesse projeto decidimos criar um sistema que seria de grande utilidade em agencias do correio e em grandes transportadoras. Se trata de um sistema que identifica e separa caixas a partir de seu tamanho.

Para Montar utilizamos:

● 3 led’s de cores diferentes

● 1 Protoboard

● 1 Arduino Uno

● 1 Sensor ultrassônico HC-SR04

● Fios jumpers

● Caixas de diferentes tamanhos

Em resumo no nosso projeto os Leds representam o destino que cada caixa deve ter, o Led Vermelho acenderá caso a caixa tenha mais de 20 cm, o amarelo caso a caixa tenha entre 10 e 20 cm e o Led verde será acionado se a caixa tiver tamanho inferior a 10 cm.

Abaixo o codigo que utilizamos no arduino.

#include <Ultrasonic.h>

//Trigger no pino 6 - e Echo no pino 7

Ultrasonic ultrasonic(6,7);

//Declarando as constantes referentes aos pinos digitais.

const int ledVerde = 13;

const int ledAmarelo = 12;

const int ledVermelho = 11;

long microsec = 0;

float distanciaCM = 0;

void setup() {

  Serial.begin(9600);

   

  //Definindo pinos digitais

  pinMode(ledVerde,OUTPUT); //13 como de saída.

  pinMode(ledAmarelo,OUTPUT); //12 como de saída.

  pinMode(ledVermelho,OUTPUT); //11 como de saída.

}

void loop() { 

  microsec = ultrasonic.timing();

  /*Convertendo a distância em CM*/

  distanciaCM = ultrasonic.convert(microsec, Ultrasonic::CM);

  ledDistancia();

  Serial.print(distanciaCM);

  Serial.println(" cm");

  delay(1000);

}

void ledDistancia() {

   

  //Apagando todos os leds

  digitalWrite(ledVerde,LOW); 

  digitalWrite(ledAmarelo,LOW);

  digitalWrite(ledVermelho,LOW);

   

  //Acendendo o led correspondente ao tamanho da caixa

  if (distanciaCM > 20 and distanciaCM < 30) {

    digitalWrite(ledVerde,HIGH); 

  }

   

  if (distanciaCM <=20 and distanciaCM >= 10) {

    digitalWrite(ledAmarelo,HIGH);

  }

   

  if (distanciaCM < 10) {

    digitalWrite(ledVermelho,HIGH);

  }

}

Vídeo da execução do projeto:

Projeto final (MECHANIACS)

Simulação de um sensor de estacionamento utilizando Arduino

  Elementos que compõem o projeto

• Arduino UNO;
• Protoboard;
• Sensor HC-SR04;
• Um LED vermelho;
• Um LED amarelo;
• Um LED verde;
• Fios jumper

  Código

  

  Funcionamento

     Os três LEDs indicam a que distância determinado objeto se encontra do sensor ultrassônico. 

LED verde: Indica que o objeto está numa distância superior à 20cm.

LED amarelo: Indica que o objeto está numa distância entre 20 e 10cm.

LED vermelho: Indica que o objeto está numa distância de menos de 10cm.

   

     Além disso, incorporamos um alerta sonoro ao projeto por meio do buzzer, alterando o valor do delay para cada intervalo de distância.

Trabalho Final - Alarme Focalizado com Arduíno

Grupo: Avalon 

Este projeto consiste na criação de um alarme com um Arduino. Neste projeto nos determinando uma senha que inicializa o programa, um led verde que sinaliza o recebimento de informações, o sensor de distância possui um alcance de 80cm e um led vermelho para brilhar de acordo com a distância. Quando algo entra em seu alcance ele emite um sinal sonoro e e um sinal luminoso de um led vermelho sinalizando a existência de algum objeto.

 

A finalidade do alarme é sua utilização em sistemas de segurança de domicílios, permitindo um controle de acesso em determinado local, sendo colocando em pontos-chaves da residência, como janelas, portas e etc.

Componentes usados:

Um Arduíno;
Um alto-falante;

Um sensor de distância;

Um led verde;

Um led vermelho;

Um controle e um receptor de sinal infravermelho.

Tutorial de Utilização:

Ao iniciar pela primeira vez o usuário deve clicar um botão de configuração para alterar a senha posteriormente, após isso, digitar uma senha de 4 dígitos. Funciona com qualquer controle e o Led verde piscando significa que o usuário já pode digitar. Após a inclusão, o sistema irá verificar a área de utilização emitindo um sinal sonoro e piscando o Led verde. Pronto, o sistema já está em funcionamento, indicado pelo Led Verde aceso. Ao disparar, a senha deve ser digitada, e se estiver correta o sistema vai desarmar, nesse caso, a luz vermelha estará piscando.

Vídeo do Funcionamento:

Código do Programa:

 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#include <Arduino.h>
#include <NewTone.h> //  Biblioteca de som inclusa porque a função normal tune() conflita com IRremote
#include <IRremote.h>
#include <IRremoteInt.h>
#include <Ultrasonic.h>

#define pinoTrigger 4 // Pino do sensor ultrassonico
#define pinoEcho 5  // Pino do sensor ultrassonico
#define autoFalante 9
#define ledVermelho 10
#define ledVerde 12
#define pinoIR 3

int contador; // Contador utilizado diversas vezes em for
float confirmacao;
float proximidade = 0; // Proximidade mínima para disparo, regulada automaticamente
float bonof = 0;
float bmenu = 0;
float casa [4] = {0, 0, 0, 0}; // Strings de senha
float senha [4] = {0, 0, 0, 0}
unsigned long last = millis();

Ultrasonic ultrasonic(pinoTrigger, pinoEcho); // Definindo os pinos para a função ultrassonic
IRrecv irrecv(pinoIR);  //  Definindo os pinos para a função IRremote
decode_results results; // Para a função IRremote

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int confirmarSenha() {  // Função iniciada quando o sistema ativa o alarme
  for (contador = 0; contador <= 3; contador++) {
    while (casa[contador] == 0) {
      alarme();
      if (irrecv.decode(&results)) {
        noNewTone(autoFalante);
        NewTone(autoFalante, 1000);
        digitalWrite(ledVerde, HIGH);
        delay(30);
        noNewTone(autoFalante);
        digitalWrite(ledVerde, LOW);
        irrecv.resume();
        casa[contador] = results.value;
        Serial.println(casa[contador]);
        delay(500);
      }
    }
  }
  if (casa[0] == senha[0] && casa[1] == senha[1] && casa[2] == senha[2] && casa[3] == senha[3]) {
    casa[0] = casa[1] = casa[2] = casa[3] = 0;
    noNewTone(autoFalante);
    NewTone(autoFalante, 1000);
    delay(1000);
    noNewTone(autoFalante);
    delay(1200);
    return 1; // Senha OK
  } else {
    casa[0] = casa[1] = casa[2] = casa[3] = 0;
    NewTone(autoFalante, 500);
    delay(1000);
    noNewTone(autoFalante);
    delay(1200);
    return 0; // Senha Negada
  }
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int disparo() { // Função que define a ativação do alarme
  if ((ultrasonic.convert(ultrasonic.timing(), Ultrasonic::CM))-1 < proximidade) {
    return 1;
  } else {
    return 0;
  }
}


/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void configuracaoInicialDeDistancia(void) {
  for (contador = 600; contador >= 5; contador *= 0.8) {  // Apitar variando a velocidade
    NewTone(autoFalante, 1500);
    digitalWrite(ledVerde, HIGH);
    delay(50);
    noNewTone(autoFalante);
    digitalWrite(ledVerde, LOW);
    delay(contador);
  }

  for (contador = 1; contador <= 5; contador++) { // Pegar 5 amostras para a média
    proximidade += ((ultrasonic.convert(ultrasonic.timing(), Ultrasonic::CM)));
    delay(10);
  }
  proximidade = (abs(proximidade) + 1) / 5; // Impedir o 0 e tirar a média
  if (proximidade > 80) {
    proximidade = 80; // Limite onde não há muita variação
  } else {
    proximidade *= 0.8; // Taxa de 20% de variação
  }
  Serial.print("DISTANCIA DE ATIVAÇÃO DE: ");
  Serial.print(proximidade);
  Serial.println(" CM");
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void alarme(void) {  // Função que reproduz o som de alarme
  noNewTone(autoFalante);
  digitalWrite(ledVermelho, LOW);
  delay(50);
  NewTone(autoFalante, 1000);
  digitalWrite(ledVermelho, HIGH);
  delay(30);
  NewTone(autoFalante, 800);
  delay(50);
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void onof_configuracao(void) {  // Função que liga, desliga e configura os botoes e senha do sistema
  if (irrecv.decode(&results)) {
    irrecv.resume();
    if (results.value == bonof) {
      digitalWrite(ledVerde, LOW);
      digitalWrite(ledVermelho, HIGH);
      Serial.println("DESATIVADO!");
      delay(5000);
      while (confirmacao != bonof) {
        if (irrecv.decode(&results)) {
          irrecv.resume();
          confirmacao = results.value;
          Serial.println(results.value);
        }
        delay(1000);
      }
      digitalWrite(ledVermelho, LOW);
      digitalWrite(ledVerde, HIGH);
      confirmacao = 0;
      delay(5000);
      Serial.println("ATIVADO!");


    }

    if (results.value == bmenu) {
      Serial.println("CONFIRMACAO DE SENHA!");
      digitalWrite(ledVerde, LOW);
      digitalWrite(ledVermelho, LOW);
      delay(2000);
      digitalWrite(ledVerde, HIGH);
      digitalWrite(ledVermelho, HIGH);
      delay(200);
      digitalWrite(ledVerde, LOW);
      digitalWrite(ledVermelho, LOW);
      delay(2000);

      for (contador = 0; contador <= 3; contador++) {
        while (casa[contador] == 0) {
          if (irrecv.decode(&results)) {
            noNewTone(autoFalante);
            NewTone(autoFalante, 1000);
            digitalWrite(ledVerde, HIGH);
            delay(30);
            noNewTone(autoFalante);
            digitalWrite(ledVerde, LOW);
            irrecv.resume();
            casa[contador] = results.value;
            Serial.println(casa[contador]);
            delay(500);
          }
          delay(500);
        }
      }

      if (casa[0] == senha[0] && casa[1] == senha[1] && casa[2] == senha[2] && casa[3] == senha[3]) {
        casa[0] = casa[1] = casa[2] = casa[3] = 0;
        delay(500);
        noNewTone(autoFalante);
        NewTone(autoFalante, 1000);
        delay(1000);
        noNewTone(autoFalante);
        Serial.println("CONFIGURACAO INICIADA!");
        confirmacao = 0;
        while (confirmacao == 0) {
          if (irrecv.decode(&results)) {
            noNewTone(autoFalante);
            NewTone(autoFalante, 1000);
            digitalWrite(ledVerde, HIGH);
            delay(30);
            noNewTone(autoFalante);
            digitalWrite(ledVerde, LOW);
            irrecv.resume();
            confirmacao = results.value;
            bonof = results.value;
            Serial.println(bonof);
            delay(1200);
          }
          delay(500);
        }
        confirmacao = 0;
        for (contador = 0; contador <= 3; contador++) {
          while (confirmacao == 0) {
            if (irrecv.decode(&results)) {
              noNewTone(autoFalante);
              NewTone(autoFalante, 1000);
              digitalWrite(ledVerde, HIGH);
              delay(30);
              noNewTone(autoFalante);
              digitalWrite(ledVerde, LOW);
              irrecv.resume();
              confirmacao = results.value;
              senha[contador] = results.value;
              Serial.println(senha[contador]);
              delay(1200);
            }
            delay(500);
          }
          confirmacao = 0;
        }
        digitalWrite(ledVerde, HIGH);
      } else {
        casa[0] = casa[1] = casa[2] = casa[3] = 0;
        NewTone(autoFalante, 500);
        delay(1000);
        noNewTone(autoFalante);
        delay(1000);
        digitalWrite(ledVerde, HIGH);
        delay(1200);
      }
    }
  }
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void setup() {
  Serial.begin(9600);
  pinMode(8, OUTPUT);
  pinMode(ledVerde, OUTPUT);
  pinMode(ledVermelho, OUTPUT);
  irrecv.enableIRIn();

  while (bmenu == 0) {  // Configura o botão menu antes de iniciar o sensoriamento
    digitalWrite(ledVerde, HIGH);
    delay(500);
    digitalWrite(ledVerde, LOW);
    if (irrecv.decode(&results)) {
      noNewTone(autoFalante);
      NewTone(autoFalante, 1000);
      digitalWrite(ledVerde, HIGH);
      delay(30);
      noNewTone(autoFalante);
      digitalWrite(ledVerde, LOW);
      irrecv.resume();
      bmenu = results.value;
      Serial.println(bmenu);
      delay(1500);
    }
    delay(500);
  }

  for (contador = 0; contador <= 3; contador++) { // Configura a senha antes de iniciar o sensoriamento
    while (senha[contador] == 0) {
      digitalWrite(ledVerde, HIGH);
      delay(500);
      digitalWrite(ledVerde, LOW);
      if (irrecv.decode(&results)) {
        noNewTone(autoFalante);
        NewTone(autoFalante, 1000);
        digitalWrite(ledVerde, HIGH);
        delay(30);
        noNewTone(autoFalante);
        digitalWrite(ledVerde, LOW);
        irrecv.resume();
        senha[contador] = results.value;
        Serial.println(senha[contador]);
        delay(1500);
      }
      delay(500);
    }
  }
  configuracaoInicialDeDistancia(); // Onde apita para determinar a distancia de disparo
  digitalWrite(ledVerde, HIGH); // Simboliza a operatividade do sistema
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void loop() { // Aqui o sistema entra em operação
  onof_configuracao();
  if (disparo() == 1) {
    Serial.println("DISPARADO!");
    digitalWrite(ledVermelho, LOW);
    digitalWrite(ledVerde, LOW);
    while (confirmarSenha() == 0) {  }
    Serial.println("DESTRAVADO!");
    digitalWrite(ledVermelho, LOW);
    digitalWrite(ledVerde, HIGH);
  } else {
    noNewTone(autoFalante);
    delay(250);
  }
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////