Ayuda con los timers internos para proyecto de 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();
  }
}

Esta misma consulta que estaba por comenzar a responder en el Foro de Electrónica la posteas acá asi que 2x1.
Lo primero que te voy a pedir es que ayudes con alguna explicación de los pulsadores.
No deberíamos tener qeu deducir de tu código que hace cada uno porque tampoco lo dices en el código y hay que inferirlo por las acciones.
Ayudanos para poder ayudarte.

Bueno esta en el código pero costaba muy poco explicarlo en tu consulta.

Esto es una cuestión de concepto. JAMAS y lo enfatizo en mayúsculas uses Serial.print en una interrupción.
Imagina, tu hablas de un tick cada 62.5mseg supon que tu impresión por serial demore mas que eso?
Pero llevalo a un timer mas rápido y ahi será mas evidente.
Si quieres imprimir ticks lo haces en otro lugar. En el loop y que imprima lo que corresponda a cada ciclo.

Bueno mi análisis de tu código dice lo siguiente:

  1. Usas un prescaler de 1024 debido a CS10 = 1 y CS12 = 1
    para un tick x segundo debiste usar OCR1A = 15624; y no 15675
    ya que la formula es
    // = (1610^6) / (freq1024) - 1

Luego viene la complicación.
Tienes un tick por segundo y ahora ? supongo que quieres decrementar tu seteo.
No entiendo para que quieres en la rutina de COMP poner a 0 los ticks a menos que fuera cada 60 ticks = 1 min

PErdon esque me acabo de dar cuenta de que borre medio mensage sin darme cuena, aqui esta entero. En cuanto a lo del serial.print en una interrupción lo quitare. ahora te explico lo que quiero hacer:
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

Obviamente he hecho algunos cambios basados en mis criterios.

//------------------------------------------------------------------------
/*
*  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();
}

He probado el codigo que has escrito (Muchas gracias por haberte puesto a mirarlo y reescribirlo, ya que eso requiere trabajo), y ahora vale que hace la cuenta atrás, pero cuando llega a 0 y 0 el timer no se para y sigue contando en negativo :(, coo si el cli() no funcionase y no deshabilitara el timer. Ademas no se por que, cuando pulsas los botones 4 veces para subir o bajar los minutos o segundos, se queda bloqueado
Si puedo en un rato te subo un video para que lo veas y asi veas como tengo conectadas las cosas, etc.

Tambien decirte y comentarte la idea final que tengo es de hacer la cuenta atras, pero con una barra de progreso con los caracteres que estan declarados arriba. Lo de la barra lo he conseguido hacer pero con delays sin programar timer ni nada asi, solo por saber como programarla y tambien hacer un boton de cancel en el caso de que se quiera cancelar el conteo hacia atras. Todo ello encenderia unos leds de una insoladora.
Muchisimas gracias y un saludo.

Hola he modificado un poco el código y siguen sin pararse las interrupciones :frowning:

//------------------------------------------------------------------------
/*
*  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.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++;
}

Bien, no te preocupes, yo me enteré casualmente porque dejé activa la simulación y cuando la miro decía -16:23 jajajaja
falló la simple eliminación de las interrupciones o eso pensé.

Bueno estuvo interesante el repaso de timers..

//------------------------------------------------------------------------
/*
*  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;
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){ // NO SIRVE PARA NADA
     ticks=0;
  }
  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;
  }   
}

Falta la barra de progreso que no se como quieres hacerla asi que te lo dejo a ti.

Corrigiendo algunas cosas he conseguido que cuente y mas cosas pero a la hora de pintar la barra me dibuja lo que quiere y me desplaza el texto. Ahora parece como si el lcd.setcursor funcionara como le diera la gana.
Pd ya lo puse en el otro foro pero tu código no me llegaba a funcionar bien así que fijándote en el tuyo fui corrigiendo cosas del mio..., si consigo solucionar este problema ya estaría todo echo y habría aprendido un montón

//------------------------------------------------------------------------
/*
*  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; 
}

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

LCDBar Graph Library