Estou lendo um sensor DHT22 temperatura e umidade + data e hora com o  sensor DS-3231. 

Quando eu mudo de tela estou utilizando a função DELAY, isso atrasa o programa. 

tentei usar a função Millis mas algo está errado. 

Alguém poderia me ajudar?    

void setup() { //............. TEMPO SETUP

pinMode (Botao, INPUT_PULLUP); // ENTRADA 33 liga led verm direto
pinMode (LedVerde, OUTPUT); // saida para rele 38
pinMode (LedVermelho, OUTPUT); // SAIDA 38 INDICA TEMPO LIGADO
digitalWrite (LedVerde, HIGH);
digitalWrite (LedVermelho, HIGH);
// TEMPERATURA
{

lcd.begin();
lcd.backlight();
Serial.begin(9600);  
lcd.setCursor(0, 0);
lcd.print("Testando o sen-"); 
lcd.setCursor(0, 1);
lcd.print("sor de tempera-"); 


currentMillis = millis();

if(currentMillis - previousMillis >= 5000) {previousMillis = currentMillis; cont++; lcd.clear();}

if(cont > 6){cont = 1;


lcd.setCursor(0, 0);
lcd.print("tura e umidade"); 
lcd.setCursor(0,1);
lcd.print("DHT22!");

}

Exibições: 1261

Responder esta

Respostas a este tópico

Bom dia.

Pelo que vi na sua lógica, você está limpando o LCD a cada 5 segundos e imprimindo no lcd a cada 25 segundos, depois quando passar mais cinco segundos limpa novamente e começa tudo de novo.

Acredito que não deva ser isso que você deseje fazer.

Outra coisa que percebi é que (pelo menos pelo trecho de código colado aqui) é que não está inicializando as variáveis previousMIllis e cont. 

Edson explica melhor como deseja que seja o comportamento para fazer a impressão em seu LCD.

Só uma pequena observação nesse seu código.

Acho que nesse seu exemplo a variável previousMillis deveria ser global ou do tipo estática, pois da forma que está ai nesse seu exemplo ela sempre será zero.

Talvez deveria ser declarada assim

static long previousMillis = 0; // Ai só seria inicializada uma única vez e guardaria o valor setado abaixo.

Agora deixa sugerir uma forma de fazer um simples delay com apenas uma única variável de controle.

Acho que para um simples "delay" poderia ser feito assim:

// Declara a variável de forma global do tipo unsigned long

unsigned long comparador = 0;

// No loop você faria apenas a comparação:

if ( comparador < millis() ) {

  comparador = millis() + 1000; // Substitua aqui 1000 pelo tempo desejado 

  // Executa aqui o que tem de ser feito ..... 

}

A lógica fica bem simples, consumindo menos memória (utiliza apenas uma variável).

Olha agora se pretende utilizar em outros locais, terá de criar uma variável de controle em cada local.

Uma vez que se for utilizar a mesma variável ela será sobreposta pela próxima chamada ao método.

Quanto ao aumento, é estranho.

Para poder utilizar a função genérica você teria de fazer uma parada estilo DELAY.

Mais tarde irei fazer uns testes e posto aqui o resultado.

Tranquilo amigo.

Só que a função tal como está postada não funciona.

Ela é uma função que não retorna nada (tipo void), e não preenche nenhum variável externa, ou seja, da forma como foi postada ai não vi nenhuma forma real de utilizar.

Acredito que utilize com sucesso uma função para tal fim, mais creio que o escopo da função não seja como postou.

Observe:

void myDelay (int ms) // Nunca retorna nada pois o tipo é void
{
   long previousMillis = 0; // O valor sempre iniciará como zero pois está sendo informado para fazer tal, outra coisa é o tipo de dado deveria ser unsigned long e não long
   unsigned long currentMillis = millis (); 
   if (currentMillis - previousMillis > ms) {

      // Acredito que aqui deveria setar algum flag, ou fazer algo qui.
      previousMillis = currentMillis; 
   }
}

Quando eu digo que precisa de uma variável para cada controle de tempo individual é pelo fato de ter algo para comparar com o millis atual, do contrário não teríamos como saber em que hora fazer as coisas. 

Espero que não entenda como crítica, é apenas uma observação espero que construtiva.

Show amigo.

Vou dar uma estudada nessa lib.

Abraço.

amigo sua sugestao foi legal mas não esta funcionando, me parece que isso é um pepino.... 

Valeu 

Ola  meu amigo,  no consigo resolver essa bucha,  será que conseguiria me ajudar? 

to enrolado com o millis no display 

valeu, realmente não funciona  para outros locais, obrigado pela força

valeu pela ajuda , vou testar a sua sugestão, mas era isso o que eu estava buscando tornar mais simples a funcao Millis 

abraços 

Bom dia ES,

Recomendações:


1. Remova seu sketch da área de texto do seu tópico;
2. Leia http://labdegaragem.com/forum/topics/sugest-o-de-como-postar
3. Comente as linhas do seu sketch. Fica mais fácil entender o que vc quer fazer com cada 
     linha e facilita a ajuda.
4. Clique em : " Deseja carregar arquivos? " e depois em " Escolher arquivo" e anexe o arquivo 
    com o seu sketch.

O seu sketch aparece aqui incompleto, pois faltam as varias definições.

Quando se usa a função millis(), deve definir as variáveis que guardam os valores de tempos 

sempre no formato unsigned long.

A função millis() é renovada em 2 situações (reset do arduino ou overflow) .

O overflow ocorre a cada 49 dias, 17 horas, 2 min, 47 seg e 295 miliseg.  (Valor 4,294,967,295)

Isto ocorre poque o registrador usado pelo timer tem um tamanho de 4 bytes = 0xFFFFFFFF,

este valor em decimal é = 4,294,967,295, sendo assim , ao usar variáveis com valores obtidos de millis(),

a variável precisa ser unsigned long.

Se for somente long, haverá erro pois o valor a partir  de 2.147.483.647 (0x7FFFFFFF)  o valor na variável 

ficará negativo.

RV

Segue o skatch completo com os comentários.   

ainda não  achei a soluça para a função delay.. 

// CONTROLE DE TEMPO COM BOTAO DE START
// EDSON SANTINI
// 29-08-2018
// LCD I2C FUNCIONANDO

// temp e humidade com LCD FUNCIONANDO
// sensor DHT 22 FUNCIONANDO
// FUNCIONANDO IF AND ELSE
// EDSON SANTINI
// 29-08-2018
// led vermelho funciona pelo botao de impulso
// led amarelo pelo contador
// temp e humidade com LCD FUNCIONANDO
// sensor DHT 22 FUNCIONANDO
// FUNCIONANDO IF AND ELSE

// LIGACOES
// LCD 2 LINHAS 16 COLUNAS
// PINOS LCD // PINOS RDUINO
// 1 VSS - GND
// 2 VDD + 5V
// 3 VO POT 10K - CENTRO
// 4 RS - DIGITAL 9
// 5 RW - DIGITTAL - GND
// 6 E - D8
// 7 DO - N/U
// 8 D1 - N/U
// 9 D2 - N/U
// 10 D3 - N/U
// 11 - D4 - DIGITAL 5
// 12 - D5 - DIGITAL 4
// 13 - D6 - DIGITAL 3
// 14 - D7 - DIGITAL 2
// 15 - A (ANODO) - CENTRO DO POT (2) (RECEBE +)
// 15 - k (KATODO) - GND

// PINOS 24 E 26 SAIDA PARA RELE - TEMPERATURA
// LED VERMELHO FUNCIONA PELO BOTAO DE IMPULO
// LED AMARELO PELO TIMER

// TIMER ---- PARA LIGAÇÕES

// BOTAO LIGA LED VERMELHO


// BIBLIOTECAS

#include <TimerOne.h>
#include <Arduino.h>
#include <Wire.h>
#include "DHT.h" //Biblioteca do DHT
#include <LiquidCrystal.h> //Biblioteca do LCD
//LiquidCrystal lcd(9, 8, 5, 4, 3, 2); // configurações do LCD sem I2C
#include <LiquidCrystal_I2C.h>

// Set the LCD address to 0x3F for a 16 chars and 2 line display
LiquidCrystal_I2C lcd(0x3F, 16, 2);


#define PINODHT A1 //Pino para comunicação com DHT
#define TIPODHT DHT22 //DHT22(AM2302/ AM2321)

DHT dht(PINODHT, TIPODHT); //Configuraçãoes do DHT

// DECLARANDO PINOS DE SAIDA TEMPO

int Botao = 33 ; // LIGA CONTROLE DO TEMPO

int LedVerde = 36; // LED 1 // SAIDA CONTROLE RELE MOTOR GIRO
int LedVermelho = 38; // LED 2 // LIGA QUANDO BOTAO DE TEMPO DE GIRO LIGAR

boolean estadoBotao = true;
boolean estAntBotao = true;
boolean estadoPisca = false;
unsigned long tempo1 = 0;
unsigned long tempo2 = 0;


// DECLARANDO PINOS DE SAIDA TEMPERATURA

int azul = 22; // SAIDA SENSOR TEMPERATURA
int amarelo = 24; // SAIDA SENSOR TEMPERATURA LIGA RELE TEMPERATURA
int vermelho = 26; // SAIDA SENSOR TEMPERATURA

int tempPin = A1; // ENTRADA SENSOR DE TEMPERATURA
int valorSensorTemp = 0;
int valorTemp;
float temperatura; // armazena temperatura

void setup() { //............. TEMPO SETUP

pinMode (Botao, INPUT_PULLUP); // ENTRADA 33 liga led verm direto
pinMode (LedVerde, OUTPUT); // saida para rele 38
pinMode (LedVermelho, OUTPUT); // SAIDA 38 INDICA TEMPO LIGADO
digitalWrite (LedVerde, HIGH);
digitalWrite (LedVermelho, HIGH);

// TEMPERATURA
{

lcd.begin();
lcd.backlight();
Serial.begin(9600); //tempo de leitura


lcd.setCursor(0, 0);
lcd.print("Testando o sen-"); // ESCREVE TESTANDO
lcd.setCursor(0, 1);
lcd.print("sor de tempera-"); // SENSOR DE TEMPERATURA

//colocar tempo para leitura ??????????????
{
lcd.clear(); // LIMPA
lcd.setCursor(0, 0);
lcd.print("tura e umidade"); // ESCREVE UMIDADE
lcd.setCursor(0,1);
lcd.print("DHT22!");

//colocar tempo para leitura ??????????????
{
lcd.clear();
dht.begin(); //Inicializa o DHT

}
pinMode (azul, OUTPUT); // PINO 22
pinMode (amarelo, OUTPUT); // PINO 24
pinMode (vermelho, OUTPUT); // PINO 26


pinMode (LedVerde, OUTPUT);
pinMode (LedVermelho, OUTPUT);
digitalWrite (LedVerde, HIGH);
digitalWrite (LedVermelho, LOW);}


}}

void loop() // LOOP CONTROE DO TEMPO
{

estadoBotao = digitalRead(Botao);
if(!estadoBotao && estAntBotao)
{estadoPisca = !estadoPisca;
}
estAntBotao = estadoBotao;

if (estadoPisca) {
digitalWrite (LedVermelho, HIGH ); // se estiver contando tempo led ligado
}
else {
digitalWrite (LedVermelho, LOW); // se não estiver contando tempo led apagado
}

if (estadoPisca) {

if((millis() - tempo1) >=7500){ // TEMPO GIRO DO MOTOR CONTANDO DESLIGADO CONTANDO 2HS
digitalWrite (LedVerde, LOW); // LED LIGADO (VALOR NEGADO)

}
if ((millis() - tempo1) <=2500) { // TEMPO DO GIRO DO MOTOR LIGADO
digitalWrite (LedVerde, HIGH); // LED DESLIGADO

}
if((millis() - tempo1) >= 10000) // IMPORTANTE SOMAR OS TEMPOS DESLIGADO
tempo1 = millis(); // + LIGADO PARA ZERAR O CONTADOR

}else{ digitalWrite(LedVerde, HIGH);}
delay (1);

// LOOP TEMPERATURA
//Ler a temperatura ou umidade leva cerca de 250 milisegundos!

{
float h = dht.readHumidity(); //Lê a temperatura em Celsius (padrão)
float t = dht.readTemperature(); // Checando se qualquer leitura falhou.
if (isnan(h) || isnan(t)) {
lcd.setCursor(0, 1);
lcd.print("Falha ao ler");
return;
float temperature, lim;
lim = 37; // coloque a temp desejada ???
}
lcd.setCursor(0,0);
lcd.print("Umid: ");
lcd.setCursor(6,0);
lcd.print(h);
lcd.setCursor(12,0);
lcd.print("%U ");
lcd.setCursor(0,1);
lcd.print("Temp: ");
lcd.setCursor(6,1);
lcd.print(t );
lcd.setCursor(12, 1);
lcd.print("*C ");
lcd.setCursor (5,0);
delay (2000);


lcd.clear();
lcd.print(" TESTE ");
lcd.setCursor (0,1);
delay (1000);
lcd.clear();
lcd.setCursor (4,0);
lcd.print ("DO display ");
delay(1000);
lcd.setCursor (5,1);
lcd.print (" para a " );
delay(1000);
lcd.clear();
lcd.setCursor (1,0);
lcd.print (" funçao ");
lcd.setCursor (0,1);
lcd.print (" MILIIS");
delay (3000);

// declaracao do time apos voide loop


if (t <37.5) // MINIMA TEMPERATURA DESEJADA
{
digitalWrite (vermelho, LOW); // LIGAR RELE ON
}
else if (t > 37.9) // MAXIMA TEMPERATURA DESEJADA
{
digitalWrite (vermelho, HIGH); // RELE OFF
} }}

Amigo acredito que nesse seu caso você deveria criar uma maquina de estado.

Você poderia criar um enum e guardar os estados que deseja e tratar isso no loop.

Por exemplo:


// Para controle do tempo de impressão1
unsigned long timeout = 0;

// Cria um enum com todas as opções que deseja para imprimir
enum EX_DISPLAY{
EXIBE_TEMPERATURA,
EXIBE_TESTE,
OPCAO_MAXIMA
}
unsigned char opcao_display = EXIBE_TEMPERATURA;

setup(){

....

}

void imprimeTemperatura(){

lcd.setCursor(0,0);
lcd.print("Umid: ");
lcd.setCursor(6,0);
lcd.print(h);
lcd.setCursor(12,0);
lcd.print("%U ");
lcd.setCursor(0,1);
lcd.print("Temp: ");
lcd.setCursor(6,1);
lcd.print(t );
lcd.setCursor(12, 1);
lcd.print("*C ");
lcd.setCursor (5,0);

}

void imprimeTeste(){

lcd.clear();
lcd.print(" TESTE ");
lcd.setCursor (0,1);
delay (1000);
lcd.clear();
lcd.setCursor (4,0);
lcd.print ("DO display ");
delay(1000);
lcd.setCursor (5,1);
lcd.print (" para a " );
delay(1000);
lcd.clear();
lcd.setCursor (1,0);
lcd.print (" funçao ");
lcd.setCursor (0,1);
lcd.print (" MILIIS");

}

loop(){

  ...

  if ( timeout < millis() ){

 opcao_display++; 

  timeout = millis() + 3000; // Vai alterar o display a cada 3 segundos

}


switch(opcao_display)
{
case EXIBE_TEMPERATURA:
imprimeTemperatura();
break;
case EXIBE_TESTE:
imprimeTeste();
break;
default:
// Retorna para opção 0
opcao_display = EXIBE_TEMPERATURA;
break;
}

}

É apenas um exemplo, acredito que talvez seja isso que queira fazer.

Esse é um exemplo bem básico de uma maquina de estado.

RSS

© 2024   Criado por Marcelo Rodrigues.   Ativado por

Badges  |  Relatar um incidente  |  Termos de serviço