ayuda programa dimeo 6 canales

Tema en 'Programación' iniciado por pucelaroberto, 27 Nov 2013.

  1. pucelaroberto

    pucelaroberto

    Mensajes:
    601
    Registrado:
    19 Feb 2008
    Ubicación:
    españa
    Hola buenas haber si me puede ayudar alguien que entienda de programación ,
    para empezar yo poquito y lo poco que hice fue a golpe de pedal y ayuda porque me he atascado y no se salir :

    Hice la programación para todo lo que corresponde al tema del arduino y bien hacer pantallas de muestra y alguna cosilla mas pero llego al tema del dimeo y no soy capaz , gracias a un chico del foro le copie su programa del dimeo y lo adapte al mio dentro de lo que puede pero el suyo es de 8 canales y el mio de 6 , asta hay bien le anule dos canales y ya esta;
    pero su funcionamiento es el siguiente tiene el canal 3 simpre encendido por la noche y yo no quiero eso , eso es fácil en canal 3 lo anulo la parte de luzluna y ya esta pero el problema es que en este programa se dimean los 6 canales por igual y yo lo que quiero es :

    Que primero enciendan el dimeo los canales impares ( azules ) y mas tarde los pares ( blancos ) y a la hora de anochecer lo contrario que se apague el dimeo de los pares y poco después de los impares

    eso es lo que no soy capaz de modificar en este programa haber si alguin me puede ayudar ( a ser posible que la hora de empiece de los canales pares e impares sea una variable para poder modificar cuando se quiera )

    este es el programa entero que tengo:

    #include <Wire.h> // Incluye la librería Wire
    #include "RTClib.h" // Incluye la librería RTClib
    #include <LiquidCrystal_I2C.h>
    #include <OneWire.h>
    #include <DallasTemperature.h>
    RTC_DS1307 RTC;
    LiquidCrystal_I2C lcd(0x27,20,4);

    //***********************************************************************
    //***************** DECLARACION DE ENTRADAS / SALIDAS ****************
    //***********************************************************************

    // DECLARACION DE ENTRADAS
    #define sonda_1 0 // Entrada analogica A0 Sonda 1
    #define sonda_2 1 // Entrada analogica A1 Sonda 2
    #define sonda_3 2 // Entrada analogica A2 Sonda 3
    #define sonda_A 3 // Entrada analogica A3 Sonda Arduino
    #define cambio_pantalla 8 // Cambio de pantalla entrada digital nº8
    #define boya_parada_bomba 9 // Boya de nivel minimo parada de bomba subida
    #define boya_nivel_relleno 10 // Boya de nivel alarma de relleno Sump
    #define boya_nivel_75_sump 11 // Boya de nivel nivel maximo sump
    #define boya_nivel_max_sump 12 // Boya de nivel nivel maximo urna Principal
    #define entrada_vacia 13 // +++++++++++++++ VACIA +++++++++++++++++++

    // DECLARACION DE SALIDAS
    #define salida_ventilador_1 53 // Salida ventilador 1 Modulo 1 led
    #define salida_ventilador_2 51 // Salida ventilador 2 Modulo 2 led
    #define salida_ventilador_3 49 // Salida ventilador 3 Modulo 3 led
    #define salida_ventilador_A 47 // Salida ventilador arduino
    #define salida_bomba_subida 45 // Salida bomba subida
    #define salida_5 43 // Salida
    #define salida_6 41 // Salida
    #define puesta_on_FA 39 // Salida puesta on fuente alimentacion led
    #define salida_8 37 // +++++++++++++++ VACIA +++++++++++++++++++
    #define salida_9 35 // +++++++++++++++ VACIA +++++++++++++++++++
    #define salida_10 33 // +++++++++++++++ VACIA +++++++++++++++++++
    #define salida_11 31 // +++++++++++++++ VACIA +++++++++++++++++++
    #define salida_12 29 // +++++++++++++++ VACIA +++++++++++++++++++
    #define salida_13 27 // +++++++++++++++ VACIA +++++++++++++++++++
    #define salida_14 25 // +++++++++++++++ VACIA +++++++++++++++++++
    #define salida_15 23 // +++++++++++++++ VACIA +++++++++++++++++++

    //***************************************************************************
    //***************************************************************************
    //***************************************************************************
    //***************************************************************************

    // DECLARACION DIMEO PANTALLA
    #define salida_PWM_1 2 // Dimeo canal 1
    #define salida_PWM_2 3 // Dimeo canal 2
    #define salida_PWM_3 4 // Dimeo canal 3
    #define salida_PWM_4 5 // Dimeo canal 4
    #define salida_PWM_5 6 // Dimeo canal 5
    #define salida_PWM_6 7 // Dimeo canal 6
    byte canal_1 = 2; // Pin digital PWM
    byte canal_2 = 3; // Pin digital PWM
    byte canal_3 = 4; // Pin digital PWM
    byte canal_4 = 5; // Pin digital PWM
    byte canal_5 = 6; // Pin digital PWM
    byte canal_6 = 7; // Pin digital PWM


    float hmediodia= 14; // hora que establecemos como medio dia
    float hluna=1; // numero de horas de luna
    float hamplitud= 3; // horas de amplitud del dia, hmediodia-hamplitud es el momento de amanecer
    float pwmmax = 200; // pwm maximo para los canales de luz
    float mmediodia = hmediodia*60; // calcula el minuto del medio dia ejemplo 17*60
    float mluna = hluna * 60; // minutos que dura la fase de luna
    float mamplitud = hamplitud*60; // minutos que duara "amplitud"
    float msubida = mamplitud / 2; // minutos que cuesta pasar de pwm=0 hasta pwm=pwmmax
    float mfin = mmediodia + mamplitud; // minuto a partir del cual solo queda luz luna
    float minicio = mmediodia - mamplitud; // minuto del dia en el que amanece
    float pwmteorico = 0; // pwm teorico que calcula en cada minuto, puede ser mayor que 255
    float pwm=0; // variable que en la que guardara pwm en cada minuto
    float mactual=0; // variable en la que guardara en minuto actual del dia
    float pwmluna=200; // pwm que establezcamos para periodo luna
    boolean c1,c2,c3,c4,c5,c6;

    //***************************************************************************
    //***************************************************************************
    //***************************************************************************
    //***************************************************************************






    // DECLARACION DE VARIABLES DE ENTRADAS
    boolean CAMBIO_PANTALLA, BOYA_PARADA_BOMBA, BOYA_NIVEL_RELLENO, BOYA_NIVEL_75_SUMP, BOYA_NIVEL_MAX_SUMP;



    //***********************************************************************
    //***********************************************************************
    //***********************************************************************

    // DECLARACION DE CONSTANTES

    #define temperatura_max_led 25 // Temperatura maxima de los led.
    #define temperatura_min_led 20 // Temperatura minima de los led.
    #define temperatura_max_arduino 25 // Temperatura maxima del arduino
    #define numero_menus 5 // Numero de menus de LCD


    // DECLARACION DE VARIABLES DEL PROGRAMA

    int hora, minutos, segundos, dia, mes, ano, d,me,n, menu = 0, menu_aux = 0;
    float T1,T2,T3,TA;
    char temperatura1[5],temperatura2[5],temperatura3[5],temperaturaA[5], reloj[8], h[2], m[2], s[2];
    int valor_dimeo_led_canal_1;
    boolean intermitencia = 0;
    int fase_dimeo;

    //***********************************************************************
    //***********************************************************************
    //***********************************************************************
    //***********************************************************************
    //************************ PROGRAMA *****************************
    //***********************************************************************
    //***********************************************************************
    //***********************************************************************
    //***********************************************************************

    void setup () // Programa de inicio.
    {
    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
    lcd.init(); // Inicializa el LCD.
    lcd.backlight(); // Establece la iluminación del LCD.
    for (int i = 2; i <= 13; i++) // Declaracion de salidas PWM
    pinMode(i,OUTPUT);
    for (int i = 22; i <= 52; i++) // Declaracion de entradas digitales
    { pinMode(i,INPUT); i++; }
    for (int i = 23; i <= 53; i++) // Declaracion de salidas digitales
    { pinMode(i,OUTPUT); i++; }

    }

    void loop ()
    {
    leer_entradas();
    activar_salidas();
    seleccion_menu();
    escribir_temperatura_arduino();
    escribir_lcd(0,0,reloj);
    dimeo();

    }










    //***********************************************************************
    //***********************************************************************
    //***********************************************************************
    //***********************************************************************
    //************************ FUNCIONES *****************************
    //***********************************************************************
    //***********************************************************************
    //***********************************************************************
    //***********************************************************************

    void leer_entradas()
    {
    T1 = (5.0 * analogRead(sonda_1)*100.0)/1023.0;
    T2 = (5.0 * analogRead(sonda_2)*100.0)/1023.0; // Calculo para transformar el valor analogico en dato de temperatura en centigrados
    T3 = (5.0 * analogRead(sonda_3)*100.0)/1023.0;
    TA = (5.0 * analogRead(sonda_A)*100.0)/1023.0;
    itoa(T1,temperatura1,10); itoa(T2,temperatura2,10); itoa(T3,temperatura3,10); itoa(TA,temperaturaA,10); // El numero diez es para hacerlo un numero decimal
    CAMBIO_PANTALLA = digitalRead(cambio_pantalla);
    BOYA_PARADA_BOMBA = digitalRead(boya_parada_bomba);
    BOYA_NIVEL_RELLENO = digitalRead(boya_nivel_relleno);
    BOYA_NIVEL_75_SUMP = digitalRead(boya_nivel_75_sump);
    BOYA_NIVEL_MAX_SUMP =digitalRead(boya_nivel_max_sump);
    obtener_reloj();

    if(intermitencia == 1) intermitencia = 0; else intermitencia = 1;
    delay(500);



    }

    void activar_salidas()
    {
    if(T1 > temperatura_max_led) digitalWrite(salida_ventilador_1, HIGH); //Poner a 1 el ventilador modulo 1
    if(T1 < temperatura_min_led) digitalWrite(salida_ventilador_1, LOW); //Parar ventilador
    if(T2 > temperatura_max_led) digitalWrite(salida_ventilador_2, HIGH); //Poner a 1 el ventilador modulo 2
    if(T2 < temperatura_min_led) digitalWrite(salida_ventilador_2, LOW); //Parar ventilador
    if(T3 > temperatura_max_led) digitalWrite(salida_ventilador_3, HIGH); //Poner a 1 el ventilador modulo 3
    if(T3 < temperatura_min_led) digitalWrite(salida_ventilador_3, LOW); //Parar ventilador
    if(TA > temperatura_max_led) digitalWrite(salida_ventilador_A, HIGH); //Poner a 1 el ventilador modulo A
    if(TA < temperatura_min_led) digitalWrite(salida_ventilador_A, LOW); //Parar ventilador
    menu_aux = menu;
    if ( CAMBIO_PANTALLA == 1) // Aumentar de pantalla
    {
    lcd.clear();
    if(menu >= numero_menus)
    menu = 0;
    else
    menu++;
    }
    if (BOYA_NIVEL_RELLENO == 1) { menu = 100; lcd.clear(); } // Activar la alarma de rellenado de nivel
    else if(menu == 100)
    {
    menu = 0; lcd.clear();
    }



    }

    void menu_temperaturas()
    {
    escribir_lcd(6,0,"T.PANTALLA");

    escribir_lcd(0,1, "Temp. M1 :"); escribir_lcd(12,1, temperatura1); escribir_lcd(14,1, "\337c");

    escribir_lcd(0,2, "Temp. M2 :"); escribir_lcd(12,2, temperatura2); escribir_lcd(14,2, "\337c");

    escribir_lcd(0,3, "Temp. M3 :"); escribir_lcd(12,3, temperatura3); escribir_lcd(14,3, "\337c");
    if(T1 > temperatura_max_led)
    if(intermitencia == 1)
    escribir_lcd(19,1,"X");
    else
    escribir_lcd(19,1,"+");
    if(T1 < temperatura_min_led) escribir_lcd(19,1, " ");
    if(T2 > temperatura_max_led)
    if(intermitencia == 1)
    escribir_lcd(19,2,"X");
    else
    escribir_lcd(19,2,"+");
    if(T2 < temperatura_min_led) escribir_lcd(19,2, " ");
    if(T3 > temperatura_max_led)
    if(intermitencia == 1)
    escribir_lcd(19,3,"X");
    else
    escribir_lcd(19,3,"+");
    if(T3 < temperatura_min_led) escribir_lcd(19,3, " ");


    }

    void menu_1()
    {
    char porcentaje[5];
    escribir_lcd(7,0, "P.CANALES");
    escribir_lcd(2,1, "1= ");
    if (c1 == 0)
    escribir_lcd(5,1, "0");
    else
    {
    itoa(pwm*0.3921,porcentaje,10);
    escribir_lcd(5,1, porcentaje);
    }
    lcd.printstr("%");

    escribir_lcd(2,2, "2= ");
    if (c2 == 0)
    escribir_lcd(5,2, "0");
    else
    {
    itoa(pwm*0.3921,porcentaje,10);
    escribir_lcd(5,2, porcentaje);
    }
    lcd.printstr("%");

    escribir_lcd(2,3, "3= ");
    if (c3 == 0)
    escribir_lcd(5,3, "0");
    else
    {
    itoa(pwm*0.3921,porcentaje,10);
    escribir_lcd(5,3, porcentaje);
    }
    lcd.printstr("%");

    escribir_lcd(11,1, "4= ");
    if (c4 == 0)
    escribir_lcd(14,1, "0");
    else
    {
    itoa(pwm*0.3921,porcentaje,10);
    escribir_lcd(14,1, porcentaje);
    }
    lcd.printstr("%");

    escribir_lcd(11,2, "5= ");
    if (c5 == 0)
    escribir_lcd(14,2, "0");
    else
    {
    itoa(pwm*0.3921,porcentaje,10);
    escribir_lcd(14,2, porcentaje);
    }
    lcd.printstr("%");

    escribir_lcd(11,3, "6= ");
    if (c6 == 0)
    escribir_lcd(14,3, "0");
    else
    {
    itoa(pwm*0.3921,porcentaje,10);
    escribir_lcd(14,3, porcentaje);
    }
    lcd.printstr("%");

    }

    void menu_2()
    {
    escribir_lcd(6,0, "NIVEL SUMP");
    escribir_lcd(0,3, "25%");
    escribir_lcd(6,3, "50%");
    escribir_lcd(11,3, "75%");
    escribir_lcd(16,3, "100%");

    if (BOYA_PARADA_BOMBA==0)escribir_lcd(0,2,"*****");
    else escribir_lcd(0,2," ");

    if (BOYA_NIVEL_RELLENO==0)escribir_lcd(5,2,"*****");
    else escribir_lcd(5,2," ");

    if (BOYA_NIVEL_75_SUMP==0)escribir_lcd(10,2,"*****");
    else escribir_lcd(10,2," ");

    if (BOYA_NIVEL_MAX_SUMP==0)escribir_lcd(15,2,"*****");
    else escribir_lcd(15,2," ");



    }
    void menu_3()
    {
    escribir_lcd(7,0, "Menu 3");
    }
    void menu_4()
    {
    escribir_lcd(7,0, "Menu 4");
    }
    void menu_5()
    {
    char dim[5]; int numero;
    if(fase_dimeo == 0)
    escribir_lcd(7,0, "Atardecer");
    if(fase_dimeo == 1)
    escribir_lcd(7,0, "Amanecer");
    if(fase_dimeo == 2)
    escribir_lcd(7,0, "Dia");

    escribir_lcd(0,1, "PWM: "); //itoa(pwm,dim,10); escribir_lcd(5,1,dim );
    numero = (pwm / 21);
    for (int i = 0; i < numero; i++)
    {
    escribir_lcd(i+8,1,"*");
    }

    escribir_lcd(0,2, "PWMTeo: "); //itoa(pwmteorico,dim,10); escribir_lcd(8,2,dim );
    numero = (pwmteorico / 21);
    for (int i = 0; i < numero; i++)
    {
    escribir_lcd(i+8,2,"*");
    }

    escribir_lcd(0,3, "PWMMax: "); //itoa(pwmmax,dim,10); escribir_lcd(12,3,dim );
    numero = (pwmmax / 21);
    for (int i = 0; i < numero; i++)
    {
    escribir_lcd(i+8,3,"*");
    }

    }
    void menu_bienvenida()
    {
    escribir_lcd(5,1, "GODO`S REEF");
    escribir_lcd(5,2, "Version v4");
    for(int i = 0; i<=19;i++)
    {
    escribir_lcd(i,3,"X");
    delay(200);
    }
    }

    void menu_alarma_sonda_relleno()
    {
    escribir_lcd_parpadeo(4,2, "RELLENAR SUMP"," ", 0);
    }

    void seleccion_menu()
    {

    if (menu == 0)
    {
    menu_temperaturas();
    }
    if (menu == 1)
    {
    menu_1();
    }
    if (menu == 2)
    {
    menu_2();
    }
    if (menu == 3)
    {
    menu_3();
    }
    if (menu == 4)
    {
    menu_4();
    }
    if (menu == 5)
    {
    menu_5();
    }
    if (menu == 100)
    menu_alarma_sonda_relleno();
    }



    //***********************************************************************
    //***********************************************************************
    //***********************************************************************
    //***********************************************************************
    //*********** DIMEO DIMEO DIMEO DIMEO **********************
    //***********************************************************************
    //***********************************************************************
    //***********************************************************************
    //***********************************************************************

    void dimeo ()
    {
    mactual = hora *60 + minutos;
    if(mactual > minicio && mactual <= mmediodia) //calcula el minuto actual, si es despues de amanecer y antes de medio dia
    {
    pwmteorico=(mactual-minicio)/msubida*pwmmax; //calcula la proporcion de minutos subbida consumida //y lo multiplica por pwmmax para calcula pwmteorico que puede ser mayor de 255
    }

    if(mactual>mmediodia && mactual <= mfin) //si es despues de medio dia y antes de anochecer
    { //calcula la proporcion de minutos ha bajado hasta anochcer consumida
    pwmteorico=((mfin-mactual)/msubida*pwmmax)+pwmluna; //y lo multiplica por pwmmax para calcula pwmteorico que puede ser mayor de 255
    }
    if(mactual > mfin && mactual <= (mfin + mluna) )
    {
    pwmteorico=pwmluna;
    }
    if(mactual+1440 < mfin+mluna)
    {
    pwmteorico=pwmluna;
    }
    //si en algun momento hemos dejado pwmteorico por encima de pwmmax deja pwm con el la constante que hemos dejado como pwmmax y si no con el que ha calculado
    if(pwmteorico>=pwmmax)
    {
    pwm = pwmmax;
    }
    else
    {
    pwm=pwmteorico;
    }
    float tluna=(hora*60)+minutos;

    if(mactual > mfin && mactual <= (mfin + mluna) && tluna >=0 )

    {
    // COMPRUEBA QUE SEA ENTRE EL FIN DEL ATARDECER Y ANTES DE LAS 00:00 Y ESCRIBE LA POTENCIA DE LA
    // LUNA SOLO EN EL CANAL 450, EL RESTO LO ESCRIBO A 0, ES DECIR APAGADO
    pwm=pwmluna;
    fase_dimeo = 0;
    analogWrite (canal_1,0); c1=0;
    analogWrite (canal_2,0); c2=0;
    analogWrite (canal_3,pwm); c3=1;
    analogWrite (canal_4,0); c4=0;
    analogWrite (canal_5,0); c5=0;
    analogWrite (canal_6,0); c6=0;
    // analogWrite (ledvioleta,0);
    // analogWrite (ledocw,0);
    }
    else if (tluna >=0 && tluna < minicio)

    {
    // COMPRUEBA QUE SEA PASADA LAS 00:00 Y ANTES DEL AMANECER Y ESCRIBE LA POTENCIA DE LA
    // LUNA SOLO EN EL CANAL 450, EL RESTO LO ESCRIBO A 0, ES DECIR APAGADO
    pwm=pwmluna;
    fase_dimeo = 1;
    analogWrite (canal_1,0); c1=0;
    analogWrite (canal_2,0); c2=0;
    analogWrite (canal_3,pwm); c3=1;
    analogWrite (canal_4,0); c4=0;
    analogWrite (canal_5,0); c5=0;
    analogWrite (canal_6,0); c6=0;
    // analogWrite (ledvioleta,0);
    // analogWrite (ledocw,0);
    }
    else
    { //SI NO SE CUMPLE LAS 2 SENTENCIAS ANTERIORES, EJECUTA ESTA Y ESCRIBE LA POTENCIA PWM EN TODOS LOS CANALES
    fase_dimeo = 2;
    analogWrite (canal_1,pwm); c1=1;
    analogWrite (canal_2,pwm); c2=1;
    analogWrite (canal_3,pwm); c3=1;
    analogWrite (canal_4,pwm); c4=1;
    analogWrite (canal_5,pwm); c5=1;
    analogWrite (canal_6,pwm); c6=1;
    //analogWrite (canal_1,pwm);
    //analogWrite (canal_1,pwm);
    }

    }





















    //***********************************************************************
    //***********************************************************************
    //***********************************************************************
    //***********************************************************************
    //*********** FUNCIONES QUE NO HAY QUE TOCAR **********************
    //***********************************************************************
    //***********************************************************************
    //***********************************************************************
    //***********************************************************************

    void escribir_lcd (int columna, int fila, char* dato)
    {
    lcd.setCursor(columna, fila); lcd.printstr(dato);
    }

    void escribir_lcd_parpadeo(int columna, int fila, char* dato,char* dato2, boolean todo)
    {
    if( intermitencia == 1)
    {
    lcd.setCursor(columna,fila); lcd.printstr(dato);
    }
    else
    if ( todo == 1 )
    lcd.clear();
    else
    {
    lcd.setCursor(columna,fila);
    lcd.printstr(dato2);
    }
    }
    void obtener_reloj()
    {
    DateTime now = RTC.now();
    hora = now.hour(),DEC; minutos = now.minute(),DEC; segundos = now.second(),DEC;
    itoa(hora,h,10); itoa(minutos,m,10); itoa(segundos,s,10);
    if(hora < 10) { h[1] = h[0]; h[0] = '0'; }
    if(minutos < 10) { m[1] = m[0]; m[0] = '0'; }
    if(segundos < 10) { s[1] = s[0]; s[0] = '0'; }
    reloj[0] = h[0]; reloj[1] = h[1]; reloj[2] = ':'; reloj[3] = m[0]; reloj[4] = m[1]; //reloj[5] = ':'; reloj[6] = s[0]; reloj[7] = s[1]; reloj[8] = '\n';
    }

    void escribir_temperatura_arduino()
    {
    if (TA > temperatura_max_arduino)
    {
    escribir_lcd_parpadeo(17,0,temperaturaA," ",0); escribir_lcd(19,0,"\337");
    }
    else
    {
    escribir_lcd(17,0,temperaturaA); escribir_lcd(19,0,"\337");
    }
    }

    /*void obtener_fecha() // Función para crear la hora
    {
    DateTime now = RTC.now();
    dia = now.day(),DEC; mes = now.month(),DEC; ano = now.year(),DEC;
    itoa(dia,d,10); itoa(mes,me,10); itoa(ano,n,10);
    if(dia < 10) { d[1] = d[0]; d[0] = '0'; }
    if(mes < 10) { me[1] = me[0]; me[0] = '0'; }
    if(ano < 10) { n[1] = n[0]; n[0] = '0'; }
    fecha[0] = d[0]; fecha[1] = d[1]; fecha[2] = ':'; fecha[3] = me[0]; fecha[4] = me[1]; fecha[5] = ':'; fecha[6] = n[0];
    fecha[7] = n[1]; fecha[8] = n[2]; fecha[9] = n[3];
    }
    */