window_lib.c

Go to the documentation of this file.

/*
**
****************************************************************************
**
**
**             Copyright (c) 2005 - Atmel Corporation
**             Proprietaty Information
**
** Project     : AT90CAN128 / ATmega88 window lift
** Module      : window_lib.c
** Description : automotive window lift Control & ANTI-PINCH
**
**
** Version :     Date:         Author:      Comment:
**    1.0        June.2005    F.G.          Creation
**
**
**
**
**              The following Fuses should be set:-
**
**
**
** LICENSE -
**
** ATMEL - 2005
** All software programs are provided 'as is' without warranty of any kind:
** Atmel does not state the suitability of the provided materials for any
** purpose. Atmel hereby disclaim all warranties and conditions with regard
** to the provided software, including all implied warranties, fitness for
** a particular purpose, title and non-infringement.In no event will Atmel
** be liable for any indirect or consequential damages or any damages
** whatsoever resulting from the usage of the software program.
****************************************************************************
**
*/


/*_____ I N C L U D E S ____________________________________________________*/

#include "window_lib.h"
#include "filtre1.h"
#include "eep_lib.h"
#include "lib_window\hall_sensor_ISR.h"
#include "timer1_ovf_isr.h"

/*_____ G L O B A L S ________________________________________________________*/

un_eep_WindowParam eep; 

/* ----- Globals for window control & anti-pinch --- */

U8 last_direction;

U8 direction;

signed char ctrl_state = STOP_STATE;

U16 position; 

U16 ref;

U16 current;

U8 pinch_threshold;

U16 pinch;

U8 gain;

U8 h_max_mm;

U8 h_max;

U16 window_height_mm;

U16 h_detect_min_mm;

U16  h_detect_min;

U16 top_mm;

U16 backlash;

U16 down; 

st_b_point_tab  block_point;

st_b_point point_temp;

U16 start_pos;

U16 stop_pos;

U8 update=0;

/*_____ P R I V A T E - F U N C T I O N S ____________________________________*/

signed char get_window_state (void)
{
  return (ctrl_state);
}

signed char force_window_state (signed char temp)
{
  ctrl_state=temp;
  return (ctrl_state);
}

U16 get_h_detect_min(void)
{
  return (h_detect_min);
}

U8 get_h_max(void)
{
  return (h_max);
}

U8 init_window_size_position()
{
  U8 returned_state;
  static U8 init_state = INIT_START_INIT;
  static U16 init_pos = 0;
  U16 temp16;
  U32 temp32;
  static signed char go_up_cmde=0, go_down_cmde=0;
  if((ADC & 0x200)== 0x200)current = mean_16(0);
  else current = mean_16(ADC);

  returned_state = window_ctrl(&go_up_cmde, &go_down_cmde, ANTI_PINCH_DISABLED);

  //---------------------------------
  blocking_point(returned_state);
  
  //---------------------------------
  switch (init_state)
  {
  case INIT_START_INIT:
    if ((returned_state != STOP_STATE) || (returned_state != STOPING_STATE))
      force_window_state(STOPING_STATE);  // force motor stop
    
    if (returned_state == STOP_STATE)  
    { // ready to start init operation
      go_down_cmde = CMDE_NEW_CMDE;       // command : initialize window at Bottom
      init_state = INIT_DETECT_BOTTOM;
      TCNT1 = 0;                          // Reset timeout detection
    }
    break;
  //---------------------------------
  case INIT_DETECT_BOTTOM:                // wait bottom detection
    if( (current > 350) || (TIMEOUT && (current > 200)))
    {                                     // bottom detected
      SET_MOTOR_OFF();                    //motor mosfet OFF
      put_position(0xFFFF);
      go_down_cmde = CMDE_NO_CMDE;
      go_up_cmde = CMDE_NO_CMDE;
      init_state = INIT_START_TOP_DETECT;
      erase_block_point();          // erase blocking point table before rebuild
    }
    else if (returned_state == STOP_STATE)
      go_down_cmde = CMDE_NEW_CMDE;
    break;
  //---------------------------------
  case INIT_START_TOP_DETECT:             // Wait current to be low
    if (current < 5)                      // current has decrease
    {
      go_down_cmde = CMDE_NO_CMDE;
      go_up_cmde = CMDE_NEW_CMDE;         // initiate top detection
      init_state = INIT_DETECT_TOP;
      TCNT1 = 0;                          // Reset timeout detection
    }
    break;
  //---------------------------------
  case INIT_DETECT_TOP:                   // wait top detection
    if((current > 350) || (TIMEOUT&& (current > 200)))
    {                                     // top detected
      SET_MOTOR_OFF();                    // motor mosfet OFF
      temp16 = get_position();
      down = 0xFFFF - temp16;
      block_point_set_origin (temp16);    // set top origin for blocking points
      put_position(0);
      force_window_state(STOPING_STATE);  // force motor stop
      init_state = INIT_COMPUTE_PARAMS;   // compute over parameters
    }
    else if (returned_state == STOP_STATE)
      go_up_cmde = CMDE_NEW_CMDE;
    break;
  //---------------------------------
  case INIT_COMPUTE_PARAMS:
    temp32 = (((U32)down<<8));              // top_mm: number of hall sensor
    top_mm = (U16)(temp32/window_height_mm);// edges per millimeters * 256
    h_detect_min = (U16)(((U32)h_detect_min_mm*top_mm)>>8);
    h_max = (U8)(((U32)h_max_mm*top_mm)>>8);
    init_state = INIT_BACKLASH_START;       // break loop, initialisation ends
    break;
  //---------------------------------
  case INIT_BACKLASH_START:
    if ((returned_state != STOP_STATE) || (returned_state != STOPING_STATE))
      force_window_state(STOPING_STATE);    // force motor stop
    
    if ((returned_state == STOP_STATE) && (current < 5))
    { // ready to start down operation
      go_down_cmde = CMDE_NEW_CMDE;         // command : downward operation command
      init_state = INIT_BACKLASH_DOWN;
      TCNT1 = 0;                            // Reset timeout detection
    }
    break;
  //---------------------------------
  case INIT_BACKLASH_DOWN:
    if (get_position() >= (h_detect_min>>1))
    {
      if ((returned_state == STOP_STATE)&&(current < 5))
      {
        init_state = INIT_BACKLASH_ACQUIRE;
        init_pos = get_position();
        go_up_cmde = CMDE_NEW_CMDE;         // command : upward operation command
      }
      else
        force_window_state(STOPING_STATE);  // force motor stop
    }
    else if (returned_state != GO_DOWN_STATE)
      go_down_cmde = CMDE_NEW_CMDE;         // command : downward operation command
    break;    
  //---------------------------------
  case INIT_BACKLASH_ACQUIRE:
    if (get_position() < (init_pos - (top_mm >> 3))) // maximum backlash: 32mm
    { // Stop acquisition
      if (returned_state == STOP_STATE)              
      {
        init_state = INIT_END_INIT;
      }
      else
        force_window_state(STOPING_STATE);  // force motor stop
    }
    else if (returned_state == STOP_STATE)
      go_up_cmde = CMDE_NEW_CMDE;   // command : downward operation command
    else if ((current - ref) > (pinch >> 2))     // Check startup
    { // Bashlash defined at startup as:
      // - Operating direction has changed
      // - Current reference is up to date: Current - reference < pinch / 4
      backlash = init_pos - get_position();
    }
    break;        
  //---------------------------------    
  default:
    init_state = INIT_START_INIT;
    break;
  }
  return (init_state);
}


U8 Read_Eep_WindowParameters(void)
{
  U8 i;
  U8 init_to_perform = INIT_EEP_DONE;
  U32 temp;
  U8 *eep_b_point_ptr;
  eep_b_point_ptr = (void *)&block_point; // pointer to block_point structure
  
  // restore EEPROM into application buffer
  for (i = 0; i < sizeof(eep); i++)
  {
    eep.U8_ptr[i] = EEPROM_read(i);
  }
  
  for (i = 0; i < sizeof(block_point); i++)
  {
    eep_b_point_ptr[i] = EEPROM_read(i + PT_NUM_ADR);
  }
  
  position          = eep.param.position;
  last_direction    = eep.param.last_direction;
  gain              = eep.param.gain;
  pinch_threshold   = eep.param.pinch_threshold;
  window_height_mm  = eep.param.window_height_mm;
  h_detect_min_mm   = eep.param.h_detect_min_mm;
  h_max_mm          = eep.param.h_max_mm;
  down              = eep.param.down;
  backlash          = eep.param.backlash;
  
  //------------ Check / Restore positionnig and area parameters ---------------
  if (  (position           == 0xFFFF)      // Check position
      ||(last_direction     == 0xFF)        // Check last_direction
      ||(down               == 0xFFFF)      // Check down 
      ||(backlash           == 0xFFFF)      // Check backlash
      ||(block_point.pt_num > PT_NUM_MAX))  // Check pt_num
  {
    // Request for adaptation / learning function to initialise it
    init_to_perform |= INIT_POSITION_REQUEST;
    // Clear blocking points area
    for (i = 0; i < sizeof(block_point); i++)
      eep_b_point_ptr[i] = 0;       
  }
  
  //------------ Check / Restore Default user parameters -----------------------
  if (  (window_height_mm   == 0xFFFF)      // Has to be parametred by user
      ||(gain               == 0xFF)
      ||(pinch_threshold    == 0xFF)
      ||(h_detect_min_mm    == 0xffff)
      ||(h_max_mm           == 0xff))
  { 
    // Has to be parametred by user 
    // (default val in window_lib.h)
    window_height_mm = WINDOW_HEIGHT_MM;    // Restore window_height_mm
    gain = GAIN;                            // Restore gain
    pinch_threshold = PINCH_THRES;          // Restore pinch_threshold
    h_detect_min_mm = H_DETECT_MIN_MM;      // Restore h_detect_min
    h_max_mm = H_MAX_MM;                    // Restore h_max_mm
  }
  
  temp = (((U32)down<<8));                  // top_mm: number of hall sensor
  top_mm = (U16)(temp/window_height_mm);    // edges per millimeters * 256
  pinch = ((U16)gain*pinch_threshold) >> 5; //compute pinch value
 
  // ----------- Window lift considered correctly initiated/positionned --------
  if (INIT_EEP_DONE == init_to_perform)
  {
    h_detect_min = (U16)(((U32)h_detect_min_mm*top_mm)>>8);
    h_max = (U8)(((U32)h_max_mm*top_mm)>>8);
  }
  return (init_to_perform);
}

void save_window_parameters(void)
{
  U8 i;
  U8 *U8_ptr;
  U32 temp;
  U8 *eep_b_point_ptr;
  eep_b_point_ptr = (void *)&block_point; // pointer to block_point structure
  
  if (save_k > 1 && ctrl_state == STOP_STATE)// stop and then no operation (timer1_ovf)
  {
    // Check if window-lift has been operated and parameters need to be stored
    if (save_k==2)     
    {
      eep.param.position          = get_position();
      eep.param.last_direction    = last_direction;
      eep.param.gain              = gain;
      eep.param.pinch_threshold   = pinch_threshold;
      eep.param.window_height_mm  = window_height_mm;
      eep.param.h_detect_min_mm   = h_detect_min_mm;
      eep.param.h_max_mm          = h_max_mm;
      eep.param.down              = down;
      eep.param.backlash          = backlash;
      U8_ptr = eep.U8_ptr;
    }
    // New parameters have been uploaded, It requires storage to EEPROM
    else if(save_k == 3)  
    {
      U8_ptr = eep.U8_ptr;  // Initiliaze Pointer to parse 
      
      gain                      = eep.param.gain;
      pinch_threshold           = eep.param.pinch_threshold;
      window_height_mm          = eep.param.window_height_mm;
      h_detect_min_mm           = eep.param.h_detect_min_mm;
      h_max_mm                  = eep.param.h_max_mm;
      
      temp = (((U32)down<<8));                    // top_mm: number of hall sensor
      top_mm = (U16)(temp/window_height_mm);      // edges per millimeters * 256
      pinch = ((U16)gain*pinch_threshold) >> 5;   //compute pinch value

    }
    
    // EEPROM window lift parameters storage
    for (i = 0; i < sizeof(eep); i++)
    {
      EEPROM_write(i, U8_ptr[i]);
    }  
    // EEPROM window lift blocking points storage    
    for (i = 0; i < sizeof(block_point); i++)
    {
      EEPROM_write(i + PT_NUM_ADR, eep_b_point_ptr[i]);
    }
    save_k=1; // Update flag : parameters has been saved
  }
}

U8 window_ctrl(signed char *up_cmde,signed char *down_cmde,U8 no_anti_pinch)
{
  static U16 delay=0;
  static int k_init;
  U16 position = get_position();
  switch(ctrl_state)
  {
    //--------------------------------------------------------------------------
    case STOP_STATE:          // stop state
      SET_MOTOR_OFF();                //motor mosfet OFF
      if((position!=k_init) || (delay>0))
      {
        delay=0;
      }
      k_init=position;                //put init position
      last_direction=direction;       // save last operation direction to take mechanical backlash into account
      if (*up_cmde == CMDE_NEW_CMDE)
      {
        *up_cmde = CMDE_PERFORMED;
        if (position > (top_mm >> 7)) //software top limit (2 mm)
        {
          direction = UPWARD;         // upward
          RESET_MOTOR_DIRECTION();    // turn off direction relay
          SET_MOTOR_ON();             // motor mosfet ON
          ctrl_state=START_UP_STATE;
          delay=0;
          TCNT1=0; // Start initialization for speed measurment & timeout
        }
      }
      if (*down_cmde == CMDE_NEW_CMDE)
      {
          *down_cmde= CMDE_PERFORMED;
          direction = DOWNWARD;       // downward
          SET_MOTOR_DIRECTION();      // turn on direction relay
          //SET_MOTOR_ON();           // motor on in GO_DOWN_STATE
          delay=0;
          ctrl_state=GO_DOWN_STATE;
          TCNT1=0; // Start initialization for speed measurment & timeout
      }

      break;
    //--------------------------------------------------------------------------
    case START_UP_STATE:       // acceleration
      if (no_anti_pinch != ANTI_PINCH_DISABLED)
      {
        if(   (position < (k_init - backlash))
           || (position < (k_init - (backlash >> 2))
               &&last_direction == UPWARD) ) // start_up complete (backlash)
        {
          start_pos=position; // start position used to refresh blocking points
          update=1;           // flag used for blocking points
          ctrl_state=GO_UP_STATE;
        }
        else if (TIMEOUT)
        {
          if (current>5)
            ctrl_state=PINCH_STATE;
          else
          {
            /*INSERT CODE HERE
              TO REPORT A DEFAULT*/
          }
        }
      }
      else
      {
        start_pos=position; // start position used to determine backlash value
        ctrl_state = GO_UP_STATE;
      }
      if (*up_cmde == CMDE_NEW_CMDE || *down_cmde == CMDE_NEW_CMDE)
        ctrl_state=STOPING_STATE;
      break;
    //--------------------------------------------------------------------------
    case GO_UP_STATE:       // normal go upward operation
      if ( *up_cmde == CMDE_NEW_CMDE || *down_cmde == CMDE_NEW_CMDE)
        ctrl_state=STOPING_STATE;
        
      if ( (current > (pinch + ref + get_block_point(position))) || TIMEOUT )
      {
        if (position > h_max)
        {
          ctrl_state=OBSTRUCT_STATE;
        }
        else if (position < (top_mm >> 7)) // software top limit (2 mm)
        {
          SET_MOTOR_OFF();
          ctrl_state=STOP_STATE;
        }
        else if (TIMEOUT)
        {
          SET_MOTOR_OFF();
          ctrl_state=STOP_STATE;
          if ( (position < h_max) && (position>0)) // if mechanical top limit
            position--;                    // position correction
            put_position(position);
        }
      }
      else if (position < (top_mm >> 7))   //software top limit (2 mm)
      {
        ctrl_state = STOPING_STATE;
      }
      else if (current<5 && position<h_detect_min)
     {  // no current ( = defaut)
            /*INSERT CODE HERE
            TO REPORT A DEFAULT*/
        if (delay>30)       //go upward step by step in pinch area
        {
          ctrl_state = STOPING_STATE;
          delay=0;
        }
        else
          delay++;
     }

      break;
    //--------------------------------------------------------------------------
    case OBSTRUCT_STATE:     
            if (*up_cmde == CMDE_NEW_CMDE)
              ctrl_state=STOPING_STATE;
            
            // Check Anti-pinch rules
            if(   (position < h_detect_min)   // Check Pinch Area
               && (position > h_max) 
               && (direction == UPWARD)       // Check Direction
               && (no_anti_pinch == ANTI_PINCH_ENABLED))
            {
              ctrl_state=PINCH_STATE;         // Pinch conditions are met
            }
            else if (position < (top_mm >> 7))// Check software top limit (1mm)
            {
              SET_MOTOR_OFF();
              ctrl_state=STOP_STATE;
            }
            else if (TIMEOUT)                     // time out: null speed
            {
                SET_MOTOR_OFF();
                ctrl_state=STOP_STATE;
                if (position<h_max && position>0) //if mechanical top limit
                {
                  position--;                     // position correction
                  put_position(position);
                }
            }
            else
              ctrl_state=GO_UP_STATE;
            break;
    //--------------------------------------------------------------------------
    case PINCH_STATE:
            SET_MOTOR_OFF();            //pinch : stop motor
            if ((delay>5)&(current<5))  //delay & low current
            {
              ctrl_state=REVERSE_STATE;
              SET_MOTOR_DIRECTION();    // turn off direction relay
              TCNT1=0;                  // reset TIMEOUT
            }
            else
              delay++;
            break;
    //--------------------------------------------------------------------------
    case REVERSE_STATE:                 // pinch : go downward
            if (position<h_detect_min)
            {
              direction=DOWNWARD;
              SET_MOTOR_ON();           // turn on FET
            }
            else
            {
              ctrl_state=STOPING_STATE;
            }
            if(TIMEOUT)
              ctrl_state=STOPING_STATE;
            break;
    //--------------------------------------------------------------------------
    case STOPING_STATE:                   // stop request
            SET_MOTOR_OFF();              // turn off FET
            if (TIMEOUT)
            {
              RESET_MOTOR_DIRECTION();    // turn off direction relay
              *up_cmde = CMDE_PERFORMED;  // empty push button buffer
              *down_cmde = CMDE_PERFORMED;// to inhibit all commands
              ctrl_state=STOP_STATE;
            }
            break;
    //--------------------------------------------------------------------------
    case GO_DOWN_STATE:                   // go downward
              if(delay>20)                // wait relay in position
                SET_MOTOR_ON();           // motor mosfet ON
              else
                delay++;

              if (position>down)          // bottom stop limit
              {
                if(*down_cmde == CMDE_NO_CMDE || TIMEOUT)
                {
                  SET_MOTOR_OFF();
                  ctrl_state=STOPING_STATE;
                }
                else  // go down till push button relax or timeout
                {     // allow manually go_down

                  position=down;
                  put_position(position);
                }

              }
              else if (TIMEOUT)
              {
                if (current>5)      // ensure motor is connected : current > 0
                {
                  position=down;    // bottom: adjust position
                  put_position(down);
                  ctrl_state=STOPING_STATE;
                }
                else
                {
                  /* INSERT CODE HERE
                   * TO REPORT A DEFAULT
                   * HALL SENSOR TIMEOUT DETECTION
                   * AND NO CURRENT*/
                  ctrl_state=STOPING_STATE;
                  SET_MOTOR_OFF();  //
                }
              }
              if (*down_cmde == CMDE_NEW_CMDE || *up_cmde == CMDE_NEW_CMDE) 
              {
                ctrl_state=STOPING_STATE; //stop command
              }
              break;
    //--------------------------------------------------------------------------
    default:
            SET_MOTOR_OFF();        //motor mosfet OFF
            ctrl_state=STOP_STATE;
  }
  return (ctrl_state);
}

U8 blocking_point(signed char window_state)
{
  static U8 point_state=NORMAL_STATE; //blocking point state;
  U16 position=get_position();        

  //blocking point management
  if (window_state == GO_UP_STATE)
  {
    switch(point_state)
    {
      case NORMAL_STATE:
        if ((current-ref) > (pinch>>1) && position < h_detect_min)
        {
          point_temp.origin=position; // save hard/blocking origin position
          update=1;
          point_state = BLOCKING_STATE;
        }
        break;

      case BLOCKING_STATE:
        if ( (current-ref) < (pinch/3))
        {
          point_temp.end=position; // save hard/blocking end position
          point_state = SORT_STATE;
        }
        break;

      case SORT_STATE:
        update_point();
        point_state = NORMAL_STATE;
        break;

      default:
        point_state = NORMAL_STATE;
        break;
    }
  }
  else if (window_state == STOPING_STATE)
  {
    stop_pos=position;
    point_state = NORMAL_STATE;
  }
  else if (window_state == STOP_STATE)
  {
    if (update==1)
    {
      stop_pos=position;
      clean_point();
      update=0;
    }
    point_state = NORMAL_STATE;
  }

  return (point_state);
}

U8 update_point (void)
{
  U8 i=0,j=0;
  while ((block_point.point[i].end>point_temp.origin) && (i < (PT_NUM_MAX -1)))
         i++;
  if ( i < PT_NUM_MAX)
  {
    if (block_point.point[i].origin<=point_temp.end)
    {// new blocking point, shift following results
      if (block_point.pt_num<PT_NUM_MAX-1)
      {
        block_point.pt_num++;
        for(j=block_point.pt_num;j>i;j--)
        {
          block_point.point[j].origin = block_point.point[j-1].origin;
          block_point.point[j].end = block_point.point[j-1].end;
          block_point.point[j].occ = block_point.point[j-1].occ;
        }
        block_point.point[i].origin = point_temp.origin;
        block_point.point[i].end = point_temp.end;
        block_point.point[i].occ = 2;
      }
  
    }
    else
    {//update blocking point reference
      block_point.point[i].origin = point_temp.origin;
      block_point.point[i].end = point_temp.end;
      block_point.point[i].occ += 2;
      if (block_point.point[i].occ>=4)
        block_point.point[i].occ=5;
    }
  }
  else
  {
    // PT_NUM_MAX is reached: No more block points will be referenced
    // Nothing to do
  }
  return (0);
}

U8 get_table_indice (U16 position)
{
  U8 i=0;
  while (block_point.point[i].origin<position && i<PT_NUM_MAX &&block_point.point[i].origin!=0)  //get table indice of starting point
    i++;
  return (i);
}

void clean_point(void)
{
  U8 i=0,j,end;
  end = get_table_indice (start_pos);
  i = get_table_indice (stop_pos);
  while (i<block_point.pt_num && i<end)    // scan table elements (in the last move area)
  {
    block_point.point[i].occ--;
    if (block_point.point[i].occ==0) // erase data
    {
      for (j=i;j<block_point.pt_num;j++)
      {
        block_point.point[j].origin = block_point.point[j+1].origin;
        block_point.point[j].end = block_point.point[j+1].end;
        block_point.point[j].occ = block_point.point[j+1].occ;
      }
      block_point.point[j+1].origin=0;
      block_point.point[j+1].end=0;
      block_point.point[j+1].occ=0;
      if (block_point.pt_num>0)
        block_point.pt_num--;
    }
    i++;
  }
}

U8 get_block_point(U16 position)
{
  U8 i,blocking_value=0;
  for(i=0;i<PT_NUM_MAX;i++)
  {
    if (position<=block_point.point[i].origin)
    {
      if (position>=block_point.point[i].end)
      {
        blocking_value = (pinch>>1);
        break;
      }
    }
  }
  return (blocking_value);
}

void erase_block_point(void)
{
  U8 i, *b_point_ptr;
  b_point_ptr = (void *)&block_point; // pointer to block_point structure
  for(i=0;i<sizeof(block_point);i++)
  {
    b_point_ptr[i] = 0;
  }
}

void block_point_set_origin(U16 origin)
{
  U8 i;
  for(i=0;i<PT_NUM_MAX;i++)
  {
    if (block_point.point[i].occ != 0)
    {
    block_point.point[i].origin -= origin;
    block_point.point[i].end    -= origin;
    }
  }
}

void init_window_peripherals(void)
{
#if defined (__ATmega88__) || defined (__ATmega168__) || defined (__AVR_ATmega88__) || defined (__AVR_ATmega168__)
  
   /*init PCINT 10  Pin change interrupt initialisation */
  PCICR |= 1 << PCIE1;     // PCINT14...8 interrupt pins enabled 
  PCMSK1 |= 1 << PCINT10;  // PCINT10 interrupt pin enabled 
  
  /* init ADC */
  ADMUX |= 1 << REFS0;     // conversion result right ajusted in ADC, AVCC with external capacitor at AREF pin, ADC0 selected
  
  /* init timer/counter 1 */
  TCCR1B = TCCR1B | (1 << CS12);  // CS12 = 1, period = 2.097152 sec
  TIMSK1 |= 1<<TOIE1;             // enable timer/counter1 overflow interrupt 
  
  /* init timer/counter 0 */
  TCCR0B = TCCR0B | (1 << CS01)/*|(1 << CS00)*/;  // clock = fclock/8
  TIMSK0 |= 1<<TOIE0;             // enable timer 0 overflow interrupt   


#elif defined(__AT90PWM2__) || defined(__AT90PWM3__) || defined(__AVR_AT90PWM2__) || defined(__AVR_AT90PWM3__)
  // Init External interrupt for Hall effect sensors
  EICRA = 0x01; // Rising Edge
  EIMSK = 0x01; // INT0

  // Init ADC and Amplifier for current measurement
  init_adc();
  init_amp0();

  // Init Timer/Counter 0 to execute the current measurement
  TCCR0B = TCCR0B | (1 << CS01)/*|(1 << CS00)*/;  // clock = fclock/8
  TIMSK0 |= 1<<TOIE0;             // enable overflow interrupt on timer 0

  // Init Timer/Counter 1 to save parameters every 2 sec
  TCCR1B = TCCR1B | (1 << CS12);  // CS12 = 1, period = 2.097152 sec
  TIMSK1 |= 1<<TOIE1;             // interrupt enable on timer/counter1 overflow

#else
  #error "Update init_window_peripherals() routine for your MCU"
#endif
}

---