¿Aún no conoces AMA?

Hazte socio de Acuariofilia Madrid Asociación.
ABIERTO EL PLAZO DE INSCRIPCIÓN: DEL 1 AL 15 DE JUNIO.

Más info
image01

Atlas de peces de AM

¡Hemos alcanzado las 800 fichas! Visita nuestro atlas de peces actualizado.

Más info
image01

Cardúmenes y sociabilidad

Nueva actualización de la tabla con una extensa relación de peces, donde podrás conocer qué entorno necesita cada especie, su sociabilidad y si convive o no en cardumen. ¡Pasa a descubrirla!

Mas info
image01
Aula Arduino para principiantes.
Respuestas: 1783    Visitas: 440294
#691
De todos los errores que te da debes fijarte en:

Cao1_Menu.h:20: error: 'LiquidCrystal_I2C' does not name a type

Si no te reconoce ese tipo es porque no está pillando la librería. Esta se usa en un montón de sitios donde te va a ir dando muchos errores. Yo ahora tengo probada la última versión en mi Linux y en un portatil con Windows, y creo que Xavi que la ha descargado tampoco tiene ese problema.

Si te funciona el LCD con algún ejemplo, es porque usa alguna librería para LiquidCrystal_I2C. Combrueba que los includes para 'LiquidCrystal_I2C' en CAO1 y en tu programa de ejemplo para el LCD. Tienes que ir haciendo comprobaciones.
#692
ahora este C:\Program Files (x86)\Arduino\libraries\TinyAdafruit_RGBLCDShield\TinyAdafruit_MCP23017.cpp:227:​ error: 'TinyWireM' was not declared in this scope
#693
eso es problema de la libreria o que ?
#694
(28-09-2014, 09:50 AM)william escribió: ahora este C:\Program Files (x86)\Arduino\libraries\TinyAdafruit_RGBLCDShield\TinyAdafruit_MCP23017.cpp:227:​ error: 'TinyWireM' was not declared in this scope

CAO1 usa una serie de módulos. Uno de ellos es la librería 'liquidcrystal_i2c'.
Para ello hace el include
#include <LiquidCrystal_I2C.h>

Dependiendo del fabricante diversos LCD usan diferentes implementaciones de esa librería que ofrecen idéntica funcionalidad y por ello usan el mismo nombre.

Para que CAO1 pudiera hacer uso de 'TinyAdafruit_MCP23017' tendría que hacer un include del tipo.
#include <TinyAdafruit_MCP23017.h>

Cosa que seguramente tengas en el ejemplo que te funciona con ese LCD.
Yo igonoro si tu LCD es compatible con alguna de las librerías 'LiquidCrystal_I2C' y cual de ellas serviría. Lo que pone en el fuente es esto:

Adafruit_MCP23017: This is a library for the MCP23017 i2c port expander

La librería LiquidCrystal es un estándar para librerías LCD basadas en el chipsets Hitachi HD44780 o compatibles.

Yo he desarrollado para un hardware concreto y desconozco si existe un módulo compatible con lo que tu tienes. Acabo de localizar una página bastante completita sobre la variedad de hardware de LCDs para Arduino.

http://playground.arduino.cc/Code/LCD

Necesitas localizar una librería ' LiquidCrystal_I2C' que reconozca tu hardware. Es muy probable que no seas el primer usuario de Arduino que tiene esa necesidad, así que en foros de Arduino podrías encontrar a alguien que te diga donde descargar la librería adecuada para usar el estandar 'LiquidCrystal' con tu LCD. Este estándar es muy utilizado y por ello es fácil que muchos fabricantes busquen la compatibilidad con él.

No sé si empezar a descargar algunas de estas librerías e ir probando es una opción razonable después de ver la variedad de hardware que existe para LCDs.

Si alguien sabe algo estaría bien que lo comentara. Si yo me entero de algo te lo cuento. Me siento identificado contigo porque jamás fuí capaz de hacer funcionar mi primer LCD I2C y ahora que veo todo esto, puede que aquello se tratara de un problema similar al tuyo.

Yo suelo comentar donde compro el hardware, porque sé que hay mucho hardware de características muy similares que o bien son incompatibles o que necesitan de algo diferente a lo que yo uso.
#695
hola ,pues molestando de nuevo actualmente dimeo mi lampara con arduino,tips 142 y un codigo que me paso un companero de otro foro y la verdad me ayudo mucho , tengo una fuente de poder de 30 AMP.12v y como ya he explicado soy un novato ya he bajado el codigo de don castro pero aun no tengo ni la pantalla ni los botones jejeje solo tengo el arduino2560 mega y una tarjeta de 8 relevadores especial para arduino,pues estoy empezando de 0 desde sustrato,lampara,tanque,plantas,filtro,tapa y fuente de poder,todo con calma jeje
la verdad no se como activar un relevado a cierta hora(ejemplo8 pm) quiero desactivar mi fuente de poder por la noche a las 8 pm y encenderla alas 8am para cortar consumo minimo por la noche gracias espero alguien me ayude

mi reloj es un RTC DS1307
#696
(30-09-2014, 07:44 AM)libre escribió: hola ,pues molestando de nuevo actualmente dimeo mi lampara con arduino,tips 142 y un codigo que me paso un companero de otro foro y la verdad me ayudo mucho , tengo una fuente de poder de 30 AMP.12v y como ya he explicado soy un novato ya he bajado el codigo de don castro pero aun no tengo ni la pantalla ni los botones jejeje solo tengo el arduino2560 mega y una tarjeta de 8 relevadores especial para arduino,pues estoy empezando de 0 desde sustrato,lampara,tanque,plantas,filtro,tapa y fuente de poder,todo con calma jeje
la verdad no se como activar un relevado a cierta hora(ejemplo8 pm) quiero desactivar mi fuente de poder por la noche a las 8 pm y encenderla alas 8am para cortar consumo minimo por la noche gracias espero alguien me ayude

mi reloj es un RTC DS1307

Prefiero que nos tuteemos. Llámame simplemente Antonio.
En España solemos usar la palabra relé para relevador. Lo comento porque nunca lo había escuchado. En la Wikipedia viene de las dos formas. Siempre se aprende algo nuevo. Smile

Si quieres dejar fijo en el código el horario bastariá leer en el RTC el campo de las horas y comprobar si está comprendido entre 8 y 19. A las 08:00 se encendería y a las 20:00 se apagaría. Basta con conectar uno de esos circuitos de relevadores a una entrada digital del arduino que deberás configurarla como salida. Lo estoy simplificando al máximo. Serviría para programar horas en punto con minutos a cero y quedaría fijp enm el código. Así sería más sencillo de programar.

Si lo que deseas es poder programar la hora de encendido y apagado haya que programar la posibilidad de guardar ambas horas en la EEPROM (memoria no volatil) del Arduino. En la versión actual de CAO no se contempla la programación de tareas a determinadas horas salvo el dimeado.

Si necesitas ayuda para implementar la solución sencillita que propuse al principio (de 8AM a 8PM) esa si te la puedo facilitar.
#697
#include <Wire.h>
#include "RTClib.h"
#include <OneWire.h>
RTC_DS1307 RTC; // Crea el o
Código PHP:
bjeto RTC 

void setup 
()  

Serial.begin(9600); // Establece la velocidad de datos del puerto serie 
Wire.begin(); // Establece la velocidad de datos del bus I2C 
RTC.begin();// Establece la velocidad de datos del RTC 
//RTC.adjust(DateTime(__DATE__, __TIME__)); Solo lo habilitamos la primera vez para poner en hora el reloj 


void loop () { 
  
int minute
  
int hour
  
int tiempo
DateTime now RTC.now(); // Obtiene la fecha y hora del RTC 
Serial.print(now.year(), DEC); 
Serial.print('/'); 
Serial.print(now.month(), DEC); 
Serial.print('/'); 
Serial.print(now.day(), DEC); 
Serial.print(' '); 
Serial.print(now.hour(), DEC); 
Serial.print(':'); 
Serial.print(now.minute(), DEC); 
Serial.print(':'); 
Serial.print(now.second(), DEC); 
Serial.println(); 
Serial.print("Dia de la semana: "); 
Serial.println(now.dayOfWeek(), DEC); 

tiempo=(now.hour()*60)+now.minute(); // Para que sea un numero entero lo medimos en minutos 

 
if (tiempo 60)  
  {  
   
tiempo=tiempo+1440// para cuando sean las 12 de la noche (00 horas) 
  
}  
Serial.println(); 
Serial.print("Tiempo: "); 
Serial.println(tiempo); 
delay(200); // La información se actualiza cada 1 seg. 
Luces (tiempo); 




void Luces(int tiempo)  
{  
 
///////////tiempos de progamacion//////////  
 
int PotLED;  
 
int InicioAmanecerLED=550//9:00 
 
int FinAmanecerLED=610//10:00 //  
 
int InicioAnochecerLED=1050//5:30PM//  
 
int FinAnochecerLED=1170//7:30PM//  
 
int MaxLED=180;///(41%=3750 LM last 139 

 //Maximo que vamos a encender los LED sobre 255 
 ///////////tiempos de progamacion noche azul//////////  
 
int Potazul;  
 
int InicioAmanecerazul=720//12:00  
 
int FinAmanecerazul=900//3:00PM //  
 
int InicioAnochecerazul=1170//7:20PM//  
 
int FinAnochecerazul=1230//8:30PM//  
 
int Maxazul=100//(93%=562 LM)
 //Maximo que vamos a encender los LED sobre 255  
     ///end blue night////
      ///////////tiempos de progamacion  ROJO //////////  
 
int Potrojo;  
 
int InicioAmanecerrojo=720//12:00  
 
int FinAmanecerrojo=900//1:00PM //  
 
int InicioAnochecerrojo=1130//6:50PM//  
 
int FinAnochecerrojo=1200//7:20PM//  
 
int Maxrojo=180;//(51%=562 LM)  //Maximo que vamos a encender los LED sobre 255 
//pin rojos
if(Potrojo < 0)
{
Potrojo=0;
}

if(Potrojo >Maxrojo)
{
Potrojo=Maxrojo;
}
analogWrite(7, Potrojo);

delay(100);


}
pues este es parte de codigo que he usado he tratado de dale salida a un pin digital pero no enciende ,enciende ya que acabo el ciclo de anochecer y se apaga el rele al encender la luces por la manana el codigo es sencillito no tiene mas que salidas para la pantalla led .baje tu codigo el dia que lo liberaste pero como dije ,solo tengo el arduino ,placa de relevadores [Imagen: %24_57.JPG]
y el tiny rtc ,estoy haciendo esto por pasos y el ultimo es colocar una pantalla lateral en la tapa(que aun estoy por hacer)
gracias de verdad
#698
Libre, igual tu problema es que los relés chinos ( vamos, casi todos), tienen lógica negativa, es decir, se abren con LOW y se cierran con HIGH.

Si es este tu problema, es tan sencillo como cambiar en tu código LOW por HIGH.

Saludos
#699
(30-09-2014, 09:08 PM)xavi escribió: Libre, igual tu problema es que los relés chinos ( vamos, casi todos), tienen lógica negativa, es decir, se abren con LOW y se cierran con HIGH.

Si es este tu problema, es tan sencillo como cambiar en tu código LOW por HIGH.

Saludos
Big GrinBig GrinBig GrinBig GrinBig GrinBig Grin pues nunca se me ocurrio eso tratare de hacerlo
#700
Libre estás intentando usar un relevalor con PWM con un valor máximo de 180. (51%)
Le estás mandando al relé un tren de pulsos positivos de unos 500 Hz. Los relevadores tienen carga inductiva que hacen mucha resistencia al paso de la corriente alterna. Incluso podrían estar llegando picos de contracorriente al Arduino con un voltaje considerable.

El control de los Leds po puedes hacer con PWM pero para el relé no.
No uses nunca analogWrite sobre un pin conectado a un relé.

Usa digitalWrite(RelePin, HIGH); o digitalWrite(RelePin, LOW);
Si quieres además usar los LEDs cada uno usará una salida diferente.
#701
hola una cosa si alguien puede echarme una mano con mi codigo porque quiero que amanecer empiece por ejemplo a las 12:30 pero solo puedo hacerlo en horas enteras que pudo poner para minutos gracias

/**********************************************************************************************/
/* */
/* Programa : Atenuador de Luces para acuario. */
/* Autor : William Alvez */
/* Pais de Origen : España */
/* Fecha de Inicio : XX Septiembre de 2014 */
/* Fecha de Termino : XX Septiembre de 2014 */
/* version : 0.60 */
/* Comentarios : Este programa se maneja con un reloj de tiempo real y una pantalla LCD */
/* Para fijar la hora de amanecer , dia y atardecer del acuario. Utiliza */ /* iluminacion de led. */
/* */
/**********************************************************************************************/

#include <LiquidCrystal.h>
#include <Wire.h>
#define DS1307_I2C_ADDRESS 0x68

byte second, minute, hour, dayOfWeek, dayOfMonth, month, year;

byte decToBcd(byte val)
{
return ( (val/10*16) + (val%10) );
}

//*****************************************************************************
// Convierte BCD (binario decimal codificado) a números normales decimales
//*****************************************************************************

byte bcdToDec(byte val)
{
return ( (val/16*10) + (val%16) );
}


void setDateDs1307(
byte second, // 0-59
byte minute, // 0-59
byte hour, // 1-23
byte dayOfWeek, // 1-7
byte dayOfMonth, // 1-28/29/30/31
byte month, // 1-12
byte year) // 0-99
{
Wire.beginTransmission(DS1307_I2C_ADDRESS);
Wire.write(0);
Wire.write(decToBcd(second)); // 0 a bit 7 inicia el reloj
Wire.write(decToBcd(minute));
Wire.write(decToBcd(hour)); // Si usted quiere 12 hora am/pm usted tiene que poner el
// bit 6 (tambien tiene que cambiar readDateDs1307)

Wire.write(decToBcd(dayOfWeek));
Wire.write(decToBcd(dayOfMonth));
Wire.write(decToBcd(month));
Wire.write(decToBcd(year));
Wire.endTransmission();
}

//*********************************************************
// Establece la fecha y el tiempo del ds1307
//*********************************************************

void getDateDs1307(byte *second,
byte *minute,
byte *hour,
byte *dayOfWeek,
byte *dayOfMonth,
byte *month,
byte *year)
{
// Resetea el registro puntero
Wire.beginTransmission(DS1307_I2C_ADDRESS);
Wire.write(0);
Wire.endTransmission();
Wire.requestFrom(DS1307_I2C_ADDRESS, 7);

// Alguno de estos necesitan enmascarar porque ciertos bits son bits de control
*second = bcdToDec(Wire.read() & 0x7f);
*minute = bcdToDec(Wire.read());
*hour = bcdToDec(Wire.read() & 0x3f); // Need to change this if 12 hour am/pm
*dayOfWeek = bcdToDec(Wire.read());
*dayOfMonth = bcdToDec(Wire.read());
*month = bcdToDec(Wire.read());
*year = bcdToDec(Wire.read());
}

LiquidCrystal lcd(24, 23, 28, 27, 26, 25);

//****************************************************************
// ILUMINACION LUCES *
//****************************************************************


int led1 = 2; // Pin digital PWM
int led2 = 3; // Pin digital PWM
int led3 = 4; // Pin digital PWM
int led4 = 5; // Pin digital PWM
int led5 = 6; // Pin digital PWM

//****************************************************************
// Potencias *
//****************************************************************


int pamanecer= 20; // Potencia amanecer 0-100%
int pdia= 50; // Potencia luz dia 0-100%
int psol= 95; // Potencia luz Sol 0-100%
int patardecer= 25; // Potencia atardecer 0-100%
int pluna= 1; // Potencia de luna (1-10 valores PWM solo leds azules)

//****************************************************************
// Horas *
//****************************************************************

int hamanecer= 13; // Hora fase amanecer
int hdia= 14; // Hora fase día
int hsol= 16; // Hora fase Sol
int tsol= 5; // Duracion de Sol , horas
int hatardecer= 21; // Hora atardecer
int hluna= 22; // Hora fase luna
int tluna= 1; // Duración luna , horas
int vpwm= 2; // Tiempo del efecto en cada fase, minutos

//****************************************************************
// Calculos para el programa (no modificar) *
//****************************************************************

int pwm=0;
int pwmamanecer=(pamanecer*2.55);//Calculamos la potencia de salida
int pwmdia=(pdia*2.55);
int pwmsol=(psol*2.55);
int pwmatardecer=(patardecer*2.55);
int pwmluna=(pluna*2.55);
int faseluz = 0;
int delayamanecer=(vpwm*700000)/(pwmamanecer);//Calculamos cada cuanto tiempo da un paso de intensidad
int delaydia=(vpwm*600000)/(pwmdia-pwmamanecer);
int delaysol=(vpwm*800000)/(pwmsol-pwmdia);
int delayatardecer=(vpwm*300000)/(pwmsol-pwmatardecer);
int delayluna=(vpwm*800000)/(pwmatardecer-pwmluna);

//****************************************************************
// Setup() *
//****************************************************************

void setup()
{
//RELOJ//
Wire.begin();
Serial.begin(9600);
lcd.begin(16,2); // DEfine pantalla LCD de 16x2
/*
second = 00;
minute = 57;
hour = 12;
dayOfWeek = 3;
dayOfMonth = 1;
month = 10;
year = 14;

setDateDs1307(second, minute, hour, dayOfWeek, dayOfMonth, month, year);

*/
//****************************************************************
// ILUMINACION *
//****************************************************************


pinMode(led1, OUTPUT);
pinMode(led2, OUTPUT);
pinMode(led3, OUTPUT);
pinMode(led4, OUTPUT);
pinMode(led5, OUTPUT);
}

//****************************************************************
// Loop () (Programa Principal) *
//****************************************************************

void loop()
{
/************************************************************/
/* Obtiene la hora desde el reloj de tiempo real */
/************************************************************/

getDateDs1307(&second, &minute, &hour, &dayOfWeek, &dayOfMonth, &month, &year);

lcd.setCursor(0,1);

if (dayOfMonth < 10)
lcd.print("0");

lcd.print(dayOfMonth, DEC);
lcd.setCursor(2,1);
lcd.print("/");
lcd.setCursor(3,1);

if (month < 10)
lcd.print("0");
lcd.print(month, DEC);
lcd.setCursor(5,1);
lcd.print("/");

if (year < 10)
lcd.print("0");
lcd.print(year, DEC);
lcd.setCursor(2,0);

if (hour < 10)
lcd.print("0");

lcd.print(hour, DEC);
lcd.setCursor(5,0);
lcd.print(":");
lcd.setCursor(7,0);

if (minute < 10)
lcd.print("0");

lcd.print(minute, DEC);
lcd.setCursor(10,0);
lcd.print(":");

if (second < 10)
lcd.print("0");
lcd.print(second, DEC);

lcd.setCursor(8,1);
switch (dayOfWeek)
{
case 1:
lcd.print(" Lunes");
break;
case 2:
lcd.print(" Martes");
break;
case 3:
lcd.print(" Miercoles");
break;
case 4:
lcd.print(" Jueves");
break;
case 5:
lcd.print(" Viernes");
break;
case 6:
lcd.print(" Sabado");
break;
case 7:
lcd.print(" Domingo");
break;
} // Cierre del switch


/*********************************************/
/* Ejecuta la subrutina de Luz */
/*********************************************/

luz();


}

/*********************************************************/
/* Subrutina de Luz() */
/*********************************************************/


void luz ()
{

//FASE 1 - AMANECER

if (hour >= hamanecer && hour < hdia && faseluz ==0){ //FASE1
if (pwm!=pwmamanecer) { //Hasta que el valor de pwm no llege al valor pwmamanecer ira aumentandolo

analogWrite (led1,pwm);//Escribimos la potencia
analogWrite (led2,pwm);//Lo mismo
pwm++;//sube un paso la intensidad
delay(delayamanecer);//Esperamos para cumplir el tiempo de dimeado deseado
}
else
{faseluz = 1;}//Cuando el valor pwm ya ha llegado al deseado pasaremos a la siguiente fase
}

//FASE 2 - DIA

if (hour >= hdia && hour < hsol && faseluz <2) { //FASE2
if (pwm!=pwmdia){

analogWrite (led1,pwm);//Escribimos la potencia en el canal de leds azules
analogWrite (led2,pwm);//Lo mismo para el blanco
analogWrite (led3,pwm);//Escribimos la potencia en el canal de leds azules
analogWrite (led4,pwm);//Lo mismo para el blanco
analogWrite (led5,pwm);//Escribimos la potencia en el canal de leds azules
pwm++;
delay(delaydia);
}
else
{faseluz = 2;}
}

//FASE 3 - SOL

if (hour >= hsol && hour < hatardecer && faseluz <3) { //FASE3
if (pwm!=pwmsol) {

analogWrite (led1,pwm);//Escribimos la potencia en el canal de leds azules
analogWrite (led2,pwm);//Lo mismo para el blanco
analogWrite (led3,pwm);//Escribimos la potencia en el canal de leds azules
analogWrite (led4,pwm);//Lo mismo para el blanco
analogWrite (led5,pwm);//Escribimos la potencia en el canal de leds azules
pwm++;
delay(delaysol);
}
else
{faseluz = 3;}
}

//FASE 4 - ATARDECER I

if (hour >= hsol+tsol && hour < hatardecer && faseluz <4) { //FASE4
if (pwm!=pwmdia){
if (pwm==255){
pwm=pwmdia-1;
} //Por si reiniciamos en esta fase
analogWrite (led1,pwm);//Escribimos la potencia en el canal de leds azules
analogWrite (led2,pwm);//Lo mismo para el blanco
analogWrite (led3,pwm);//Escribimos la potencia en el canal de leds azules
analogWrite (led4,pwm);//Lo mismo para el blanco
analogWrite (led5,pwm);//Escribimos la potencia en el canal de leds azules
pwm--;
delay(delaysol);
}
else
{faseluz = 4;}
}

//FASE 5 - ATARDECER II

if (hour >= hatardecer && hour < hluna && faseluz <5){ //FASE5
if (pwm!=pwmatardecer){
if (pwm==0){
pwm=pwmatardecer+1;
} //Por si reiniciamos en esta fase
analogWrite (led1,pwm);//Escribimos la potencia en el canal de leds azules

analogWrite (led2,pwm);//Lo mismo para el blanco
analogWrite (led3,pwm);//Escribimos la potencia en el canal de leds azules
analogWrite (led4,pwm);//Lo mismo para el blanco
analogWrite (led5,pwm);//Escribimos la potencia en el canal de leds azules
pwm--;
delay(delayatardecer);
}
else
{faseluz = 5;}
}

//FASE 6 - LUNA

if (hour >= hluna && hour < hluna+tluna && faseluz <6){ //FASE6
if (pwm!=pwmluna) {
if (pwm==255){
pwm=pwmluna-1;
} //Por si reiniciamos en esta fase
analogWrite (led1,pwm);//Escribimos la potencia en el canal de leds azules
analogWrite (led2,pwm);//Lo mismo para el blanco
analogWrite (led3,pwm);//Escribimos la potencia en el canal de leds azules
analogWrite (led4,pwm);//Lo mismo para el blanco
analogWrite (led5,pwm);//Escribimos la potencia en el canal de leds azules
pwm--;
delay(delayluna);
}
else
{
faseluz = 6;

analogWrite (led2,0);//Lo mismo para el blanco
analogWrite (led3,0);//Escribimos la potencia en el canal de leds azules
analogWrite (led4,0);
}
}

//FASE 7 - APAGADO

if (hour >=hluna+tluna && faseluz==6) {
if (pwm!=0){
pwm--;
analogWrite (led5,pwm);
analogWrite (led1,pwm);
delay(delayluna);
}
else
{faseluz = 0;}
}

Serial.print("pwm:");
Serial.print(pwm);
Serial.print(" pwmamanecer:");
Serial.print(pwmamanecer);
Serial.print(" pwmdia:");
Serial.print(pwmdia);
Serial.print(" pwmsol:");
Serial.print(pwmsol);
Serial.print(" pwmatardecer:");
Serial.print(pwmatardecer);
Serial.print(" pwmluna:");
Serial.print(pwmluna);
Serial.print(" fase luz:");
Serial.println(faseluz);
delay(1000);
} /* Cierre de loop () */
#702
Puedes contar minutos del día igual que lo hizo libre
(libre puso 7:20PM pero a mi no me engaña ji, ji) -fisch.gif
int InicioAnochecerazul=1170; // 7:30PM (19*60) + 30
int FinAnochecerazul =1230; // 8:30PM (20*60) + 30

Es la forma de poder usar un dato entero, pero 23:59 sería (23*60) + 59 = 1439
y aunque no nos queda margen para contar segundos del día, si que nos queda margen para contar las décimas de minuto del día haríamos lo siguiente:

Las 23:59:59 sería (23*600) + 59*10 + 59/6 = 14399

Concretamente uso la función siguiente en CAO1:

int Cao1_FotoPeriod::RTC_DMdD(){
DateTime now = RTC.now();
return ( (now.hour()*600) + (now.minute()*10) + now.second()/6);
}

Con ello tampoco rebasamos el máximo valor para los enteros.
#703
hola gracias por responder una cosa porque yo soy nuevo en arduino no se como ustedes pero pongo esto
int hamanecer=720; // Hora fase amanecer
int hamanece= 735; // Minutos fase luz
int hamanece1= 750; // Minutos fase luz

aparte tengo que declarar algo mas en otra parte
#704
Me has preguntado como se hace y te he respondido. Lógicamente habría que cambiar todos los datos que se usan para eso y tenerlo en cuenta en cada una de las comparaciones que se hacen. Si yo te toco en esas tres líneas nada más, dejará de funcionarte. Es un tipo de cambio que afecta a todo el programa. -huh.gif

Wiliam, saca una copia de seguridad y haz pruebas. Deberías intentarlo. Quizás no te funcione a la primera, pero así es como se aprende ¿no?

Yo no puedo dedicarme a hacerle el programa a todo el que necesite algo y encima partir de un código que no me gusta como está planteado. Eso no tendría sentido. -pardon.gif

Mi tarea es resolver dudas y proporcionar los conocimientos que la gente necesita para que los usen en sus proyectos y enseñarles.

Ánimo, inténtalo tú mismo.
#705
hola yo no digo que me lo agas solo que aparte de eso tengo que declarar mas cosas dime que tengo que declarar y yo voy probando y se que mi codigo no te gusta pero es que el cao no e podido hacer nada con el me pierdo por todos lados

Usuarios navegando en este tema: 2 invitado(s)


Salto de foro: