window_lib.c File Reference

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

Go to the source code of this file.

Functions
signed char	get_window_state (void)
	get_window_state reports state Returns window control machine state
signed char	force_window_state (signed char temp)
	force_window_state Forces state
U16	get_h_detect_min (void)
	get_h_detect_min reports the distance from top to activate anti-pinch
U8	get_h_max (void)
	get_h_max reports the distance from top to disable anti-pinch
U8	init_window_size_position ()
	Allows to automatically operate window down, then up to detect Bottom and top ends, and backlash : It's an adaptation routine.
U8	Read_Eep_WindowParameters (void)
	Read and check parameters stored into eeprom.
void	save_window_parameters (void)
	Store window-lift parameters to eeprom memory when required.
U8	window_ctrl (signed char *up_cmde, signed char *down_cmde, U8 no_anti_pinch)
	Manage window lift.
U8	blocking_point (signed char window_state)
	blocking point detection state machine
U8	update_point (void)
	Creates/Refresh data in the blocking points table.
U8	get_table_indice (U16 position)
	get the indice of the next blocking point referenced in the table in function of a given position
void	clean_point (void)
	erase not existing blocking points (which stopped to occur)
U8	get_block_point (U16 position)
	Returns blocking point value for the given position.
void	erase_block_point (void)
	clear all block points structure fields.
void	block_point_set_origin (U16 origin)
	Changes All blocking points reference/origin position. Useful after adaptation time (first init) : after reference origin is known.
void	init_window_peripherals (void)
	Initialize window lift requiered peripherals like ADC, TIMERs, Pin Change, Interrupts.
Variables
un_eep_WindowParam	eep
	eeprom parameters
U8	last_direction
	Window operating direction during last operation (according to command).
U8	direction
	Window operating direction (according to command).
signed char	ctrl_state = STOP_STATE
	Window-lift Control state (see Window lift control state machine definitions).
U16	position
	Window position buffer.
U16	ref
	Computed current reference ( I(A) <-> ADC * ADC gain ).
U16	current
	Current Image: Has to be filtered (meaned) for the algorithm to work well.
U8	pinch_threshold
	Pinch Threshold: Must be parametred by user (in Newton).
U16	pinch
	Normalized pinch threshold according to gain (motor & ADC parameters).
U8	gain
	Global gain to determine pinch value.
U8	h_max_mm
	Distance from top of window to inactivate anti-pinch in mm Filled by used in eeprom or by default value (see Default Window area and measurement definitions).
U8	h_max
	Distance from top of window to inactivate anti-pinch in hall sensor edges computed using h_max_mm and down variables.
U16	window_height_mm
	Opening apartus height in millimeters (filled by user) (see Default Window area and measurement definitions).
U16	h_detect_min_mm
	Distance from top of window to activate anti-pinch in millimeters (mm) Filled by used in eeprom or by default value (see Default Window area and measurement definitions).
U16	h_detect_min
	Distance from top to activate anti-pinch (in hall sensor edges number) computed using h_detect_min_mm and down variables.
U16	top_mm
	number of hall sensor edges per millimeters (left shifted by 8 to allow a good precision, see Default Window area and measurement definitions).
U16	backlash
	Backlash value (measured, in hall sensor edges number when revesing direction at intialization time by adaptation routine : init_window_size_position()).
U16	down
	Down is the number of hall sensor edges for a top to bottom operation Filled by adaptation routine or by user (see Default Window area and measurement definitions).
st_b_point_tab	block_point
	blocking points ram storing table.
st_b_point	point_temp
	blocking point temporary buffer.
U16	start_pos
	Remembers the start position of the window lift to refresh blocking points table, starting from this position, when window lift operation ends.
U16	stop_pos
	Remembers the stop position of the window lift to refresh blocking points table, until this position, when window lift operation ends.
U8	update = 0
	Flag used to refresh blocking points when window lift operation ends.

---

Function Documentation

signed char get_window_state

(

void

)

get_window_state reports state Returns window control machine state

Returns:

window state

Definition at line 158 of file window_lib.c.

References ctrl_state.

{
  return (ctrl_state);
}

signed char force_window_state

(

signed char

temp

)

force_window_state Forces state

Force window control machine state

Returns:

window state

Definition at line 168 of file window_lib.c.

References ctrl_state.

Referenced by init_window_size_position().

{
  ctrl_state=temp;
  return (ctrl_state);
}

U16 get_h_detect_min

(

void

)

get_h_detect_min reports the distance from top to activate anti-pinch

Returns:

bottom height limit to activate anti-pinch (in hall sensor 'tops')

Definition at line 178 of file window_lib.c.

References h_detect_min.

{
  return (h_detect_min);
}

U8 get_h_max

(

void

)

get_h_max reports the distance from top to disable anti-pinch

Returns:

bottom height limit to activate anti-pinch (in hall sensor 'tops')

Definition at line 187 of file window_lib.c.

References h_max.

{
  return (h_max);
}

U8 init_window_size_position

(

void

)

Allows to automatically operate window down, then up to detect Bottom and top ends, and backlash : It's an adaptation routine.

An init loop runs until init ends (until init_state isn't INIT_END_INIT) After each complete analog conversion, (ADIF read to 1 is reseted) state machine is executed:

• init state: initiate a downward opertation, next state will be bottom detection.
• bottom detection: state monitors overcurrent. An overccurrent lead to consider that window is at bottom position. So, Position is changed to it's maximum value 0xFFFF, Next state is set to top detection and upward opertation begins.
• Top detection: This state monitors overcurrent. During this step, position is updated by hall_sensor_ISR (decremented while window is moving upward) An overcurrent lead to consider, that window is at top position. Then, Next state is to compute parameters while stoping window.
• Compute parameters: Difference between 0xFFFF and current position is stored in 'down' to reference bottom position. Position is set to 0 (origin position). As Parameters are computed, start learning backlash
• Start mechanical backlash: Initiate a new downward operation.
• Downard operation: Until window-lift is into anti-pinch area. Then stop operation and start backlash aquisition.
• Backlash aquisition: Allow to measure Backlash (mechanical non-linearity) when a reverse direction operation is performed. It uses current and reference to do so. Next step ends initialization.

  Warning:

  • Function shall be interrupted by hall_sensor_ISR which refreshes position value on hall sensor edges.
  • Function ends only when all operations have been performed.

  Parameters:

  none,use

  globals

  Precondition:

  Precondition.init_window_peripherals should have been called before.

Definition at line 233 of file window_lib.c.

References ANTI_PINCH_DISABLED, backlash, block_point_set_origin(), blocking_point(), CMDE_NEW_CMDE, CMDE_NO_CMDE, current, down, erase_block_point(), force_window_state(), get_position(), GO_DOWN_STATE, h_detect_min, h_detect_min_mm, h_max, h_max_mm, INIT_BACKLASH_ACQUIRE, INIT_BACKLASH_DOWN, INIT_BACKLASH_START, INIT_COMPUTE_PARAMS, INIT_DETECT_BOTTOM, INIT_DETECT_TOP, INIT_END_INIT, INIT_START_INIT, INIT_START_TOP_DETECT, pinch, put_position(), ref, STOP_STATE, STOPING_STATE, top_mm, window_ctrl(), and window_height_mm.

{
  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

)

Read and check parameters stored into eeprom.

Reads EEprom to load parameters, When they are not initialized:

• initialize them using default parameters
• returns a status to require a parameter identification/adaptation

Returns:

Initialisation status (see Initialisation status definitions)

Definition at line 375 of file window_lib.c.

References backlash, st_eep_WindowParam::backlash, block_point, down, st_eep_WindowParam::down, eep, gain, st_eep_WindowParam::gain, h_detect_min_mm, st_eep_WindowParam::h_detect_min_mm, h_max_mm, st_eep_WindowParam::h_max_mm, INIT_EEP_DONE, INIT_POSITION_REQUEST, last_direction, st_eep_WindowParam::last_direction, un_eep_WindowParam::param, pinch_threshold, st_eep_WindowParam::pinch_threshold, position, st_eep_WindowParam::position, st_b_point_tab::pt_num, PT_NUM_ADR, PT_NUM_MAX, un_eep_WindowParam::U8_ptr, window_height_mm, and st_eep_WindowParam::window_height_mm.

{
  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

)

Store window-lift parameters to eeprom memory when required.

Store parameters table and blocking to eeprom according to sake_k flag:

• When sake_k flag equals 2, actually used parameters are stored
• When sake_k flag equals 3, New parameters are stored, overwriting those actually used.
• Otherwise, do nothing

Warning:

sake_k has to be 2 or 3 for parameters to be written. Flag is then cleared (set to 1)

Definition at line 458 of file window_lib.c.

References st_eep_WindowParam::backlash, backlash, block_point, ctrl_state, st_eep_WindowParam::down, down, eep, st_eep_WindowParam::gain, gain, get_position(), st_eep_WindowParam::h_detect_min_mm, h_detect_min_mm, st_eep_WindowParam::h_max_mm, h_max_mm, st_eep_WindowParam::last_direction, last_direction, un_eep_WindowParam::param, pinch, st_eep_WindowParam::pinch_threshold, st_eep_WindowParam::position, PT_NUM_ADR, save_k, STOP_STATE, un_eep_WindowParam::U8_ptr, st_eep_WindowParam::window_height_mm, and window_height_mm.

{
  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
	)

Manage window lift.

Manage window lift operations according to upward, downward and no_anti_pinch commands. Monitors measured current and position to reverse window when necessary.

Warning:

Ensure all initialization has been performed before enabling anti-pinch. ADC must be complete and result must be filtered before using it!

Parameters:

	*up_cmde	Initiate or Report command (see window_ctrl() parameter)
	*down_cmde	Range : CMDE_NO_CMDE, CMDE_NEW_CMDE, CMDE_PERFORMED
	no_anti_pinch	Enable/disable anti-pinch window_ctrl() parameter

Precondition:

Precondition.mean_16 should have been called before

Returns:

(U8)window control machine state (see Window lift control state machine definitions)

Definition at line 529 of file window_lib.c.

References ANTI_PINCH_DISABLED, ANTI_PINCH_ENABLED, backlash, CMDE_NEW_CMDE, CMDE_NO_CMDE, CMDE_PERFORMED, ctrl_state, current, direction, down, DOWNWARD, get_block_point(), get_position(), GO_DOWN_STATE, GO_UP_STATE, h_detect_min, h_max, last_direction, OBSTRUCT_STATE, pinch, PINCH_STATE, position, put_position(), ref, REVERSE_STATE, start_pos, START_UP_STATE, STOP_STATE, STOPING_STATE, update, and UPWARD.

Referenced by init_window_size_position().

{
  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

)

blocking point detection state machine

Manages blocking point detection state machine. It's used to calibrate and update blocking points.

Parameters:

window_state

is required for detection to be synchronized on the window lift state machine.

Precondition:

Precondition.window_ctrl should have been called before.

Definition at line 775 of file window_lib.c.

References BLOCKING_STATE, clean_point(), current, st_b_point::end, get_position(), GO_UP_STATE, h_detect_min, NORMAL_STATE, st_b_point::origin, pinch, point_temp, position, ref, SORT_STATE, stop_pos, STOP_STATE, STOPING_STATE, update, and update_point().

Referenced by init_window_size_position().

{
  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

)

Creates/Refresh data in the blocking points table.

Definition at line 833 of file window_lib.c.

References block_point, st_b_point::end, st_b_point::occ, st_b_point::origin, st_b_point_tab::point, point_temp, st_b_point_tab::pt_num, and PT_NUM_MAX.

Referenced by blocking_point().

{
  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

)

get the indice of the next blocking point referenced in the table in function of a given position

Definition at line 877 of file window_lib.c.

References block_point, st_b_point::origin, st_b_point_tab::point, and PT_NUM_MAX.

Referenced by clean_point().

{
  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

)

erase not existing blocking points (which stopped to occur)

Definition at line 887 of file window_lib.c.

References block_point, st_b_point::end, get_table_indice(), st_b_point::occ, st_b_point::origin, st_b_point_tab::point, st_b_point_tab::pt_num, start_pos, and stop_pos.

Referenced by blocking_point().

{
  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

)

Returns blocking point value for the given position.

When a blocking point has been registered for the position provided in parameter, returns the threshold to be added to pinch value. Otherwise, when no blocking point is registered for this position, returns 0

Parameters:

position

Any position where a blocking point could exist

Returns:

Blocking point threshold for this position or 0

Definition at line 923 of file window_lib.c.

References block_point, st_b_point::end, st_b_point::origin, pinch, st_b_point_tab::point, and PT_NUM_MAX.

Referenced by window_ctrl().

{
  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

)

clear all block points structure fields.

Writes 0 to all block point fields (in RAM)

Definition at line 944 of file window_lib.c.

References block_point.

Referenced by init_window_size_position().

{
  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

)

Changes All blocking points reference/origin position. Useful after adaptation time (first init) : after reference origin is known.

Parse blocking point table to change all existing points origin and end positions

Parameters:

origin

Actual origin offset, which shall be removed

Definition at line 962 of file window_lib.c.

References block_point, st_b_point::end, st_b_point::occ, st_b_point::origin, st_b_point_tab::point, and PT_NUM_MAX.

Referenced by init_window_size_position().

{
  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

)

Initialize window lift requiered peripherals like ADC, TIMERs, Pin Change, Interrupts.

Depending on MCU used:

• Initialize Timer 1, Timer 0 as counters with overflow interrupts
• Initialize Pinch Change interrupt
• Initialize ADC

Warning:

used MCU shall be defined in config.h

Definition at line 985 of file window_lib.c.

{
#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
}

---

Variable Documentation

U8 h_max_mm

Distance from top of window to inactivate anti-pinch in mm Filled by used in eeprom or by default value (see Default Window area and measurement definitions).

Definition at line 102 of file window_lib.c.

Referenced by init_window_size_position(), Read_Eep_WindowParameters(), and save_window_parameters().

U8 h_max

Distance from top of window to inactivate anti-pinch in hall sensor edges computed using h_max_mm and down variables.

Definition at line 106 of file window_lib.c.

Referenced by get_h_max(), init_window_size_position(), and window_ctrl().

U16 window_height_mm

Opening apartus height in millimeters (filled by user) (see Default Window area and measurement definitions).

Definition at line 110 of file window_lib.c.

Referenced by init_window_size_position(), Read_Eep_WindowParameters(), and save_window_parameters().

U16 h_detect_min_mm

Distance from top of window to activate anti-pinch in millimeters (mm) Filled by used in eeprom or by default value (see Default Window area and measurement definitions).

Definition at line 114 of file window_lib.c.

Referenced by init_window_size_position(), Read_Eep_WindowParameters(), and save_window_parameters().

U16 h_detect_min

Distance from top to activate anti-pinch (in hall sensor edges number) computed using h_detect_min_mm and down variables.

Definition at line 118 of file window_lib.c.

Referenced by blocking_point(), get_h_detect_min(), init_window_size_position(), and window_ctrl().

U16 top_mm

number of hall sensor edges per millimeters (left shifted by 8 to allow a good precision, see Default Window area and measurement definitions).

Definition at line 122 of file window_lib.c.

Referenced by init_window_size_position().

U16 backlash

Backlash value (measured, in hall sensor edges number when revesing direction at intialization time by adaptation routine : init_window_size_position()).

Definition at line 127 of file window_lib.c.

Referenced by init_window_size_position(), Read_Eep_WindowParameters(), save_window_parameters(), and window_ctrl().

U16 down

Down is the number of hall sensor edges for a top to bottom operation Filled by adaptation routine or by user (see Default Window area and measurement definitions).

Definition at line 131 of file window_lib.c.

Referenced by init_window_size_position(), Read_Eep_WindowParameters(), save_window_parameters(), and window_ctrl().

st_b_point_tab block_point

blocking points ram storing table.

It's managed by blocking_point() routine It contains all detected blocking points, and is adapted at operating time.

Definition at line 135 of file window_lib.c.

Referenced by block_point_set_origin(), clean_point(), erase_block_point(), get_block_point(), get_table_indice(), Read_Eep_WindowParameters(), save_window_parameters(), and update_point().

st_b_point point_temp

blocking point temporary buffer.

It's managed by blocking_point() routine while operating to add or refresh blocking points in block_point structure.

Definition at line 139 of file window_lib.c.

Referenced by blocking_point(), and update_point().

U16 start_pos

Remembers the start position of the window lift to refresh blocking points table, starting from this position, when window lift operation ends.

Definition at line 143 of file window_lib.c.

Referenced by clean_point(), and window_ctrl().

U16 stop_pos

Remembers the stop position of the window lift to refresh blocking points table, until this position, when window lift operation ends.

Definition at line 147 of file window_lib.c.

Referenced by blocking_point(), and clean_point().

U8 update = 0

Flag used to refresh blocking points when window lift operation ends.

Definition at line 150 of file window_lib.c.

Referenced by blocking_point(), and window_ctrl().

---