window_lib.h File Reference

#include "config.h"

Go to the source code of this file.

Data Structures
struct	st_eep_WindowParam
	Structure used to store window lift parameters in eeprom. More...
union	un_eep_WindowParam
	union used to easily parse eeprom parameters structure More...
struct	st_b_point
	definition of window lift blocking points data type More...
struct	st_b_point_tab
Defines
#define	PINCH_THRES   80
	Newton value, Threshold added to reference for comparison with motor current.
#define	GAIN   27
	GAIN : Necessary to determine PINCH value.
#define	PINCH   (unsigned char)(GAIN * PINCH_THRES >> 5)
	Default Comparison Value (computed to be in range with ADC gain) Right shifted after computation (because gain was left shifted).
#define	WINDOW_HEIGHT_MM   450
	height of the window in mm, used to determine anti-pinch working area, Default value used to initiate eeprom while nothing has been parametred.
#define	TOP_MM   2.0222
	Number of hall effect sensor tops/mm = hall_tops/window_height Default value to compute following areas.
#define	H_DETECT_MIN_MM   210
	Distance from top of window to activate anti-pinch in millimeters (mm).
#define	H_DETECT_MIN   (U16)(H_DETECT_MIN_MM*TOP_MM)
	Distance from top to activate anti-pinch (in hall sensor edges number).
#define	H_MAX_MM   20
	Distance from top of window to inactivate anti-pinch in mm (rubber + 4mm).
#define	H_MAX   (U16)(H_MAX_MM*TOP_MM)
	Distance from top to inactivate anti-pinch (in hall sensor edges number).
#define	DOWN   (U16)(WINDOW_HEIGHT_MM*TOP_MM)
	Default Distance between window top and bottom (in hall sensor edges number).
#define	PT_NUM_MAX   8
	Max number of storable Blocking point in eeprom.
#define	PT_NUM_ADR   15
	Eeprom address of saved blocking points number.
#define	STOP_STATE   0
	Window lift stopped: waiting up/down commands.
#define	START_UP_STATE   1
	Transient state: waiting mechanical backlash end.
#define	GO_UP_STATE   2
	Window is moving up: Monitor position & current.
#define	OBSTRUCT_STATE   3
	Pinching condition has been met by current monitoring: check postion vs pinch area.
#define	PINCH_STATE   4
	Pinch Confirmed: Reverse window movement (Standard behavior).
#define	REVERSE_STATE   5
	Waiting reverse movement end: monitors position is down to pinch area.
#define	STOPING_STATE   6
	Waiting motor to be stopped (Timeout).
#define	GO_DOWN_STATE   7
	Window is moving down.
#define	NORMAL_STATE   1
#define	BLOCKING_STATE   2
#define	SORT_STATE   5
#define	INIT_START_INIT   0
#define	INIT_DETECT_BOTTOM   1
#define	INIT_START_TOP_DETECT   2
#define	INIT_DETECT_TOP   3
#define	INIT_COMPUTE_PARAMS   4
#define	INIT_BACKLASH_START   5
#define	INIT_BACKLASH_DOWN   6
#define	INIT_BACKLASH_ACQUIRE   7
#define	INIT_END_INIT   8
#define	INIT_EEP_DONE   0x00
#define	INIT_POSITION_REQUEST   0x01
#define	INIT_RE_INIT   0x80
#define	ANTI_PINCH_ENABLED   0
	enables anti-pinch through window_ctrl()
#define	ANTI_PINCH_DISABLED   1
	disables anti-pinch through window_ctrl()
#define	CMDE_NO_CMDE   0
	No up, down or stop command requested.
#define	CMDE_NEW_CMDE   1
	Up, down or stop command requested.
#define	CMDE_PERFORMED   2
	Up, down or stop command performed.
#define	UPWARD   1
	Operating direction is upward.
#define	DOWNWARD   0
	Operating direction is downward.
Functions
U8	Read_Eep_WindowParameters (void)
	Read and check parameters stored into eeprom.
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.
signed char	get_window_state (void)
	get_window_state reports state Returns window control machine 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
signed char	force_window_state (signed char temp)
	force_window_state Forces state
void	save_window_parameters (void)
	Store window-lift parameters to eeprom memory when required.
U8	window_ctrl (signed char *, signed char *, U8)
	Manage window lift.
U8	update_point (void)
	Creates/Refresh data in the blocking points table.
void	clean_point (void)
	erase not existing blocking points (which stopped to occur)
U8	get_table_indice (U16)
	get the indice of the next blocking point referenced in the table in function of a given position
U8	blocking_point (signed char)
	blocking point detection state machine
U8	get_block_point (U16)
	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
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	direction
	Window operating direction (according to command).
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).
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).
U8	h_max
	Distance from top of window to inactivate anti-pinch in hall sensor edges computed using h_max_mm and down variables.

---

Define Documentation

#define PT_NUM_MAX   8

Max number of storable Blocking point in eeprom.

Definition at line 113 of file window_lib.h.

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

#define PT_NUM_ADR   15

Eeprom address of saved blocking points number.

Definition at line 116 of file window_lib.h.

Referenced by Read_Eep_WindowParameters(), and save_window_parameters().

#define NORMAL_STATE   1

Definition at line 142 of file window_lib.h.

Referenced by blocking_point().

#define BLOCKING_STATE   2

Definition at line 143 of file window_lib.h.

Referenced by blocking_point().

#define SORT_STATE   5

Definition at line 145 of file window_lib.h.

Referenced by blocking_point().

#define UPWARD   1

Operating direction is upward.

Definition at line 182 of file window_lib.h.

Referenced by window_ctrl().

#define DOWNWARD   0

Operating direction is downward.

Definition at line 183 of file window_lib.h.

Referenced by window_ctrl().

---

Function Documentation

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 st_eep_WindowParam::backlash, backlash, block_point, st_eep_WindowParam::down, down, eep, st_eep_WindowParam::gain, gain, st_eep_WindowParam::h_detect_min_mm, h_detect_min_mm, st_eep_WindowParam::h_max_mm, h_max_mm, INIT_EEP_DONE, INIT_POSITION_REQUEST, st_eep_WindowParam::last_direction, last_direction, un_eep_WindowParam::param, st_eep_WindowParam::pinch_threshold, pinch_threshold, st_eep_WindowParam::position, position, st_b_point_tab::pt_num, PT_NUM_ADR, PT_NUM_MAX, un_eep_WindowParam::U8_ptr, st_eep_WindowParam::window_height_mm, and 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);
}

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);
}

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);
}

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);
}

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);
}

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 backlash, st_eep_WindowParam::backlash, block_point, ctrl_state, down, st_eep_WindowParam::down, eep, gain, st_eep_WindowParam::gain, get_position(), h_detect_min_mm, st_eep_WindowParam::h_detect_min_mm, h_max_mm, st_eep_WindowParam::h_max_mm, last_direction, st_eep_WindowParam::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, window_height_mm, and st_eep_WindowParam::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 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);
}

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_table_indice

(

U16

)

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);
}

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

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().

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().

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().

---