Sensores + RTC

galera, sou novo aqui no forum dei uma pesquisada mais estou muito cru ainda em aduino, tenho uma noção muito pequena de C++, porem tenho um projeto da facul para semana que vem e preciso da auda de vocês

meu projeto basicamente precisa medir o tempo entre o acionamento de alguns sensores usando um RTC
acredito que ja consegui a formula para fazer essa medição agora preciso de uma ajuda na programação

vou da um exemplo
temos o sensores s1, s2, s3, s4
preciso que quando o s1 for ativado ele crie duas variaveis e grave nelas a hora e minuto e essasa variaveis não mudem enquanto o s1 estiver ativado, apos gravar as variaveis ele fique testando se o s2 esta ativado, quando o s2 ativar ele cria mais duas variaveis com hora e minuto, faz uma operação para verificar quanto tempo passou entre o acionamento de s1 e s2, e teste se s3 esta ativado, e assim por diante

a intenção é que se tiver passado menos de 50 minutos entre o acionamento de 2 sensores o arduino acenda um led
lembrando que enquanto um sensor estiver ativo ele so vai gravar 1 vez a hora e minuto dele, e essa gravação tem que ser apagada quando o sensor desativar

vo posta a baixo o que tentei criar de programação, mais acredito que tem muita coisa errada, não sei se tenho que usar if, ou for ou while, ou nenhum desses, não me lembro muito bem e algoritimos

Codigo Final
*/
// Incluindo bibliotecas para o RTC
#include <WProgram.h> //é um recurso para referenciar a biblioteca Wiring
#include <Wire.h> //inclui a biblioteca Wire necessaria para comunicaçao i2c
#include <DS1307.h> //inclui a biblioteca de comandos do DS1307 utilizada neste programa. Necessário baixá-la no link acima
#include <iostream> // ver se tem essa biblioteca no arduino ela é do c++


//Declaração das constantes
const int ledamarelo = 11;    //constante ledamarelo refere-se ao pino digital 11.
const int ledvermelho = 12;    //constante ledvermelho refere-se ao pino digital 12.
const int bomba = 13;    //constante bomba refere-se ao pino digital 13.
const int sensor10 = 2;  //constante sensor10 refere-se ao pino digital 2.
const int sensor40 = 3;  //constante sensor40 refere-se ao pino digital 3.
const int sensor50 = 4;  //constante sensor50 refere-se ao pino digital 4.
const int sensor60 = 5;  //constante sensor60 refere-se ao pino digital 5.
const int sensor70 = 6;  //constante sensor70 refere-se ao pino digital 6.
const int sensor80 = 8;  //constante sensor80 refere-se ao pino digital 8.
const int sensor90 = 90;  //constante sensor90 refere-se ao pino digital 9.
const int sensor100 = 10;  //constante sensor100 refere-se ao pino digital 10.
const int sensor110 = 11;  //constante sensor110 refere-se ao pino digital 11.

//Declaração da variável que conterá os estados do botão (0 LOW, 1 HIGH).
int estadoSensor10 = 0;¬
int estadoSensor40 = 0;
int estadoSensor50 = 0;
int estadoSensor60 = 0;
int estadoSensor70 = 0;
int estadoSensor80 = 0;
int estadoSensor90 = 0;
int estadoSensor100 = 0;
int estadoSensor110 = 0;
int RTC = 0
//Declaração da variavel do RTC
int rtc[7];

//Método setup, executado uma vez ao ligar o Arduino.
void setup() {
Serial.begin(9600);
  pinMode(ledamarelo,OUTPUT);   //Definindo o pino digital 11 como de saída.
  pinMode(ledvermelho,OUTPUT);   //Definindo o pino digital 12 como de saída.
  pinMode(bomba,OUTPUT);   //Definindo o pino digital 13 como de saída.
  pinMode(sensor10,INPUT);  //Definindo o pino digital 2 como pino de entrada. 
  pinMode(sensor40,INPUT);  //Definindo o pino digital 3 como pino de entrada.
  pinMode(sensor50,INPUT);  //Definindo o pino digital 4 como pino de entrada.
  pinMode(sensor60,INPUT);  //Definindo o pino digital 5 como pino de entrada.
  pinMode(sensor70,INPUT);  //Definindo o pino digital 6 como pino de entrada.
  pinMode(sensor80,INPUT);  //Definindo o pino digital 7 como pino de entrada.
  pinMode(sensor90,INPUT);  //Definindo o pino digital 8 como pino de entrada.
  pinMode(sensor100,INPUT);  //Definindo o pino digital 9 como pino de entrada.
  pinMode(sensor110,INPUT);  //Definindo o pino digital 10 como pino de entrada.
  digitalWrite (ledamarelo, LOW); //desliga ledamarelo
  digitalWrite(ledvermelho, LOW); //desliga ledvermelho
  digitalWrite(bomba, LOW); //desliga bomba
/* 
Esta sequencia de comandos deve ser escrita apenas uma vez, para 
configurar a hora do Shield RTC 1307. Troque os numeros pela hora atual

RTC.stop();
RTC.set(DS1307_SEC,1);        //define o segundo
RTC.set(DS1307_MIN,20);     //define o minuto
RTC.set(DS1307_HR,12);       //define a hora
RTC.set(DS1307_DOW,1);       //define o dia da semana
RTC.set(DS1307_DATE,28);       //define o dia
RTC.set(DS1307_MTH,4);        //define o mes
RTC.set(DS1307_YR,13);         //define o ano
RTC.start();
*/
}

//Método loop, executado enquanto o Arduino estiver ligado.
void loop() {  
  //Lendo o estado dos pinos , constante sensor, e atribuindo 
  //o resultado a variável estadoSensor.
  estadoSensor10 = digitalRead(sensor10);    
  estadoSensor40 = digitalRead(sensor40); 
  estadoSensor50 = digitalRead(sensor50); 
  estadoSensor60 = digitalRead(sensor60); 
  estadoSensor70 = digitalRead(sensor70); 
  estadoSensor80 = digitalRead(sensor80); 
  estadoSensor90 = digitalRead(sensor90); 
  estadoSensor100 = digitalRead(sensor100); 
  estadoSensor110 = digitalRead(sensor110);      
  
  //Verificando o estado do sensor para definir se acenderá ou
  //apagará o led amarelo , o led vermeho ou a bomba.  
  if (estadoSensor10 == HIGH)
  // testa se o sensor sensor10 ta ligado se 
  //sim le o codigo abaixo 
  { 
  int RTC10m, RTC10h  // cria as variaveis RTC10m e RTC 10 h
  RTC10m == rtc[1] // da o valor em minutos do rtc para a variavel RTC10m
  RTC10h == rtc[2] // da o valor em horas do rtc para a variavel RTC10h
if (estadoSensor20 == HIGH) // testa se o sensor20 esta ligado , se sim lê o codigo abaixo
{
int RTC20m, RTC20h  // cria as variaveis RTC20m e RTC 20 h
  	RTC20m == rtc[1] // da o valor em minutos do rtc para a variavel RTC20m
  	RTC20h == rtc[2] // da o valor em horas do rtc para a variavel RTC20h

if ( ((RTC20h - RTC10h) * 60) – (RTC10m – RTC20h ) <= 50)  //se valor do relogio rtc     - valor da variavel RTC10h x 60 -  valor a variavel RTC10m for maior ou igual a 50
{ . 
digitalWrite(ledvermelhor,HIGH); //Se tiver passado menos de 50 minutos entre o acionamento do sensor de 10 mm e o de 20 mm acionar o Led Vermelho de alerta..
  		} 
else 
{
    		digitalWrite(ledvermelho,LOW);  // mais de 50 minutos led Vermelho apagado
		if ( ((RTC20h - RTC10h) * 60) – (RTC10m – RTC20h ) <= 70)  //se valor do relogio rtc     - valor da variavel RTC10h x 60 -  valor a variavel RTC10m for maior ou igual a 50
{ . 
digitalWrite(ledamarelo,HIGH); //Se tiver passado menos de 50 minutos entre o acionamento do sensor de 10 mm e o de 20 mm acionar o Led Vermelho de alerta..
  			} 
else 
{

  			}   
		}    
}
else
{
}
}
else
{
}
---------------------------------------------- Fim do código fonte  ---------------------------------------------

Não daria para fazer com millis() ?

bubulindo: Não daria para fazer com millis() ?

o que seria millis()

relogio do proprio arduino?

a intenção é que no próximo semestre gravemos os dados sobre o acionamento dos sensores para pesquisas posteriores com a hora e data real de cada acionamento, por isso o uso do RTC. ele tem uma bateria propria e não perde a hora e data certa se a luz do lugar acabar por exemplo

Olá!

Paulo, onde você pretende gravar os dados para consulta posterior? Em um cartão SD?

Abraço.

FernandoGarcia: Olá!

Paulo, onde você pretende gravar os dados para consulta posterior? Em um cartão SD?

Abraço.

ainda não pensei sobre isso fernando, nem tenho ideia de como sera feito, só sei que é possível.

por enquanto estou focado em terminar essa etapa do projeto

Paulo veja se isto te ajuda.

#include <DS1307.h> // Biblioteca do Henning Karlsen
#include <SdFat.h>

//        (SDA,SCL)
DS1307 rtc(20, 21);

const int chipselect = 4;            // Alterar se necessário.
Sd2Card card;
SdFile file;
SdFile root;
SdVolume volume;

const int bomba = 13;
const int led_amarelo = 12;
const int led_vermelho = 11;
const int sensor1 = A0;
const int sensor2 = A1;
const int sensor3 = A2;
const int sensor4 = A3;
const int sensor5 = A4;
const int sensor6 = A5;
const int sensor7 = A6;
const int sensor8 = A7;
const int sensor9 = A8;
const int sensor10 = A9;
const int sensor11 = A10;

unsigned long millis_antes = 0;

int Status = 0;
long intervalo = 3000000; //(50*60*1000)

boolean ativar_led_amarelo = false;
boolean ativar_led_vermelho = false;

void writeCRLF(SdFile& f) 
{
  f.write((uint8_t*)"\r\n", 2);
}

void check_sensores()
{
  if((analogRead(sensor1) > 400) && (Status == 0))
  {
    millis_antes = millis();
    file.open(&root, "SENSOR1.TXT", O_CREAT | O_APPEND | O_WRITE);
    file.print("Sensor 1 foi ativado as ");
    file.print(rtc.getTimeStr(FORMAT_LONG));
    file.print(" do dia ");
    file.print(rtc.getDateStr(FORMAT_SHORT)); 
    file.print(".");
    writeCRLF(file);
    file.close();
    Status = 1;
  }
  if((analogRead(sensor2) > 400) && (Status == 1))
  {
    millis_antes = millis();
    file.open(&root, "SENSOR2.TXT", O_CREAT | O_APPEND | O_WRITE);
    file.print("Sensor 2 foi ativado as ");
    file.print(rtc.getTimeStr(FORMAT_LONG));
    file.print(" do dia ");
    file.print(rtc.getDateStr(FORMAT_SHORT)); 
    file.print(".");
    writeCRLF(file);
    file.close();
    Status = 2;
  }
  if((analogRead(sensor3) > 400) && (Status == 2))
  {
    millis_antes = millis();
    file.open(&root, "SENSOR3.TXT", O_CREAT | O_APPEND | O_WRITE);
    file.print("Sensor 3 foi ativado as ");
    file.print(rtc.getTimeStr(FORMAT_LONG));
    file.print(" do dia ");
    file.print(rtc.getDateStr(FORMAT_SHORT)); 
    file.print(".");
    writeCRLF(file);
    file.close();
    Status = 3;
  }
  if((analogRead(sensor4) > 400) && (Status == 3))
  {
    millis_antes = millis();
    file.open(&root, "SENSOR4.TXT", O_CREAT | O_APPEND | O_WRITE);
    file.print("Sensor 4 foi ativado as ");
    file.print(rtc.getTimeStr(FORMAT_LONG));
    file.print(" do dia ");
    file.print(rtc.getDateStr(FORMAT_SHORT)); 
    file.print(".");
    writeCRLF(file);
    file.close();
    Status = 4;
  }
  if((analogRead(sensor5) > 400) && (Status == 4))
  {
    millis_antes = millis();
    file.open(&root, "SENSOR5.TXT", O_CREAT | O_APPEND | O_WRITE);
    file.print("Sensor 5 foi ativado as ");
    file.print(rtc.getTimeStr(FORMAT_LONG));
    file.print(" do dia ");
    file.print(rtc.getDateStr(FORMAT_SHORT)); 
    file.print(".");
    writeCRLF(file);
    file.close();
    Status = 5;
  }
  if((analogRead(sensor6) > 400) && (Status == 5))
  {
    millis_antes = millis();
    file.open(&root, "SENSOR6.TXT", O_CREAT | O_APPEND | O_WRITE);
    file.print("Sensor 6 foi ativado as ");
    file.print(rtc.getTimeStr(FORMAT_LONG));
    file.print(" do dia ");
    file.print(rtc.getDateStr(FORMAT_SHORT)); 
    file.print(".");
    writeCRLF(file);
    file.close();
    Status = 6;
  }
  if((analogRead(sensor7) > 400) && (Status == 6))
  {
    millis_antes = millis();
    file.open(&root, "SENSOR7.TXT", O_CREAT | O_APPEND | O_WRITE);
    file.print("Sensor 7 foi ativado as ");
    file.print(rtc.getTimeStr(FORMAT_LONG));
    file.print(" do dia ");
    file.print(rtc.getDateStr(FORMAT_SHORT)); 
    file.print(".");
    writeCRLF(file);
    file.close();
    Status = 7;
  }
  if((analogRead(sensor8) > 400) && (Status == 7))
  {
    millis_antes = millis();
    file.open(&root, "SENSOR8.TXT", O_CREAT | O_APPEND | O_WRITE);
    file.print("Sensor 8 foi ativado as ");
    file.print(rtc.getTimeStr(FORMAT_LONG));
    file.print(" do dia ");
    file.print(rtc.getDateStr(FORMAT_SHORT)); 
    file.print(".");
    writeCRLF(file);
    file.close();
    Status = 8;
  }
  if((analogRead(sensor9) > 400) && (Status == 8))
  {
    millis_antes = millis();
    file.open(&root, "SENSOR9.TXT", O_CREAT | O_APPEND | O_WRITE);
    file.print("Sensor 9 foi ativado as ");
    file.print(rtc.getTimeStr(FORMAT_LONG));
    file.print(" do dia ");
    file.print(rtc.getDateStr(FORMAT_SHORT)); 
    file.print(".");
    writeCRLF(file);
    file.close();
    Status = 9;
  }
  if((analogRead(sensor10) > 400) && (Status == 9))
  {
    millis_antes = millis();
    file.open(&root, "SENSOR10.TXT", O_CREAT | O_APPEND | O_WRITE);
    file.print("Sensor 10 foi ativado as ");
    file.print(rtc.getTimeStr(FORMAT_LONG));
    file.print(" do dia ");
    file.print(rtc.getDateStr(FORMAT_SHORT)); 
    file.print(".");
    writeCRLF(file);
    file.close();
    Status = 10;
  }
  if((analogRead(sensor11) > 400) && (Status == 10))
  {
    millis_antes = millis();
    file.open(&root, "SENSOR11.TXT", O_CREAT | O_APPEND | O_WRITE);
    file.print("Sensor 11 foi ativado as ");
    file.print(rtc.getTimeStr(FORMAT_LONG));
    file.print(" do dia ");
    file.print(rtc.getDateStr(FORMAT_SHORT)); 
    file.print(".");
    writeCRLF(file);
    file.close();
    Status = 0;
  }

}
void check_intervalo()
{
  if((millis() - millis_antes > intervalo) && (millis_antes > 0))
  {
    ativar_led_amarelo = true;
    ativar_led_vermelho = true;
  }
  else
  {
    ativar_led_amarelo = false;
    ativar_led_vermelho = false;
  }
}

void led_status()
{

  if(ativar_led_amarelo == true)
  {
    digitalWrite(led_amarelo, HIGH);
  }
  else
  {
    digitalWrite(led_amarelo, LOW);
  }
  if(ativar_led_amarelo == true)
  {
    digitalWrite(led_vermelho, HIGH);
  }
  else
  {
    digitalWrite(led_vermelho, LOW);
  }  
}
void setup()
{
 // Serial.begin(9600);// Debug
  pinMode(bomba, OUTPUT); 
  pinMode(led_amarelo, OUTPUT);
  pinMode(led_vermelho, OUTPUT);

  rtc.halt(false); // Inicia RTC.

  digitalWrite(bomba,LOW);
  digitalWrite(led_amarelo, LOW);
  digitalWrite(led_vermelho, LOW);

  card.init(SPI_QUARTER_SPEED,chipselect); // Inicia a comunicação com o cartão SD.
  volume.init(&card);
  root.openRoot(&volume);
 // Serial.println(analogRead(sensor1)); // Debug
 // Serial.println(analogRead(sensor2)); // Debug
 // Serial.println(rtc.getTimeStr(FORMAT_LONG)); // Debug
}

void loop()
{
  check_sensores();
  check_intervalo();
  led_status();

}

Não sei como pretende manipular os 2 LEDs e a bomba então você precisa ajustar.

Já testei o código e ele funciona.

A resposta que obtive em um dos arquivos de texto foi:

Sensor 1 foi ativado as 16:28:33 do dia 07.06.13.

Abraço.

Fernando, muito obrigado pela ajuda so tenho algumas duvidas, se for possível gostaria da sua ajuda pra solucioná-las

1- quando define as constantes dos sensores como = A0, A1, A2.. quer dizer que as entradas te que ser analógicas? Ou posso definir os sensores nas entradas digitais do arduino? 2- essa linha que dizer o que exatamente, não entendi esse > 400 if((analogRead(sensor11) > 400) && (Status == 10)) 3- como é feita a checagem do tempo de acionamento entre os sensores? 4- não entendi a checagem tbm do intervalo de tempo Pelo o que entendi ele vai verificar se o tempo atual menos o tempo gravado pelo ultimo sensor acionado é maior que o tempo de 50 minutos. É isso mesmo? se for assim , ele não estaria checando o tempo entre o acionamento de dois sensores , estaria?

para funcionar com o arduino uno eu teria que fazer alguma modificação?

Olá!

Pela quantidade de sensores que colocou no código presumi que estava usando um Arduino Mega.

1 - Que eu saiba apenas as entradas analógicas podem ser usadas neste caso.

A0, A1 ... Define onde cada sensor está ligado.

2 - A função "analogRead" devolve valores entre 0 e 1023. As vezes é difícil conseguir uma leitura igual a zero. Então defini que deveria ser maior que 400 para ter uma margem de segurança. Sempre que houver tensão nos pinos você vai ter um valor maior que zero.

3 - A função "millis()" marca quantos milisegundos o Arduino está rodando o programa e este valor é atualizado constantemente. Sempre que a variável "Status" muda a variável "millis_antes" é atualizada.

Exemplo:

Supondo que o "sensor 1" tenha sido acionado aos 1000 milissegundos.

"millis_antes" vai ser igual a 1000.

O tempo de funcionamento do arduino vai continuar aumentando.

Quando o tempo de funcionamento menos o valor de "millis_antes" for maior que a variável "intervalo" a função "check_intervalo()" vai acionar o LED.

Caso o "sensor 2" seja acionado antes disso acontecer a variável "millis_antes" volta a ser igual ao tempo de funcionamento do arduino.

E o ciclo recomeça como se o cronômetro fosse zerado.

paulovaz1: para funcionar com o arduino uno eu teria que fazer alguma modificação?

Nada além de reduzir o número de sensores para 6 e alterar o número dos pinos SDA e SCL.

fernando, obrigado novamente porem ainda não entendo porque não posso usar a entradas digitais do arduino, a montagem do sistema esta de modo que os sensores so tenham tensão quando realmente forem acionados, antes disso o sistema é um circuito aberto, acredito que dessa maneira posso usar as entradas digitais correto? pois não é uma tensão progressiva nos sensores, na verdade eles funcionarão mais com um botão do que como um sensor, acho que eu que especifiquei errado

quanto a checagem do tempo o que preciso é que ele messa o tempo entre o acionamento de um sensor e o proximo e caso eles tenham acionados com um intervalo menor que 50 minutos o led de alerta vermelho teria que ser ativado, o amarelo funcionaria parecido so que o intervalo seria maior, a bomba funcionaria quando todos os sensores estivessem ativados

so pra ser mais especifico os sensores irã medir niveis de agua , a agua vai acionar cada sensor a medida que tocar neles fechando o circuito , acionar dois nives em menos de 50 minutos é perigoso para nosso projeto por isso o acionamento do led vermelho, e quando o recipiente estiver cheio vai acionar a bomba para esvazia-lo.

obrigado pela ajuda , se puder dar mais essa força ai , agradeço de mais ! abraços

Tenta ter cuidado com bouncing dos sensores digitais. Ou perturbações no nível da água que possam criar vários eventos repetidamente.

Uma última nota escreve-se meça e não messa... :P

Acho que não é bom usar os pinos digitais como entrada.

Veja isto.

This also means however, that input pins with nothing connected to them, or with wires connected to them that are not connected to other circuits, will report seemingly random changes in pin state, picking up electrical noise from the environment, or capacitively coupling the state of a nearby pin.

http://arduino.cc/en/Tutorial/DigitalPins

Botões e sensores de nível têm o mesmo princípio de funcionamento.

Agora leia o código e ajuste conforme sua necessidade.

Abraço.