cap.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 _CAP_H_
#define _CAP_H_


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

// drivers
#include "sw/modules/types/src/types.h"


// modules





#ifdef __cplusplus
extern "C" {
#endif


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


#define CAP1_BASE_ADDR              (0x00006A00)

#define CAP2_BASE_ADDR              (0x00006A20)

#define CAP3_BASE_ADDR              (0x00006A40)


#define CAP_ECCTL1_FREESOFT_BITS   (3 << 14)

#define CAP_ECCTL1_PRESCALE_BITS   (31 << 9)

#define CAP_ECCTL1_CAPLDEN_BITS   (1 << 8)

#define CAP_ECCTL1_CTRRST4_BITS   (1 << 7)

#define CAP_ECCTL1_CAP4POL_BITS   (1 << 6)

#define CAP_ECCTL1_CTRRST3_BITS   (1 << 5)

#define CAP_ECCTL1_CAP3POL_BITS   (1 << 4)

#define CAP_ECCTL1_CTRRST2_BITS   (1 << 3)

#define CAP_ECCTL1_CAP2POL_BITS   (1 << 2)

#define CAP_ECCTL1_CTRRST1_BITS   (1 << 1)

#define CAP_ECCTL1_CAP1POL_BITS   (1 << 0)


#define CAP_ECCTL2_APWMPOL_BITS   (1 << 10)

#define CAP_ECCTL2_CAPAPWM_BITS   (1 << 9)

#define CAP_ECCTL2_SWSYNC_BITS    (1 << 8)

#define CAP_ECCTL2_SYNCOSEL_BITS  (3 << 6)

#define CAP_ECCTL2_SYNCIEN_BITS   (1 << 5)

#define CAP_ECCTL2_TSCTRSTOP_BITS (1 << 4)

#define CAP_ECCTL2_REARM_BITS     (1 << 3)

#define CAP_ECCTL2_STOP_WRAP_BITS (3 << 1)

#define CAP_ECCTL2_CONTONESHOT_BITS (1 << 0)


#define CAP_ECCxxx_CTRCOMP_BITS  (1 << 7)

#define CAP_ECCxxx_CTRPRD_BITS   (1 << 6)

#define CAP_ECCxxx_CTROVF_BITS   (1 << 5)

#define CAP_ECCxxx_CEVT4_BITS    (1 << 4)

#define CAP_ECCxxx_CEVT3_BITS    (1 << 3)

#define CAP_ECCxxx_CEVT2_BITS    (1 << 2)

#define CAP_ECCxxx_CEVT1_BITS    (1 << 1)

#define CAP_ECCxxx_INT_BITS      (1 << 0)




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

typedef enum
{
    CAP_Int_Type_CTR_CMP = (1 << 7),     
    CAP_Int_Type_CTR_PRD = (1 << 6),     
    CAP_Int_Type_CTR_OVF = (1 << 5),     
    CAP_Int_Type_CEVT4 = (1 << 4),       
    CAP_Int_Type_CEVT3 = (1 << 3),       
    CAP_Int_Type_CEVT2 = (1 << 2),       
    CAP_Int_Type_CEVT1 = (1 << 1),       
    CAP_Int_Type_Global = (1 << 0),      
    CAP_Int_Type_All = 0x00FF            
} CAP_Int_Type_e;

typedef enum
{
    CAP_Prescale_By_1 = (0 << 9),    
    CAP_Prescale_By_2 = (1 << 9),    
    CAP_Prescale_By_4 = (2 << 9),    
    CAP_Prescale_By_6 = (3 << 9),    
    CAP_Prescale_By_8 = (4 << 9),    
    CAP_Prescale_By_10 = (5 << 9),   
    CAP_Prescale_By_12 = (6 << 9),   
    CAP_Prescale_By_14 = (7 << 9),   
    CAP_Prescale_By_16 = (8 << 9),   
    CAP_Prescale_By_18 = (9 << 9),   
    CAP_Prescale_By_20 = (10 << 9),  
    CAP_Prescale_By_22 = (11 << 9),  
    CAP_Prescale_By_24 = (12 << 9),  
    CAP_Prescale_By_26 = (13 << 9),  
    CAP_Prescale_By_28 = (14 << 9),  
    CAP_Prescale_By_30 = (15 << 9),  
    CAP_Prescale_By_32 = (16 << 9),  
    CAP_Prescale_By_34 = (17 << 9),  
    CAP_Prescale_By_36 = (18 << 9),  
    CAP_Prescale_By_38 = (19 << 9),  
    CAP_Prescale_By_40 = (20 << 9),  
    CAP_Prescale_By_42 = (21 << 9),  
    CAP_Prescale_By_44 = (22 << 9),  
    CAP_Prescale_By_46 = (23 << 9),  
    CAP_Prescale_By_48 = (24 << 9),  
    CAP_Prescale_By_50 = (25 << 9),  
    CAP_Prescale_By_52 = (26 << 9),  
    CAP_Prescale_By_54 = (27 << 9),  
    CAP_Prescale_By_56 = (28 << 9),  
    CAP_Prescale_By_58 = (29 << 9),  
    CAP_Prescale_By_60 = (30 << 9),  
    CAP_Prescale_By_62 = (31 << 9)   
} CAP_Prescale_e;

typedef enum
{
    CAP_RunMode_HardStop = (0 << 14),
    CAP_RunMode_SoftStopAfterCycle = (1 << 14),
    CAP_RunMode_FreeRun = (2 << 14)
} CAP_RunMode_e;

typedef enum
{
    CAP_Stop_Wrap_CEVT1 = (0 << 1),     
    CAP_Stop_Wrap_CEVT2 = (1 << 1),     
    CAP_Stop_Wrap_CEVT3 = (2 << 1),     
    CAP_Stop_Wrap_CEVT4 = (3 << 1)      
} CAP_Stop_Wrap_e;

typedef enum
{
    CAP_Event_1 = 0,     
    CAP_Event_2,         
    CAP_Event_3,         
    CAP_Event_4          
} CAP_Event_e;

typedef enum
{
    CAP_Polarity_Rising = 0,     
    CAP_Polarity_Falling         
} CAP_Polarity_e;


typedef enum
{
    CAP_Reset_Disable = 0,     
    CAP_Reset_Enable           
} CAP_Reset_e;

typedef enum
{
    CAP_SyncOut_SyncIn = (0 << 6),     
    CAP_SyncOut_CTRPRD = (1 << 6),     
    CAP_SyncOut_Disable = (2 << 6)    
} CAP_SyncOut_e;


typedef struct _CAP_Obj_
{
    volatile uint32_t      TSCTR;        
    volatile uint32_t      CTRPHS;       
    volatile uint32_t      CAP1;         
    volatile uint32_t      CAP2;         
    volatile uint32_t      CAP3;         
    volatile uint32_t      CAP4;         
    volatile uint16_t      Rsvd_1[8];    
    volatile uint16_t      ECCTL1;       
    volatile uint16_t      ECCTL2;       
    volatile uint16_t      ECEINT;       
    volatile uint16_t      ECEFLG;       
    volatile uint16_t      ECECLR;       
    volatile uint16_t      ECEFRC;       

} CAP_Obj;


typedef struct _CAP_Obj_ *CAP_Handle;


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


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



extern void CAP_setModeCap(CAP_Handle capHandle);

extern void CAP_setModeApwm(CAP_Handle capHandle);

static inline void CAP_clearInt(CAP_Handle capHandle, const CAP_Int_Type_e intType)
{ 
    CAP_Obj *cap = (CAP_Obj *)capHandle;
    
    cap->ECECLR |= intType;
    
    return;
}

extern void CAP_disableCaptureLoad(CAP_Handle capHandle);

extern void CAP_disableInt(CAP_Handle capHandle, const CAP_Int_Type_e intType);

extern void CAP_disableSyncIn(CAP_Handle capHandle);

extern void CAP_disableTimestampCounter(CAP_Handle capHandle);

extern void CAP_enableCaptureLoad(CAP_Handle capHandle);

extern void CAP_enableInt(CAP_Handle capHandle, const CAP_Int_Type_e intType);

extern void CAP_enableSyncIn(CAP_Handle capHandle);

extern void CAP_enableTimestampCounter(CAP_Handle capHandle);

static inline uint32_t CAP_getCap1(CAP_Handle capHandle)
{
    CAP_Obj *cap = (CAP_Obj *)capHandle;
    
    return (cap->CAP1);
} // end of CAP_getCap1() function

static inline uint32_t CAP_getCap2(CAP_Handle capHandle)
{
    CAP_Obj *cap = (CAP_Obj *)capHandle;
    
    return (cap->CAP2);
} // end of CAP_getCap2() function

static inline uint32_t CAP_getCap3(CAP_Handle capHandle)
{
    CAP_Obj *cap = (CAP_Obj *)capHandle;
    
    return (cap->CAP3);
} // end of CAP_getCap3() function

static inline uint32_t CAP_getCap4(CAP_Handle capHandle)
{
    CAP_Obj *cap = (CAP_Obj *)capHandle;
    
    return (cap->CAP4);
} // end of CAP_getCap4() function

static inline void CAP_rearm(CAP_Handle capHandle)
{
    CAP_Obj *cap = (CAP_Obj *)capHandle;
    
    cap->ECCTL2 |= CAP_ECCTL2_REARM_BITS;
    
    return;
} // end of CAP_rearm() function

extern void CAP_setCapEvtPolarity(CAP_Handle capHandle, const CAP_Event_e event, const CAP_Polarity_e polarity);

extern void CAP_setCapEvtReset(CAP_Handle capHandle, const CAP_Event_e event, const CAP_Reset_e reset);

extern void CAP_setCapContinuous(CAP_Handle capHandle);

extern void CAP_setCapOneShot(CAP_Handle capHandle);

static inline void CAP_setApwmPeriod(CAP_Handle capHandle, const uint32_t period)
{
    CAP_Obj *cap = (CAP_Obj *)capHandle;
    
    cap->CAP1 = period;
    
    return;
} // end of CAP_setApwmPeriod() function

static inline void CAP_setApwmCompare(CAP_Handle capHandle, const uint32_t compare)
{
    CAP_Obj *cap = (CAP_Obj *)capHandle;
    
    cap->CAP2 = compare;
    
    return;
} // end of CAP_setApwmCompare() function

static inline void CAP_setApwmShadowPeriod(CAP_Handle capHandle, const uint32_t shadowPeriod)
{
    CAP_Obj *cap = (CAP_Obj *)capHandle;

    cap->CAP3 = shadowPeriod;

    return;
} // end of CAP_setApwmShadowPeriod() function

extern void CAP_setStopWrap(CAP_Handle capHandle, const CAP_Stop_Wrap_e stopWrap);

extern void CAP_setSyncOut(CAP_Handle capHandle, const CAP_SyncOut_e syncOut);

extern CAP_Handle CAP_init(void *pMemory,const size_t numBytes);



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

#endif // end of _CAP_H_ definition