Ligar e desligar rele com RTC em dias alternados e horas usando Arduino uno

Boas

Gostava que me facultassem os codigos para poder acionar lampadas atraves de reles que estão ligados ao arduino

Por exemplo: Ligar 2ª ;4ª e 6ª as 18h00 e desligar as 00H30

Domingo; 3ª; e 5ª Ligar as 22H00 e desligar as 11h00.

Preciso da vossa ajuda

desde já o meu obrigado

Exibições: 13535

Responder esta

Respostas a este tópico

Boa noite

obrigado mas o rtc que tenho é o DS3231

http://www.dx.com/p/ds3231-high-precision-real-time-clock-module-bl...

esse código nã dá

estou tentando com este

#include <LiquidCrystal.h> //Inclui a biblioteca do LCD
#include <Wire.h>
#include <Time.h>
#include <DallasTemperature.h>
#include <OneWire.h>
#include <DS1307RTC.h>

#define ONE_WIRE_BUS 10
#define RELAY13 //pino do rele
OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);
DeviceAddress insideThermometer = { 0x28, 0xDF, 0x63, 0x51, 0x05, 0x00, 0x00, 0xC3 };

// Pinos de comando dos botões do relógio
#define clockSet A0 // Pinos de comando dos botões do relógio
#define clockUp 9
#define clockDown 8
 
//Estados de Clock
#define stClockRunning 0
#define stSetDay 1         //define o ano
#define stSetMonth 2       //define o mes
#define stSetYear 3       //define o dia
#define stSetDow 4        //define o dia da semana
#define stSetHour 5       //define a hora
#define stSetMinute 6     //define o minuto
#define stSetSecond 7     //define o segundo
int pinorelay13 = 13;
int stat = stClockRunning;
 
LiquidCrystal lcd(12, 11, 5, 4, 3, 2); //configuração dos pinos do lcd
 
void Print(int number)
{
 lcd.print(number/10);
 lcd.print(number%10);
}
 
// Preenchimento do display LCD
void printTime()
{
 lcd.setCursor(2,1); Print(hour());
 lcd.print(":"); Print(minute());
 lcd.print(":"); Print(second());
 lcd.setCursor(3,0); Print(day());
 lcd.print("/"); Print(month());
 lcd.print("/"); Print(year());
 lcd.setCursor(0,0);
 lcd.noCursor(); // Cursor invisível
 lcd.noBlink(); // Efeito blink desligado
 
 if (stat != stClockRunning)
 lcd.print("*");
 else
 lcd.print(" ");
 simbolorelogio();
 lcd.setCursor(0,1);
 lcd.write(3);
 
 switch(stat)
 {
 case stSetDay:
 lcd.setCursor(1,0);
 lcd.print("d ");
 lcd.setCursor(4,0);
 lcd.cursor(); // Cursor visível
 lcd.blink(); // Cursor piscando
 break;
 case stSetMonth:
 lcd.setCursor(1,0);
 lcd.print("m ");
 lcd.setCursor(7,0);
 lcd.cursor(); // Cursor visível
 lcd.blink(); // Cursor piscando
 break;
 case stSetYear:
 lcd.setCursor(1,0);
 lcd.print("a ");
 lcd.setCursor(12,0);
 lcd.cursor(); // Cursor visível
 lcd.blink(); // Cursor piscando
 break;
 case stSetHour:
 lcd.setCursor(1,0);
 lcd.print("h ");
 lcd.setCursor(3,1);
 lcd.cursor(); // Cursor visível
 lcd.blink(); // Cursor piscando
 break;
 case stSetMinute:
 lcd.setCursor(1,0);
 lcd.print("M ");
 lcd.setCursor(6,1);
 lcd.cursor(); // Cursor visível
 lcd.blink(); // Cursor piscando
 break;
 case stSetSecond:
 lcd.setCursor(1,0);
 lcd.print("s ");
 lcd.setCursor(9,1);
 lcd.cursor(); // Cursor visível
 lcd.blink(); // Cursor piscando
 break;
 }
}
 
// Lê pino usando limiar, como um interruptor, isto é,
// interruptor pressionado primeira vez liga, pela segunda vez desliga
int readPinSwitch(int pin, int threshold)
{
 if (digitalRead(pin))
 {
 unsigned long tt = millis();
 while (digitalRead(pin));
 if ((millis() - tt) > threshold)
 return 1;
 else
 return 0;
 }
 else
 return 0;
}
 
//Lê pino usando limiar
int readPin(int pin, int threshold)
{
 if (digitalRead(pin))
 {
 unsigned long tt = millis();
 while ((digitalRead(pin) && (millis() - tt) <= threshold));
 if (digitalRead(pin))
 return 1;
 else
 return 0;
 }
 else
 return 0;
}
 
// obter novo status, se houver
int getStat()
{
 if (readPinSwitch(clockSet,300))
 if (stat == stSetSecond)
 return stClockRunning;
 else
 return stat+1;
 else
 return stat;
}
 
// definir Arduino e tempo do RTC
void setRTCTime(int hour, int minute, int second, int day, int month, int year)
{
// define tempo do Arduino
 setTime(hour,minute,second,day,month,year);
 time_t t = now();
// define tempo do RTC
 RTC.set(t);
}
 
void simbolorelogio()
{
 byte relogio[8] = {
 B00000,
 B01110,
 B10101,
 B10111,
 B10001,
 B01110,
 B00000,
 B00000};
 lcd.createChar(3, relogio); // Cria o caractere personalizado de um relogio
}
void printTemperature(DeviceAddress deviceAddress)
{
float tempC = sensors.getTempC(deviceAddress);
if (tempC == -127.00) {
lcd.print("Error");
}


else
{
lcd.setCursor(11,1);  
lcd.print(tempC);
lcd.print("");

}
}
 
void setup()
{
 pinMode(pinorelay13, OUTPUT); //Define o pino como saida
sensors.begin();
sensors.setResolution(insideThermometer, 10);
    // Start the I2C interface
    Wire.begin();
       
    // Start the serial interface
    Serial.begin(9600);
lcd.begin(16, 2);     
lcd.clear(); // start with a blank screen

setSyncProvider(RTC.get);   // the function to get the time from the RTC
  if(timeStatus()!= timeSet)

 pinMode(clockUp,INPUT); // configura os pinos dos botões como entrada
 pinMode(clockDown,INPUT);
 pinMode(clockSet,INPUT);
 
 
 if(timeStatus()!= timeSet) // verifica status do RTC e retorna erro
 {
 lcd.setCursor(0,0);
 lcd.print("Erro do RTC:");
 lcd.setCursor(0,1);
 lcd.print("Ajuste o Relogio");
 delay(3000);
 lcd.clear();
 }
}
 
int oldStat = stat;
unsigned long t=millis();
 
void loop()
{
 digitalClockDisplay();  
   delay(1000);
}
void digitalClockDisplay(){
  // digital clock display of the time
  Serial.print(hour());
  printDigits(minute());
  printDigits(second());
  Serial.print(" ");
  Serial.print(day());
  Serial.print(" ");
  Serial.print(month());
  Serial.print(" ");
  Serial.print(year());
  Serial.println();
}

void printDigits(int digits){
  // utility function for digital clock display: prints preceding colon and leading 0
  Serial.print(":");
  if(digits < 10)
    Serial.print('0');
  Serial.print(digits);
{

/*
Comando utilizado apenas pra ficar enviando via USB a hora atual
para que possam monitorar no "serial monitor" do simulador Arduino
e ver se esta tudo funcionando de acordo
*/

{

  //Aciona o rele
  digitalWrite(pinorelay13, HIGH);
  delay(50); //Aguarda 2 Horas
  //Desliga o rele
  digitalWrite(pinorelay13, LOW);
  delay(50); //Aguarda 5 segundos e reinicia o processo
  sensors.requestTemperatures();

printTemperature(insideThermometer);
lcd.setCursor(17,1);
delay(04/33/20); //
  //Desliga o rele

  delay(04/36/20); //Aguarda 5 segundos   
 
 int value = 0;
 printTime(); // rotina que imprime o tempo no lcd
 delay(100);
 stat=getStat();
 if (stat != oldStat)
 {
 t=millis();
 oldStat = stat;
 }
 else
 if ((stat != stClockRunning) && ((millis() - t) > 30000)) //tempo em milisegundos que o ajuste do relógio ficará disponível para ser alterado
 stat=stClockRunning;
 switch(stat)
 {
 case stClockRunning:
 break;
 case stSetDay:
 // inicializa value
 value=day();
 //si botao UP (para cima) for pressionado
 while(readPin(clockUp,200))
 {
 value++;
 if (value > 31)
 value=1;
 setRTCTime(hour(),minute(),second(),value,month(),year());
 printTime();
 }
 //si botao DOWN (para baixo) for pressionado
 while(readPin(clockDown,200))
 {
 value--;
 if (value < 1)
 value=31;
 setRTCTime(hour(),minute(),second(),value,month(),year());
 printTime();
 }
 break;
// ver comentários em stSetDay
 case stSetMonth:
 value=month();
 while(readPin(clockUp,200))
 {
 value++;
 if (value > 12)
 value=1;
 setRTCTime(hour(),minute(),second(),day(),value,year());
 printTime();
 }
 while(readPin(clockDown,200))
 {
 value--;
 if (value < 1)
 value=12;
 setRTCTime(hour(),minute(),second(),day(),value,year());
 printTime();
 }
 break;
 case stSetYear:
 value=year();
 while(readPin(clockUp,200))
 {
 value++;
 if (value > 2050)
 value=2000;
 setRTCTime(hour(),minute(),second(),day(),month(),value);
 printTime();
 }
 while(readPin(clockDown,200))
 {
 value--;
 if (value < 2000)
 value=2050;
 setRTCTime(hour(),minute(),second(),day(),month(),value);
 printTime();
 }
 break;
 case stSetHour:
 value=hour();
 while(readPin(clockUp,200))
 {
 value++;
 if (value > 23)
 value=0;
 setRTCTime(value,minute(),second(),day(),month(),year());
 printTime();
 }
 while(readPin(clockDown,200))
 {
 value--;
 if (value < 1)
 value=24;
 setRTCTime(value,minute(),second(),day(),month(),year());
 printTime();
 }
 break;
 case stSetMinute:
 value=minute();
 while(readPin(clockUp,200))
 {
 value++;
 if (value > 59)
 value=0;
 setRTCTime(hour(),value,second(),day(),month(),year());
 printTime();
 }
 while(readPin(clockDown,200))
 {
 value--;
 if (value < 0)
 value=59;
 setRTCTime(hour(),value,second(),day(),month(),year());
 printTime();
 }
 break;
 case stSetSecond:
 value=minute();
 while(readPin(clockUp,200))
 {
 value++;
 if (value > 59)
 value=0;
 setRTCTime(hour(),minute(),value,day(),month(),year());
 printTime();
 }
 while(readPin(clockDown,200))
 {
 value--;
 if (value < 0)
 value=59;
 setRTCTime(hour(),minute(),value,day(),month(),year());
 printTime();
 }
 }
 }
}
}

mas está dificil e tambem falta os dias da semana.

Com este já tem dias da semana mas flta colocar os 3 botões para acertar a ora no LCD para não estar sempre ligando ao PC

e falta o principal que e desligar e ligar os reles as horas programadas.

#include <Wire.h>
#include <Time.h>
#define enderecoI2C 0x68

#include <LiquidCrystal.h> //Inclui a biblioteca do LCD
#include <DallasTemperature.h>
#include <OneWire.h>
#include <DS1307RTC.h>


#define ONE_WIRE_BUS 10
#define clockSet A0 // Pinos de comando dos botões do relógio
#define clockUp 9
#define clockDown 8

OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);
/* Como este módulo trabalha em grupos de 7 Bytes, então define-se as
   variáveis para esse conjunto de 7 dados, que são as horas e data.
*/
byte segundo, minuto, hora, diaDaSemana, diaDoMes, mes, ano;

LiquidCrystal lcd(12, 11, 5, 4, 3, 2); //configuração dos pinos do lcd
DeviceAddress insideThermometer = { 0x28, 0xDF, 0x63, 0x51, 0x05, 0x00, 0x00, 0xC3 };



#define stClockRunning 0
#define stSetDay 1
#define stSetMonth 2
#define stSetYear 3
#define stSetHour 4
#define stSetMinute 5
#define stSetSecond 6
#define stSetSecond 7     //define o segundo

int stat = stClockRunning;
 



void Print(int number)
{
 lcd.print(number/10);
 lcd.print(number%10);
}
 
// Preenchimento do display LCD
void printTime()
{
 lcd.setCursor(4,1); Print(hour());
 lcd.print(":"); Print(minute());
 lcd.print(":"); Print(second());
 lcd.setCursor(3,0); Print(day());
 lcd.print("/"); Print(month());
 lcd.print("/"); Print(year());
 lcd.setCursor(0,0);
 lcd.noCursor(); // Cursor invisível
 lcd.noBlink(); // Efeito blink desligado
 
 
 if (stat != stClockRunning)
 lcd.print("*");
 else
 lcd.print(" ");
 simbolorelogio();
 lcd.setCursor(1,1);
 lcd.write(3);
 
 switch(stat)
 {
 case stSetDay:
 lcd.setCursor(1,0);
 lcd.print("d ");
 lcd.setCursor(4,0);
 lcd.cursor(); // Cursor visível
 lcd.blink(); // Cursor piscando
 break;
 case stSetMonth:
 lcd.setCursor(1,0);
 lcd.print("m ");
 lcd.setCursor(7,0);
 lcd.cursor(); // Cursor visível
 lcd.blink(); // Cursor piscando
 break;
 case stSetYear:
 lcd.setCursor(1,0);
 lcd.print("a ");
 lcd.setCursor(12,0);
 lcd.cursor(); // Cursor visível
 lcd.blink(); // Cursor piscando
 break;
 case stSetHour:
 lcd.setCursor(1,0);
 lcd.print("h ");
 lcd.setCursor(5,1);
 lcd.cursor(); // Cursor visível
 lcd.blink(); // Cursor piscando
 break;
 case stSetMinute:
 lcd.setCursor(1,0);
 lcd.print("M ");
 lcd.setCursor(8,1);
 lcd.cursor(); // Cursor visível
 lcd.blink(); // Cursor piscando
 break;
 case stSetSecond:
 lcd.setCursor(1,0);
 lcd.print("s ");
 lcd.setCursor(11,1);
 lcd.cursor(); // Cursor visível
 lcd.blink(); // Cursor piscando
 break;
 }
}
 
// Lê pino usando limiar, como um interruptor, isto é,
// interruptor pressionado primeira vez liga, pela segunda vez desliga
int readPinSwitch(int pin, int threshold)
{
 if (digitalRead(pin))
 {
 unsigned long tt = millis();
 while (digitalRead(pin));
 if ((millis() - tt) > threshold)
 return 1;
 else
 return 0;
 }
 else
 return 0;
}
 
//Lê pino usando limiar
int readPin(int pin, int threshold)
{
 if (digitalRead(pin))
 {
 unsigned long tt = millis();
 while ((digitalRead(pin) && (millis() - tt) <= threshold));
 if (digitalRead(pin))
 return 1;
 else
 return 0;
 }
 else
 return 0;
}
 
// obter novo status, se houver
int getStat()
{
 if (readPinSwitch(clockSet,300))
 if (stat == stSetSecond)
 return stClockRunning;
 else
 return stat+1;
 else
 return stat;
}
 
// definir Arduino e tempo do RTC
void setRTCTime(int hour, int minute, int second, int day, int month, int year)
{
// define tempo do Arduino
 setTime(hour,minute,second,day,month,year);
 time_t t = now();
// define tempo do RTC
 RTC.set(t);
}
 
void simbolorelogio()
{
 byte relogio[8] = {
 B00000,
 B01110,
 B10101,
 B10111,
 B10001,
 B01110,
 B00000,
 B00000};
 lcd.createChar(3, relogio); // Cria o caractere personalizado de um relogio
}
void printTemperature(DeviceAddress deviceAddress)
{
float tempC = sensors.getTempC(deviceAddress);
if (tempC == -127.00) {
lcd.print("Error");
}


else
{
lcd.setCursor(11,1);  
lcd.print(tempC);
lcd.print("");

}
}



void setup()
{
sensors.begin();
sensors.setResolution(insideThermometer,10);
Wire.begin();             //inicializando a biblioteca.


 
pinMode(clockUp,INPUT); // configura os pinos dos botões como entrada
pinMode(clockDown,INPUT);
pinMode(clockSet,INPUT);
Serial.begin(9600);     //serial à uma velocidade de 9600bps(baud).
lcd.begin(16, 2);     
lcd.clear(); // start with a blank screen                            
setSyncProvider(RTC.get);   // the function to get the time from the RTC
if(timeStatus()!= timeSet)
{
lcd.setCursor(0,0);
 lcd.print("Erro do RTC:");
 lcd.setCursor(0,1);
 lcd.print("Ajuste o Relogio");
 delay(3000);
 lcd.clear();
 }
}
 
int oldStat = stat;
unsigned long t=millis();
 
 

 
 

void loop()
{
 

   
 
 
  imprimeDadosModulo();    //chamando a função para imprimir na tela os dados
                           //gravados no módulo.
  delay(2000);             //aguardando 2 segundos para próxima leitura.
}


////////////
// FUNÇÃO //
////////////
/* Essa função configura o módulo com dados de hora e data inicialmente desejados.
   Essa função deve ser executada uma única vez na inicialização do módulo, pois
   ao definir os dados inicias no módulo, fará como que ele comece a contar o
   tempo e nunca mais pare de contar enquanto tiver energia, seja ela fornecida
   pela fonte principal ou pela bateria auxiliar de 3V.  
   Logo para as próximas compilações deve-se colocar um comentário na chamada
   da função configuraModulo() localizada no setup().  
 
   Para escrever os dados de hora e data no módulo deve-se realizar os seguintes passos:
        1) Abrir a comunicação I2C em modo de gravação;
        2) Redefinir o ponteiro para o primeiro registro (0x00);
        3) Escrever sete bytes de dados;
        4) Finalizar o modo de gravação.
*/
void configuraModulo()
{
  /* Inicializando as variáveis abaixo com os dados de hora e data desejados.
     Lembrando que quando o dado for menor que 10, ou seja, tiver apenas um dígito
     não deve-se digitar o zero à esquerda. Exemplo: se deseja armazenar na variável hora
     o valor de 9horas, digite apenas o dígito 9, nunca 09.
  */
//segundo = 0;
//minuto = 48;
//hora = 27;
//diaDaSemana = 3;
//diaDoMes = 27;
//mes = 8;
//ano = 14;

  Wire.beginTransmission(enderecoI2C); //Abrindo o modo I2C no modo de gravação.
  Wire.write((byte)0x00);   //Redefinindo o ponteiro para o primeiro registro (0x00).
 
  //Para escrever dados no módulo é necessário uma conversão de Decimal para Binário
  Wire.write(decToBcd(segundo));      //convertendo os segundos.
  Wire.write(decToBcd(minuto));       //convertendo os minutos.
  Wire.write(decToBcd(hora));         //convertendo as horas.
  Wire.write(decToBcd(diaDaSemana));  //dia da semana, onde o domingo começa com "0".
  Wire.write(decToBcd(diaDoMes));     //convertendo o dia do mês.
  Wire.write(decToBcd(mes));          //convertendo o mês.
  Wire.write(decToBcd(ano));          //convertendo o ano.
  Wire.endTransmission();             //finalizando o modo de gravação.
}


/*Essa função é reponsável por ler os dados de hora e data gravados no módulo e
   imprimi-los na tela do Monitor Serial.
*/
void imprimeDadosModulo()
{
  /* Como para valores menores que 10 o dado armazenado no módulo possui apenas
     um dígito, então será criado variáveis de ajustes, permitindo que no momento
     da impressão na tela esses valores com apenas um dígito sejam mostrados com  
     um zero à esquerda. Exemplo: ao invés de 9:58:10 a impressão ficará 09:58:10  
  */
  String ajustaSegundo;
  String ajustaMinuto;
  String ajustaHora;
  String ajustaDiaDoMes;
  String ajustaMes;
 
  /* Para ler os dados de hora e data no módulo deve-se realizar os seguintes passos:
        1) Abrir a comunicação I2C em modo de gravação;
        2) Redefinir o ponteiro para o primeiro registro (0x00);
        3) Finalizar o modo de gravação;
        4) Abrir a comunicação I2C em modo de leitura;
        5) Ler os sete bytes de dados.
  */
  Wire.beginTransmission(enderecoI2C); //Abrindo o modo I2C no modo de gravação.
  Wire.write((byte)0x00); //Redefinindo o ponteiro para o primeiro registro (0x00).
  Wire.endTransmission(); //finalizando o modo de gravação.
  Wire.requestFrom(enderecoI2C, 7);    //Abrindo o modo I2C no modo de leitura.

  //Para ler e posteriormente imprimir os dados lidos do módulo é necessário uma
  //conversão de Binário para Decimal.
  segundo = bcdToDec(Wire.read() & 0x7f); //Alguns dados precisam de máscaras antes
                                          //da conversão porque certos bits são
                                          //bits de controle.
  minuto = bcdToDec(Wire.read());         //convertendo os minutos.
  hora = bcdToDec(Wire.read() & 0x3f);    //Alguns dados precisam de máscaras antes
                                          //da conversão porque certos bits são
                                          //bits de controle. Essa máscara define o
                                          //relógio para trabalhar no modo de 24h.
  diaDaSemana = bcdToDec(Wire.read());    //dia da semana, onde domingo começa com "0".
  diaDoMes = bcdToDec(Wire.read());       //convertendo o dia do mês.
  mes = bcdToDec(Wire.read());            //convertendo o mês.
  ano = bcdToDec(Wire.read());            //convertendo o ano.
 
  //Imprimindo os dois dígitos das horas separados por dois pontos.
  Serial.print("    ");
  //chmando a função ajustaZero para o caso de dados gravado no módulo com apenas um dígito.
  ajustaHora += ajustaZero(hora);
  Serial.print(ajustaHora);
  Serial.print(":");
  //chmando a função ajustaZero para o caso de dados gravado no módulo com apenas um dígito.
  ajustaMinuto += ajustaZero(minuto);
  Serial.print(ajustaMinuto);
  Serial.print(":");
  //chmando a função ajustaZero para o caso de dados gravado no módulo com apenas um dígito.
  ajustaSegundo += ajustaZero(segundo);
  Serial.println(ajustaSegundo);
 
  Serial.print("  ");

 switch(diaDaSemana)
  {
    case 0:Serial.println("0"); break; //se a variável diaDaSemana for zero
                                             //imprima na tela "Domingo"    
    case 1:Serial.println("1"); break; //idem ao anterior
    case 2:Serial.println("2"); break;  //idem
    case 3:Serial.println("3"); break;  //idem
    case 4:Serial.println("4"); break;  //idem
    case 5:Serial.println("5"); break;   //idem
    case 6:Serial.println("6"); break;   //idem
 
  }
  //Imprimindo os dois dígitos das datas separadas por uma barra.
  Serial.print(" ");
  //chmando a função ajustaZero para o caso de dados gravado no módulo com apenas um dígito.
  ajustaDiaDoMes += ajustaZero(diaDoMes);
  Serial.print(ajustaDiaDoMes);
  Serial.print("/");
  //chmando a função ajustaZero para o caso de dados gravado no módulo com apenas um dígito.
  ajustaMes += ajustaZero(mes);
  Serial.print(ajustaMes);
  Serial.print("/");
  Serial.println(ano);
 
  Serial.println(); //salta uma linha.
 
 lcd.setCursor(4,0);
  lcd.print(ajustaHora);
  lcd.print(":");
  lcd.print(ajustaMinuto);
  lcd.print(":");
  lcd.print(ajustaSegundo);
  lcd.setCursor(0,1);
  lcd.print(ajustaDiaDoMes);
  lcd.print("/");
  lcd.print(ajustaMes);
  lcd.print("/");
  lcd.print(ano);
 
  sensors.requestTemperatures();
  printTemperature(insideThermometer);
  lcd.setCursor(11,1);
 
}





/* Função que realiza uma conversão de Decimal para Binário.
   Utilizada na gravação de dados no módulo.
*/
byte decToBcd(byte val)
{
  return ( (val/10*16) + (val%10) );
}
 
/* Função que realiza uma conversão de Binário para Decimal.
   Utilizada na impressão dos dados na tela do Monitor Serial.
*/
byte bcdToDec(byte val)
{
  return ( (val/16*10) + (val%16) );
}


/* Essa função insere o dígito "0" à esquerda dos dados gravados no módulo com
   apenas um dígito, já que os valores menores que 10 são armazenados no módulo
   com apenas um dígito.  
*/
String ajustaZero(byte dado)
{
  String dadoAjustado;
  if (dado < 10)
  {
    dadoAjustado += "0";  //concatena o dígito "0" ao valor da variável.
  }
  dadoAjustado += dado;   //concatena o dígito "0" ao valor do dado.
 
  return dadoAjustado;    //retorna o valor do dado ajustado.
}

Já agora qual melhor livro em portugues para aprender sobre arduino

Alguém teria o projeto deste sistema?

Gostaria de ligar  e desligar por um tempo três vezes por semana um solenoide  irrigando meu jardim...

Alguém help?

Eu estou precisando de algo parecido para ligar uma sirene que avisa a hora de entrada e saída de funcionários.

Tenho um rtc desses, reles e a sirene.

Logo vou dar noticias se o projeto deu certo.

Abracos

Pessoal, bom dia.

Tenho um pronto que achei para 6 canais com PIC16F628A.

Vou tentar incluir aqui o esquema e o código.

Abraços 

J.Antonio

Alguém poderia me ajudar como postar o código (hexa) e o arquivo do Proteus ? 

No aguardo.

Valeu

Valeu Antonio, aguardo!

Abraço!

RSS

© 2024   Criado por Marcelo Rodrigues.   Ativado por

Badges  |  Relatar um incidente  |  Termos de serviço