AULA 11 - Microcontroladores - Eng: mudanças entre as edições
Ir para navegação
Ir para pesquisar
imported>Fargoud |
imported>Fargoud |
||
| Linha 346: | Linha 346: | ||
==Protótipo== | ==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. | |||
[[image: prototIsa.png| center]] | |||
Vídeos do protótipo: | |||
[ https://drive.google.com/file/d/1dTqL8hMPjcCjt4NV5gCucpOLvToaIy0J/view?usp=sharing Funcionamento automático pelo horário] | |||
[https://drive.google.com/file/d/1p1ufiBx8Ptear9Lhecm9obuWR28PAkMJ/view?usp=sharing vídeo mostrando o cãozinho utilizando o equipamento] | |||
[https://drive.google.com/file/d/1XH5Ps3ahB-kcQ5rgyC1KCQY-e31pR_cH/view?usp=sharing vídeo demonstrando que sistema detecta quando pote já está cheio] | |||
[ https://drive.google.com/file/d/1gmUPzKrA7FdNxhqYH64MBSkDGQnZSrUE/view?usp=sharing vídeo com explicação detalhada do código] | |||
Edição das 08h27min de 23 de abril de 2021
Trabalho Bernardo
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.
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.
Vídeos do protótipo:
[ https://drive.google.com/file/d/1dTqL8hMPjcCjt4NV5gCucpOLvToaIy0J/view?usp=sharing Funcionamento automático pelo horário]
vídeo mostrando o cãozinho utilizando o equipamento
vídeo demonstrando que sistema detecta quando pote já está cheio
[ https://drive.google.com/file/d/1gmUPzKrA7FdNxhqYH64MBSkDGQnZSrUE/view?usp=sharing vídeo com explicação detalhada do código]
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
| < Projeto 2 - Alimentador automático de pets | AULA 11 - Projeto 2 - Protótipos dos Alunos - Apresentação | Projeto 3 - Sistema de segurança residencial > |
|---|