qep.h

Go to the documentation of this file.

/* --COPYRIGHT--,BSD
 * Copyright (c) 2015, Texas Instruments Incorporated
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * *  Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * *  Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * *  Neither the name of Texas Instruments Incorporated nor the names of
 *    its contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 * --/COPYRIGHT--*/
#ifndef _QEP_H_
#define _QEP_H_



// **************************************************************************
// the includes

// drivers
#include "sw/drivers/cpu/src/32b/f28x/f2806x/cpu.h"


// modules
#include "sw/modules/math/src/32b/math.h"
#include "sw/modules/types/src/types.h"





#ifdef __cplusplus
extern "C" {
#endif


// **************************************************************************
// the defines

#define QEP1_BASE_ADDR      (0x00006B00)

#define QEP2_BASE_ADDR      (0x00006B40)

// QDECCTL Register
#define QEP_QDECCTL_QSRC                     (3  << 14)     
#define QEP_QDECCTL_SOEN                     (1  << 13)     
#define QEP_QDECCTL_SPSEL                    (1  << 12)     
#define QEP_QDECCTL_XCR                      (1  << 11)     
#define QEP_QDECCTL_SWAP                     (1  << 10)     
#define QEP_QDECCTL_IGATE                    (1  <<  9)     
#define QEP_QDECCTL_QAP                      (1  <<  8)     
#define QEP_QDECCTL_QBP                      (1  <<  7)     
#define QEP_QDECCTL_QIP                      (1  <<  6)     
#define QEP_QDECCTL_QSP                      (1  <<  5)     

// QEPCTL Register
#define QEP_QEPCTL_FREESOFT                  ( 3 << 14)     
#define QEP_QEPCTL_PCRM                      ( 3 << 12)     
#define QEP_QEPCTL_SEI                       ( 3 << 10)     
#define QEP_QEPCTL_IEI                       ( 3 <<  8)     
#define QEP_QEPCTL_SWI                       ( 1 <<  7)     
#define QEP_QEPCTL_SEL                       ( 1 <<  6)     
#define QEP_QEPCTL_IEL                       ( 3 <<  4)     
#define QEP_QEPCTL_QPEN                      ( 1 <<  3)     
#define QEP_QEPCTL_QCLM                      ( 1 <<  2)     
#define QEP_QEPCTL_UTE                       ( 1 <<  1)     
#define QEP_QEPCTL_WDE                       ( 1 <<  0)     

// QPOSCTL Register
#define QEP_QPOSCTL_PCSHDW                   (   1 << 15)   
#define QEP_QPOSCTL_PCLOAD                   (   1 << 14)   
#define QEP_QPOSCTL_PCPOL                    (   1 << 13)   
#define QEP_QPOSCTL_PCE                      (   1 << 12)   
#define QEP_QPOSCTL_PCSPW                    (4095 <<  0)   

// QCAPCTL Register
#define QEP_QCAPCTL_CEN                      (   1 << 15)   
#define QEP_QCAPCTL_CCPS                     (   7 <<  4)   
#define QEP_QCAPCTL_UPPS                     (  15 <<  0)   

// QEINT Register
#define QEP_QEINT_UTO                        (   1 << 11)   
#define QEP_QEINT_IEL                        (   1 << 10)   
#define QEP_QEINT_SEL                        (   1 <<  9)   
#define QEP_QEINT_PCM                        (   1 <<  8)   
#define QEP_QEINT_PCR                        (   1 <<  7)   
#define QEP_QEINT_PCO                        (   1 <<  6)   
#define QEP_QEINT_PCU                        (   1 <<  5)   
#define QEP_QEINT_WTO                        (   1 <<  4)   
#define QEP_QEINT_QDC                        (   1 <<  3)   
#define QEP_QEINT_QPE                        (   1 <<  2)   
#define QEP_QEINT_PCE                        (   1 <<  1)   

// QFLG Register
#define QEP_QFLG_UTO                         (   1 << 11)   
#define QEP_QFLG_IEL                         (   1 << 10)   
#define QEP_QFLG_SEL                         (   1 <<  9)   
#define QEP_QFLG_PCM                         (   1 <<  8)   
#define QEP_QFLG_PCR                         (   1 <<  7)   
#define QEP_QFLG_PCO                         (   1 <<  6)   
#define QEP_QFLG_PCU                         (   1 <<  5)   
#define QEP_QFLG_WTO                         (   1 <<  4)   
#define QEP_QFLG_QDC                         (   1 <<  3)   
#define QEP_QFLG_QPE                         (   1 <<  2)   
#define QEP_QFLG_PCE                         (   1 <<  1)   

// QCLR Register
#define QEP_QCLR_UTO                         (   1 << 11)   
#define QEP_QCLR_IEL                         (   1 << 10)   
#define QEP_QCLR_SEL                         (   1 <<  9)   
#define QEP_QCLR_PCM                         (   1 <<  8)   
#define QEP_QCLR_PCR                         (   1 <<  7)   
#define QEP_QCLR_PCO                         (   1 <<  6)   
#define QEP_QCLR_PCU                         (   1 <<  5)   
#define QEP_QCLR_WTO                         (   1 <<  4)   
#define QEP_QCLR_QDC                         (   1 <<  3)   
#define QEP_QCLR_QPE                         (   1 <<  2)   
#define QEP_QCLR_PCE                         (   1 <<  1)   

// QFRC Register
#define QEP_QFRC_UTO                         (   1 << 11)   
#define QEP_QFRC_IEL                         (   1 << 10)   
#define QEP_QFRC_SEL                         (   1 <<  9)   
#define QEP_QFRC_PCM                         (   1 <<  8)   
#define QEP_QFRC_PCR                         (   1 <<  7)   
#define QEP_QFRC_PCO                         (   1 <<  6)   
#define QEP_QFRC_PCU                         (   1 <<  5)   
#define QEP_QFRC_WTO                         (   1 <<  4)   
#define QEP_QFRC_QDC                         (   1 <<  3)   
#define QEP_QFRC_QPE                         (   1 <<  2)   
#define QEP_QFRC_PCE                         (   1 <<  1)   

// QEPSTS Register
#define QEP_QEPSTS_UPEVNT                   (   1 << 7)     
#define QEP_QEPSTS_FDF                      (   1 << 6)     
#define QEP_QEPSTS_QDF                      (   1 << 5)     
#define QEP_QEPSTS_QDLF                     (   1 << 4)     
#define QEP_QEPSTS_COEF                     (   1 << 3)     
#define QEP_QEPSTS_CDEF                     (   1 << 2)     
#define QEP_QEPSTS_FIMF                     (   1 << 1)     
#define QEP_QEPSTS_PCEF                     (   1 << 0)     

// **************************************************************************
// the typedefs

typedef enum
{
    QEP_Qsrc_Quad_Count_Mode=(0 << 14),                     
    QEP_Qsrc_Dir_Count_Mode=(1 << 14),                      
    QEP_Qsrc_Up_Count_Mode=(2 << 14),                       
    QEP_Qsrc_Down_Count_Mode=(3 << 14)                      
} QEP_Qsrc_e;

typedef enum
{
    QEP_Spsel_Index_Pin_Sync_Output=(0 << 12),              
    QEP_Spsel_Strobe_Pin_Sync_Output=(1 << 12)              
} QEP_Spsel_e;

typedef enum
{
    QEP_Xcr_2x_Res=(0 << 11),                               
    QEP_Xcr_1x_Res=(1 << 11)                                
} QEP_Xcr_e;

typedef enum
{
    QEP_Swap_Not_Swapped=(0 << 10),                         
    QEP_Swap_Swapped=(1 << 10)                              
} QEP_Swap_e;

typedef enum
{
    QEP_Igate_Disable=(0 << 9),                             
    QEP_Igate_Enable=(1 << 9)                               
} QEP_Igate_e;

typedef enum
{
    QEP_Qap_No_Effect=(0 << 8),                             
    QEP_Qap_Inverted=(1 << 8)                               
} QEP_Qap_e;

typedef enum
{
    QEP_Qbp_No_Effect=(0 << 7),                             
    QEP_Qbp_Inverted=(1 << 7)                               
} QEP_Qbp_e;

//
typedef enum
{
    QEP_Qip_No_Effect=(0 << 6),                             
    QEP_Qip_Inverted=(1 << 6)                               
} QEP_Qip_e;

typedef enum
{
    QEP_Qsp_No_Effect=(0 << 5),                             
    QEP_Qsp_Inverted=(1 << 5)                               
} QEP_Qsp_e;

typedef enum
{
    QEPCTL_Freesoft_Immediate_Halt=(0 << 14),               
    QEPCTL_Freesoft_Rollover_Halt=(1 << 14),                
    QEPCTL_Freesoft_Unaffected_Halt=(2 << 14)               
} QEPCTL_Freesoft_e;

typedef enum
{
    QEPCTL_Pcrm_Index_Reset=(0 << 12),                      
    QEPCTL_Pcrm_Max_Reset=(1 << 12),                        
    QEPCTL_Pcrm_First_Index_Reset=(2 << 12),                
    QEPCTL_Pcrm_Unit_Time_Reset=(3 << 12)                   
} QEPCTL_Pcrm_e;

typedef enum
{
    QEPCTL_Sei_Nothing=(0 << 10),                           
    QEPCTL_Sei_Rising_Edge_Init=(2 << 10),                  
    QEPCTL_Sei_Rising_Falling_Edge_Init=(3 << 10)           
} QEPCTL_Sei_e;

typedef enum
{
    QEPCTL_Iei_Nothing=(0 << 8),                            
    QEPCTL_Iei_Rising_Edge_Init=(2 << 8),                   
    QEPCTL_Iei_Rising_Falling_Edge_Init=(3 << 8)            
} QEPCTL_Iei_e;

typedef enum
{
    QEPCTL_Swi_Nothing=(0 << 7),                            
    QEPCTL_Swi_Auto_Init_Counter=(1 << 7)                   
} QEPCTL_Swi_e;

typedef enum
{
    QEPCTL_Sel_Rising_Edge=(0 << 6),                        
    QEPCTL_Sel_Rising_Falling_Edge=(1 << 6)                 
} QEPCTL_Sel_e;

typedef enum
{
    QEPCTL_Iel_Rising_Edge=(1 << 4),                        
    QEPCTL_Iel_Falling_Edge=(2 << 4),                       
    QEPCTL_Iel_Software_Index_Marker=(3 << 4)               
} QEPCTL_Iel_e;

typedef enum
{
    QEPCTL_Qclm_Latch_on_CPU_Read=(0 << 2),                 
    QEPCTL_Qclm_Latch_on_Unit_Timeout=(1 << 2)              
} QEPCTL_Qclm_e;

typedef enum
{
    QPOSCTL_Pcshdw_Load_Immediate=(0 << 15),                
    QPOSCTL_Pcshdw_Shadow_Enabled=(1 << 15)                 
} QPOSCTL_Pcshdw_e;

typedef enum
{
    QPOSCTL_Pcload_Load_Posn_Count_Zero=(0 << 14),          
    QPOSCTL_Pcload_Load_Posn_Count_Equal_Compare=(1 << 14)  
} QPOSCTL_Pcload_e;

typedef enum
{
    QPOSCTL_Pcpol_Active_High=(0 << 13),                    
    QPOSCTL_Pcpol_Active_Low=(1 << 13)                      
} QPOSCTL_Pcpol_e;

typedef enum
{
    QCAPCTL_Ccps_Capture_Div_1=(0 << 4),                    
    QCAPCTL_Ccps_Capture_Div_2=(1 << 4),                    
    QCAPCTL_Ccps_Capture_Div_4=(2 << 4),                    
    QCAPCTL_Ccps_Capture_Div_8=(3 << 4),                    
    QCAPCTL_Ccps_Capture_Div_16=(4 << 4),                   
    QCAPCTL_Ccps_Capture_Div_32=(5 << 4),                   
    QCAPCTL_Ccps_Capture_Div_64=(6 << 4),                   
    QCAPCTL_Ccps_Capture_Div_128=(7 << 4)                   
} QCAPCTL_Ccps_e;

typedef enum
{
    QCAPCTL_Upps_Div_1_Prescale=(0 << 0),                   
    QCAPCTL_Upps_Div_2_Prescale=(1 << 0),                   
    QCAPCTL_Upps_Div_4_Prescale=(2 << 0),                   
    QCAPCTL_Upps_Div_8_Prescale=(3 << 0),                   
    QCAPCTL_Upps_Div_16_Prescale=(4 << 0),                  
    QCAPCTL_Upps_Div_32_Prescale=(5 << 0),                  
    QCAPCTL_Upps_Div_64_Prescale=(6 << 0),                  
    QCAPCTL_Upps_Div_128_Prescale=(7 << 0),                 
    QCAPCTL_Upps_Div_256_Prescale=(8 << 0),                 
    QCAPCTL_Upps_Div_512_Prescale=(9 << 0),                 
    QCAPCTL_Upps_Div_1024_Prescale=(10 << 0),                
    QCAPCTL_Upps_Div_2048_Prescale=(11 << 0)                
} QCAPCTL_Upps_e;

typedef enum
{
    QEINT_Uto=(1 << 11),                                    
    QEINT_Iel=(1 << 10),                                    
    QEINT_Sel=(1 << 9),                                     
    QEINT_Pcm=(1 << 8),                                     
    QEINT_Pcr=(1 << 7),                                     
    QEINT_Pco=(1 << 6),                                     
    QEINT_Pcu=(1 << 5),                                     
    QEINT_Wto=(1 << 4),                                     
    QEINT_Qdc=(1 << 3),                                     
    QEINT_Qpe=(1 << 2),                                     
    QEINT_Pce=(1 << 1)                                      
} QEINT_e;


typedef enum
{
  UPEVNT=(1 << 7),                        
  FDF=   (1 << 6),                        
  QDF=   (1 << 5),                        
  QDLF=  (1 << 4),                        
  COEF=  (1 << 3),                        
  CDEF=  (1 << 2),                        
  FIMF=  (1 << 1),                        
  PCEF=  (1 << 0)                         
} QEP_qepsts_e;

typedef struct _QEP_Obj_
{
  uint32_t      QPOSCNT;       
  uint32_t      QPOSINIT;      
  uint32_t      QPOSMAX;       
  uint32_t      QPOSCMP;       
  uint32_t      QPOSILAT;      
  uint32_t      QPOSSLAT;      
  uint32_t      QPOSLAT;       
  uint32_t      QUTMR;         
  uint32_t      QUPRD;         
  uint16_t      QWDTMR;        
  uint16_t      QWDPRD;        
  uint16_t      QDECCTL;       
  uint16_t      QEPCTL;        
  uint16_t      QCAPCTL;       
  uint16_t      QPOSCTL;       
  uint16_t      QEINT;         
  uint16_t      QFLG;          
  uint16_t      QCLR;          
  uint16_t      QFRC;          
  uint16_t      QEPSTS;        
  uint16_t      QCTMR;         
  uint16_t      QCPRD;         
  uint16_t      QCTMRLAT;      
  uint16_t      QCPRDLAT;      
} QEP_Obj;


typedef struct _QEP_Obj_ *QEP_Handle;


// **************************************************************************
// the globals


// **************************************************************************
// the function prototypes

inline void QEP_clear_all_interrupt_flags (QEP_Handle qepHandle)
{
  QEP_Obj *qep = (QEP_Obj *)qepHandle;

  qep->QCLR = 0xfff;

  return;
} // end of QEP_clear_all_interrupt_flags() function

inline void QEP_clear_interrupt_flag (QEP_Handle qepHandle, const QEINT_e QEINT)
{
  QEP_Obj *qep = (QEP_Obj *)qepHandle;

  qep->QCLR |= QEINT;

  return;
} // end of QEP_clear_interrupt_flag() function

inline void QEP_clear_posn_counter (QEP_Handle qepHandle)
{
  QEP_Obj *qep = (QEP_Obj *)qepHandle;

  qep->QPOSCNT = 0;

  return;
} // end of QEP_clear_posn_counter() function

inline void QEP_disable_all_interrupts (QEP_Handle qepHandle)
{
  QEP_Obj *qep = (QEP_Obj *)qepHandle;

  qep->QEINT = 0;

  return;
} // end of QEP_disable_all_interrupts () function

inline void QEP_disable_capture (QEP_Handle qepHandle)
{
  QEP_Obj *qep = (QEP_Obj *)qepHandle;

  qep->QCAPCTL &= (~QEP_QCAPCTL_CEN);

  return;
} // end of QEP_disable_capture () function

inline void QEP_disable_gate_index (QEP_Handle qepHandle)
{
  QEP_Obj *qep = (QEP_Obj *)qepHandle;

  qep->QDECCTL &= (~QEP_QDECCTL_IGATE);

  return;
} // end of QEP_disable_gate_index () function

inline void QEP_disable_interrupt (QEP_Handle qepHandle, const QEINT_e QEINT)
{
  QEP_Obj *qep = (QEP_Obj *)qepHandle;

  qep->QEINT &= (~QEINT);

  return;
} // end of QEP_disable_interrupt

inline void QEP_disable_posn_compare (QEP_Handle qepHandle)
{
  QEP_Obj *qep = (QEP_Obj *)qepHandle;

  qep->QPOSCTL &= (~QEP_QPOSCTL_PCE);

  return;
} // end of QEP_disable_posn_compare () function

inline void QEP_disable_posn_compare_shadow (QEP_Handle qepHandle)
{
  QEP_Obj *qep = (QEP_Obj *)qepHandle;

  qep->QPOSCTL &= (~QEP_QPOSCTL_PCSHDW);

  return;
} // end of QEP_disable_posn_compare_shadow () function

inline void QEP_disable_sync_out (QEP_Handle qepHandle)
{
  QEP_Obj *qep = (QEP_Obj *)qepHandle;

  qep->QDECCTL &= (~QEP_QDECCTL_SOEN);

  return;
} // end of QEP_disable_sync_out () function

inline void QEP_disable_unit_timer (QEP_Handle qepHandle)
{
  QEP_Obj *qep = (QEP_Obj *)qepHandle;

  qep->QEPCTL &= (~QEP_QEPCTL_UTE);

  return;
} // end of QEP_disable_unit_timer () function

inline void QEP_disable_watchdog (QEP_Handle qepHandle)
{
  QEP_Obj *qep = (QEP_Obj *)qepHandle;

  qep->QEPCTL &= (~QEP_QEPCTL_WDE);

  return;
} // end of QEP_disable_watchdog () function

inline void QEP_enable_capture (QEP_Handle qepHandle)
{
  QEP_Obj *qep = (QEP_Obj *)qepHandle;

  qep->QCAPCTL |= (uint16_t)QEP_QCAPCTL_CEN;

  return;
} // end of QEP_enable_capture () function

inline void QEP_enable_counter (QEP_Handle qepHandle)
{
  QEP_Obj *qep = (QEP_Obj *)qepHandle;

  qep->QEPCTL |= QEP_QEPCTL_QPEN;

  return;
} // end of QEP_enable_counter () function

inline void QEP_enable_gate_index (QEP_Handle qepHandle)
{
  QEP_Obj *qep = (QEP_Obj *)qepHandle;

  qep->QDECCTL |= QEP_Igate_Enable;

  return;
} // end of QEP_enable_gate_index () function

inline void QEP_enable_interrupt (QEP_Handle qepHandle, const QEINT_e QEINT)
{
  QEP_Obj *qep = (QEP_Obj *)qepHandle;

  qep->QEINT |= QEINT;

  return;
} // end of QEP_enable_interrupt () function

inline void QEP_enable_posn_compare (QEP_Handle qepHandle)
{
  QEP_Obj *qep = (QEP_Obj *)qepHandle;

  qep->QPOSCTL |= QEP_QPOSCTL_PCE;

  return;
} // end of QEP_enable_posn_compare () function

inline void QEP_enable_posn_compare_shadow (QEP_Handle qepHandle)
{
  QEP_Obj *qep = (QEP_Obj *)qepHandle;

  qep->QPOSCTL |= (uint16_t)QEP_QPOSCTL_PCSHDW;

  return;
} // end of QEP_enable_posn_compare_shadow () function

inline void QEP_enable_sync_out (QEP_Handle qepHandle)
{
  QEP_Obj *qep = (QEP_Obj *)qepHandle;

  qep->QDECCTL |= QEP_QDECCTL_SOEN;

  return;
} // end of QEP_enable_sync_out () function

inline void QEP_enable_unit_timer (QEP_Handle qepHandle)
{
  QEP_Obj *qep = (QEP_Obj *)qepHandle;

  qep->QEPCTL |= QEP_QEPCTL_UTE;

  return;
} // end of QEP_enable_unit_timer () function

inline void QEP_enable_watchdog (QEP_Handle qepHandle)
{
  QEP_Obj *qep = (QEP_Obj *)qepHandle;

  qep->QEPCTL |= QEP_QEPCTL_WDE;

  return;
} // end of QEP_enable_watchdog () function

inline void QEP_force_interrupt (QEP_Handle qepHandle, const QEINT_e QEINT)
{
  QEP_Obj *qep = (QEP_Obj *)qepHandle;

  qep->QFRC |= QEINT;

  return;
} // end of QEP_force_interrupt () function

extern QEP_Handle QEP_init(void *pMemory,const size_t numBytes);

inline uint16_t QEP_read_capture_period_latch (QEP_Handle qepHandle)
{
  QEP_Obj *qep = (QEP_Obj *)qepHandle;

  return(qep->QCPRDLAT);
} // end of QEP_read_capture_period_latch () function

inline uint16_t QEP_read_capture_timer_latch (QEP_Handle qepHandle)
{
  QEP_Obj *qep = (QEP_Obj *)qepHandle;

  return(qep->QCTMRLAT);
} // end of QEP_read_capture_timer_latch () function

inline uint16_t QEP_read_interrupt_flag (QEP_Handle qepHandle, const QEINT_e QEINT)
{
  QEP_Obj *qep = (QEP_Obj *)qepHandle;

  return((uint16_t)(qep->QFLG & QEINT));
} // end of QEP_read_interrupt_flag () function

inline uint32_t QEP_read_posn_compare (QEP_Handle qepHandle)
{
  QEP_Obj *qep = (QEP_Obj *)qepHandle;

  return(qep->QPOSCMP);
} // end of QEP_read_posn_compare () function

inline uint32_t QEP_read_posn_count (QEP_Handle qepHandle)
{
  QEP_Obj *qep = (QEP_Obj *)qepHandle;

  return(qep->QPOSCNT);
} // end of QEP_read_posn_count () function

inline uint32_t QEP_read_posn_index_latch (QEP_Handle qepHandle)
{
  QEP_Obj *qep = (QEP_Obj *)qepHandle;

  return(qep->QPOSILAT);
} // end of QEP_read_posn_index_latch () function

inline uint32_t QEP_read_posn_latch (QEP_Handle qepHandle)
{
  QEP_Obj *qep = (QEP_Obj *)qepHandle;

  return(qep->QPOSLAT);
} // end of QEP_read_posn_latch () function

inline uint32_t QEP_read_posn_strobe_latch (QEP_Handle qepHandle)
{
  QEP_Obj *qep = (QEP_Obj *)qepHandle;

  return(qep->QPOSSLAT);
} // end of QEP_read_posn_strobe_latch () function

inline uint16_t QEP_read_status (QEP_Handle qepHandle)
{
  QEP_Obj *qep = (QEP_Obj *)qepHandle;

  return(qep->QEPSTS);
} // end of QEP_read_status () function

inline void QEP_reset_counter (QEP_Handle qepHandle)
{
  QEP_Obj *qep = (QEP_Obj *)qepHandle;

  qep->QEPCTL &= (~QEP_QEPCTL_QPEN);

  return;
} // end of QEP_reset_counter () function

inline void QEP_reset_status (QEP_Handle qepHandle, const QEP_qepsts_e qepsts)
{
  QEP_Obj *qep = (QEP_Obj *)qepHandle;

  qep->QEPSTS |= (qepsts);

  return;
} // end of QEP_reset_status() function

inline void QEP_set_capture_latch_mode (QEP_Handle qepHandle, const QEPCTL_Qclm_e QEPCTL_Qclm)
{
  QEP_Obj *qep = (QEP_Obj *)qepHandle;

  qep->QEPCTL &= (~QEP_QEPCTL_QCLM);
  qep->QEPCTL |= QEPCTL_Qclm;

  return;
} // end of QEP_set_capture_latch_mode () function

inline void QEP_set_capture_period (QEP_Handle qepHandle, const uint16_t period)
{
  QEP_Obj *qep = (QEP_Obj *)qepHandle;

  qep->QCPRD = period;

  return;
} // end of QEP_set_capture_period () function

inline void QEP_set_capture_prescale (QEP_Handle qepHandle, const QCAPCTL_Ccps_e QCAPCTL_Ccps)
{
  QEP_Obj *qep = (QEP_Obj *)qepHandle;

  qep->QCAPCTL &= (~QEP_QCAPCTL_CCPS);
  qep->QCAPCTL |= QCAPCTL_Ccps;
} // end of QEP_set_capture_prescale () function

inline void QEP_set_emu_control (QEP_Handle qepHandle, const QEPCTL_Freesoft_e QEPCTL_Freesoft)
{
  QEP_Obj *qep = (QEP_Obj *)qepHandle;

  qep->QEPCTL &= (~QEP_QEPCTL_FREESOFT);
  qep->QEPCTL |= QEPCTL_Freesoft;

  return;
} // end of QEP_set_emu_control () function

inline void QEP_set_ext_clock_rate (QEP_Handle qepHandle, const QEP_Xcr_e QEP_Xcr)
{
  QEP_Obj *qep = (QEP_Obj *)qepHandle;

  qep->QDECCTL &= (~QEP_QDECCTL_XCR);
  qep->QDECCTL |= QEP_Xcr;

  return;
} // end of QEP_set_ext_clock_rate () function

inline void QEP_set_index_event_init (QEP_Handle qepHandle, const QEPCTL_Iei_e QEPCTL_Iei)
{
  QEP_Obj *qep = (QEP_Obj *)qepHandle;

  qep->QEPCTL &= (~QEP_QEPCTL_IEI);
  qep->QEPCTL |= QEPCTL_Iei;

  return;
} // end of QEP_set_index_event_init () function

inline void QEP_set_index_event_latch (QEP_Handle qepHandle, const QEPCTL_Iel_e QEPCTL_Iel)
{
  QEP_Obj *qep = (QEP_Obj *)qepHandle;

  qep->QEPCTL &= (~QEP_QEPCTL_IEL);
  qep->QEPCTL |= QEPCTL_Iel;

  return;
} // end of QEP_set_index_event_latch

inline void QEP_set_index_polarity (QEP_Handle qepHandle, const QEP_Qip_e QEP_Qip)
{
  QEP_Obj *qep = (QEP_Obj *)qepHandle;

  qep->QDECCTL &= (~QEP_QDECCTL_QIP);
  qep->QDECCTL |= QEP_Qip;

  return;
} // end of QEP_set_index_polarity () function

inline void QEP_set_max_posn_count (QEP_Handle qepHandle, const uint32_t max_count)
{
  QEP_Obj *qep = (QEP_Obj *)qepHandle;

  qep->QPOSMAX = max_count;

  return;
} // end of QEP_set_max_posn_count () function

inline void QEP_set_posn_compare_pulse_width (QEP_Handle qepHandle, const uint16_t pulse_width)
{
  QEP_Obj *qep = (QEP_Obj *)qepHandle;
  uint16_t pulse_width_masked;

  pulse_width_masked = pulse_width & 4095;
  qep->QPOSCTL &= (~QEP_QPOSCTL_PCSPW);
  qep->QPOSCTL |= pulse_width_masked;

  return;
} // end of QEP_set_posn_compare_pulse_width () function

inline void QEP_set_posn_compare_shadow_load (QEP_Handle qepHandle, const QPOSCTL_Pcload_e QPOSCTL_Pcload)
{
  QEP_Obj *qep = (QEP_Obj *)qepHandle;

  qep->QPOSCTL &= (~QEP_QPOSCTL_PCLOAD);
  qep->QPOSCTL |= QPOSCTL_Pcload;

  return;
} // end of QEP_set_posn_compare_shadow_load () function

inline void QEP_set_posn_count_reset_mode (QEP_Handle qepHandle, const QEPCTL_Pcrm_e QEPCTL_Pcrm)
{
  QEP_Obj *qep = (QEP_Obj *)qepHandle;

  qep->QEPCTL &= (~QEP_QEPCTL_PCRM);
  qep->QEPCTL |= QEPCTL_Pcrm;

  return;
} // end of QEP_set_posn_count_reset_mode () function

inline void QEP_set_posn_init_count (QEP_Handle qepHandle, const uint32_t init_count)
{
  QEP_Obj *qep = (QEP_Obj *)qepHandle;

  qep->QPOSINIT = init_count;

  return;
} // end of QEP_set_posn_init_count () function

inline void QEP_set_select_sync_pin (QEP_Handle qepHandle, const QEP_Spsel_e QEP_SPsel)
{
  QEP_Obj *qep = (QEP_Obj *)qepHandle;

  qep->QDECCTL &= (~QEP_QDECCTL_SPSEL);
  qep->QDECCTL |= QEP_SPsel;

  return;
} // end of QEP_set_select_sync_pin () function

inline void QEP_set_soft_init (QEP_Handle qepHandle, const QEPCTL_Swi_e QEPCTL_Swi)
{
  QEP_Obj *qep = (QEP_Obj *)qepHandle;

  qep->QEPCTL &= (~QEP_QEPCTL_SWI);
  qep->QEPCTL |= QEPCTL_Swi;

  return;
} // end of QEP_set_soft_init () function

inline void QEP_set_strobe_event_init (QEP_Handle qepHandle, const QEPCTL_Sei_e QEPCTL_Sei)
{
  QEP_Obj *qep = (QEP_Obj *)qepHandle;

  qep->QEPCTL &= (~QEP_QEPCTL_SEI);
  qep->QEPCTL |= QEPCTL_Sei;

  return;
} // end of QEP_set_strobe_event_init () function

inline void QEP_set_strobe_event_latch (QEP_Handle qepHandle, const QEPCTL_Sel_e QEPCTL_Sel)
{
  QEP_Obj *qep = (QEP_Obj *)qepHandle;

  qep->QEPCTL &= (~QEP_QEPCTL_SEL);
  qep->QEPCTL |= QEPCTL_Sel;

  return;
} // end of QEP_set_strobe_event_latch () function

inline void QEP_set_strobe_polarity (QEP_Handle qepHandle, const QEP_Qsp_e QEP_Qsp)
{
  QEP_Obj *qep = (QEP_Obj *)qepHandle;

  qep->QDECCTL &= (~QEP_QDECCTL_QSP);
  qep->QDECCTL |= QEP_Qsp;

  return;
} // end of QEP_set_strobe_polarity () function

inline void QEP_set_swap_quad_inputs (QEP_Handle qepHandle, QEP_Swap_e QEP_Swap)
{
  QEP_Obj *qep = (QEP_Obj *)qepHandle;

  qep->QDECCTL &= (~QEP_QDECCTL_SWAP);
  qep->QDECCTL |= QEP_Swap;

  return;
} // end of QEP_set_swap_quad_inputs () function

inline void QEP_set_synch_output_compare_polarity (QEP_Handle qepHandle, const QPOSCTL_Pcpol_e QPOSCTL_Pcpol)
{
  QEP_Obj *qep = (QEP_Obj *)qepHandle;

  qep->QPOSCTL &= (~QEP_QPOSCTL_PCPOL);
  qep->QPOSCTL |= QPOSCTL_Pcpol;

  return;
} // end of QEP_set_synch_output_compare_polarity () function

inline void QEP_set_unit_period (QEP_Handle qepHandle, const uint32_t unit_period)
{
  QEP_Obj *qep = (QEP_Obj *)qepHandle;

  qep->QUPRD = unit_period;

  return;
} // end of QEP_set_unit_period () function

inline void QEP_set_unit_posn_prescale (QEP_Handle qepHandle, const QCAPCTL_Upps_e QCAPCTL_Upps)
{
  QEP_Obj *qep = (QEP_Obj *)qepHandle;

  qep->QCAPCTL &= (~QEP_QCAPCTL_UPPS);
  qep->QCAPCTL |= QCAPCTL_Upps;

  return;
} // end of QEP_set_unit_posn_prescale () function

inline void QEP_set_watchdog_period (QEP_Handle qepHandle, const uint16_t watchdog_period)
{
  QEP_Obj *qep = (QEP_Obj *)qepHandle;

  qep->QWDPRD = watchdog_period;

  return;
} // end of QEP_set_watchdog_period () function

inline void QEP_set_A_polarity (QEP_Handle qepHandle, const QEP_Qap_e QEP_Qap)
{
  QEP_Obj *qep = (QEP_Obj *)qepHandle;

  qep->QDECCTL &= (~QEP_QDECCTL_QAP);
  qep->QDECCTL |= QEP_Qap;

  return;
} // end of QEP_set_A_polarity () function

inline void QEP_set_B_polarity (QEP_Handle qepHandle, const QEP_Qbp_e QEP_Qbp)
{
  QEP_Obj *qep = (QEP_Obj *)qepHandle;

  qep->QDECCTL &= (~QEP_QDECCTL_QBP);
  qep->QDECCTL |= QEP_Qbp;

  return;
} // end of QEP_set_B_polarity () function

inline void QEP_set_QEP_source (QEP_Handle qepHandle, const QEP_Qsrc_e QEP_Qsrc)
{
  QEP_Obj *qep = (QEP_Obj *)qepHandle;

  // set the value
  qep->QDECCTL &= (~QEP_QDECCTL_QSRC);
  qep->QDECCTL |= QEP_Qsrc;

  return;
} // end of QEP_set_QEP_source () function


inline void QEP_setup_strobe_event_latch (QEP_Handle qepHandle, const QEPCTL_Sel_e QEPCTL_Sel)
{
  QEP_Obj *qep = (QEP_Obj *)qepHandle;

  qep->QEPCTL &= (~QEP_QEPCTL_SEL);
  qep->QEPCTL |= QEPCTL_Sel;

  return;
} // end of QEP_setup_strobe_event_latch () function


inline void QEP_write_posn_compare (QEP_Handle qepHandle, const uint32_t posn)
{
  QEP_Obj *qep = (QEP_Obj *)qepHandle;

  qep->QPOSCMP = posn;

  return;
} // end of QEP_write_posn_compare () function

#ifdef __cplusplus
}
#endif // extern "C"

#endif // end of _QEP_H_ definition