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

De IFSC
Ir para navegação Ir para pesquisar
imported>Fargoud
imported>Fargoud
Sem resumo de edição
 
(6 revisões intermediárias pelo mesmo usuário não estão sendo mostradas)
Linha 4: Linha 4:


----------------
----------------
=Trabalho Bernardo =
=AULA DE PROJETO 2=


==Protótipo==
==TEMA PROPOSTO: ''Sistema de monitoramento de horta'' - HORTA MICROCONTROLADA==


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


[https://drive.google.com/file/d/1HqMIbjNGdu6Z450rAH8eF7w19jGAKLfs/view?usp=sharing  Vídeo do protótipo]
O aluno deverá projetar, construir e apresentar (código e ''hardware'') um sistema de monitoramento de um ou mais parâmetros relacionados à cultivo de plantas (temperatura, umidade do solo, umidade do ar, luminosidade, cor das folhas, reflexão da luz, etc) e alguma intervenção em função destes parâmetros.


==Firmware==
O arduino lerá valor(es) de sensor(es) e, de acordo com padrões pré-estabelecidos, poderá fazer irrigação, aquecimento, resfriamento, abertura ou fechamento de coberturas, portas, etc, para melhorar as condições da horta.


#include <Stepper.h>
O sistema também poderá fazer armazenamento em memória e traçado dos parâmetros, em display.
#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=
==ESPECIFICAÇÕES DE PROJETO==


==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).
===TEMPO DE PROJETO:===


Utilizou servo motor.
'''A apresentação deverá ser feita, impreterivelmente, das 13:30h até às 16:00h do dia <u>06/02/25</u>'''.


[https://drive.google.com/file/d/1T0cJ1DCdJ9S9eXDImcBwffDrYZnl8sWG/view?usp=sharing Vídeo do protótipo]


===COMPONENTES:===


O aluno pode adquirir seus próprios componentes e materiais, ou solicitar uma lista de componentes ao Almoxarifado do Curso, com Wagner ou Rafael, com antecedência mínima de 48 h, com relação ao dia da apresentação!


==Firmware==
Componentes solicitados após o prazo terão que ser adquiridos pelo próprio aluno.


#include <Servo.h>
Todo componente perdido ou avariado deverá ser, obrigatoriamente, substituído pelo aluno, sob pena de ser reprovado na disciplina, por comportamento inapropriado.
#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=
===ESPECIFICAÇÕES DO PROTÓTIPO:===  


==Protótipo==
Com exceção do display e teclado, todo restante do ''hardware'' deverá ser desenvolvido pelo próprio aluno.


O ''firmware'' poderá conter partes de códigos de outrem, mas deverá, obrigatoriamente, conter pelo menos 50% de código de autoria do próprio aluno.


Não é imprescindível que o protótipo funcione, mas a coerência no desenvolvimento, e habilidade em aproveitar o que foi aprendido nas aulas anteriores serão avaliadas.


[  Vídeo do protótipo]


==Firmware==


  /*
===APRESENTAÇÃO:===
  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
Cada aluno disporá de ate 40 min para montar e apresentar seu protótipo, durante a Aula de Apresentação. Este deverá explicar as dificuldades que encontrou, e as soluções que aplicou para lidar com estas dificuldades.
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=
Os demais alunos devem utilizar esta oportunidade para aprender com o trabalho do colega, e a frequência e comportamento perante a apresentação dos outros também será avaliada.


==Protótipo==
Por fim, o aluno deverá sugerir utilizações práticas para seu protótipo e aprimoramentos neste, de forma que sua funcionalidade e aplicabilidades sejam incrementadas.




===Hardware/Eletrônica===
==AVALIAÇÃO==
 
[https://photos.app.goo.gl/M98G3ZXSBWFQRawB6  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==




O aluno será avaliado da seguinte maneira:


# Qualidade do protótipo - '''PESO 4''' - será avaliado, principalmente, o empenho do aluno em propor soluções criativas, complexas e interessantes. O funcionamento do protótipo é desejável, mas não imprescindível. A professora vai tentar quantificar o número de horas despendidas no projeto, por meio da complexidade do ''hardware'' e ''firmware'' apresentados.
# Organização - '''PESO 3''' - organização e disciplina são imprescindíveis para um profissional da área de TI. Será avaliada a capacidade do aluno em gerenciar seu tempo e seu projeto, especificando prazos e metas para o atingimento de seus objetivos.
# Apresentação - '''PESO 3''' - seja como empregado de uma empresa de TI, seja como aluno de um programa de pós-graduação, seja como empresário, um profissional de Engenharia deve saber apresentar seu produto/projeto. Assim, a professora vai avaliar o entusiasmo e empenho do aluno em defender seu projeto, nos aspectos técnico e pessoal.


Material auxiliar: [https://www.sta-eletronica.com.br/artigos/arduinos/utilizando-o-modulo-rfid-com-o-arduino-uno Utilizando o módulo RFID]




Linha 597: Linha 71:
{| border="1" cellpadding="5" cellspacing="0"  
{| border="1" cellpadding="5" cellspacing="0"  
! style="background: #cdc5bf;" | [[AULA 10 - Microcontroladores - Eng| < Projeto 2 - Alimentador automático de ''pets'']]  
! style="background: #cdc5bf;" | [[AULA 10 - Microcontroladores - Eng| < Projeto 2 - Alimentador automático de ''pets'']]  
! style="background: #cdc5bf;" | AULA 11 -  Projeto 2 - Protótipos dos Alunos - Apresentação
! style="background: #cdc5bf;" | AULA 11 -  Projeto 2 - Apresentação
! style="background: #cdc5bf;" | [[AULA 12 - Microcontroladores - Eng| Projeto 3 - Sistema de segurança residencial > ]]
! style="background: #cdc5bf;" | [[AULA 12 - Microcontroladores - Eng| Projeto 3 - Sistema de segurança residencial > ]]
|}
|}

Edição atual tal como às 14h40min de 5 de dezembro de 2024

<< Página do curso


AULA DE PROJETO 2

TEMA PROPOSTO: Sistema de monitoramento de horta - HORTA MICROCONTROLADA

O aluno deverá projetar, construir e apresentar (código e hardware) um sistema de monitoramento de um ou mais parâmetros relacionados à cultivo de plantas (temperatura, umidade do solo, umidade do ar, luminosidade, cor das folhas, reflexão da luz, etc) e alguma intervenção em função destes parâmetros.

O arduino lerá valor(es) de sensor(es) e, de acordo com padrões pré-estabelecidos, poderá fazer irrigação, aquecimento, resfriamento, abertura ou fechamento de coberturas, portas, etc, para melhorar as condições da horta.

O sistema também poderá fazer armazenamento em memória e traçado dos parâmetros, em display.


ESPECIFICAÇÕES DE PROJETO

TEMPO DE PROJETO:

A apresentação deverá ser feita, impreterivelmente, das 13:30h até às 16:00h do dia 06/02/25.


COMPONENTES:

O aluno pode adquirir seus próprios componentes e materiais, ou solicitar uma lista de componentes ao Almoxarifado do Curso, com Wagner ou Rafael, com antecedência mínima de 48 h, com relação ao dia da apresentação!

Componentes solicitados após o prazo terão que ser adquiridos pelo próprio aluno.

Todo componente perdido ou avariado deverá ser, obrigatoriamente, substituído pelo aluno, sob pena de ser reprovado na disciplina, por comportamento inapropriado.


ESPECIFICAÇÕES DO PROTÓTIPO:

Com exceção do display e teclado, todo restante do hardware deverá ser desenvolvido pelo próprio aluno.

O firmware poderá conter partes de códigos de outrem, mas deverá, obrigatoriamente, conter pelo menos 50% de código de autoria do próprio aluno.

Não é imprescindível que o protótipo funcione, mas a coerência no desenvolvimento, e habilidade em aproveitar o que foi aprendido nas aulas anteriores serão avaliadas.


APRESENTAÇÃO:

Cada aluno disporá de ate 40 min para montar e apresentar seu protótipo, durante a Aula de Apresentação. Este deverá explicar as dificuldades que encontrou, e as soluções que aplicou para lidar com estas dificuldades.

Os demais alunos devem utilizar esta oportunidade para aprender com o trabalho do colega, e a frequência e comportamento perante a apresentação dos outros também será avaliada.

Por fim, o aluno deverá sugerir utilizações práticas para seu protótipo e aprimoramentos neste, de forma que sua funcionalidade e aplicabilidades sejam incrementadas.


AVALIAÇÃO

O aluno será avaliado da seguinte maneira:

  1. Qualidade do protótipo - PESO 4 - será avaliado, principalmente, o empenho do aluno em propor soluções criativas, complexas e interessantes. O funcionamento do protótipo é desejável, mas não imprescindível. A professora vai tentar quantificar o número de horas despendidas no projeto, por meio da complexidade do hardware e firmware apresentados.
  2. Organização - PESO 3 - organização e disciplina são imprescindíveis para um profissional da área de TI. Será avaliada a capacidade do aluno em gerenciar seu tempo e seu projeto, especificando prazos e metas para o atingimento de seus objetivos.
  3. Apresentação - PESO 3 - seja como empregado de uma empresa de TI, seja como aluno de um programa de pós-graduação, seja como empresário, um profissional de Engenharia deve saber apresentar seu produto/projeto. Assim, a professora vai avaliar o entusiasmo e empenho do aluno em defender seu projeto, nos aspectos técnico e pessoal.

Material auxiliar: Utilizando o módulo RFID


<< Página do curso

< Projeto 2 - Alimentador automático de pets AULA 11 - Projeto 2 - 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=19158”