STC8x_TIMER.h

浏览该文件的文档.

/*-----------------------------------------------------------------------
|                            FILE DESCRIPTION                           |
-----------------------------------------------------------------------*/
/*----------------------------------------------------------------------
  - File name     : STC8x_TIMER.h
  - Author        : zeweni
  - Update date   : 2020.05.11
  - Copyright(C)  : 2020-2021 zeweni. All rights reserved.
-----------------------------------------------------------------------*/
/*------------------------------------------------------------------------
|                            COPYRIGHT NOTICE                            |
------------------------------------------------------------------------*/
/*
 * Copyright (C) 2021, zeweni (17870070675@163.com)
 
 * This file is part of 8051 ELL low-layer libraries.
 
 * 8051 ELL low-layer libraries is free software: you can redistribute 
 * it and/or modify it under the terms of the Apache-2.0 License.
 
 * 8051 ELL low-layer libraries is distributed in the hope that it will 
 * be useful,but WITHOUT ANY WARRANTY; without even the implied warranty 
 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 
 * Apache-2.0 License for more details.
 
 * You should have received a copy of the Apache-2.0 License.8051 ELL 
 * low-layer libraries. If not, see <http://www.apache.org/licenses/>.
**/
/*-----------------------------------------------------------------------
|                               INCLUDES                                |
-----------------------------------------------------------------------*/
#ifndef __STC8x_TIMER_H_
#define __STC8x_TIMER_H_
 
/*--------------------------------------------------------
| @Description: ELL library core                         |
--------------------------------------------------------*/
#include "ELL_CORE.h"
 
/*--------------------------------------------------------
| @Description: STC8x MCU Register                       |
--------------------------------------------------------*/
 
#if    (PER_LIB_MCU_MUODEL == STC8Ax)
    #include "STC8Ax_REG.h"  
#elif  (PER_LIB_MCU_MUODEL == STC8Cx)
    #include "STC8Cx_REG.h"
#elif  (PER_LIB_MCU_MUODEL == STC8Fx)
    #include "STC8Fx_REG.h"
#elif  (PER_LIB_MCU_MUODEL == STC8Gx)
    #include "STC8Gx_REG.h"
#elif  (PER_LIB_MCU_MUODEL == STC8Hx)
    #include "STC8Hx_REG.h"
#endif
 
 
/*-----------------------------------------------------------------------
|                                 DATA                                  |
-----------------------------------------------------------------------*/
 
#ifndef PER_LIB_MCU_MUODEL  
    #define PER_LIB_MCU_MUODEL STC8Ax
#endif
 
 
#ifndef PER_LIB_TIMER_CTRL
    #define PER_LIB_TIMER_CTRL 1
#endif
 
 
#ifndef PER_LIB_TIMER_INIT_CTRL
    #define PER_LIB_TIMER_INIT_CTRL 1
#endif
 
#ifndef PER_LIB_TIMER_WORK_CTRL
    #define PER_LIB_TIMER_WORK_CTRL 1
#endif
 
#ifndef PER_LIB_TIMER_NVIC_CTRL
    #define PER_LIB_TIMER_NVIC_CTRL 1
#endif
 
 
typedef enum
{
    TIMER_Type_Timer   = 0x00,  
    TIMER_Type_Counter = 0x01   
}   TIMERType_Type;
 
 
typedef enum
{
    TIMER_16BitAutoReload       = 0x00, 
    TIMER_16Bit                 = 0x01, 
    TIMER_8BitAutoReload        = 0x02, 
    TIMER_16BitAutoReloadNoMask = 0x03  
}   TIMERMode_Type;
 
 
typedef enum
{
    TIMER_TCY_1T  = 0x00,   
    TIMER_TCY_12T = 0x01    
}   TIMERTCycle_Type;
 
 
typedef struct 
{
#if  (PER_LIB_MCU_MUODEL == STC8Cx ||PER_LIB_MCU_MUODEL == STC8Gx || PER_LIB_MCU_MUODEL == STC8Hx)
    uint8_t SysClkDiv;       
#endif
    TIMERType_Type Type;      
    TIMERMode_Type Mode;      
    TIMERTCycle_Type TCycle;  
    BOOL ClkOut;              
    uint32_t Time;           
    BOOL Run;                 
}   TIMER_InitType;
 
 
/*-----------------------------------------------------------------------
|                             API FUNCTION                              |
-----------------------------------------------------------------------*/
#if (PER_LIB_TIMER_CTRL == 1)
 
    #if (PER_LIB_TIMER_INIT_CTRL == 1)
 
        FSCSTATE TIMER5_Wake_Up_Power(uint16_t value,BOOL run);
 
 
        FSCSTATE TIMER0_Init(const TIMER_InitType *timerx);
 
 
        FSCSTATE TIMER1_Init(const TIMER_InitType *timerx);
 
 
        FSCSTATE TIMER2_Init(const TIMER_InitType *timerx);
 
 
        FSCSTATE TIMER3_Init(const TIMER_InitType *timerx);
 
 
        FSCSTATE TIMER4_Init(const TIMER_InitType *timerx);
 
    #endif
 
    #if (PER_LIB_TIMER_NVIC_CTRL == 1)
 
        FSCSTATE NVIC_TIMER0_Init(NVICPri_Type pri,BOOL run);
 
 
        FSCSTATE NVIC_TIMER1_Init(NVICPri_Type pri,BOOL run);
 
 
        FSCSTATE NVIC_TIMER2_Init(BOOL run);
 
 
        FSCSTATE NVIC_TIMER3_Init(BOOL run);
 
 
        FSCSTATE NVIC_TIMER4_Init(BOOL run);
 
 
        #define    TIMER2_CLEAR_FLAG()    do{ AUXINTIF &= 0xFE; }while(0)
 
 
        #define    TIMER3_CLEAR_FLAG()    do{ AUXINTIF &= 0xFD; }while(0)
 
 
        #define    TIMER4_CLEAR_FLAG()    do{ AUXINTIF &= 0xFB; }while(0)
 
 
        #define NVIC_TIMER0_PRI(pri)                  \
        do{                                           \
            IPH = (IPH & 0xFD) |  (pri & 0x02) ;      \
            IP  = (IP  & 0xFD) | ((pri & 0x01) << 1); \
        }while(0)
 
 
        #define NVIC_TIMER1_PRI(pri)                  \
        do{                                           \
            IPH = (IPH & 0xF7) | ((pri & 0x02) << 2); \
            IP  = (IP  & 0xF7) | ((pri & 0x01) << 3); \
        }while(0)
 
 
        #define    NVIC_TIMER0_CTRL(run)     do{ ET0 = run; }while(0)
 
 
        #define    NVIC_TIMER1_CTRL(run)     do{ ET1 = run; }while(0)
 
 
        #define    NVIC_TIMER2_CTRL(run)     do{ IE2 = (IE2 & 0xFB) | (run << 2); }while(0)
 
 
        #define    NVIC_TIMER3_CTRL(run)     do{ IE2 = (IE2 & 0xDF) | (run << 5); }while(0)
 
 
        #define    NVIC_TIMER4_CTRL(run)     do{ IE2 = (IE2 & 0xBF) | (run << 6); }while(0)
 
    #endif
 
                
    #if (PER_LIB_TIMER_WORK_CTRL == 1)
        #define    TIMER0_WORK_CTRL(run)     do{ TR0 = run; }while(0)   
 
        
        #define    TIMER1_WORK_CTRL(run)     do{ TR1 = run; }while(0)   
        
        
 
        #define    TIMER2_WORK_CTRL(run)     do{AUXR = (AUXR & 0xEF) | (run << 4);  }while(0)   
        
        
        #define    TIMER3_WORK_CTRL(run)     do{ T4T3M = (T4T3M & 0xF7) | (run << 3)}while(0)   
        
        
        #define    TIMER4_WORK_CTRL(run)     do{ T4T3M = (T4T3M & 0x7F) | (run << 7)}while(0)       
 
        #define    TIMER0_CLEAR_CNT()    do{T0L = 0;  T0H = 0;}while(0)
 
        #define    TIMER1_CLEAR_CNT()    do{T1L = 0;  T1H = 0;}while(0)
 
        #define    TIMER2_CLEAR_CNT()    do{T2L = 0;  T2H = 0;}while(0)
 
        #define    TIMER3_CLEAR_CNT()    do{T3L = 0;  T3H = 0;}while(0)
 
        #define    TIMER4_CLEAR_CNT()    do{T4L = 0;  T4H = 0;}while(0)
 
        #define    TIMER0_RELOAD_CNT()                    \
        do{                                               \
            T0L = (uint8_t)(G_Time0_CntValue);           \
            T0H = (uint8_t)(G_Time0_CntValue >> 8);      \
        }while(0)
        
        
        #define    TIMER1_RELOAD_CNT()                    \
        do{                                               \
            T1L = (uint8_t)(G_Time1_CntValue);           \
            T1H = (uint8_t)(G_Time1_CntValue >> 8);      \
        }while(0)
                
        
        FSCSTATE TIMER0_Set_Time(uint32_t time);
        
 
        FSCSTATE TIMER1_Set_Time(uint32_t time);
 
        #if (PER_LIB_MCU_MUODEL == STC8Ax || PER_LIB_MCU_MUODEL == STC8Fx)
            FSCSTATE TIMER2_Set_Time(uint32_t time);
        #elif (PER_LIB_MCU_MUODEL == STC8Cx || PER_LIB_MCU_MUODEL == STC8Gx || PER_LIB_MCU_MUODEL == STC8Hx)
            FSCSTATE TIMER2_Set_Time(uint8_t clkDiv,uint32_t time); 
        #endif          
 
 
        #if (PER_LIB_MCU_MUODEL == STC8Ax || PER_LIB_MCU_MUODEL == STC8Fx)
            FSCSTATE TIMER3_Set_Time(uint32_t time);
        #elif (PER_LIB_MCU_MUODEL == STC8Cx || PER_LIB_MCU_MUODEL == STC8Gx || PER_LIB_MCU_MUODEL == STC8Hx)
            FSCSTATE TIMER3_Set_Time(uint8_t clkDiv,uint32_t time);
        #endif          
        
        
        #if (PER_LIB_MCU_MUODEL == STC8Ax || PER_LIB_MCU_MUODEL == STC8Fx)
            FSCSTATE TIMER4_Set_Time(uint32_t time);
        #elif (PER_LIB_MCU_MUODEL == STC8Cx || PER_LIB_MCU_MUODEL == STC8Gx || PER_LIB_MCU_MUODEL == STC8Hx)
            FSCSTATE TIMER4_Set_Time(uint8_t clkDiv,uint32_t time);
        #endif          
 
 
    #endif
#endif
/*-----------------------------------------------------------------------
|                   END OF FLIE.  (C) COPYRIGHT zeweni                  |
-----------------------------------------------------------------------*/
#endif