AULA 11 - Microcontroladores - Eng: mudanças entre as edições

De IFSC
Ir para navegação Ir para pesquisar
imported>Fargoud
imported>Fargoud
Linha 240: Linha 240:
==Protótipo==
==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]
[ Vídeo do protótipo]


==Firmware==
==Firmware==

Edição das 08h13min de 23 de abril de 2021

<< Página do curso


Trabalho Bernardo

Protótipo

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

Vídeo do protótipo

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

Hardware/Eletrônica

Vídeo Projeto 2 Alimentador de peixes Thiago

Partes Mecânicas

Firmware

 #include <LiquidCrystal.h> //Inclui biblioteca do LCD
 #include <Stepper.h> 
     
 LiquidCrystal lcd(12, 11, 5, 4, 3, 2); 
 const int stepsPerRevolution = 500;
 //Inicializa a biblioteca utilizando as portas de 8,9,10 e 13 para 
 //ligacao ao motor 
 Stepper myStepper(stepsPerRevolution, 8,10,9,13);  
 
 int segundo,minuto,hora,dia,mes,ano; 
 unsigned long UtlTime; 
 
 void setup(){ 
  //Determina a velocidade inicial do motor 
   myStepper.setSpeed(60);
   
   //Para o LCD 
   UtlTime=0;   
   minuto=0;   
   hora=0;   
   dia=0;   
   mes=0;   
   ano=0;   
   Serial.begin(9600); 
   lcd.begin(16, 2);      
   
   lcd.setCursor(0,0);   
   lcd.print(" Data e hora ");   
   lcd.setCursor(0,1);   
   lcd.print(" com Arduino");   
   delay (2000); 
  
   //Configura o minuto   
   lcd.clear();   
   lcd.setCursor(0,0);   
   lcd.print("Minuto: ");   
   Serial.print("\nEntre Minuto:");  
   while(minuto==0){     
     if (Serial.available() > 0){       
     minuto= Serial.parseInt();
     Serial.print(minuto);     
     }   
   }   
   lcd.print(minuto);   
   delay(1000);

    //Configura a hora   
   lcd.clear();   
   lcd.setCursor(0,0);   
   lcd.print("Hora: ");   
   Serial.print("\nEntre Hora:"); 
   while(hora==0){     
     if (Serial.available() > 0){       
     hora= Serial.parseInt();
     Serial.print(hora);     
     }   
   }   
   lcd.print(hora);   
   delay(1000); 
 
   //Configura o Dia   
   lcd.clear();   
   lcd.setCursor(0,0);   
   lcd.print("Dia: ");   
   Serial.print("\nEntre Dia:");   
   while(dia==0)   
   {     
     if (Serial.available() > 0){       
       dia= Serial.parseInt();
        Serial.print(dia);     
     }   
   }   
   lcd.print(dia);   
   delay(1000);    
   
   //Configura o mês   
   lcd.clear();   
   lcd.setCursor(0,0);   
   lcd.print("Mes: ");   
   Serial.print("\nEntre Mes:");  
   while(mes==0)   
   {     
     if (Serial.available() > 0){       
       mes= Serial.parseInt();
        Serial.print(mes);     
     }   
   }   
   lcd.print(mes);   
   delay(1000);    
   
   //Configura o Ano   
   lcd.clear();   
   lcd.setCursor(0,0);   
   lcd.print("Ano: ");   
   Serial.print("\nEntre ano:");   
   while(ano==0){     
     if (Serial.available() > 0){       
       ano= Serial.parseInt();
       Serial.print(ano);    
     }   
   }   
   lcd.print(ano);   
   delay(1000);    
   lcd.clear(); 
 }
 
 void EscreveDataHora(){  
   if(millis()-UtlTime<0){     
     UtlTime=millis();   
   }   
   else{     
     segundo=int((millis()-UtlTime)/1000);   
   }   
   if(segundo>59){     
     segundo=00;
     lcd.clear();     
     minuto++;     
     UtlTime=millis();     
     if(minuto>59){       
       hora++;
       lcd.clear();       
       minuto=00;       
       if(hora>23){         
         dia++;         
         hora=00;         
         if(mes==1||mes==3||mes==5||mes==7||mes==8||mes==10||mes==12){           
           if(dia>31){             
             dia=1;             
             mes++;             
             if(mes>12){               
              ano++;               
              mes=1;             
             } 
           }       
         }         
       else if(mes==2){           
          if(ano%400==0){             
           if(dia>29){               
             dia=1;               
             mes++;             
           }           
          }         
           else if((ano%4==0)&&(ano%100!=0)){             
             if(dia>29){              
               dia=1;               
               mes++;             
             }           
           }           
           else{             
             if(dia>28){               
               dia=1;               
               mes++;             
             }           
           }         
         }         
       else{           
         if(dia>30){             
           dia=1;             
           mes++;           
         }         
       }      
     }     
   }   
 }    
   lcd.setCursor(0,0);   
   lcd.print("Data ");   
   lcd.print(dia);   
   lcd.print("/");   
   lcd.print(mes);   
   lcd.print("/");   
   lcd.print(ano);  
   lcd.setCursor(0,1);   
   lcd.print("Hora ");   
   lcd.print(hora);   
   lcd.print(":");   
   lcd.print(minuto);   
   lcd.print(":");   
   lcd.print(segundo);
 }
  
 void SelecionaHoraAlimentaPET(){
   //Seleciona a hora da refeição
   int h=15;
   //Seleciona os minutos da refeição
   int m=15;
   
   //Mostra no DISPLAY
   if(hora==h&&minuto==m&&segundo>=30){
     lcd.clear(); 
     lcd.setCursor(0,0);
     lcd.print(" Hora da racao ");
     lcd.setCursor(0,1);
     lcd.print(" Bom apetite! ");
     //Liga o motor
     LigaMotor();
   }
   else{
      lcd.clear();
      EscreveDataHora();
   }
 }
 void LigaMotor(){
 //O motor faz 2 giros completos
  for (int i = 0; i<=2; i++)
  {
    myStepper.step(2048); 
    delay(2000);
  }
  delay(2000);
}
 
  void loop(){ 
   EscreveDataHora();
   SelecionaHoraAlimentaPET();
 }

Trabalho Vitor

Protótipo

Hardware/Eletrônica

Partes Mecânicas

Firmware

<< Página do curso

< Projeto 2 - Alimentador automático de pets AULA 11 - Projeto 2 - Protótipos dos Alunos - Apresentação Projeto 3 - Sistema de segurança residencial >
Disponível em “https://wiki.ifsc.edu.br/index.php?title=AULA_11_-_Microcontroladores_-_Eng&oldid=19152”