[Namiga]

El contaste creo que es por potenciómetro externo. No se puede controlar por código

En el mío también es así.

Por cierto, en el código he puesto la inicialización para 20x4. No sé si tu LCD es 20x4 o 16x2.

Antonio, el mio tambien es de 20*4

[juanma1970]

Esta es mi lcd

[Antonio Castro]

Cuando publique lo que estoy haciendo habrá código libre bajo licencia Creative Commons en forma de módulos de librería.

Al usar lo mismo que yo, te puedo ayudar mejor y además más adelante podrás usar algunos de mis módulos para lo que te interese. Concretamente estoy pensando en hacer un sistema de gestión de menús que estará basado en ese Display de 20x4.

PD:
Un dipositivo muy baratito que estoy usando y que seguramente os interesará a muchos es un zumbador.

Lo más economico es usar un disco piezo cerámico. Valen menos de un euro y se pueden conectar directamente a una salida digital de arduino.

Me refiero a lo que os muestro en imagen:



Son muy fáciles de usar:
Solo hay que soldarles un par de cablecitos como en la imagen y listo. Yo les sueldo cable unifilar, porque al ser más rígido sirven de soporte y al dejar suspendido el disco no se entorpece la generación del sonido. Basta conectar un cable a masa y el otro al pin de una salida digital. Para activarlo basta ejecutar tone(pinDeSalida, frecuencia, Milisegundos);

Aunque sea para poder emitir un simple beep para llamar la atención hacia el LCD en algún momento y para emitir un sonido bitonal de alarma ya merece la pena.

[juanma1970]

Buenas noches, hoy me ha llegado el chip atmega 328 , lo he puesto y Voila funciona....y despues de petar el segundo he decidido que voy a tener que hacer otro tipo de crepusculo, o sea , me rindo ....estoy abierto a cualquier sugerencia, doy datos a quien me los pida y lo dicho ........cualquier respuesta es buena para mi en estos momentos de frustracion.

[Namiga]

Yo te paso lo que tengo yo. Es muy simple y no hace atardecer, solo amaneces ... pero por que no me he puesto a calacular el tiempo necesario
Cuando controle el reloj sera más facil .. supongo

Código:

int led1 = 2;           // the pin that the LED is attached to
int led2 = 3;           // the pin that the LED is attached to
int led3 = 4;           // the pin that the LED is attached to
int led4 = 5;           // the pin that the LED is attached to
int brightness = 0;    // how bright the LED is
int fadeAmount = 1;    // how many points to fade the LED by

// the setup routine runs once when you press reset:
void setup()  {
  // declare pin 2,3,4,5 to be an output:
  pinMode(led1, OUTPUT);
  pinMode(led2, OUTPUT);
  pinMode(led3, OUTPUT);
  pinMode(led4, OUTPUT);
}

// the loop routine runs over and over again forever:
void loop()  {
  // set the brightness of pin 2,3,4,5:
  analogWrite(led1, brightness);
  analogWrite(led2, brightness);
  analogWrite(led3, brightness);
  analogWrite(led4, brightness);

if(brightness<170)
    {
        brightness++;
    }
    if(brightness>=170)
    {
        brightness=170;
    }
    
  // wait for 900 milliseconds to see the dimming effect    
  delay(900);                            
}

Habría que ajustar mejor el delay
Y la variable brightnes la dejo en 170 de momento. es un 70% de la potencia total

[carlosterre]

Yo te paso lo que tengo yo. Es muy simple y no hace atardecer, solo amaneces ... pero por que no me he puesto a calacular el tiempo necesario
Cuando controle el reloj sera más facil .. supongo

Código:

int led1 = 2;           // the pin that the LED is attached to
int led2 = 3;           // the pin that the LED is attached to
int led3 = 4;           // the pin that the LED is attached to
int led4 = 5;           // the pin that the LED is attached to
int brightness = 0;    // how bright the LED is
int fadeAmount = 1;    // how many points to fade the LED by

// the setup routine runs once when you press reset:
void setup()  {
  // declare pin 2,3,4,5 to be an output:
  pinMode(led1, OUTPUT);
  pinMode(led2, OUTPUT);
  pinMode(led3, OUTPUT);
  pinMode(led4, OUTPUT);
}

// the loop routine runs over and over again forever:
void loop()  {
  // set the brightness of pin 2,3,4,5:
  analogWrite(led1, brightness);
  analogWrite(led2, brightness);
  analogWrite(led3, brightness);
  analogWrite(led4, brightness);

if(brightness<170)
    {
        brightness++;
    }
    if(brightness>=170)
    {
        brightness=170;
    }
    
  // wait for 900 milliseconds to see the dimming effect    
  delay(900);                            
}

Habría que ajustar mejor el delay
Y la variable brightnes la dejo en 170 de momento. es un 70% de la potencia total

Namiga, aunque la solución buena es la que dice Antonio, mientras cacharreas y aprendes algo de C puedes hacer algo muy simple en tu rutina de pruebas para tener el atardecer:

Si te fijas tienes una variable que fija el incremento de brillo para el led. Basta que cambies su valor por un incremento negativo y tendrás el atardecer hasta el apagado.

Si haces algo puramente secuencial sin estructurar en absoluto puedes tener el efecto. Pero insisto que la solución de Antonio es lo suyo!

El tema sería algo como:

unsigned long duraciondia; //ms en un dia
unsigned long duracionfotoperiodo; //ms a tope en fotoperiodo
unsigned long duracionfade; //ms para fadein y fadeout

Basta que en el loop pongas una lógica que haga:

1) calcular tiempo de fadein y fadeout (=número de pasos por el delay del fade en ms)
2) calcular el tiempo apagado (=día menos 2xtiempo de fadein menos fotoperiodo)
3) hacer en bucle

Fadein
Esperar fotoperiodo
Fadeout (repetir lo mismo que fadein, pero con fadeamount -1 y testeando para 0 en vez de max
Esperar apagado
Volver a empezar el bucle

Hay un poco de pupurri en el código que has puesto (ie tienes el fadeamount pero también usas brightness++ que es un fadeamount de 1. Usa esto en su lugar:

brightness+=fadeamount;

De esta forma cuando fadeamount es negativo estarás reducíendo intensidad. Pero ni siquiera hace falta:

for(; brightness<maxbrightness; brightness+=fadeamount) {
delay(fadedelay);
}
delay(duracionfotoperiodo);
for(; brightness>0; brightness-=fadeamount) {
delay(fadedelay);
}
delay(duraciondia-duracionfotoperiodo-2*fadedelay*maxbrightness);

Perdona que estoy con el móvil y es una castaña escribir cosas al vuelo así... Sólo son ideas muy básicas, pero a lo mejor te sirven.

[Namiga]

Gracias carlos
Luego le echo un vistazo en casa

Si eres capaz de escribir eso en el movil, es que sabes programar MUUUUUUUCHO

[juanma1970]

BUeno , veo que no os andais con chiquitas.....agradeceria tambien un crokis para el circuito yo tengo 2 lineas de leds de 24 x 3 w con unas fuentes de alimentacion deamwell 60-48D.

[Namiga]

BUeno , veo que no os andais con chiquitas.....agradeceria tambien un crokis para el circuito yo tengo 2 lineas de leds de 24 x 3 w con unas fuentes de alimentacion deamwell 60-48D.

Pues a mi no me cuadra ...
los led de 3W van a minimo de 3,2V ... por 24 unidades son 76,8v si los pones en serie .... y la fuente te da 48V

Como los quieres poner ???

A mi me salen 15 leds por linea para esa fuente ...

[Antonio Castro]

Os voy a mandar un programita que demuestra como puede sincronizarse el dimeo con el momento del día. Es un programa de demo.

Solo trata un canal y establece únicamente cuatro tipo de zonas horarias para definir el comportamiento del dimeo. Las zonas diurna y nocturna entregan un valor constante y las zonas crepusculares (alba y ocaso) harán uso de una función de interpolación.

Para poder interpolar es muy util elegir una buena medida que indique con precisión suficiente el momento del diía en fución de la hora. El momento del día serán unidades del tipo decimas de minutos. ( 24 horas equivaldría a 14400 decimas de minutos).

Así los valores podrán ser gestionados con un valor tipo entero y que entregan suficiente precisión. Solo se requiere un RTC para probar el programa.

Mi recomendación para el entorno Arduino es que si algo se puede hacer con un entero, no lo hagais con un long, y si puede hacerse con un long no lo hagáis con un float.

Que lo disfruteis.

Código:

#include <Wire.h>
#include <RTClib.h>

/***********************************************************
  Programa para ilustrar la forma de vincular la intensidad
  de un dimeo de leds a la hora del dia.
************************************************************/

// NOTA:
// Para poder trabajar con datos de tipo entero, dentro de
// periodos de 24 horas, consideraremos como unidad de tiempo
// las decimas de minutos.
// 14400 decimas de minutos del dia = 24 horas

RTC_DS1307   RTC;
char         CadAux[22];
int          DecMinDelDia; // valor entre 0..14400

// Vamos a definir los límites de cuatro zonas horarias
// en decimas de minutos del dia (rango= 0..14400)
// Noche, Alba, Dia, Crepusculo
// **** Requisitos *************
// IniAlba > 0
// IniDia  > IniAlba
// IniOcaso > IniDia
// IniNoche > IniOcaso
// IniNoche < 14400
// El programa no funcionará bien
// si no se cumplen esos requisitos
// ***************************
#define IniAlba   4800   // 8:00 = 8*60 * 10
#define IniDia    5100   // 8:30 = ((8*60)  + 30) * 10
#define IniOcaso 11700   // 19:30 = ((19*60) + 30) * 10
#define IniNoche 12000   // 20:00 = 20*60 * 10

// Para ver si funciona correctamente puede situar alguno de los valores
// de inicios crepusculares (IniAlba o IniOcaso) para que coincidan con
// la hora actual (suponiendo que el RTC esté en hora).


#define DimLuzBlancaNoche  0
#define DimLuzBlancaDia    245


// *********************************************************************
// Interpolacion lineal
// MinDD será un valor intermedio entre Time0 y TimeF
// Se devolvera un valor interpolado intermedio entre Dim0 y DimF
// Se hace el calculo con datos long para evitar falta de precision
// derivados de problemas de redondeos.
// *********************************************************************
long InterpoLineal(long Time0, long MinDD, long TimeF, long Dim0, long DimF){

    sprintf(CadAux, "T0=%ld, MinDD=%ld, TF=%ld, D0=%ld, DF=%ld",
            Time0, MinDD, TimeF, Dim0, DimF);
    Serial.println(CadAux);
    return ( ((MinDD-Time0)*(DimF-Dim0) / (TimeF-Time0)) + Dim0 );
}

// ********************************************************************
// Funcion que devuelve un valor comprendido entre 0..14400
// que se corresponderá con la decima de minuto del día.
// 60 * 10 * 24 = 14400
// *********************************************************************
int DecMinutosDelDia(){
    DateTime now = RTC.now();
    return ( (now.hour() * 600) + ( now.minute() * 10) + now.second()/6 );
}

// **********************************************
void DimLuzBlanca (int DecMinDelDia){
    int Dimeo;

    if (DecMinDelDia<=IniAlba){ // Noche pasadas la 24h
        Dimeo=DimLuzBlancaNoche;
    }
    else if ((DecMinDelDia>IniAlba) && (DecMinDelDia<IniDia) ){ // Alba
        Dimeo=InterpoLineal(IniAlba, DecMinDelDia, IniDia, DimLuzBlancaNoche, DimLuzBlancaDia);
    }
    else if ((DecMinDelDia>=IniDia) && (DecMinDelDia<=IniOcaso)  ){ // Dia
        Dimeo=DimLuzBlancaDia;
    }
    else if ((DecMinDelDia>IniOcaso) && (DecMinDelDia<IniNoche)  ){ // ocaso
        Dimeo=InterpoLineal(IniOcaso, DecMinDelDia, IniNoche, DimLuzBlancaDia, DimLuzBlancaNoche);
    }
    else if (DecMinDelDia>=IniNoche) { // Noche antes de las 24h
        Dimeo=DimLuzBlancaNoche;
    }
    else{
        Dimeo=-1; // Error de programacion
    }
    sprintf(CadAux, "Dimeo LuzBlanca(%d)", Dimeo);
    Serial.println(CadAux);
}


// **********************************************
// Calcular la intensidad de luz de cada canal
// correspondiente al valor DecMinDelDia
// **********************************************
void ActualizarDimeos (int DecMinDelDia){
    DimLuzBlanca (DecMinDelDia);
    /*** de forma análoga haríamos
    DimLuzAzul (DecMinDelDia);
    DimLuzRoja (DecMinDelDia);
    DimLuzAmbar (DecMinDelDia);
    ***/
}


// *****************
void setup () {
    Serial.begin(9600);
    Wire.begin();
    RTC.begin();
    if (! RTC.isrunning()) {
        Serial.println("RTC is NOT running!");
    // Tomamos la fecha de complicación como fecha arbitraria
    RTC.adjust(DateTime(__DATE__, __TIME__));
    }
}

// *****************
void loop () {
    DateTime now = RTC.now();

     sprintf(CadAux, "%04d-%02d-%02d %02d:%02d:%02d",
            now.year(), now.month(),  now.day(),
            now.hour(), now.minute(), now.second() );
    Serial.println(CadAux);
    DecMinDelDia= DecMinutosDelDia();
    sprintf(CadAux, "Minuto del dia = %d", DecMinDelDia);
    ActualizarDimeos (DecMinDelDia);
    Serial.println(CadAux);
    delay(5000); // esperamos 5 segundos
}

[juanma1970]

BUeno , veo que no os andais con chiquitas.....agradeceria tambien un crokis para el circuito yo tengo 2 lineas de leds de 24 x 3 w con unas fuentes de alimentacion deamwell 60-48D.

Pues a mi no me cuadra ...
los led de 3W van a minimo de 3,2V ... por 24 unidades son 76,8v si los pones en serie .... y la fuente te da 48V

Como los quieres poner ???

A mi me salen 15 leds por linea para esa fuente ...

La pantalla hace ya un año que la tengo puesta con 24 leds por linea , segun donde los compre me dijeron que maximo podia poner 24 leds por fuente, supongo que no estaran nunca al 100%, haciendo numeros se quedan siempre al 75 % pero yo he probado de poner solo 16 leds y da la misma intensidad , lo que pasa es que la fuente es dimeable por dentro, me explico, la abres y tiene un regulador que llega a 60V, comprobandolo con un tester me salen casi 70v.
Los materiales los commpre en faciled.com

[juanma1970]

Hola, despues de un monton de pruebas y cagadas no consigo hacer funcionar los leds con el dimeo , o estoy muy saturado o ya no me da el coco para mas , a ver si antonio acaba de su proyecto y nos explica algo, mañana pondre todos los datos posibles para ver si hacemos funcionar esto, gracias.

[Namiga]

Antonio ... Gracias por el Codigo
Juanma... Que es lo que ni te funciona??
Dinos como has hecho la conexión y que usas para el dimeo
A mi me funciono a la segunda

[Antonio Castro]

Hola, despues de un monton de pruebas y cagadas no consigo hacer funcionar los leds con el dimeo , o estoy muy saturado o ya no me da el coco para mas , a ver si antonio acaba de su proyecto y nos explica algo, mañana pondre todos los datos posibles para ver si hacemos funcionar esto, gracias.

Si tienes un gráfico que muestre el esquema del circuito, te ayudaremos a buscar las posibles causas.

[juanma1970]

Esto es lo que tengo, no se como enviaros un circuito.Solo esto.