Haz una pregunta
  Foros de Electrónica » Diseño digital » Microcontroladores y sistemas embebidos » Arduino y Raspberry Pi
Foros Registrarse ¿Olvidaste tu contraseña?

Temas similares

25/11/2015 #1


Interrupciones internas en Arduino


Hola y buenas, hace tiempo que estoy intentando hacer algo que alomejor les parecerá simple, pero me estoy empezando a liar mucho con la parte de la barra de progreso.
Ahora es explico lo de la barra de progreso y en que consiste todo.
En primer lugar contaros que lo que quiero hacer es lo siguiente:

Tengo una LCD y 5 pulsadores en la protoboard y el arduino ya conectados (los pines se ven en el codigo)
Una vez iniciado se muestra un mensage inicial y tras esto se pone una pantalla para configurar el tiempo
este tiempo se controla mediante 4 de los 5 botones: 2 para subir y bajar de 5 segundos en 5 segundos y los otros dos para subir y bajar un minuto, todo con su correspondiente control para que no meta numeros negativos, que cuando llegue a 55 seg +5 se sume un minuto, etc... Hasta aqui todo funciona perfectamente
Una vez configurado el tiempo con el ultimo boton mi intencion final es que se muestre una barra de progreso en funcion del tiempo seleccionado, con lo que haciendo una serie de calculos mi idea era poner un timer cada 62,5ms con lo que para todas las posibles combinaciones de tiempo introducidas por el usuario, me diera un numero entero de ticks en el timer con los que poder ir dibujando las barritas en el lcd.

Bueno, configurando las interrupciones y haciendo pruebas queria simplemente que cuando le diera al quinto boton comenzara a contar el timer a un ciclo de tiempo lento y que se me parase y volviera a la seleccion de tiempo al llegar a un numero de ticks X (en el ejemplo del codigo mostrado es 21). Pues bueno, esto no me sale, usando el cli(); el timer sigue contando y no vuelve a nada... he probado mil cosas y no se que hacer.
Os dejo el código a ver si podeis ayudarme, lo agradeceria mucho!!
un saludo

Código:
//------------------------------------------------------------------------
/*
*  Codigo de control para insoladora con lcd y programacion de tiempo
*  Autor: Gabriel Garcia Garrido
*  Fecha: Noviembre 2015
*/
//------------------------------------------------------------------------

// (Conexiones)
/*
* RS: pin 7
* EN: pin 8
* D4: pin 9
* D5: pin 10
* D6: pin 11
* D7: pin 12
*/

//incluir la libreria LiquidCrystal

#include <LiquidCrystal.h>
#include <avr/io.h>
#include <avr/interrupt.h>

LiquidCrystal lcd(7,8,9,10,11,12);

//Creacion de los caracteres para la cuenta atras

byte p20[8] = {
  B10000,
  B10000,
  B10000,
  B10000,
  B10000,
  B10000,
  B10000,
};
byte p40[8] = {
  B11000,
  B11000,
  B11000,
  B11000,
  B11000,
  B11000,
  B11000,
};
byte p60[8] = {
  B11100,
  B11100,
  B11100,
  B11100,
  B11100,
  B11100,
  B11100,
};
byte p80[8] = {
  B11110,
  B11110,
  B11110,
  B11110,
  B11110,
  B11110,
  B11110,
};
byte p100[8] = {
  B11111,
  B11111,
  B11111,
  B11111,
  B11111,
  B11111,
  B11111,
};
int SegProg=0;
int MinProg=0;
int SegProgAnt=0;
int MinProgAnt=0;
int estadoactual=0;
int estadoanterior=0;
int estadoactual1=0;
int estadoanterior1=0;
int estadoactual2=0;
int estadoanterior2=0;
int estadoactual3=0;
int estadoanterior3=0;
int estadoactual4=0;
int estadoanterior4=0;
int pulsador1=3;
int pulsador2=4;
int pulsador3=5;
int pulsador4=6;
int pulsador5=13;
int ticks=0;


void setup(){
  Serial.begin(9600);
  pinMode(pulsador1,INPUT);
  pinMode(pulsador2,INPUT);
  pinMode(pulsador3,INPUT);
  pinMode(pulsador4,INPUT);
  pinMode(pulsador5,INPUT);
  lcd.begin(16,2);
  MostrarMensageInicio();
  InterruptConfig();
  ImpIniSet();
}

void loop(){
  
  
  SeleccionDeTiempo();
  ImprSetTime();
  
  
  estadoactual4=digitalRead(pulsador5);
  if(estadoanterior4==LOW  &&  estadoactual4==HIGH){
    lcd.setCursor(0,0);
    lcd.print("                ");
    lcd.setCursor(0,1);
    lcd.print("                ");
    sei();
  }
  if(estadoanterior==HIGH  &&  estadoactual==LOW){
    estadoanterior=estadoactual;
    
  }
  
}

void MostrarMensageInicio(){
  lcd.setCursor(0,0);
  lcd.print(" Firmware v1.0  ");
  lcd.setCursor(0,1);
  lcd.print("  Starting up   ");
  delay(3000);
  lcd.setCursor(0,0);
  lcd.print("                ");
  lcd.setCursor(0,1);
  lcd.print("                ");
  
}


//-----------------------------funcion de configuracion de tiempo------------------------
void SeleccionDeTiempo(){
  
  //lectura del flanco del pulsador de seg ascendente
  
  estadoactual=digitalRead(pulsador1);
  if(estadoanterior==LOW  &&  estadoactual==HIGH){
    SegProg=SegProg+5;
    if(SegProg==60){
      SegProg=0;
      MinProg+=1;
    }
    lcd.print("                ");
    estadoanterior=estadoactual;
    Serial.print(MinProg);
    Serial.print(SegProg);
  }
  if(estadoanterior==HIGH  &&  estadoactual==LOW){
    estadoanterior=estadoactual;
  }
  
  //lectura del flanco del pulsador de seg descendente
  
  estadoactual1=digitalRead(pulsador2);
  if(estadoanterior1==LOW  &&  estadoactual1==HIGH){
    SegProg-=5;
     if(SegProg==-5){
      if(MinProg==0){
        SegProg=0;
        MinProg=0;
      }
      else{
        SegProg=55;
        MinProg-=1;
      }
    }
    lcd.print("                ");
    estadoanterior1=estadoactual1;
    Serial.print(MinProg);
    Serial.print(SegProg);
  }
  if(estadoanterior1==HIGH  &&  estadoactual1==LOW){
    estadoanterior1=estadoactual1;
  }
  
  //lectura del flanco del pulsador de min ascendente
  
  estadoactual2=digitalRead(pulsador3);
  if(estadoanterior2==LOW  &&  estadoactual2==HIGH){
    MinProg+=1;
    lcd.print("                ");
    estadoanterior2=estadoactual2;
    Serial.print(MinProg);
    Serial.print(SegProg);
  }
  if(estadoanterior2==HIGH  &&  estadoactual2==LOW){
    estadoanterior2=estadoactual2;
  }
  
  //lectura del flanco del pulsador de min descendente
  
  estadoactual3=digitalRead(pulsador4);
  if(estadoanterior3==LOW  &&  estadoactual3==HIGH){
    MinProg-=1;
    lcd.print("                ");
    estadoanterior3=estadoactual3;
    Serial.print(MinProg);
    Serial.print(SegProg);
  }
  if(estadoanterior3==HIGH  &&  estadoactual3==LOW){
    estadoanterior3=estadoactual3;
  }
 
  // Imposicion para tiempos negativos o mayor de 100 
  
  if (SegProg<0)
  {
    SegProg =0;
  }
  if (MinProg<0)
  {
    MinProg =0;
  }
  if(MinProg>99){
    MinProg=99;
  }
}

//-------------------- -Instrucciones de LCD- ----------------------------------
void ImpIniSet(){
  lcd.setCursor(0,0);
  lcd.print("   Set Time:    ");
  lcd.setCursor(0,1);
  lcd.print("     00:00      ");
}

void ImprSetTime(){
    if(MinProg!=MinProgAnt || SegProg!=SegProgAnt){
      lcd.setCursor(0,0);
      lcd.print("   Set Time:    ");
      lcd.setCursor(5,1);
      if(MinProg<10){
        lcd.print("0");
        lcd.print(MinProg);
        if(SegProg<10){
          lcd.print(":0");
          lcd.print(SegProg);
        }
        else{
          lcd.print(":");
          lcd.print(SegProg);
        }
      }
      else{
        lcd.print(MinProg);
        if(SegProg<10){
          lcd.print(":0");
          lcd.print(SegProg);
        }
        else{
          lcd.print(":");
          lcd.print(SegProg);
        }
      }
      MinProgAnt=MinProg;
      SegProgAnt=SegProg;
  }
}


//-------------------- -Instrucciones de interrupciones- -----------------------
void InterruptConfig(){  
  cli();
  TCCR1A=0;
  TCCR1B=0;
  
  // para lo s 62,5 ms OCR1A=975;
  OCR1A=15675;
  TCCR1B |= (1<<WGM12);
  
  TCCR1B |= (1<<CS10);
  TCCR1B |= (1<<CS12);
  
  TIMSK1=(1<<OCIE1A);
}

ISR(TIMER1_COMPA_vect){
  ticks++;
  Serial.print(ticks);
  if(ticks==21){
    ticks=0;
    cli();
  }
}
28/11/2015 #2


Bueno ya te respondí en el otro foro pero lo hago acá también para que no luzca como vacía la respuesta.
Obviamente he hecho algunos cambios basados en mis criterios.
Falta hacer funcionar los caracteres especiales del LCD para indicar progreso.
Vas a encontrar que yo definí un lcd 20x4 asi que corrige eso.
Para barra de progreso yo uso una librería que funciona perfecto. Si te interesa te paso el link.

Código:
//------------------------------------------------------------------------
/*
*  Codigo de control para insoladora con lcd y programacion de tiempo
*  Autor: Gabriel Garcia Garrido
*  Fecha: Noviembre 2015
*/
//------------------------------------------------------------------------

// (Conexiones)
/*
* RS: pin 7
* EN: pin 8
* D4: pin 9
* D5: pin 10
* D6: pin 11
* D7: pin 12
*/

//incluir la libreria LiquidCrystal

#include <LiquidCrystal.h>
#include <avr/io.h>
#include <avr/interrupt.h>

LiquidCrystal lcd(7,8,9,10,11,12);

//Creacion de los caracteres para la cuenta atras

byte p20[8] = {
  B10000,
  B10000,
  B10000,
  B10000,
  B10000,
  B10000,
  B10000,
};

byte p40[8] = {
  B11000,
  B11000,
  B11000,
  B11000,
  B11000,
  B11000,
  B11000,
};
byte p60[8] = {
  B11100,
  B11100,
  B11100,
  B11100,
  B11100,
  B11100,
  B11100,
};
byte p80[8] = {
  B11110,
  B11110,
  B11110,
  B11110,
  B11110,
  B11110,
  B11110,
};
byte p100[8] = {
  B11111,
  B11111,
  B11111,
  B11111,
  B11111,
  B11111,
  B11111,
};

int SegProg           =  0;
int MinProg           =  0;
volatile int Seg      =  0;
volatile int Min      =  0;

int SegProgAnt        =  0;
int MinProgAnt        =  0;
int estadoactual      =  0;
int estadoanterior    =  0;
int estadoactual1     =  0;
int estadoanterior1   =  0;
int estadoactual2     =  0;
int estadoanterior2   =  0;
int estadoactual3     =  0;
int estadoanterior3   =  0;
int estadoactual4     =  0;
int estadoanterior4   =  0;

const byte pulsador1  =  3;       // lectura del flanco del pulsador de seg ascendente
const byte pulsador2  =  4;       // lectura del flanco del pulsador de seg descendente
const byte pulsador3  =  5;       // lectura del flanco del pulsador de min ascendente
const byte pulsador4  =  6;       // lectura del flanco del pulsador de min descendente
const byte pulsador5  = 13;
volatile int ticks    =  0;
int ticksAnterior;
bool MuestroReloj     = false;

void setup(){
  Serial.begin(9600);
  pinMode(pulsador1,INPUT);
  pinMode(pulsador2,INPUT);
  pinMode(pulsador3,INPUT);
  pinMode(pulsador4,INPUT);
  pinMode(pulsador5,INPUT);
  lcd.begin(20,4);
  MostrarMensageInicio();
  InterruptConfig();
  ImpIniSet();
}

void loop(){
  char buffer[20];
  
  SeleccionDeTiempo();
  if (MuestroReloj)
     ImprSetTime(Min, Seg);
  else
     ImprSetTime(MinProg, SegProg);
  
  if (ticks != ticksAnterior) {
    Serial.print(ticks);

    // if (MuestroReloj) {
    //   sprintf(buffer," MinSeg = %02d:%02d", Min, Seg);
    //   Serial.println(buffer);    
    // }
    ticksAnterior = ticks;
  }
  
  estadoactual4 = digitalRead(pulsador5);
  
  if (estadoanterior4 == LOW && estadoactual4 == HIGH){
     lcd.setCursor(0,0);
     lcd.print("     Time:        ");
     lcd.setCursor(0,1);
     Min = MinProg;
     Seg = SegProg;
     MuestroReloj = true;
     Serial.println("Habilito Timer");
     sei();
  }
  estadoanterior4 = estadoactual4;  
  
}

void MostrarMensageInicio(){
  lcd.setCursor(0,0);
  lcd.print(" Firmware v1.0  ");
  lcd.setCursor(0,1);
  lcd.print("  Starting up   ");
  delay(300);
  lcd.setCursor(0,0);
  lcd.print("                ");
  lcd.setCursor(0,1);
  lcd.print("                "); 
}

void imprimeTiempo(int tmMin, int tmSeg) {
  char buffer[20];
    sprintf(buffer," %02d:%02d", tmMin, tmSeg);
    lcd.setCursor(5,1);
    lcd.print(buffer);
    Serial.println(buffer);
}

//----------------------------funcion de configuracion de tiempo-----------------------
void SeleccionDeTiempo(){
   
  //lectura del flanco del pulsador de seg ascendente
  
  estadoactual = digitalRead(pulsador1);
  if (estadoanterior == LOW  &&  estadoactual == HIGH){
     SegProg += 5;
     if (SegProg == 60){
        SegProg = 0;
        MinProg += 1;
     }
    //lcd.print("                ");
    imprimeTiempo(MinProg, SegProg);
  }
  estadoanterior = estadoactual;
  
  
  //lectura del flanco del pulsador de seg descendente
  
  estadoactual1 = digitalRead(pulsador2);
  if (estadoanterior1==LOW  &&  estadoactual1==HIGH){
     SegProg -= 5;
     if (SegProg == -5) {
        if (MinProg == 0){
           SegProg = 0;
           MinProg = 0;
        }
        else{
           SegProg = 55;
           MinProg -= 1;
        }
     }
     //lcd.print("                ");
    imprimeTiempo(MinProg, SegProg);
  }
  estadoanterior1 = estadoactual1;
  
  //lectura del flanco del pulsador de min ascendente
  
  estadoactual2 = digitalRead(pulsador3);
  if(estadoanterior2 == LOW  &&  estadoactual2==HIGH){
    MinProg += 1;
    imprimeTiempo(MinProg, SegProg);
  }
  estadoanterior2 = estadoactual2;

  //lectura del flanco del pulsador de min descendente
  
  estadoactual3 = digitalRead(pulsador4);
  if (estadoanterior3 == LOW  &&  estadoactual3==HIGH){
     MinProg -= 1;
     imprimeTiempo(MinProg, SegProg);
  }
  estadoanterior3 = estadoactual3;
 
  // Imposicion para tiempos negativos o mayor de 100 
  
  if (SegProg < 0)  {
    SegProg = 0;
  }
  if (MinProg < 0)  {
    MinProg = 0;
  }
  if (MinProg > 99) {
    MinProg = 99;
  }
}

//------------------ Instrucciones de LCD ----------------------------------
void ImpIniSet(){
  lcd.setCursor(0,0);
  lcd.print("   Set Time:    ");
  lcd.setCursor(6,1);
  lcd.print("00:00");
}

void ImprSetTime(int tmMin, int tmSeg){

    char buffer[20];
    sprintf(buffer," %02d:%02d", tmMin, tmSeg);

    if(tmMin!=MinProgAnt || tmSeg!=SegProgAnt){
      lcd.setCursor(0,0);
      if (MuestroReloj)
          lcd.print("     Time:      ");  
      else
          lcd.print("   Set Time:    ");
      lcd.setCursor(5,1);
      lcd.print(buffer);
      Serial.println(buffer);  
      MinProgAnt=tmMin;
      SegProgAnt=tmSeg;
    }
}


//-------------------- Instrucciones de interrupciones -----------------------
void InterruptConfig(){  
  cli();
  TCCR1A = 0;
  TCCR1B = 0;
  TCNT0  = 0; 
  
  // para lo s 62,5 ms OCR1A=975;
  OCR1A = 15624; // = (16*10^6) / (freq*1024) - 1 (must be <256)
  TCCR1B |= (1<<WGM12);
  
  TCCR1B |= (1<<CS10);
  TCCR1B |= (1<<CS12);  // Prescaler a 1024
  
  TIMSK1 = (1<<OCIE1A);
  //sei();
}


ISR(TIMER1_COMPA_vect){
  ticks++;
  //Serial.print(ticks);
  // 

  if(ticks==60){
     ticks=0;
  
  //   cli();
  }
  Seg -= 1;
  if (Seg < 0) {
     Seg = 59;
     Min -= 1;
  }
    
  if (Min == 0 && Seg == 0)
     cli();
}
29/11/2015 #3


jajajaja vale, la verdad que me gusta mas este, no se si lo habras leido en el otro pero he modificado mi codigo cambiando algunas cosas que vi del tuyo (Que por cierto muchas gracias por currartelo y ponerte a reescribir mi codigo y entenderlo) pero sigo sin conseguir deshanilitar las interrupcion. Probando el codigo que me pones hay varias cosas que no me funcionan, si le doy 4 veces a el boton que sea se queda pillado. luego quiero separar la cuenta atras de poder pulsar los botones de subir y bajar tiempo (Como ves he implementado algo asi en mi codigo nuevo)
Mi idea final es una vez introducido el tiempo, se pulsa el boton y comienza la barra de progreso sin opcion a subir o bajar el tiempo, para un futuro introducir un boton mas de calcelar.
El problema con mi nuevo codigo que te pongo aqui ahora esque el timer sigue contando y aun asi cuando llega a 21, no vuelve a la ventana de seleccion de tiempo

Código:
//------------------------------------------------------------------------
/*
*  Codigo de control para insoladora con lcd y programacion de tiempo
*  Autor: Gabriel Garcia Garrido
*  Fecha: Noviembre 2015
*/
//------------------------------------------------------------------------

// (Conexiones)
/*
* RS: pin 7
* EN: pin 8
* D4: pin 9
* D5: pin 10
* D6: pin 11
* D7: pin 12
* Pulsador 1: 3
* Pulsador 2: 4
* Pulsador 3: 5
* Pulsador 4: 6
* Pulsador 5: 13
*/

//incluir la libreria LiquidCrystal

#include <LiquidCrystal.h>
#include <avr/io.h>
#include <avr/interrupt.h>

//Creacion de los caracteres para la cuenta atras

byte p20[8] = {
  B10000,
  B10000,
  B10000,
  B10000,
  B10000,
  B10000,
  B10000,
};
byte p40[8] = {
  B11000,
  B11000,
  B11000,
  B11000,
  B11000,
  B11000,
  B11000,
};
byte p60[8] = {
  B11100,
  B11100,
  B11100,
  B11100,
  B11100,
  B11100,
  B11100,
};
byte p80[8] = {
  B11110,
  B11110,
  B11110,
  B11110,
  B11110,
  B11110,
  B11110,
};
byte p100[8] = {
  B11111,
  B11111,
  B11111,
  B11111,
  B11111,
  B11111,
  B11111,
};

// Declaracion de las variables


LiquidCrystal lcd(7,8,9,10,11,12);

const byte pulsador1           =   3;
const byte pulsador2           =   4;
const byte pulsador3           =   5;
const byte pulsador4           =   6;
const byte pulsador5           =  13;

volatile int SegProg    =   0;
volatile int MinProg    =   0;
volatile int SegProgAnt =   1;
volatile int MinProgAnt =   1;
int MIN                 =   0;
int SEG                 =   0;

int estadoactual        =   0;
int estadoanterior      =   0;
int estadoactual1       =   0;
int estadoanterior1     =   0;
int estadoactual2       =   0;
int estadoanterior2     =   0;
int estadoactual3       =   0;
int estadoanterior3     =   0;
int estadoactual4       =   0;
int estadoanterior4     =   0;

int ticks               =   0;
int ticksAnterior       =   0;

//-------------------------------SETUP-----------------------------------------
void setup(){
  
  //Se inicia el puerto serie
  Serial.begin(9600);
  
  //Configuracion de los pines de los pulsadores
  pinMode(pulsador1,INPUT);
  pinMode(pulsador2,INPUT);
  pinMode(pulsador3,INPUT);
  pinMode(pulsador4,INPUT);
  pinMode(pulsador5,INPUT);
  
  // de declara e inicia LCD
  lcd.begin(16,2);
  
  //Se configuran la interrupcion para la cuenta atras
  InterruptConfig();
  
  // Se muestra el mensage de inicio y la pantalla de seleccion de tiempo a 0
  MostrarMensageInicio();
  ImpIniSet();
}

//------------------------------------LOOP-----------------------------------
void loop(){
  
  SeleccionDeTiempo();  //control del tiempo con los 4 botones de seleccion
  ImprTime(SegProg,MinProg);        // imprime el tiempo configurado
  
  
  //Al pulsar el botol 5
  
  estadoactual4=digitalRead(pulsador5);
  if(estadoanterior4==LOW  &&  estadoactual4==HIGH){
    BorrarLcd();
    sei();
    while(ticks<=21){
      Serial.write(0x0d);
      Serial.println(ticks);
      if(ticks==21){
        cli();
        ticks=0;
      }
    }
    
    estadoanterior4=estadoactual4;
  }
  if(estadoanterior==HIGH  &&  estadoactual==LOW){
    estadoanterior=estadoactual; 
  }
  
}


//-----------------------------funcion de configuracion de tiempo------------------------
void SeleccionDeTiempo(){
  
  //lectura del flanco del pulsador de seg ascendente
  
  estadoactual=digitalRead(pulsador1);
  if(estadoanterior==LOW  &&  estadoactual==HIGH){
    SegProg=SegProg+5;
    if(SegProg==60){
      SegProg=0;
      MinProg+=1;
    }
    estadoanterior=estadoactual;
  }
  if(estadoanterior==HIGH  &&  estadoactual==LOW){
    estadoanterior=estadoactual;
  }
  
  //lectura del flanco del pulsador de seg descendente
  
  estadoactual1=digitalRead(pulsador2);
  if(estadoanterior1==LOW  &&  estadoactual1==HIGH){
    SegProg-=5;
     if(SegProg==-5){
      if(MinProg==0){
        SegProg=0;
        MinProg=0;
      }
      else{
        SegProg=55;
        MinProg-=1;
      }
    }
    estadoanterior1=estadoactual1;
  }
  if(estadoanterior1==HIGH  &&  estadoactual1==LOW){
    estadoanterior1=estadoactual1;
  }
  
  //lectura del flanco del pulsador de min ascendente
  
  estadoactual2=digitalRead(pulsador3);
  if(estadoanterior2==LOW  &&  estadoactual2==HIGH){
    MinProg+=1;
    lcd.print("                ");
    estadoanterior2=estadoactual2;
  }
  if(estadoanterior2==HIGH  &&  estadoactual2==LOW){
    estadoanterior2=estadoactual2;
  }
  
  //lectura del flanco del pulsador de min descendente
  
  estadoactual3=digitalRead(pulsador4);
  if(estadoanterior3==LOW  &&  estadoactual3==HIGH){
    MinProg-=1;
    estadoanterior3=estadoactual3;
  }
  if(estadoanterior3==HIGH  &&  estadoactual3==LOW){
    estadoanterior3=estadoactual3;
  }
 
  // Imposicion para tiempos negativos o mayor de 100 
  
  if (SegProg<0)
  {
    SegProg =0;
  }
  if (MinProg<0)
  {
    MinProg =0;
  }
  if(MinProg>99){
    MinProg=99;
  }
}

//-------------------- -Instrucciones de LCD- ----------------------------------

//Muestra un mensage de inicio
void MostrarMensageInicio(){
  
  //Muestra la version y un mensage de inicializacion
  lcd.setCursor(0,0);
  lcd.print(" Firmware v1.0  ");
  lcd.setCursor(0,1);
  lcd.print("  Starting up   ");
  
  //Espera 3 segundos para poder leer la version
  delay(300000);
  BorrarLcd();
  Serial.print("Mensage de incio mostrado");
}

//Borra la LCD
void BorrarLcd(){
  
  lcd.setCursor(0,0);
  lcd.print("                ");
  lcd.setCursor(0,1);
  lcd.print("                ");  
}

//Imprime la cabecera para la seleccion del tiempo al inicio del programa
void ImpIniSet(){
  //Se coloca el cursor a 0 y se imrpime la cabecera
  lcd.setCursor(0,0);
  lcd.print("   Set Time:    ");
}

//Imprime en el LCD el valor enviado y compara con un valor anterior
void ImprTime(int SegProglcd, int MinProglcd){
  
  //Se declara una cadena de 16 para escribir el tiempo a imprimir
  char buffer[16];
  
  //Se guarda en dicha cadena el tiempo a imprimir con dos digitos
  sprintf(buffer,"%02d:%02d",MinProglcd,SegProglcd);
  
  //Si el tiempo ha cambiado (para no imprimri siempre ya que no se veria por el refresco)
    if(MinProglcd != MinProgAnt || SegProglcd != SegProgAnt){
      
      //Se mueve el cursor del lcd a el tiempo e imprimo el buffer
      lcd.setCursor(5,1);
      lcd.print(buffer);
      //Se actualizan los valores de anterior a actual
      MinProgAnt=MinProglcd;
      SegProgAnt=SegProglcd;
    }      
}


//-------------------- -Instrucciones de interrupciones- -----------------------
void InterruptConfig(){  
  
  cli();
  TCCR1A=0;
  TCCR1B=0;
  
  // para lo s 62,5 ms OCR1A=975;
  OCR1A=15675;
  TCCR1B |= (1<<WGM12);
  
  TCCR1B |= (1<<CS10);
  TCCR1B |= (1<<CS12);
  
  TIMSK1=(1<<OCIE1A);
}

ISR(TIMER1_COMPA_vect){
  ticks++;
}
Un saludo
PD: por ahora no quiero que me imprima en el lcd la cuenta atras, solo conseguir llegar a 21 ticks, que se paren las interrupciones, y volver a la pantalla de seleccion de tiempo. Primero esto y luego ya lo complicare intentando insertarle la barra
29/11/2015 #4


Esta versión corrige los defectos que señalaste. Falta el tema de la barra que te lo dejo a vos.
Buen ejercicio para fijar conococimientos con el uso del timer.

//------------------------------------------------------------------------
/*
* Codigo de control para insoladora con lcd y programacion de tiempo
* Autor: Gabriel Garcia Garrido
* Fecha: Noviembre 2015
*/
//------------------------------------------------------------------------

// (Conexiones)
/*
* RS: pin 7
* EN: pin 8
* D4: pin 9
* D5: pin 10
* D6: pin 11
* D7: pin 12
*/

//incluir la libreria LiquidCrystal

Código:
#include <LiquidCrystal.h>
#include <avr/io.h>
#include <avr/interrupt.h>

LiquidCrystal lcd(7,8,9,10,11,12);

//Creacion de los caracteres para la cuenta atras

byte p20[8] = {
  B10000,
  B10000,
  B10000,
  B10000,
  B10000,
  B10000,
  B10000,
};

byte p40[8] = {
  B11000,
  B11000,
  B11000,
  B11000,
  B11000,
  B11000,
  B11000,
};
byte p60[8] = {
  B11100,
  B11100,
  B11100,
  B11100,
  B11100,
  B11100,
  B11100,
};
byte p80[8] = {
  B11110,
  B11110,
  B11110,
  B11110,
  B11110,
  B11110,
  B11110,
};
byte p100[8] = {
  B11111,
  B11111,
  B11111,
  B11111,
  B11111,
  B11111,
  B11111,
};

int SegProg           =  0;
int MinProg           =  0;
volatile int Seg      =  0;
volatile int Min      =  0;

int SegProgAnt        =  0;
int MinProgAnt        =  0;
int estadoactual      =  0;
int estadoanterior    =  0;
int estadoactual1     =  0;
int estadoanterior1   =  0;
int estadoactual2     =  0;
int estadoanterior2   =  0;
int estadoactual3     =  0;
int estadoanterior3   =  0;
int estadoactual4     =  0;
int estadoanterior4   =  0;

const byte pulsador1  =  3;       // lectura del flanco del pulsador de seg ascendente
const byte pulsador2  =  4;       // lectura del flanco del pulsador de seg descendente
const byte pulsador3  =  5;       // lectura del flanco del pulsador de min ascendente
const byte pulsador4  =  6;       // lectura del flanco del pulsador de min descendente
const byte pulsador5  = 13;
volatile int ticks    =  0;
int ticksAnterior;
bool MuestroReloj     = false;
volatile bool StartStop = false;
bool StartStopAnt = true;

void setup(){
  Serial.begin(9600);
  pinMode(pulsador1,INPUT);
  pinMode(pulsador2,INPUT);
  pinMode(pulsador3,INPUT);
  pinMode(pulsador4,INPUT);
  pinMode(pulsador5,INPUT);
  lcd.begin(20,4);
  MostrarMensageInicio();
  InterruptConfig();
  ImpIniSet();
}

void loop(){
  char buffer[30];
  
  SeleccionDeTiempo();
  if (MuestroReloj)
     ImprSetTime(Min, Seg);
  else
     ImprSetTime(MinProg, SegProg);
  
  if (ticks != ticksAnterior) {
    sprintf(buffer, "Tick = %d", ticks);
    Serial.println(buffer);

    // if (MuestroReloj) {
    //   sprintf(buffer," MinSeg = %02d:%02d", Min, Seg);
    //   Serial.println(buffer);    
    // }
    ticksAnterior = ticks;
  }
  
  if (StartStop != StartStopAnt) {
      sprintf(buffer, "%s", StartStop?"Start":"Stop");
      Serial.println(buffer);
  }
  StartStopAnt = StartStop;
  estadoactual4 = digitalRead(pulsador5);
  
  if (estadoanterior4 == LOW && estadoactual4 == HIGH){
     lcd.setCursor(0,0);
     lcd.print("     Time:        ");
     lcd.setCursor(0,1);
     Min = MinProg;
     Seg = SegProg;
     MuestroReloj = true;
     StartStop = true;
     sprintf(buffer, "Habilito timer Min=%02d Seg=%02d", Min, Seg);
     Serial.println(buffer);
     sei();
  }
  estadoanterior4 = estadoactual4;  
  
}

void MostrarMensageInicio(){
  lcd.setCursor(0,0);
  lcd.print(" Firmware v1.0  ");
  lcd.setCursor(0,1);
  lcd.print("  Starting up   ");
  delay(300);
  lcd.setCursor(0,0);
  lcd.print("                ");
  lcd.setCursor(0,1);
  lcd.print("                "); 
}

void imprimeTiempo(int tmMin, int tmSeg) {
  char buffer[20];
    sprintf(buffer," %02d:%02d", tmMin, tmSeg);
    lcd.setCursor(5,1);
    lcd.print(buffer);
    Serial.println(buffer);
}

//----------------------------funcion de configuracion de tiempo-----------------------
void SeleccionDeTiempo(){
   
  //lectura del flanco del pulsador de seg ascendente
  
  estadoactual = digitalRead(pulsador1);
  if (estadoanterior == LOW  &&  estadoactual == HIGH){
     SegProg += 5;
     if (SegProg == 60){
        SegProg = 0;
        MinProg += 1;
     }
    //lcd.print("                ");
    imprimeTiempo(MinProg, SegProg);
  }
  estadoanterior = estadoactual;
  
  
  //lectura del flanco del pulsador de seg descendente
  
  estadoactual1 = digitalRead(pulsador2);
  if (estadoanterior1==LOW  &&  estadoactual1==HIGH){
     SegProg -= 5;
     if (SegProg == -5) {
        if (MinProg == 0){
           SegProg = 0;
           MinProg = 0;
        }
        else{
           SegProg = 55;
           MinProg -= 1;
        }
     }
     //lcd.print("                ");
    imprimeTiempo(MinProg, SegProg);
  }
  estadoanterior1 = estadoactual1;
  
  //lectura del flanco del pulsador de min ascendente
  
  estadoactual2 = digitalRead(pulsador3);
  if(estadoanterior2 == LOW  &&  estadoactual2==HIGH){
    MinProg += 1;
    imprimeTiempo(MinProg, SegProg);
  }
  estadoanterior2 = estadoactual2;

  //lectura del flanco del pulsador de min descendente
  
  estadoactual3 = digitalRead(pulsador4);
  if (estadoanterior3 == LOW  &&  estadoactual3==HIGH){
     MinProg -= 1;
     imprimeTiempo(MinProg, SegProg);
  }
  estadoanterior3 = estadoactual3;
 
  // Imposicion para tiempos negativos o mayor de 100 
  
  if (SegProg < 0)  {
    SegProg = 0;
  }
  if (MinProg < 0)  {
    MinProg = 0;
  }
  if (MinProg > 99) {
    MinProg = 99;
  }
}

//------------------ Instrucciones de LCD ----------------------------------
void ImpIniSet(){
  lcd.setCursor(0,0);
  lcd.print("   Set Time:    ");
  lcd.setCursor(6,1);
  lcd.print("00:00");
}

void ImprSetTime(int tmMin, int tmSeg){

    char buffer[20];
    sprintf(buffer," %02d:%02d", tmMin, tmSeg);

    if(tmMin!=MinProgAnt || tmSeg!=SegProgAnt){
      lcd.setCursor(0,0);
      if (MuestroReloj)
          lcd.print("     Time:      ");  
      else
          lcd.print("   Set Time:    ");
      lcd.setCursor(5,1);
      lcd.print(buffer);
      Serial.println(buffer);  
      MinProgAnt=tmMin;
      SegProgAnt=tmSeg;
    }
}


//-------------------- Instrucciones de interrupciones -----------------------
void InterruptConfig(){  
  cli();
  TCCR1A = 0;
  TCCR1B = 0;
  TCNT0  = 0; 
  
  // para lo s 62,5 ms OCR1A=975;
  OCR1A = 15624; // = (16*10^6) / (freq*1024) - 1 (must be <256)
  TCCR1B |= (1<<WGM12);
  
  TCCR1B |= (1<<CS10);
  TCCR1B |= (1<<CS12);  // Prescaler a 1024
  
  TIMSK1 = (1<<OCIE1A);
  //sei();
}


ISR(TIMER1_COMPA_vect){
  ticks++;

  if(ticks==60){
     ticks=0;
  
  //   cli();
  }
  Seg -= 1;
  if (Seg < 0) {
     Seg = 59;
     Min -= 1;
  }
    
  if (Min < 0) {
     Min = 0;
     Seg = 0;
     cli();          // disable global interrupts
     TCCR1A = 0;     // set entire TCCR1A register to 0
     TCCR1B = 0;     // same for TCCR1B
     StartStop = false;
  }
    
}
29/11/2015 #5


Hola buenas, me sigue ocurriendo que una vez que pulsas 4 veces cualquier botón se queda bloqueado , y cuando le doy al boton de cuanta atras me imprime en la lcd time: y el tiempo, pero no hace la cuenta atras ,ademas no se por que no me funciona el puerto serie :S. Me estoy volviendo un poco loco y alomejor te estoy volviendo loco a ti :S.
29/11/2015 #6

Avatar de Dan2013

Cuales son esas librerias ademas de LiquidCrystal.h???

Quisiera saber porque no soy muy experto en arduino. Saludos.
29/11/2015 #7


son para el control de LCDs
He corregido cosas del codigo y ahora al fiNNNN!!! consigo que haga la cuenta atras (indicandomelo por el puerto serie) y me vuelva a la pantalla de seleccion de tiempo en 0 una vez terminada esta cuenta atras. El problema esque cuando le da la gana me vuelve a la ventana de seleccion de tiempo y otras veces me llena el lcd de caracteres raros. :S
Código:
//------------------------------------------------------------------------
/*
*  Codigo de control para insoladora con lcd y programacion de tiempo
*  Autor: Gabriel Garcia Garrido
*  Fecha: Noviembre 2015
*/
//------------------------------------------------------------------------

// (Conexiones)
/*
* RS: pin 7
* EN: pin 8
* D4: pin 9
* D5: pin 10
* D6: pin 11
* D7: pin 12
* Pulsador 1: 3
* Pulsador 2: 4
* Pulsador 3: 5
* Pulsador 4: 6
* Pulsador 5: 13
*/

//incluir la libreria LiquidCrystal

#include <LiquidCrystal.h>
#include <avr/io.h>
#include <avr/interrupt.h>

//Creacion de los caracteres para la cuenta atras

byte p20[8] = {
  B10000,
  B10000,
  B10000,
  B10000,
  B10000,
  B10000,
  B10000,
};
byte p40[8] = {
  B11000,
  B11000,
  B11000,
  B11000,
  B11000,
  B11000,
  B11000,
};
byte p60[8] = {
  B11100,
  B11100,
  B11100,
  B11100,
  B11100,
  B11100,
  B11100,
};
byte p80[8] = {
  B11110,
  B11110,
  B11110,
  B11110,
  B11110,
  B11110,
  B11110,
};
byte p100[8] = {
  B11111,
  B11111,
  B11111,
  B11111,
  B11111,
  B11111,
  B11111,
};

// Declaracion de las variables


LiquidCrystal lcd(7,8,9,10,11,12);

const byte pulsador1           =   3;
const byte pulsador2           =   4;
const byte pulsador3           =   5;
const byte pulsador4           =   6;
const byte pulsador5           =  13;

volatile int SegProg    =   0;
volatile int MinProg    =   0;
volatile int SegProgAnt =   1;
volatile int MinProgAnt =   1;
int MIN                 =   0;
int SEG                 =   0;

int estadoactual        =   0;
int estadoanterior      =   0;
int estadoactual1       =   0;
int estadoanterior1     =   0;
int estadoactual2       =   0;
int estadoanterior2     =   0;
int estadoactual3       =   0;
int estadoanterior3     =   0;
int estadoactual4       =   0;
int estadoanterior4     =   0;

volatile int ticks               =   0;
volatile int ticksAnterior       =   0;
volatile int tickscopia          =   0;

//-------------------------------SETUP-----------------------------------------
void setup(){
  
  //Se inicia el puerto serie
  Serial.begin(9600);
  
  //Configuracion de los pines de los pulsadores
  pinMode(pulsador1,INPUT);
  pinMode(pulsador2,INPUT);
  pinMode(pulsador3,INPUT);
  pinMode(pulsador4,INPUT);
  pinMode(pulsador5,INPUT);
  
  // de declara e inicia LCD
  lcd.begin(16,2);
  
  //Se configuran la interrupcion para la cuenta atras
  InterruptConfig();
  
  // Se muestra el mensage de inicio y la pantalla de seleccion de tiempo a 0
  MostrarMensageInicio();
  ImpIniSet();
}

//------------------------------------LOOP-----------------------------------
void loop(){
  
  ImprTime(SegProg,MinProg);        // imprime el tiempo configurado
  SeleccionDeTiempo();  //control del tiempo con los 4 botones de seleccion

  
  
  //Al pulsar el botol 5
  
  estadoactual4=digitalRead(pulsador5);
  if(estadoanterior4==LOW  &&  estadoactual4==HIGH){
    BorrarLcd();
    sei();
    while(ticks<=10){
      if(ticksAnterior!=ticks){
        Serial.println(ticks);
        ticksAnterior=ticks;
      }
    }
    cli();
    MinProg=0;
    SegProg=0;
    SegProgAnt=1;
    MinProgAnt=1;
    ticks=0;
    estadoanterior4=estadoactual4;
  }
  if(estadoanterior4==HIGH  &&  estadoactual4==LOW){
    estadoanterior4=estadoactual4; 
  }
  
}


//-----------------------------funcion de configuracion de tiempo------------------------
void SeleccionDeTiempo(){
  
  //lectura del flanco del pulsador de seg ascendente
  
  estadoactual=digitalRead(pulsador1);
  if(estadoanterior==LOW  &&  estadoactual==HIGH){
    SegProg=SegProg+5;
    if(SegProg==60){
      SegProg=0;
      MinProg+=1;
    }
    estadoanterior=estadoactual;
  }
  if(estadoanterior==HIGH  &&  estadoactual==LOW){
    estadoanterior=estadoactual;
  }
  
  //lectura del flanco del pulsador de seg descendente
  
  estadoactual1=digitalRead(pulsador2);
  if(estadoanterior1==LOW  &&  estadoactual1==HIGH){
    SegProg-=5;
     if(SegProg==-5){
      if(MinProg==0){
        SegProg=0;
        MinProg=0;
      }
      else{
        SegProg=55;
        MinProg-=1;
      }
    }
    estadoanterior1=estadoactual1;
  }
  if(estadoanterior1==HIGH  &&  estadoactual1==LOW){
    estadoanterior1=estadoactual1;
  }
  
  //lectura del flanco del pulsador de min ascendente
  
  estadoactual2=digitalRead(pulsador3);
  if(estadoanterior2==LOW  &&  estadoactual2==HIGH){
    MinProg+=1;
    estadoanterior2=estadoactual2;
  }
  if(estadoanterior2==HIGH  &&  estadoactual2==LOW){
    estadoanterior2=estadoactual2;
  }
  
  //lectura del flanco del pulsador de min descendente
  
  estadoactual3=digitalRead(pulsador4);
  if(estadoanterior3==LOW  &&  estadoactual3==HIGH){
    MinProg-=1;
    estadoanterior3=estadoactual3;
  }
  if(estadoanterior3==HIGH  &&  estadoactual3==LOW){
    estadoanterior3=estadoactual3;
  }
 
  // Imposicion para tiempos negativos o mayor de 100 
  
  if (SegProg<0)
  {
    SegProg =0;
  }
  if (MinProg<0)
  {
    MinProg =0;
  }
  if(MinProg>99){
    MinProg=99;
  }
}

//-------------------- -Instrucciones de LCD- ----------------------------------

//Muestra un mensage de inicio
void MostrarMensageInicio(){
  
  //Muestra la version y un mensage de inicializacion
  lcd.setCursor(0,0);
  lcd.print(" Firmware v1.0  ");
  lcd.setCursor(0,1);
  lcd.print("  Starting up   ");
  
  //Espera 3 segundos para poder leer la version
  delay(300000);
  BorrarLcd();
}

//Borra la LCD
void BorrarLcd(){
  
  lcd.setCursor(0,0);
  lcd.print("                ");
  lcd.setCursor(0,1);
  lcd.print("                ");  
}
void BorrarInf(){
  
  lcd.setCursor(0,1);
  lcd.print("                ");  
}

void BorrarSup(){
  
  lcd.setCursor(0,0);
  lcd.print("                ");  
}

//Imprime la cabecera para la seleccion del tiempo al inicio del programa
void ImpIniSet(){
  //Se coloca el cursor a 0 y se imrpime la cabecera
  BorrarSup();
  lcd.setCursor(0,0);
  lcd.print("   Set Time:    ");
}

//Imprime en el LCD el valor enviado y compara con un valor anterior
void ImprTime(int SegProglcd, int MinProglcd){
  
  //Se declara una cadena de 16 para escribir el tiempo a imprimir
  char buff[16];
  
  //Se guarda en dicha cadena el tiempo a imprimir con dos digitos
  sprintf(buff,"%02d:%02d",MinProglcd,SegProglcd);
  
  //Si el tiempo ha cambiado (para no imprimri siempre ya que no se veria por el refresco)
    if(MinProglcd != MinProgAnt || SegProglcd != SegProgAnt){
      
      //Se mueve el cursor del lcd a el tiempo e imprimo el buffer
      BorrarLcd();
      ImpIniSet();
      lcd.setCursor(5,1);
      lcd.print(buff);
      //Se actualizan los valores de anterior a actual
      MinProgAnt=MinProglcd;
      SegProgAnt=SegProglcd;
    }      
}


//-------------------- -Instrucciones de interrupciones- -----------------------
void InterruptConfig(){  
  
  cli();
  TCCR1A=0;
  TCCR1B=0;
  
  // para lo s 62,5 ms OCR1A=975;
  OCR1A=10000;
  TCCR1B |= (1<<WGM12);
  
  TCCR1B |= (1<<CS10);
  TCCR1B |= (1<<CS12);
  
  TIMSK1=(1<<OCIE1A);
}

ISR(TIMER1_COMPA_vect){
  ticks++;
}
30/11/2015 #8


Pero volviste a usar tu código original!! con algunos cambios.
El que te pase funciona perfecto.
30/11/2015 #9


SURbyte dijo: Ver Mensaje
Pero volviste a usar tu código original!! con algunos cambios.
El que te pase funciona perfecto.
No me funcionaba bien, creo que puse arriba el por que, asi que cogiendo cosas de tu codigo y el mio hice este

con el código del ultimo post me contaba bn y se me paraba el timer, lo unico esque cuando terminaba de contar y volvía a la pantalla de la seleccion de tiempo, aveces se le iba la pinza y me escribia en el LCD caracteres raros. Intentando hacer ya la barra de prograso aun con este fallo escribir este código que ni siquiera funciona y se queda todo el rato en la pantalla anterior. No me sale nada :(
Código:
//------------------------------------------------------------------------
/*
*  Codigo de control para insoladora con lcd y programacion de tiempo
*  Autor: Gabriel Garcia Garrido
*  Fecha: Noviembre 2015
*/
//------------------------------------------------------------------------

// (Conexiones)
/*
* RS: pin 7
* EN: pin 8
* D4: pin 9
* D5: pin 10
* D6: pin 11
* D7: pin 12
* Pulsador 1: 3
* Pulsador 2: 4
* Pulsador 3: 5
* Pulsador 4: 6
* Pulsador 5: 13
*/

//incluir la libreria LiquidCrystal

#include <LiquidCrystal.h>
#include <avr/io.h>
#include <avr/interrupt.h>

//Creacion de los caracteres para la cuenta atras

byte p20[8] = {
  B10000,
  B10000,
  B10000,
  B10000,
  B10000,
  B10000,
  B10000,
};
byte p40[8] = {
  B11000,
  B11000,
  B11000,
  B11000,
  B11000,
  B11000,
  B11000,
};
byte p60[8] = {
  B11100,
  B11100,
  B11100,
  B11100,
  B11100,
  B11100,
  B11100,
};
byte p80[8] = {
  B11110,
  B11110,
  B11110,
  B11110,
  B11110,
  B11110,
  B11110,
};
byte p100[8] = {
  B11111,
  B11111,
  B11111,
  B11111,
  B11111,
  B11111,
  B11111,
};

// Declaracion de las variables


LiquidCrystal lcd(7,8,9,10,11,12);

const byte pulsador1           =   3;
const byte pulsador2           =   4;
const byte pulsador3           =   5;
const byte pulsador4           =   6;
const byte pulsador5           =   13;

volatile int SegProg    =   0;
volatile int MinProg    =   0;
volatile int SegProgAnt =   1;
volatile int MinProgAnt =   1;

int estadoactual        =   0;
int estadoanterior      =   0;
int estadoactual1       =   0;
int estadoanterior1     =   0;
int estadoactual2       =   0;
int estadoanterior2     =   0;
int estadoactual3       =   0;
int estadoanterior3     =   0;
int estadoactual4       =   0;
int estadoanterior4     =   0;

volatile int ticks               =   0;
volatile int ticksAnterior       =   0;
volatile int tickscopia          =   0;
volatile int CalculoTicks        =   0;
volatile int ConteoBarras        =   0;
volatile int ConteoBarrasAnterior=   0;

volatile int i=0;
volatile int j=0;


//-------------------------------SETUP-----------------------------------------
void setup(){
  
  //Se inicia el puerto serie
  Serial.begin(9600);
  
  //Configuracion de los pines de los pulsadores
  pinMode(pulsador1,INPUT);
  pinMode(pulsador2,INPUT);
  pinMode(pulsador3,INPUT);
  pinMode(pulsador4,INPUT);
  pinMode(pulsador5,INPUT);
  
  // de declara e inicia LCD
  lcd.begin(16,2);
  lcd.createChar(0,p20);
  lcd.createChar(1,p40);
  lcd.createChar(2,p60);
  lcd.createChar(3,p80);
  lcd.createChar(4,p100);
  
  //Se configuran la interrupcion para la cuenta atras
  InterruptConfig();
  
  // Se muestra el mensage de inicio y la pantalla de seleccion de tiempo a 0
  MostrarMensageInicio();
  ImpIniSet();
}

//------------------------------------LOOP-----------------------------------
void loop(){
  
  ImprTime(SegProg,MinProg);        // imprime el tiempo configurado
  SeleccionDeTiempo();  //control del tiempo con los 4 botones de seleccion

  
  
  //Al pulsar el botol 5
  
  estadoactual4=digitalRead(pulsador5);
  if(estadoanterior4==LOW  &&  estadoactual4==HIGH){
    lcd.clear();
    lcd.setCursor(0,0);
    lcd.print("   Insolating   ");
    ActualizaCalculoTicks();
    sei();
    lcd.setCursor(0,1);
    while(ConteoBarras<=80){
      if(ConteoBarrasAnterior!=ConteoBarras){
        ConteoBarrasAnterior=ConteoBarras;
        Serial.println(ConteoBarrasAnterior);
        lcd.setCursor(i,1);
        lcd.write(j);
        j++;
        if(j>5){
          i++;
          j=0;
        }
      }
    }
    
    cli();
    ticks=0;
    
    MinProg=0;
    SegProg=0;
    SegProgAnt=1;
    MinProgAnt=1;
    ConteoBarrasAnterior=0;
    ConteoBarras=0;
    i=0;
    j=0;
    
    estadoanterior4=estadoactual4;
    lcd.clear();
  }
  if(estadoanterior4==HIGH  &&  estadoactual4==LOW){
    estadoanterior4=estadoactual4; 
  }
  
}


//-----------------------------funcion de configuracion de tiempo------------------------
void SeleccionDeTiempo(){
  
  //lectura del flanco del pulsador de seg ascendente
  
  estadoactual=digitalRead(pulsador1);
  if(estadoanterior==LOW  &&  estadoactual==HIGH){
    SegProg=SegProg+5;
    if(SegProg==60){
      SegProg=0;
      MinProg+=1;
    }
    estadoanterior=estadoactual;
  }
  if(estadoanterior==HIGH  &&  estadoactual==LOW){
    estadoanterior=estadoactual;
  }
  
  //lectura del flanco del pulsador de seg descendente
  
  estadoactual1=digitalRead(pulsador2);
  if(estadoanterior1==LOW  &&  estadoactual1==HIGH){
    SegProg-=5;
     if(SegProg==-5){
      if(MinProg==0){
        SegProg=0;
        MinProg=0;
      }
      else{
        SegProg=55;
        MinProg-=1;
      }
    }
    estadoanterior1=estadoactual1;
  }
  if(estadoanterior1==HIGH  &&  estadoactual1==LOW){
    estadoanterior1=estadoactual1;
  }
  
  //lectura del flanco del pulsador de min ascendente
  
  estadoactual2=digitalRead(pulsador3);
  if(estadoanterior2==LOW  &&  estadoactual2==HIGH){
    MinProg+=1;
    estadoanterior2=estadoactual2;
  }
  if(estadoanterior2==HIGH  &&  estadoactual2==LOW){
    estadoanterior2=estadoactual2;
  }
  
  //lectura del flanco del pulsador de min descendente
  
  estadoactual3=digitalRead(pulsador4);
  if(estadoanterior3==LOW  &&  estadoactual3==HIGH){
    MinProg-=1;
    estadoanterior3=estadoactual3;
  }
  if(estadoanterior3==HIGH  &&  estadoactual3==LOW){
    estadoanterior3=estadoactual3;
  }
 
  // Imposicion para tiempos negativos o mayor de 100 
  
  if (SegProg<0)
  {
    SegProg =0;
  }
  if (MinProg<0)
  {
    MinProg =0;
  }
  if(MinProg>99){
    MinProg=99;
  }
}

//-------------------- -Instrucciones de LCD- ----------------------------------

//Muestra un mensage de inicio
void MostrarMensageInicio(){
  
  //Muestra la version y un mensage de inicializacion
  lcd.setCursor(0,0);
  lcd.print(" Firmware v1.0  ");
  lcd.setCursor(0,1);
  lcd.print("  Starting up   ");
  
  //Espera 3 segundos para poder leer la version
  delay(100000);
  lcd.clear();
}

//Borra la LCD


//Imprime la cabecera para la seleccion del tiempo al inicio del programa
void ImpIniSet(){
  //Se coloca el cursor a 0 y se imrpime la cabecera
  lcd.clear();
  lcd.print("    Set Time    ");
}


//Imprime en el LCD el valor enviado y compara con un valor anterior
void ImprTime(int SegProglcd, int MinProglcd){
  
  //Se declara una cadena de 16 para escribir el tiempo a imprimir
  char buff[16];
  
  //Se guarda en dicha cadena el tiempo a imprimir con dos digitos
  sprintf(buff,"%02d:%02d",MinProglcd,SegProglcd);
  
  //Si el tiempo ha cambiado (para no imprimri siempre ya que no se veria por el refresco)
    if(MinProglcd != MinProgAnt || SegProglcd != SegProgAnt){
      
      //Se mueve el cursor del lcd a el tiempo e imprimo el buffer
      ImpIniSet();
      lcd.setCursor(5,1);
      lcd.print(buff);
   
      //Se actualizan los valores de anterior a actual
      MinProgAnt=MinProglcd;
      SegProgAnt=SegProglcd;
    }   
}


//-------------------- -Instrucciones de interrupciones- -----------------------
void InterruptConfig(){  
  
  cli();
  TCCR1A=0;
  TCCR1B=0;
  
  // para lo s 62,5 ms OCR1A=975;
  OCR1A=975;
  TCCR1B |= (1<<WGM12);
  
  TCCR1B |= (1<<CS10);
  TCCR1B |= (1<<CS12);
  
  TIMSK1=(1<<OCIE1A);
}

ISR(TIMER1_COMPA_vect){
  ticks++;
  if(ticks==CalculoTicks){
     ticks=0;
     ConteoBarras++; 
  }
}
//-------------------------------------------------------------
void ActualizaCalculoTicks()
{
 CalculoTicks = (((MinProg*60)+SegProg)*10000)/(80*625); 
}
---------- Actualizado después de 15 minutos ----------

bueno he corregido unas cosillas que no me di cuenta como que nunca entraba en el if por que contador y contador anterior empezaban a 0
ya con los cambios que hize sigue volviendose loca la lcd cuando presiono el boton para comenzar la cuenta con la barra
Código:
//------------------------------------------------------------------------
/*
*  Codigo de control para insoladora con lcd y programacion de tiempo
*  Autor: Gabriel Garcia Garrido
*  Fecha: Noviembre 2015
*/
//------------------------------------------------------------------------

// (Conexiones)
/*
* RS: pin 7
* EN: pin 8
* D4: pin 9
* D5: pin 10
* D6: pin 11
* D7: pin 12
* Pulsador 1: 3
* Pulsador 2: 4
* Pulsador 3: 5
* Pulsador 4: 6
* Pulsador 5: 13
*/

//incluir la libreria LiquidCrystal

#include <LiquidCrystal.h>
#include <avr/io.h>
#include <avr/interrupt.h>

//Creacion de los caracteres para la cuenta atras

byte p20[8] = {
  B10000,
  B10000,
  B10000,
  B10000,
  B10000,
  B10000,
  B10000,
};
byte p40[8] = {
  B11000,
  B11000,
  B11000,
  B11000,
  B11000,
  B11000,
  B11000,
};
byte p60[8] = {
  B11100,
  B11100,
  B11100,
  B11100,
  B11100,
  B11100,
  B11100,
};
byte p80[8] = {
  B11110,
  B11110,
  B11110,
  B11110,
  B11110,
  B11110,
  B11110,
};
byte p100[8] = {
  B11111,
  B11111,
  B11111,
  B11111,
  B11111,
  B11111,
  B11111,
};

// Declaracion de las variables


LiquidCrystal lcd(7,8,9,10,11,12);

const byte pulsador1           =   3;
const byte pulsador2           =   4;
const byte pulsador3           =   5;
const byte pulsador4           =   6;
const byte pulsador5           =   13;

volatile int SegProg    =   0;
volatile int MinProg    =   0;
volatile int SegProgAnt =   1;
volatile int MinProgAnt =   1;

int estadoactual        =   0;
int estadoanterior      =   0;
int estadoactual1       =   0;
int estadoanterior1     =   0;
int estadoactual2       =   0;
int estadoanterior2     =   0;
int estadoactual3       =   0;
int estadoanterior3     =   0;
int estadoactual4       =   0;
int estadoanterior4     =   0;

volatile int ticks               =   0;
volatile int ticksAnterior       =   0;
volatile int tickscopia          =   0;
volatile double CalculoTicks        =   0;
volatile double CalculoTicksFinal        =   0;
volatile int ConteoBarras        =   0;
volatile int ConteoBarrasAnterior=   90;
volatile int TicksTotales        =   0;
volatile int i =0;
volatile int j =0;

//-------------------------------SETUP-----------------------------------------
void setup(){
  
  //Se inicia el puerto serie
  Serial.begin(9600);
  
  //Configuracion de los pines de los pulsadores
  pinMode(pulsador1,INPUT);
  pinMode(pulsador2,INPUT);
  pinMode(pulsador3,INPUT);
  pinMode(pulsador4,INPUT);
  pinMode(pulsador5,INPUT);
  
  // de declara e inicia LCD
  lcd.begin(16,2);
  lcd.createChar(0,p20);
  lcd.createChar(1,p40);
  lcd.createChar(2,p60);
  lcd.createChar(3,p80);
  lcd.createChar(4,p100);
  
  //Se configuran la interrupcion para la cuenta atras
  InterruptConfig();
  
  // Se muestra el mensage de inicio y la pantalla de seleccion de tiempo a 0
  MostrarMensageInicio();
  ImpIniSet();
}

//------------------------------------LOOP-----------------------------------
void loop(){
  
  ImprTime(SegProg,MinProg);        // imprime el tiempo configurado
  SeleccionDeTiempo();  //control del tiempo con los 4 botones de seleccion

  
  
  //Al pulsar el botol 5
  
  estadoactual4=digitalRead(pulsador5);
  if(estadoanterior4==LOW  &&  estadoactual4==HIGH){
    cli();
    lcd.clear();
    lcd.setCursor(0,0);
    lcd.print("   Insolating   ");
    i=0;
    j=0;
    ActualizaCalculoTicks();
    ConteoBarras=0;
    sei();
    while(ConteoBarras<80){
         Serial.println("1");
         Serial.println(ConteoBarrasAnterior);
         Serial.println(ConteoBarras);
         if(ConteoBarrasAnterior!=ConteoBarras){
            ConteoBarrasAnterior=ConteoBarras;
            Serial.println("2");
            cli();
            lcd.setCursor(i,1);
            lcd.write(j);
            j++;
            
            if(j>4){
              i++;
              j=0;
            }
            
        sei();
        
        }
    }
    
    cli();
    ticks=0;
    
    MinProg=0;
    SegProg=0;
    SegProgAnt=1;
    MinProgAnt=1;
    ConteoBarras=0;
    ticks=0;
    tickscopia=0;
    ticksAnterior=0;
    TicksTotales=0;
    ConteoBarrasAnterior=1;
    i=0;
    j=0;
    
    estadoanterior4=estadoactual4;
  }
  if(estadoanterior4==HIGH  &&  estadoactual4==LOW){
    estadoanterior4=estadoactual4; 
  }
  
}


//-----------------------------funcion de configuracion de tiempo------------------------
void SeleccionDeTiempo(){
  
  //lectura del flanco del pulsador de seg ascendente
  
  estadoactual=digitalRead(pulsador1);
  if(estadoanterior==LOW  &&  estadoactual==HIGH){
    SegProg=SegProg+5;
    if(SegProg==60){
      SegProg=0;
      MinProg+=1;
    }
    estadoanterior=estadoactual;
  }
  if(estadoanterior==HIGH  &&  estadoactual==LOW){
    estadoanterior=estadoactual;
  }
  
  //lectura del flanco del pulsador de seg descendente
  
  estadoactual1=digitalRead(pulsador2);
  if(estadoanterior1==LOW  &&  estadoactual1==HIGH){
    SegProg-=5;
     if(SegProg==-5){
      if(MinProg==0){
        SegProg=0;
        MinProg=0;
      }
      else{
        SegProg=55;
        MinProg-=1;
      }
    }
    estadoanterior1=estadoactual1;
  }
  if(estadoanterior1==HIGH  &&  estadoactual1==LOW){
    estadoanterior1=estadoactual1;
  }
  
  //lectura del flanco del pulsador de min ascendente
  
  estadoactual2=digitalRead(pulsador3);
  if(estadoanterior2==LOW  &&  estadoactual2==HIGH){
    MinProg+=1;
    estadoanterior2=estadoactual2;
  }
  if(estadoanterior2==HIGH  &&  estadoactual2==LOW){
    estadoanterior2=estadoactual2;
  }
  
  //lectura del flanco del pulsador de min descendente
  
  estadoactual3=digitalRead(pulsador4);
  if(estadoanterior3==LOW  &&  estadoactual3==HIGH){
    MinProg-=1;
    estadoanterior3=estadoactual3;
  }
  if(estadoanterior3==HIGH  &&  estadoactual3==LOW){
    estadoanterior3=estadoactual3;
  }
 
  // Imposicion para tiempos negativos o mayor de 100 
  
  if (SegProg<0)
  {
    SegProg =0;
  }
  if (MinProg<0)
  {
    MinProg =0;
  }
  if(MinProg>99){
    MinProg=99;
  }
}

//-------------------- -Instrucciones de LCD- ----------------------------------

//Muestra un mensage de inicio
void MostrarMensageInicio(){
  
  //Muestra la version y un mensage de inicializacion
  lcd.setCursor(0,0);
  lcd.print(" Firmware v1.0  ");
  lcd.setCursor(0,1);
  lcd.print("  Starting up   ");
  
  //Espera 3 segundos para poder leer la version
  delay(100000);
  lcd.clear();
}

//Borra la LCD


//Imprime la cabecera para la seleccion del tiempo al inicio del programa
void ImpIniSet(){
  //Se coloca el cursor a 0 y se imrpime la cabecera
  cli();
  lcd.clear();
  lcd.print("    Set Time    ");
  sei();
}


//Imprime en el LCD el valor enviado y compara con un valor anterior
void ImprTime(int SegProglcd, int MinProglcd){
  
  //Se declara una cadena de 16 para escribir el tiempo a imprimir
  char buff[16];
  
  //Se guarda en dicha cadena el tiempo a imprimir con dos digitos
  sprintf(buff,"%02d:%02d",MinProglcd,SegProglcd);
  
  //Si el tiempo ha cambiado (para no imprimri siempre ya que no se veria por el refresco)
    if(MinProglcd != MinProgAnt || SegProglcd != SegProgAnt){
      
      //Se mueve el cursor del lcd a el tiempo e imprimo el buffer
      ImpIniSet();
      cli();
      lcd.setCursor(5,1);
      lcd.print(buff);
      sei();
   
      //Se actualizan los valores de anterior a actual
      MinProgAnt=MinProglcd;
      SegProgAnt=SegProglcd;
    }   
}


//-------------------- -Instrucciones de interrupciones- -----------------------
void InterruptConfig(){  
  
  cli();
  TCCR1A=0;
  TCCR1B=0;
  
  // para lo s 62,5 ms OCR1A=975;
  OCR1A=975;
  TCCR1B |= (1<<WGM12);
  
  TCCR1B |= (1<<CS10);
  TCCR1B |= (1<<CS12);
  
  TIMSK1=(1<<OCIE1A);
}

ISR(TIMER1_COMPA_vect){
  ticks++;
  if(ticks>=CalculoTicksFinal){
     ticks=0;
     ConteoBarras++; 
  }
}
//-------------------------------------------------------------
void ActualizaCalculoTicks()
{
 CalculoTicks = ((((MinProg*60)+SegProg)*1000)/(8*625));
 CalculoTicksFinal = CalculoTicks; 
}
30/11/2015 #10


Con la Barra de progreso uso esta librería que te recomiendo

LCDBar Graph Library
01/12/2015 #11


SURbyte dijo: Ver Mensaje
Con la Barra de progreso uso esta librería que te recomiendo

LCDBar Graph Library
acabo de mirar la libreria, pero no me sirve :( por que la barra que quiero hacer, su velocidad depende del tiempo que pogas y esa libreria no te deja hacer una barra en funcion de un tiempo.
Yo ya me hice mi funcion de barra de progreso con delays tambien pero no puedo usar delays en este caso.
01/12/2015 #12


Como que no puedes hacer una barra en función del tiempo?
Tienes 5 pasos 0, 25, 50, 75 y 100 % de barra.
Con la librería puedes poner 100 pasos o mas. El ejemplo esta con 1024 pasos.

Corrí tu programa y funciona pero muy lento.
Vi que cambiaste la frecuencia del Timer1.

La barra que tu programas funciona solo cuando presionas el pulsador 5?

Cuando pulsas el botón de segundos UP en el LCD se ven incrementados los minutos pero no los segundos

Por que cada operación que haces le antecedes un cli() y luego que la terminas un sei()
Si se inicia una cuenta con el TIMER1, no puedes parar el reloj en ningún momento!!

Todo el código esta lleno de llamadas a detener el timer1 usando cli(), no entiendo tus razones.
01/12/2015 #13


Perdon te envie una version que estaba probando cosas a ver que pasaba con las interrupciones.
Pues mira por donde que hoy he dado con una cosa que puede ser el problema.
Código:
//------------------------------------------------------------------------
/*
*  Codigo de control para insoladora con lcd y programacion de tiempo
*  Autor: Gabriel Garcia Garrido
*  Fecha: Noviembre 2015
*/
//------------------------------------------------------------------------

// (Conexiones)
/*
* RS: pin 7
* EN: pin 8
* D4: pin 9
* D5: pin 10
* D6: pin 11
* D7: pin 12
* Pulsador 1: 3
* Pulsador 2: 4
* Pulsador 3: 5
* Pulsador 4: 6
* Pulsador 5: 13
*/

//incluir la libreria LiquidCrystal

#include <LiquidCrystal.h>
#include <avr/io.h>
#include <avr/interrupt.h>

//Creacion de los caracteres para la cuenta atras

byte p20[8] = {
  B10000,
  B10000,
  B10000,
  B10000,
  B10000,
  B10000,
  B10000,
  B10000,
};
byte p40[8] = {
  B11000,
  B11000,
  B11000,
  B11000,
  B11000,
  B11000,
  B11000,
  B11000,
};
byte p60[8] = {
  B11100,
  B11100,
  B11100,
  B11100,
  B11100,
  B11100,
  B11100,
  B11100,
};
byte p80[8] = {
  B11110,
  B11110,
  B11110,
  B11110,
  B11110,
  B11110,
  B11110,
  B11110,
};
byte p100[8] = {
  B11111,
  B11111,
  B11111,
  B11111,
  B11111,
  B11111,
  B11111,
  B11111,
};

// Declaracion de las variables


LiquidCrystal lcd(7,8,9,10,11,12);

const byte pulsador1           =   3;
const byte pulsador2           =   4;
const byte pulsador3           =   5;
const byte pulsador4           =   6;
const byte pulsador5           =   13;

volatile int SegProg    =   0;
volatile int MinProg    =   0;
volatile int SegProgAnt =   1;
volatile int MinProgAnt =   1;

int estadoactual        =   0;
int estadoanterior      =   0;
int estadoactual1       =   0;
int estadoanterior1     =   0;
int estadoactual2       =   0;
int estadoanterior2     =   0;
int estadoactual3       =   0;
int estadoanterior3     =   0;
int estadoactual4       =   0;
int estadoanterior4     =   0;

volatile int ticks               =   0;
volatile int ticksAnterior       =   0;
volatile int tickscopia          =   0;
volatile int CalculoTicks        =   0;
volatile int CalculoTicksFinal        =   0;
volatile int ConteoBarras        =   0;
volatile int ConteoBarrasAnterior=   0;
volatile int TicksTotales        =   0;
volatile int i =0;
volatile int j =0;

//-------------------------------SETUP-----------------------------------------
void setup(){
  
  //Se inicia el puerto serie
  Serial.begin(9600);
  
  //Configuracion de los pines de los pulsadores
  pinMode(pulsador1,INPUT);
  pinMode(pulsador2,INPUT);
  pinMode(pulsador3,INPUT);
  pinMode(pulsador4,INPUT);
  pinMode(pulsador5,INPUT);
  
  // de declara e inicia LCD
  lcd.begin(16,2);
  lcd.createChar(0,p20);
  lcd.createChar(1,p40);
  lcd.createChar(2,p60);
  lcd.createChar(3,p80);
  lcd.createChar(4,p100);
  
  //Se configuran la interrupcion para la cuenta atras
  InterruptConfig();
  
  // Se muestra el mensage de inicio y la pantalla de seleccion de tiempo a 0
  MostrarMensageInicio();
  ImpIniSet();
}

//------------------------------------LOOP-----------------------------------
void loop(){
  
  ImprTime(SegProg,MinProg);        // imprime el tiempo configurado
  SeleccionDeTiempo();  //control del tiempo con los 4 botones de seleccion

  
  
  //Al pulsar el botol 5
  
  estadoactual4=digitalRead(pulsador5);
  if(estadoanterior4==LOW  &&  estadoactual4==HIGH){
    cli();
    i=0;
    j=0;
    ActualizaCalculoTicks();
    ConteoBarras=0;
    lcd.clear();
    lcd.setCursor(0,0);
    lcd.print("   Insolating   ");
    sei();
    while(ConteoBarras<80){
         Serial.println("ConteoBarrasAnterior");
         Serial.println(ConteoBarrasAnterior);
         Serial.println("ConteoBarras");
         Serial.println(ConteoBarras);
         if(ConteoBarrasAnterior!=ConteoBarras){
            Serial.println("Conteo Barras cambia");
            ConteoBarrasAnterior=ConteoBarras;
            Serial.println("numero i:");
            Serial.println(i);
            Serial.println("numero j:");
            Serial.println(j);
            lcd.setCursor(i,1);
            lcd.write(j);
            j++;
            
            if(j>4){
              i++;
              j=0;
            }
            
        }
    }
    
    cli();
    ticks=0;
    
    MinProg=0;
    SegProg=0;
    SegProgAnt=1;
    MinProgAnt=1;
    ConteoBarras=0;
    ticks=0;
    tickscopia=0;
    ticksAnterior=0;
    TicksTotales=0;
    ConteoBarrasAnterior=0;
    i=0;
    j=0;
    
    estadoanterior4=estadoactual4;
  }
  if(estadoanterior4==HIGH  &&  estadoactual4==LOW){
    estadoanterior4=estadoactual4; 
  }
  
}


//-----------------------------funcion de configuracion de tiempo------------------------
void SeleccionDeTiempo(){
  
  //lectura del flanco del pulsador de seg ascendente
  
  estadoactual=digitalRead(pulsador1);
  if(estadoanterior==LOW  &&  estadoactual==HIGH){
    SegProg=SegProg+5;
    if(SegProg==60){
      SegProg=0;
      MinProg+=1;
    }
    estadoanterior=estadoactual;
  }
  if(estadoanterior==HIGH  &&  estadoactual==LOW){
    estadoanterior=estadoactual;
  }
  
  //lectura del flanco del pulsador de seg descendente
  
  estadoactual1=digitalRead(pulsador2);
  if(estadoanterior1==LOW  &&  estadoactual1==HIGH){
    SegProg-=5;
     if(SegProg==-5){
      if(MinProg==0){
        SegProg=0;
        MinProg=0;
      }
      else{
        SegProg=55;
        MinProg-=1;
      }
    }
    estadoanterior1=estadoactual1;
  }
  if(estadoanterior1==HIGH  &&  estadoactual1==LOW){
    estadoanterior1=estadoactual1;
  }
  
  //lectura del flanco del pulsador de min ascendente
  
  estadoactual2=digitalRead(pulsador3);
  if(estadoanterior2==LOW  &&  estadoactual2==HIGH){
    MinProg+=1;
    estadoanterior2=estadoactual2;
  }
  if(estadoanterior2==HIGH  &&  estadoactual2==LOW){
    estadoanterior2=estadoactual2;
  }
  
  //lectura del flanco del pulsador de min descendente
  
  estadoactual3=digitalRead(pulsador4);
  if(estadoanterior3==LOW  &&  estadoactual3==HIGH){
    MinProg-=1;
    estadoanterior3=estadoactual3;
  }
  if(estadoanterior3==HIGH  &&  estadoactual3==LOW){
    estadoanterior3=estadoactual3;
  }
 
  // Imposicion para tiempos negativos o mayor de 100 
  
  if (SegProg<0)
  {
    SegProg =0;
  }
  if (MinProg<0)
  {
    MinProg =0;
  }
  if(MinProg>99){
    MinProg=99;
  }
  if(MinProg==0 && SegProg==0){
    SegProg=5;
  }
}

//-------------------- -Instrucciones de LCD- ----------------------------------

//Muestra un mensage de inicio
void MostrarMensageInicio(){
  
  //Muestra la version y un mensage de inicializacion
  lcd.setCursor(0,0);
  lcd.print(" Firmware v1.0  ");
  lcd.setCursor(0,1);
  lcd.print("  Starting up   ");
  
  //Espera 3 segundos para poder leer la version
  delay(100000);
  lcd.clear();
}

//Borra la LCD


//Imprime la cabecera para la seleccion del tiempo al inicio del programa
void ImpIniSet(){
  //Se coloca el cursor a 0 y se imrpime la cabecera
  lcd.clear();
  lcd.setCursor(0,0);
  lcd.print("    Set Time    ");
}


//Imprime en el LCD el valor enviado y compara con un valor anterior
void ImprTime(int SegProglcd, int MinProglcd){
  
  //Se declara una cadena de 16 para escribir el tiempo a imprimir
  char buff[16];
  
  //Se guarda en dicha cadena el tiempo a imprimir con dos digitos
  sprintf(buff,"%02d:%02d",MinProglcd,SegProglcd);
  
  //Si el tiempo ha cambiado (para no imprimri siempre ya que no se veria por el refresco)
    if(MinProglcd != MinProgAnt || SegProglcd != SegProgAnt){
      
      //Se mueve el cursor del lcd a el tiempo e imprimo el buffer
      ImpIniSet();
      lcd.setCursor(5,1);
      lcd.print(buff);
   
      //Se actualizan los valores de anterior a actual
      MinProgAnt=MinProglcd;
      SegProgAnt=SegProglcd;
    }   
}


//-------------------- -Instrucciones de interrupciones- -----------------------
void InterruptConfig(){  
  
  cli();
  TCCR1A=0;
  TCCR1B=0;
  
  // para lo s 62,5 ms OCR1A=975;
  OCR1A=975;
  TCCR1B |= (1<<WGM12);
  
  TCCR1B |= (1<<CS10);
  TCCR1B |= (1<<CS12);
  
  TIMSK1=(1<<OCIE1A);
}

ISR(TIMER1_COMPA_vect){
  ticks++;
  if(ticks>=CalculoTicksFinal){
     ticks=0;
     ConteoBarras++; 
  }
}
//-------------------------------------------------------------
void ActualizaCalculoTicks()
{
 CalculoTicks = ((((MinProg*60)+SegProg)*1000)/(8*625));
 CalculoTicksFinal = CalculoTicks; 
}
Usando este código, si dejo presionado el boton 5 para que empieze la barra FUNCIONA TODO PERFECTAMENTE!!!
la frecuencia del timer la cambia para que el valor calculo de ticks siempre diera un valor positivo y que con el menor tiempo seleccionado (5seg) le diera tiempo a dibujar toda la barra, Es una operacioncilla matemática
Bueno estoy flipando de por que cuando dejo el boton 5 presionado funciona todo. ¿puede ser por que esta en el input 13 y eso tiene algo que ver con algo?

---------- Actualizado después de 8 minutos ----------

Probe cambiandolo al pi 2 y pasa lo mismo, asi que debe de ser algo del código

---------- Actualizado después de 17 minutos ----------

Problema resulto, soy imbecil!! la resistencia que le puse al pulsador era muy baja! y hacia un corto casi!! te mando un video luego y lo ves q bien ha quedado!! la que puede liar una resistencia mal puesto por no ver bn su color... PUTO hardware mal montado jajajaja
Muchisimas gracias por tu ayuda! ademas ahora el codigo esta bn optimizado!!!

---------- Actualizado después de 16 minutos ----------

Codigo definitivo:

Código:
//------------------------------------------------------------------------
/*
*  Codigo de control para insoladora con lcd y programacion de tiempo
*  Autor: Gabriel Garcia Garrido
*  Fecha: Noviembre 2015
*/
//------------------------------------------------------------------------

// (Conexiones)
/*
* RS: pin 7
* EN: pin 8
* D4: pin 9
* D5: pin 10
* D6: pin 11
* D7: pin 12
* Pulsador 1: 3
* Pulsador 2: 4
* Pulsador 3: 5
* Pulsador 4: 6
* Pulsador 5: 13
*/

//incluir la libreria LiquidCrystal

#include <LiquidCrystal.h>
#include <avr/io.h>
#include <avr/interrupt.h>

//Creacion de los caracteres para la cuenta atras

byte p20[8] = {
  B10000,
  B10000,
  B10000,
  B10000,
  B10000,
  B10000,
  B10000,
  B10000,
};
byte p40[8] = {
  B11000,
  B11000,
  B11000,
  B11000,
  B11000,
  B11000,
  B11000,
  B11000,
};
byte p60[8] = {
  B11100,
  B11100,
  B11100,
  B11100,
  B11100,
  B11100,
  B11100,
  B11100,
};
byte p80[8] = {
  B11110,
  B11110,
  B11110,
  B11110,
  B11110,
  B11110,
  B11110,
  B11110,
};
byte p100[8] = {
  B11111,
  B11111,
  B11111,
  B11111,
  B11111,
  B11111,
  B11111,
  B11111,
};

// Declaracion de las variables


LiquidCrystal lcd(7,8,9,10,11,12);

const byte pulsador1           =   3;
const byte pulsador2           =   4;
const byte pulsador3           =   5;
const byte pulsador4           =   6;
const byte pulsador5           =   13;

volatile int SegProg    =   0;
volatile int MinProg    =   0;
volatile int SegProgAnt =   1;
volatile int MinProgAnt =   1;

int estadoactual        =   0;
int estadoanterior      =   0;
int estadoactual1       =   0;
int estadoanterior1     =   0;
int estadoactual2       =   0;
int estadoanterior2     =   0;
int estadoactual3       =   0;
int estadoanterior3     =   0;
int estadoactual4       =   0;
int estadoanterior4     =   0;

volatile int ticks               =   0;
volatile int ticksAnterior       =   0;
volatile int tickscopia          =   0;
volatile int CalculoTicks        =   0;
volatile int CalculoTicksFinal        =   0;
volatile int ConteoBarras        =   0;
volatile int ConteoBarrasAnterior=   0;
volatile int TicksTotales        =   0;
volatile int i =0;
volatile int j =0;

//-------------------------------SETUP-----------------------------------------
void setup(){
  
  //Se inicia el puerto serie
  Serial.begin(9600);
  
  //Configuracion de los pines de los pulsadores
  pinMode(pulsador1,INPUT);
  pinMode(pulsador2,INPUT);
  pinMode(pulsador3,INPUT);
  pinMode(pulsador4,INPUT);
  pinMode(pulsador5,INPUT);
  
  // de declara e inicia LCD
  lcd.begin(16,2);
  lcd.createChar(0,p20);
  lcd.createChar(1,p40);
  lcd.createChar(2,p60);
  lcd.createChar(3,p80);
  lcd.createChar(4,p100);
  
  //Se configuran la interrupcion para la cuenta atras
  InterruptConfig();
  
  // Se muestra el mensage de inicio y la pantalla de seleccion de tiempo a 0
  MostrarMensageInicio();
  ImpIniSet();
}

//------------------------------------LOOP-----------------------------------
void loop(){
  
  ImprTime(SegProg,MinProg);        // imprime el tiempo configurado
  SeleccionDeTiempo();  //control del tiempo con los 4 botones de seleccion

  
  
  //Al pulsar el botol 5
  
  estadoactual4=digitalRead(pulsador5);
  if(estadoanterior4==LOW  &&  estadoactual4==HIGH){
    cli();
    i=0;
    j=0;
    ActualizaCalculoTicks();
    ConteoBarras=0;
    lcd.clear();
    lcd.setCursor(0,0);
    lcd.print("   Insolating   ");
    sei();
    while(ConteoBarras<80){
         if(ConteoBarrasAnterior!=ConteoBarras){
            ConteoBarrasAnterior=ConteoBarras;
            lcd.setCursor(i,1);
            lcd.write(j);
            j++;
            if(j>4){
              i++;
              j=0;
            }
        }
    }
    
    cli();
    ticks=0;
    
    MinProg=0;
    SegProg=0;
    SegProgAnt=1;
    MinProgAnt=1;
    ConteoBarras=0;
    ticks=0;
    tickscopia=0;
    ticksAnterior=0;
    TicksTotales=0;
    ConteoBarrasAnterior=0;
    i=0;
    j=0;
    
    estadoanterior4=estadoactual4;
  }
  if(estadoanterior4==HIGH  &&  estadoactual4==LOW){
    estadoanterior4=estadoactual4; 
  }
  
}


//-----------------------------funcion de configuracion de tiempo------------------------
void SeleccionDeTiempo(){
  
  //lectura del flanco del pulsador de seg ascendente
  
  estadoactual=digitalRead(pulsador1);
  if(estadoanterior==LOW  &&  estadoactual==HIGH){
    SegProg=SegProg+5;
    if(SegProg==60){
      SegProg=0;
      MinProg+=1;
    }
    estadoanterior=estadoactual;
  }
  if(estadoanterior==HIGH  &&  estadoactual==LOW){
    estadoanterior=estadoactual;
  }
  
  //lectura del flanco del pulsador de seg descendente
  
  estadoactual1=digitalRead(pulsador2);
  if(estadoanterior1==LOW  &&  estadoactual1==HIGH){
    SegProg-=5;
     if(SegProg==-5){
      if(MinProg==0){
        SegProg=0;
        MinProg=0;
      }
      else{
        SegProg=55;
        MinProg-=1;
      }
    }
    estadoanterior1=estadoactual1;
  }
  if(estadoanterior1==HIGH  &&  estadoactual1==LOW){
    estadoanterior1=estadoactual1;
  }
  
  //lectura del flanco del pulsador de min ascendente
  
  estadoactual2=digitalRead(pulsador3);
  if(estadoanterior2==LOW  &&  estadoactual2==HIGH){
    MinProg+=1;
    estadoanterior2=estadoactual2;
  }
  if(estadoanterior2==HIGH  &&  estadoactual2==LOW){
    estadoanterior2=estadoactual2;
  }
  
  //lectura del flanco del pulsador de min descendente
  
  estadoactual3=digitalRead(pulsador4);
  if(estadoanterior3==LOW  &&  estadoactual3==HIGH){
    MinProg-=1;
    estadoanterior3=estadoactual3;
  }
  if(estadoanterior3==HIGH  &&  estadoactual3==LOW){
    estadoanterior3=estadoactual3;
  }
 
  // Imposicion para tiempos negativos o mayor de 100 
  
  if (SegProg<0)
  {
    SegProg =0;
  }
  if (MinProg<0)
  {
    MinProg =0;
  }
  if(MinProg>99){
    MinProg=99;
  }
  if(MinProg==0 && SegProg==0){
    SegProg=5;
  }
}

//-------------------- -Instrucciones de LCD- ----------------------------------

//Muestra un mensage de inicio
void MostrarMensageInicio(){
  
  //Muestra la version y un mensage de inicializacion
  lcd.setCursor(0,0);
  lcd.print(" Firmware v1.0  ");
  lcd.setCursor(0,1);
  lcd.print("  Starting up   ");
  
  //Espera 3 segundos para poder leer la version
  delay(100000);
  lcd.clear();
}

//Borra la LCD


//Imprime la cabecera para la seleccion del tiempo al inicio del programa
void ImpIniSet(){
  //Se coloca el cursor a 0 y se imrpime la cabecera
  lcd.clear();
  lcd.setCursor(0,0);
  lcd.print("    Set Time    ");
}


//Imprime en el LCD el valor enviado y compara con un valor anterior
void ImprTime(int SegProglcd, int MinProglcd){
  
  //Se declara una cadena de 16 para escribir el tiempo a imprimir
  char buff[16];
  
  //Se guarda en dicha cadena el tiempo a imprimir con dos digitos
  sprintf(buff,"%02d:%02d",MinProglcd,SegProglcd);
  
  //Si el tiempo ha cambiado (para no imprimri siempre ya que no se veria por el refresco)
    if(MinProglcd != MinProgAnt || SegProglcd != SegProgAnt){
      
      //Se mueve el cursor del lcd a el tiempo e imprimo el buffer
      ImpIniSet();
      lcd.setCursor(5,1);
      lcd.print(buff);
   
      //Se actualizan los valores de anterior a actual
      MinProgAnt=MinProglcd;
      SegProgAnt=SegProglcd;
    }   
}


//-------------------- -Instrucciones de interrupciones- -----------------------
void InterruptConfig(){  
  
  cli();
  TCCR1A=0;
  TCCR1B=0;
  
  // para lo s 62,5 ms OCR1A=975;
  OCR1A=975;
  TCCR1B |= (1<<WGM12);
  
  TCCR1B |= (1<<CS10);
  TCCR1B |= (1<<CS12);
  
  TIMSK1=(1<<OCIE1A);
}

ISR(TIMER1_COMPA_vect){
  ticks++;
  if(ticks>=CalculoTicksFinal){
     ticks=0;
     ConteoBarras++; 
  }
}
//-------------------------------------------------------------
void ActualizaCalculoTicks()
{
 CalculoTicks = ((((MinProg*60)+SegProg)*1000)/(8*625));
 CalculoTicksFinal = CalculoTicks; 
 if(MinProg==0 && SegProg ==0){
   CalculoTicks=1;
   CalculoTicksFinal=1;
 }
 Serial.println("CalculoTicks:");
 Serial.println(CalculoTicks);
}
AGRADECER A SURbyte su ayuda para conseguir mi proposito!!!!
PD en un nuevo codigo he corregido que se pueda selecionar 00:00 y que no cuente y vuleva a la pantalla de sleccion de modo
Respuesta
¿Tienes una mejor respuesta a este tema? ¿Quieres hacerle una pregunta a nuestra comunidad y sus expertos? Registrate

Buscar más temas sobre:
Lupa Arduino y Raspberry Pi

Cerrar
Foros de Electrónica » Diseño digital » Microcontroladores y sistemas embebidos » Arduino y Raspberry Pi

Powered by vBulletin® Version 3.8.4
Copyright ©2000 - 2017, Jelsoft Enterprises Ltd.
Search Engine Optimization by vBSEO ©2011, Crawlability, Inc.