PROJETO 2

Protótipo

Construído com motor de passo e controlado por IR/controle remoto

Firmware

#include <Stepper.h>
#include <IRremote.h>

// Definição de Pinos
#define STEPS 512
#define pinLed2 53
#define pinLed 34
#define RECV_PIN 32
#define pinBuzzer 30
#define pinIN4 28
#define pinIN3 26
#define pinIN2 24
#define pinIN1 22

// Definição de Objetos
IRrecv irrecv(RECV_PIN); //PASSA O PARÂMETRO PARA A FUNÇÃO irrecv
decode_results results; //VARIÁVEL QUE ARMAZENA OS RESULTADOS (SINAL IR RECEBIDO)
Stepper stepper(STEPS, pinIN1, pinIN2, pinIN3, pinIN4);

// Prototipagem de funções
void piscaled(); void apito(); void lerIr(); void automatico();

// Definição de variáveis
int vel = 30, meiavolta = 1024, tempo = 0, armazenatempo = 0, timer = 8000;
// respectivamente, a velocidade de rotação do stepper, o valor que faz ele rotacionar 180º, variavel para 
comparação de tempo, variavel para armazenamento de tempo, tempo em milisegundos.
bool estado;
// variável de estado, para pushbutton, da função timer

void setup() {
  stepper.setSpeed(vel);
  Serial.begin(9600);
  irrecv.enableIRIn();
  pinMode(pinBuzzer, OUTPUT);
  pinMode(pinLed, OUTPUT);
  pinMode(pinLed2, OUTPUT);
}

void loop() {
 lerIr(); // FUNÇÃO DE LEITURA DOS COMANDOS DO CONTROLE
 automatico(); // FUNÇÃO DE ALIMENTAÇÃO AUTOMATICA
}


void apito() {
 for (int i = 0; i < 3; i++) { // SOA O BUZZER, CONFIRMANDO O ABASTECIMENTO DE ALIMENTO
   digitalWrite(pinBuzzer, HIGH);
   delay(100);
   digitalWrite(pinBuzzer, LOW);
   delay(100);
 }
}

void piscaled() { // PISCA O LED AZUL DUAS VEZES, CONFIRMAR RECEBIMENTO DE SINAL.
 digitalWrite(pinLed, HIGH);
 delay(50);
 digitalWrite(pinLed, LOW);
 delay(50);
 digitalWrite(pinLed, HIGH);
 delay(50);
 digitalWrite(pinLed, LOW);
 delay(50);
}

void lerIr() {
 if (irrecv.decode(&results)) {
   if (results.value == 0xFFC23D || results.value == 0x5BFA89D3) { //QUANDO ESSES VALORES FOREM LIDOS DO 
CONTROLE, EXECUTAM A FUNÇÃO DE DAR COMIDA
     Serial.println("PLAY | DAR COMIDA");
     piscaled();
     stepper.step(meiavolta);
     delay(1000);
     stepper.step(meiavolta);
     delay(1000);
     apito();
   }
   if (results.value == 0xFFA857 || results.value == 0x6E570BF3) { //QUANDO ESSES VALORES FOREM LIDOS DO  
CONTROLE, EXECUTAM A FUNÇÃO DE AUMENTAR O TIMER EM 1 SEG
     Serial.println("VOLUME+ | AUMENTAR TIMER");
     timer = timer + 1000;
     piscaled();
   }
   if (results.value == 0xFFE01F || results.value == 0xA166B553) { //QUANDO ESSES VALORES FOREM LIDOS DO 
CONTROLE, EXECUTAM A FUNÇÃO DE DIMINUIR O TIMER EM 1 SEG
     Serial.println("VOLUME- | DIMINUIR TIMER");
     timer = timer - 1000;
     piscaled();
   }
   if (results.value == 0xFF629D || results.value == 0x51AA59D3) { //QUANDO ESSES VALORES FOREM LIDOS DO 
CONTROLE, O MOTOR DÁ UM PEQUENO PASSO PARA REAJUSTE DO EIXO
     Serial.println("CH | PEQUENO PASSO PARA REAJUSTE");
     piscaled();
     stepper.step(64);
   }
   if (results.value == 0xFF4AB5 || results.value == 0x8010D93) { //QUANDO ESSES VALORES FOREM LIDOS DO CONTROLE, 
LIGA A FUNÇÃO TIMER
     Serial.println("8 | LIGAR TIMER");
     if (!estado) { // SE  O ESTADO FOR 0, ELE ZERA O TEMPO DE COMPARAÇÃO, ARMAZENA O TEMPO DE EXECUÇÃO 
MOMENTANEO, E MUDA ESTADO PARA "HIGH"
       tempo = 0;
       armazenatempo = millis();
       estado = !estado;
       digitalWrite(pinLed2, estado); // LED VERMELHO, CONFIRMA A LIGAÇÃO DA FUNÇÃO TIMER
     } else {
       estado = !estado; // ESSA PARTE SERVE PARA CASO VOCÊ QUEIRA DESATIVAR O TIMER, DESLIGANDO TAMBÉM O LED.
       digitalWrite(pinLed2, estado); 
     }
     piscaled();

   }
   if (results.value == 0xFFA25D || results.value == 0xCC718833) {
     Serial.println("CH- | DIMINUIR VELOCIDADE DO PASSO"); //QUANDO ESSES VALORES FOREM LIDOS DO CONTROLE, 
DIMINUI VELOCIDADE DO MOTOR, AUMENTA A PRECISÃO DO MOTOR E AUMENTA A QUANTIDADE DE RAÇÃO.
     piscaled();
     if (vel > 5) {
       vel = vel - 5;
       stepper.setSpeed(vel);
     }
     Serial.println(vel);
   }
   if (results.value == 0xFFE21D || results.value == 0xB5A7E1D7) {
     Serial.println("CH+ | AUMENTAR VELOCIDADE DO PASSO"); //QUANDO ESSES VALORES FOREM LIDOS DO CONTROLE, 
AUMENTA A VELOCIDADE DO MOTOR, MAS DEIXA O SISTEMA MAIS INSTAVEL
     piscaled();
     if (vel < 60) {
       vel = vel + 5;
       stepper.setSpeed(vel);
     }
     Serial.println(vel);
   }
   // ESSAS FUNÇÕES DE AJUSTE, CH, CH+, CH- EXISTEM, POIS O MOTOR RESPONDE DIFERENTE A CADA NIVEL DE TENSÃO (5- 
12V).
   irrecv.resume(); //AGUARDA O RECEBIMENTO DE UM NOVO SINAL IR
 }
}
void automatico() {  // ESSA FUNÇÃO IRA DEPOSITAR O ALIMENTO, QUANDO ESTIVER LIGADA A FUNÇÃO TIMER, ASSIM, A CADA 
TEMPO DE TIMER (AJUSTÁVEL) IRÁ ALIMENTAR.
 tempo = millis() - armazenatempo; // TEMPO DE EXECUÇÃO ATUAL MENOS O TEMPO DE EXECUÇÃO ARMAZENADO.
 if (tempo > timer && estado) { // QUANDO O TEMPO DE COMPARAÇÃO FOR MAIOR QUE O TEMPO DO TIMER, E A FUNÇÃO TIMER 
ESTIVER LIGADA, EXECUTA A ALIMENTAÇÃO.
   stepper.step(meiavolta);
   delay(1000);
   stepper.step(meiavolta);
   delay(1000);
   armazenatempo = millis(); // ARMAZENA O TEMPO DE EXECUÇÃO ATUAL, MANTENDO A ALIMENTAÇÃO AUTOMATICA.
   apito();
 }
}

Trabalho Eduardo

Protótipo

Esse protótipo requer que o pet esteja na plataforma que fica logo à frente do pote, para que a ração seja liberada. E conforme mostra o vídeo, um pequeno peso na plataforma aciona o botão que manda o comando para o arduino, que por sua vez aciona o servo motor se estiver no horário correto para alimentar (led acesso).

Utilizou servo motor.

Vídeo do protótipo

Firmware

#include <Servo.h>
#define SERVO 6

//Projeto 2 - Alimentador de Pet - Eduardo Schaefer

Servo s;
int botao = 2; //Botão que vai identificar se o animal está no lugar para comer
int estado_botao = 0; // Variavel para ler o botão

int segundos = 0;

void setup ()
{
 s.attach(SERVO);
 Serial.begin(9600);
 s.write(0);
 pinMode(botao, INPUT);
 pinMode(10, OUTPUT);
}

void loop()
{
 int timer = temporizador();
 if (timer == 1)
 {
   digitalWrite(10, HIGH); //LED que informa que ja esta na hora alimentar novamente
 }
 estado_botao = digitalRead(botao);
 if (estado_botao == HIGH && timer == 1) //Se o animal estiver no local e estiver na hora de alimentar o animal o 
motor move
 {
   s.write(90);
   delay(300); //Tempo para cair ração
   s.write(0);
   segundos = 0;
   digitalWrite(10, LOW);// Led apaga e so vai acender novamente se estiver no horario para comer novamente
 }

}

int temporizador() // Função que vai determinar o intervalo que o pet será alimentado, no caso a cada 5 segundos, 
mas pode ser alterado para qualquer intervalo
{
 if (segundos == 5)
 {
   return 1;
 }
 for (segundos = 0; segundos < 5; segundos++) //contador de segundos
 {
   delay(1000);
 }


}

Trabalho Gustavo

Protótipo

Com servo motor e RTC, para configurar o horário (fixo) de alimentação.

[ https://drive.google.com/file/d/13xp0i-0w5NHwNGqzgnWaTrXnKKPcxrKe/view?usp=sharing Vídeo do protótipo]

Firmware

 /* 
 ALUNO: Gustavo Grapp Furlanetto.
 Matrícula: 1710030445.
 UC: Microcontroladores.
 Professora: Fernanda Isabel Marques Argoud.
 Esquemático da montagem: 
 - Dois compensados de madeira pregados, um para base e outro para fixar uma garrafa pet que irá armazenar a 
 comida. Uma garrafa pet de 1,5 litros fixada por 
 um parafuso, porcas e arruelas. Um encaixe de sifão de pia feito de plástico utilizado para alinhar a garrafa 
 com a distância das porcas e parafusos. Um micro servo 
 colado no bico da garrafa pet com um pedaço de acrílico para fechar o bico e manter o alimento na garrafa.
 - Arduíno Mega conectado ao módulo RTC DS1302 e ao Micro servo SG90. Cabo USB conectado ao computador.
 Pinos utilizados: Clock - Pino 22/ Data - Pino 24/ RST - Pino 26/Servo - Pino 28.
 (As imagens da estrutura foram enviadas junto com o projeto).
 Dificuldades econtradas:
 - Inicialmente a dificuldade foi na montagem da estrutura, foi necessário pensar em estratégias para que a 
 garrafa pet ficar presa, sem se mover com o motor.
 Encontrar uma peça para prender ao motor e fechar a saída do alimento também foi um desafio, já que não poderia 
 ser algo muito leve, nem muito pesado. A escolha do
 motor utilizado também foi um problema, já que a estrutura foi montada antes da fixação do motor, e o micro 
 servo não foi a primeira escolha, porém foi a que melhor 
 atendeu a necessidade.
 - Para o código, foi complicado encontrar uma biblioteca que funcionasse corretamente com o módulo RTC 
 disponível. Após esse desafio, foi necessário encontrar uma
 lógica para o movimento do motor, já que para a abertura a velocidade não importava tanto, porém para fechar o 
 recipiente era necessário controlar a velocidade de
 uma forma para controlar a porção do alimento.
 */
 #include <virtuabotixRTC.h> //Inclui a biblioteca virtuabotixRTC          
 #include "Servo.h" // Inclui a Biblioteca Servo.h 
 //Determina os pinos ligados ao modulo RTC(clock, data, rst)
 virtuabotixRTC myRTC(22, 24, 26);
 Servo servo; // Cria o objeto servo para programação 
 int angulo; // Cria a variável que controla a posição do motor
  
 void setup() {
 servo.attach(28); // Declara o pino do servo
 Serial.begin(9600);
 //Informacoes iniciais de data e hora (segundos, minutos, hora, dia da semana, dia do mes, mes, ano)
 myRTC.setDS1302Time(55, 30, 14, 4, 07, 04, 2021);
 //No programa eu não mostro data e dia da semana, mas seria possível também mostrar isso no monitor serial
 }
 void loop()  
{
 //Le as informacoes do CI
 myRTC.updateTime(); 
 //Aqui eu mostro no monior serial o horário, a partir do valor setado anteriormente
 Serial.print("Hora : ");
 //Esses if são apenas por uma questão de estética, de como mostrar o horário no monitor serial
 //Adiciona um 0 caso o valor da hora seja <10
 if (myRTC.hours < 10)
 {
   Serial.print("0");
 }
 Serial.print(myRTC.hours);
 Serial.print(":");
 //Adiciona um 0 caso o valor dos minutos seja <10
 if (myRTC.minutes < 10)
 {
   Serial.print("0");
 }
 Serial.print(myRTC.minutes);
 Serial.print(":");
 //Adiciona um 0 caso o valor dos segundos seja <10
 if (myRTC.seconds < 10)
 {
   Serial.print("0");
 }
 Serial.println(myRTC.seconds);
 delay(1000);

//A partir daqui eu faço o controle do motor
if(myRTC.hours == 14)
{
if(myRTC.minutes == 31)  
{
if(myRTC.seconds == 00)
{  
 for (angulo = 90; angulo < 180; angulo += 1) { // Comando que muda a posição do servo de 90 para 180°
 servo.write(angulo); // Escreve o angulo no motor
 delay(15); 
}
delay(30); // Tempo de espera para próximo movimento
//Esse delay controla o tempo em que o alimentador vai ficar aberto, com isso eu posso controlar o quanto de 
comida sai do recipiente, dependendo do animal
for (angulo = 180; angulo >= 90; angulo -= 5) { // Comando que muda a posição do servo de 180 para 90°
//Eu utilizei o valor de 5 pois assim o movimento de fechar o alimentador será mais rápido do que o movimento de 
abrir
servo.write(angulo); // Escreve o angulo no motor
delay(15);
} 
}
}
}
}

Trabalho Isabelle

Protótipo

Identifica se já tem comida no pote. Utilizou motor de passo, sensor ultrassônico (para detectar distância entre sensor e ração) e RTC. Funciona também automaticamente, quando se completa o horário de alimentação.