Exibindo a temperatura a partir de um NTC e LCD 16x2

INTRODUÇÃO:

Como atividade de conclusão do módulo III e, consequentemente, das atividades da disciplina de Algoritmos e Estruturas de Dados, avançamos com um projeto, cuja ideia era desenvolver, a partir dos conhecimentos adquiridos ao longo do semestre, uma atividade com o microcontrolador Arduino. O projeto desenvolvido pelo grupo consistia em um medir a temperatura ambiente, bem como as suas variações, a partir de um sensor e exibi-la em um display LCD.


COMPONENTES UTILIZADOS:

• Arduino Mega
• Protoboard
• NTC
• LCD 16x2
• Resistor 10kOhms
• Fios jumper


MONTAGEM DO PROJETO:

Para a montagem do projeto, foram montados dois circuitos independentes. O primeiro, como visto na imagem abaixo, é responsável por alimentar o NTC, que identifica a temperatura ambiente, cuja montagem é a mesma utilizada na atividade do módulo II., Já o segundo circuito alimenta o display LCD, que posteriormente imprimiria em seu visor o valor da temperatura identificado pelo NTC. Imagens das montagens do circuito podem ser vistas abaixo:

 (Ligação do NTC)

 (Ligação do LCD 16x2)

(Montagem do circuito)

(Montagem do circuito)

CÓDIGO:

O código utilizado na IDE do Arduino se assemelha bastante com o código utilizado na atividade do módulo II, cujo objetivo era medir a temperatura a partir do NTC e exibi-la no "Serial Monitor" do Arduino. A única diferença, nesse caso, está nos comandos do LCD, tal como lcd.print(temperature), cujo objetivo é exibir no LCD o valor da variável temperatura, captado pelo NTC.

VÍDEOS:

SERIAL.BEGIN

Bóia de Nível

Tendo em vista os problemas de falta de água nos últimos anos o uso de sistemas de capitação da água da chuva tem sido muito procurado. Um sistema muito utilizado e o de cisternas que ficam no nível do solo pois se utiliza o telhado como área de capitação.
O nosso projeto se baseia em um sistema com uma chave de nível ativando motobombas. Assim podendo controlar um sistema de cisternas.
O sistema cisternas funciona da seguinte maneira:


Código:

//Método setup, executado uma vez ao ligar o Arduino.
void setup() {
  pinMode(led1,OUTPUT);
  pinMode(led2,OUTPUT);
  pinMode(led3,OUTPUT);
  pinMode(btn1,INPUT);
  pinMode(btn2,INPUT);
  pinMode(btn3,INPUT);
}

//Método loop, executado enquanto o Arduino estiver ligado.
void loop() {

  s_btn1 = digitalRead(btn1);
  s_btn2 = digitalRead(btn2);
  s_btn3 = digitalRead(btn3);
 

  if (s_btn1 == HIGH) {
    digitalWrite(led1,HIGH);
    digitalWrite(led2,LOW);
    digitalWrite(led3,LOW);
  } else if(s_btn2 == HIGH){
    digitalWrite(led1,LOW);
    digitalWrite(led2,HIGH);
    digitalWrite(led3,LOW);
  } else if(s_btn3 == HIGH){
    digitalWrite(led1,LOW);
    digitalWrite(led2,LOW);
    digitalWrite(led3,HIGH);
  }    

}

Projeto:

Trabalho com Arduino - Módulo 3

Quando nos foi passado esse trabalho referente ao módulo 3, buscamos juntar o útil ao agradável, visto que já estávamos com um projeto envolvendo o arduino em andamento.

O nosso projeto visa controlar o acendimento de um led utilizando um Módulo RF por meio de transmissão e recepção. Tivemos bastante dificuldade no entendimento de algumas bibliotecas e funções do arduino, que até então eram desconhecidas para nós, como a do módulo (virtualwire), bibliotecaessa que descobrimos na internet. Porém, apesar da dificuldade, conseguimos executar o programa.

Código Transmissão:

#include <VirtualWire.h>

//Define pinos Led e Botao
const int ledPin = 13;
const int pino_botao = A0;

int valor_botao;
char Valor_CharMsg[4]; 
//Armazena estado led = ligar/desligar
int estado = 0;

void setup() 
{
  Serial.begin(9600);   
  pinMode(ledPin,OUTPUT);
  pinMode(pino_botao,INPUT);
  //Pino ligado ao pino DATA do transmissor RF
  vw_set_tx_pin(4);
  //Velocidade de comunicacao (bits por segundo)
  vw_setup(5000);
  Serial.println("Trasmissao modulo RF - Acione o botao...");
}

void loop() 
{
  //Verifica o estado do push-button
  valor_botao = digitalRead(pino_botao);
  //itoa(valor_botao,Valor_CharMsg,10);
  
  //Caso o botao seja pressionado, envia dados
  if (valor_botao == 0)
  {
    //Altera o estado do led
    estado = !estado;
    //Converte valor para envio
    itoa(estado,Valor_CharMsg,10);
    //Liga o led da porta 13 para indicar envio dos dados
    digitalWrite(13, true);
    //Envio dos dados
    vw_send((uint8_t *)Valor_CharMsg, strlen(Valor_CharMsg));
    //Aguarda envio dos dados
    vw_wait_tx();
    //Desliga o led da porta 13 ao final da transmissao
    digitalWrite(13, false);
    Serial.print("Valor enviado: ");
    Serial.println(Valor_CharMsg);
    delay(500);
  }
}

Código Recepção:

#include <VirtualWire.h>

//Define pino led
int ledPin = 5;

int valor_recebido_RF;
char recebido_RF_char[4]; 

void setup() 
{
  Serial.begin(9600);
  pinMode(ledPin, OUTPUT);
  //Pino ligado ao pino DATA do receptor RF
  vw_set_rx_pin(7);
  //Velocidade de comunicacao (bits por segundo)
  vw_setup(5000); 
  //Inicia a recepcao  
  vw_rx_start();
  Serial.println("Recepcao modulo RF - Aguardando...");
}

void loop()
{
    uint8_t buf[VW_MAX_MESSAGE_LEN];
    uint8_t buflen = VW_MAX_MESSAGE_LEN;
    
    if (vw_get_message(buf, &buflen)) 
    {
    int i;
        for (i = 0; i < buflen; i++)
       {            
          //Armazena os caracteres recebidos  
          recebido_RF_char[i] = char(buf[i]);
       }
       recebido_RF_char[buflen] = '\0';
       
       //Converte o valor recebido para integer
       valor_recebido_RF = atoi(recebido_RF_char);
         
       //Mostra no serial monitor o valor recebido
       Serial.print("Recebido: ");
       Serial.print(valor_recebido_RF);
       //Altera o estado do led conforme o numero recebido
       if (valor_recebido_RF == 1)
       {
         digitalWrite(ledPin, HIGH);
         Serial.println(" - Led aceso !");
       }
       if (valor_recebido_RF == 0)
       {
         digitalWrite(ledPin, LOW);
         Serial.println(" - Led apagado !");
       }
    }
}

Grupo G2

       

Controle de luz utilizando LDR

Controle de luz utilizando LDR

São dois circuitos:

1º - LDR 10k resistor de 10k

2º - Relé-Lâmpada

A FUNÇÃO DO ARDUÍNO: 

Fazer a interligação do dois circuitos.

COMO FUNCIONA:

LDR -> Arduino -> Relé-Lâmpada

-> O LDR é um sensor de luminosidade que vai captar a luminosidade do ambiente e tranformar ela em um valor de resistência;
-> O Arduino vai ler esse valor informado pelo LDR e vai colocar ele no parametro if do código:
-> Dependo do que o if retornar (verdadeiro ou faso) o Arduino vai emitir um sinal para o relé que irá ligar ou desligar a lâmpada;

(montagem e testes do circuito)

Para que não ocorresse interferência da luz gerada pela lâmpada sobre o LDR, foi direcionado o LDR para um lado oposto ao da lâmpada.

CIRCUITO EM FUNCIONAMENTO:

O circuito também poderia ser aprimorado para que o nível de luminosidade do ambiente possa ser alterado manualmente pelo Potenciômetro atravées de ajuste fino no próprio sistema. O potenciometro ficaria em série com o LDR.

CÓDIGO:

Créditos: GRUPO G1.

Segundo Projeto com o Arduino

O projeto tem o intuito de controlar a velocidade do motor a partir da temperatura 

detectada.

Ele pode ser dividido em duas partes básicas:

1-A leitura da temperatura via NTC, que é levada ao arduino na forma de números.

2- A mudança de velocidade do motor a partir do processamento no arduino e a mudança de tensão fornecida ao motor.

Para a leitura da temperatura foi utilizado um NTC que é um resistor sensível a temperatura.

O motor de 5v é somente um exemplo perante a possibilidade de utilizações e acionamentos que podem ser realizados.

Esse projeto abre portas para uma diversidade de projetos que tem por idéia a leitura de uma variável para o controle de um valor ou mecanismo em malha aberta.

O mecanismo, se utilizado com conceitos de eletrônica de potencia, pode acionar ao invés de um motor cc lâmpadas e até mesmo grandes maquinas.

Por mais que o sistema inicialmente tenha apresentado uma grande dificuldade, ele após algumas analises e tentativas demonstrou ser muito didático e simples. 



Código usado:

#include <Thermistor.h> // biblioteca

Thermistor temp(4); // thermistor porta 4
int pinoMotor = 9; // motor porta 9


void setup() {
pinMode(pinoMotor, OUTPUT); // pino do motor como saída
Serial.begin(9600); //comunicação do arduino para o pc em bits

}

void loop() { // função principal
  int temperature = temp.getTemp(); 
  
  Serial.print("Temperatura no Sensor eh: ");
  Serial.print(temperature);
  Serial.println("*C");
  delay(1000);
  
  if(temperature <= 23){
  analogWrite(pinoMotor, 50);  
  }
    else if (temperature > 23 && temperature < 25) {
  analogWrite(pinoMotor, 127);
  }

  else {
    analogWrite(pinoMotor, 255);
  }
  

}

Segunda experiência com Arduino

EXPERIÊNCIA

Nossa segunda experiência com o Arduino foi muito produtiva. A compreensão de todas as etapas trouxe pleno aprendizado a todo o grupo. Apesar das dificuldades enfrentadas num primeiro momento, uma vez que havia uma dificuldade na montagem dos circuitos, houve uma interação interessante entre os grupos, o que possibilitou uma troca de informações e a obtenção dos resultados esperados por todos os grupos.

CÓDIGO

MONTAGEM

Para fazer o controle da velocidade de rotação do motor CC a partir da temperatura medida pelo sensor, foi necessário realizar a montagem dos dois circuitos de forma independente.

Primeiramente, monta-se o circuito de medição de temperatura, para o qual foi utilizado um NTC (Negative Temperature Coefficient), um resistor de 10 kOhms e fios jumper, além da protoboard e do arduino. Alimenta-se com 5V na entrada no NTC, que é colocado em série com o resistor, cuja saída vai para a terra. Conecta-se também o ponto entre o NTC e o resistor à entrada analógica A4 do Arduino. A partir daí, o NTC "lê" a temperatura ambiente e o arduino traduz em números.

Após isso, monta-se o circuito do acionamento do motor CC, que usa um motor CC, um diodo 1N4001, um resistor 1 kOhms, um transistor TIP 120 e fios jumper. Conecta-se o 5V do arduino a um dos terminais do motor, em paralelo com o diodo, polarizado reversamente. Conecta-se o outro terminal ao coletor transistor e o emissor é conectado na terra (GND). À base do transistor, conecta-se o resistor de 1 kOhms, que é ligado no pino digital D9 do Arduino.

Assim, quando o arduino é alimentado, o sistema começa a funcionar com o sensor identificando a temperatura ambiente e, a partir disso, a temperatura é comparada com as condições definidas no código escrito no programa Arduino. A partir da temperatura medida, o arduino fornece mais ou menos tensão para o motor, controlando, assim, sua velocidade de rotação.

GRUPO SERIAL.BEGIN

Segunda Experiencia com o Arduino

     Nossa segunda experiência com o Arduíno não foi tão complexa quanto a primeira, pois já tínhamos alguma experiência com o mesmo, porém, não foi tão fácil e prazerosa. Um dos motivos de ainda percebermos uma leve complexidade nos problemas propostas foi a evasão de alguns integrantes do nosso grupo, restando apenas 3 integrantes, mas os mesmos foram sanados com a associação ao grupo 20programar.

     Falando um pouco sobre as atividades desenvolvidas, trabalhamos com o sensor LDR, cuja resistência varia de acordo com a luminosidade recebida onde utilizamos algumas funções do Arduíno, as famosas portas seriais e as analógicas. Passando pela atividade 6, trabalhamos com as atividade 7, 8 e 9 no qual acionamos um motor CC e adquirimos experiência no funcionamento da porta PWM, e do potenciômetro.

Já nas atividades 10 e 11, trabalhamos com o medidor de temperatura NTC que foi de suma importância para o desenvolvimento da atividade posterior, que é o principal motivo deste post.

Atividade 12 - CONTROLAR VELOCIDADE DO MOTOR CC COM TERMISTOR

     Nos reunimos no laboratório do NERA  junto com o grupo 20programar para darmos sequência a atividade 12, conforme segue abaixo.

Primeira tentativa:

Segunda tentativa:

Apos a primeira tentativa aprimoramos o programa para que ele passe a contar com 3 oscilações de velocidade em relação a temperatura, o programa resultante foi:

 GRUPO: G2

Comandos de Seleção e Repetição, G1.

 O comando WHILE:

Descrição:

O comando de repetição while tem duas partes: a expressão de teste e o corpo da repetição. O formato do while é:
while (expressão teste)
corpo da repetição

A expressão teste é inicialmente avaliada para verificar se o laço deve terminar. Caso a expressão seja verdadeira (isto é, diferente de 0 (zero)), o corpo da repetição é executado. Depois desta execução, o processo é repetido a partir da expressão teste. O corpo do laço, por sua vez, pode ser uma sentença simples ou composta.


O exemplo abaixo mostra o uso do comando de repetição while:

             int contador = 0;

             while( contador < 5 )
             {
               printf( "contador = %d\n", contador);
               contador += 1;
             }

             printf("ACABOU !!!!\n");

Saída:

             contador = 0
             contador = 1
             contador = 2
             contador = 3
             contador = 4
             ACABOU !!!!

O comando IF/IF-ELSE:

há duas variações do comando if:

1 - if (condição) comando-if else comando-else



2 - if (condição) comando-if



Descrição:

Os comandos if e if-else são instruções que permitem a execução condicional de outros comandos. 

Na forma completa, if-else, o comando-if é executado quando a condição é verdadeira, caso contrário, o comando-else é executado. A figura abaixo ilustra um bloco em pseudo-linguagem gráfica que corresponde ao comando if-else:







Há ocasiões em que o else é desnecessário, e por isso a linguagem C permite a outra construção if (sem o else) desse comando. No diagrama, o bloco comando-else (quando a condição é falsa), se torna vazio, ou seja, não existem comandos para serem executados.





O comando FOR:



Descrição:
Assim como no comando while o for repete o bloco <comandos> enquanto a <condição> se manter verdadeira.








A parte de <inicialização> é realizada apenas 1 vez, no início da execução do comando. A seguir, a <condição> é testada, e caso verdadeira, os <comandos> são executados. Após a execução dos<comandos> mas antes de testar a <condição>, a parte <incremento> do comando for é executada. 

O for é basicamente uma forma compacta de escrever um loop típico usando while. Por exemplo, para que possamos repetir algo n vezes, é comum utilizarmos a seguinte construção usando o while:

  cont = 0;
  while (cont < n)
    {
      <comandos>
      cont++;
    }
onde n e cont são variáveis inteiras, e cont++ é uma abreviação permitida em C de cont = cont + 1. Usando o comando for, esse trecho de programa seria reduzido para o seguinte:

  for (cont = 0; cont < n; cont++) <comandos>




O comando SWITCH:



Descrição:


Imagine que você quer testar um valor digitado pelo usuário com 10 números.
Você poderia fazer com IF, tranquilamente.
Porém, seu código iria ficar enorme e você teria que digitar várias vezes IF (...), IF(...)

Visando reduzir isso, vamos aprender como usar o comando switch, que iremos usar várias vezes durante nossa apostila de C, para criar menus, por exemplo, onde iremos exibir uma série de opções, o usuário vai escolher uma e vamos saber qual opção ele escolheu através de um comando switch.

A sintaxe do switch é a seguinte:


switch( opção ) { case opção1: comandos caso a opção 1 tenha sido escolhida break; 
case opção2: comandos caso a opção 2 tenha sido escolhida break; 
case opção3: comandos caso a opção 3 tenha sido escolhida break;     
default: comandos caso nenhuma das opções anteriores tenha sido escolhida }



O switch vai comparar a variável 'opção' com os 'case'. Se ele achar uma opção (case) que seja igual, ele vai rodar o código que vem após esse case, e antes do próximo case.
Caso nenhum case seja igual a 'opção', o código que está default é o que será rodado.

Caso a 'opção' seja um char, coloque entre aspas simples ' ', caso seja string coloque entre aspas duplas " " e caso seja um número, não é necessário colocar nenhum tipo de aspas.




PESQUISA REALIZADA PELO GRUPO G1.

Comandos de Seleção e Comandos de Repetição

 

1 Comandos de Seleção 

Os comandos de seleção, como o nome diz, permitem fazer uma seleção, entre uma ou mais alternativas, da ação que o computador deve tomar ou seguir. A seleção é baseada no valor de uma expressão de controle. Em C/C++, um valor pode ser testado através do comando if e as suas variações, ou através do comando switch.  

1.1 Comando IF (se) e variáveis

  

O comando IF serve para alterar o fluxo de execução de um programa em C baseado no valor, verdadeiro ou falso, de uma expressão lógica.

Estrutura básica

if (condição) {     lista de instruções }

- Se a condição for satisfeita (V), então as instruções dentro da chave serão executadas.

- Se a condição não for satisfeita (F), então será executado o que vem depois das chaves 

Variação 1 IF  ELSE

if (condição)    {     lista de instruções     }  else      {      lista de instruções      }  ......

- Se IF não obtiver resultado verdadeiro, automaticamente serão feitas as instruções que estão dentro do ELSE

- Quando acabar tanto a lista de instruções abaixo do IF, quanto a lista de instruções referente ao ELSE, ele inicia o que vem após a lista de instrução do ELSE.

Variação 2 IF  ELSEIF ELSE

if (condição)    {     lista de instruções     }  else if (condição)     {      lista de instruções      } else {      lista de instruções      }  ......

- Se a condição colocada após o IF não obtiver resultado verdadeiro, automaticamente serão verificada a condição do ELSE IF.

- Caso não seja verdadeira, faz-se a lista de isntruções que estão dentro do ELSE

-Caso a condição seja do IF ou do ELSE IF sejam VERDADEIRAS, serão realizadas as listas de instruções dos seus respectivos, e ao acabar ela executa os (....) que vem após a chave do ELSE.

-Caso a condição seja do IF ou do ELSE IF sejam FALSAS, executa o ELSE e quando se acaba executa o  (....) 

1.2 Comando Switch

Este comando é usado para se evitar a utilização de vários IF/ ElSE IF e ELSE encadeados, muito usado principalmente em estruturas de menu, a variável é comparada com um valor constante, se for verdadeira, um determinado programa é executado.

switch (variável)

{

case constante1:

Instruções;

case constante2:

break;

Instruções;

   break;

}

default

Instruções;

- A instrução break termina a execução do switch e o programa continua a executar na instrução seguinte.

- O uso do break evita testar as demais alternativas de forma desnecessária quando uma opção verdadeira já foi encontrada.

- O comando default exibe uma mensagem, caso nenhuma das alternativas anteriores seja verdadeira.

- Não são aceitas expressões condicionais no comando switch…case, somente são aceitos valores constantes.

2 Comandos de Repetição

São recursos de programação usados quando se quer que determinado trecho do programa execute uma comando ou um bloco de comando um número x de vezes. por exemplo, percorrer os indices de um vetor, realizar um somatório, etc... 

Em C para se realizar essas repetições usa-se FOR, WHILE e DO/WHILE

2.1 Comando FOR

É usado quando sabemos com exatidão a quantidade de vezes que determinado comando ou bloco de comando será executado.

for(valor_inicial; condição_final; valor_incremento)

 {

    instruções;

}

O comando for executa um conjunto de instruções, um determinado número de vezes de acordo com uma condição enquanto uma variável de controle é incrementada ou decrementada a cada passagem pelo “laço”.

2.2 Comando WHILE (Enquanto)

Executa a repetição de um bloco de instruções enquanto uma condição é verdadeira.

while (condição)

{

Instrução ou bloco de instruções;

}

- Enquanto a condição permanecer verdadeira, são executadas as instruções.

- Quando a condição se tornar falsa, o processamento será desviado para fora do laço.

2.3 Comando DO WHILE

O que o laço DO WHILE faz é executar,pelo menos uma vez, o que está dentro dele e só ao final da execução é que ele faz o teste, usando o laço WHILE. Ou seja, temos a garantia que o laço vai ser executado uma vez, sempre precisar inicializar variável ou pedir dados ao usuário antes do WHILE.

do

{

//comandos;

} while (condicao);

 -No comando while a condição é testada antes do bloco de instruções, e caso a condição seja falsa a repetição não será executada.

-No do…while o bloco de comandos é executado pelo menos uma vez de forma obrigatória, independente do resultado da expressão lógica




GRUPO G2