STC8x_UART.h

浏览该文件的文档.

/*-----------------------------------------------------------------------
|                            FILE DESCRIPTION                           |
-----------------------------------------------------------------------*/
/*----------------------------------------------------------------------
  - File name     : STC8x_UART.h
  - Author        : zeweni
  - Update date   : 2020.04.27
  - 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_UART_H_
#define __STC8x_UART_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_UART_CTRL
    #define PER_LIB_UART_CTRL 1
#endif
 
 
#ifndef PER_LIB_UART_INIT_CTRL
    #define PER_LIB_UART_INIT_CTRL 1
#endif
 
 
#ifndef PER_LIB_UART_NVIC_CTRL
    #define PER_LIB_UART_NVIC_CTRL 1
#endif
 
 
#ifndef PER_LIB_UART_WORK_CTRL
    #define PER_LIB_UART_WORK_CTRL 1
#endif
 
 
typedef enum
{
    UART_SyncShift       = 0x00, 
    UART_8bit_BRTx       = 0x01, 
    UART_9bit_Fixed_BRTx = 0x02, 
    UART_9bit_BRTx       = 0x03  
} UARTMode_Type;
 
 
typedef enum
{
    UART_BRT_TIM1 = 0x00,    
    UART_BRT_TIM2 = 0x01,    
    UART_BRT_TIM3 = 0x02,    
    UART_BRT_TIM4 = 0x03     
} UART_BRTGen_Type;
 
 
typedef enum
{
    UART_BRT_1T  = 0x00,  
    UART_BRT_12T = 0x01   
}   UART_BRTMode_Type;
 
 
typedef struct 
{
    UARTMode_Type Mode;       
    UART_BRTGen_Type BRTGen;  
    #if  (PER_LIB_MCU_MUODEL == STC8Cx ||PER_LIB_MCU_MUODEL == STC8Gx || PER_LIB_MCU_MUODEL == STC8Hx)
        uint8_t BRTGenClkDiv;  
    #endif
    UART_BRTMode_Type BRTMode;  
    BOOL BRTDouble;            
    uint32_t BaudRate;         
    BOOL MulitComm;             
    BOOL Relay;                
    BOOL RxEnable;             
} UART_InitType;
 
/*-----------------------------------------------------------------------
|                             API FUNCTION                              |
-----------------------------------------------------------------------*/
#if ( PER_LIB_UART_CTRL == 1)
 
    #if (PER_LIB_UART_INIT_CTRL == 1)
 
        FSCSTATE UART1_Init(const UART_InitType *uartx);
 
 
        FSCSTATE UART2_Init(const UART_InitType *uartx);
 
 
        FSCSTATE UART3_Init(const UART_InitType *uartx);
 
 
        FSCSTATE UART4_Init(const UART_InitType *uartx);
        
    #endif
    
    #if (PER_LIB_UART_NVIC_CTRL == 1)
 
        #define    UART1_GET_RX_FLAG()    (SCON  & 0x01)
 
 
        #define    UART2_GET_RX_FLAG()    (S2CON & 0x01)
 
 
        #define    UART3_GET_RX_FLAG()    (S3CON & 0x01)
 
 
        #define    UART4_GET_RX_FLAG()    (S4CON & 0x01)
 
 
        #define    UART1_CLEAR_RX_FLAG()  do{SCON  &= 0xFE;}while(0)
 
 
        #define    UART2_CLEAR_RX_FLAG()  do{S2CON &= 0xFE;}while(0)
 
 
        #define    UART3_CLEAR_RX_FLAG()  do{S3CON &= 0xFE;}while(0)
 
 
        #define    UART4_CLEAR_RX_FLAG()  do{S4CON &= 0xFE;}while(0)
                            
 
        #define    UART1_GET_TX_FLAG()    (SCON  & 0x02)
 
 
        #define    UART2_GET_TX_FLAG()    (S2CON & 0x02)
 
 
        #define    UART3_GET_TX_FLAG()    (S3CON & 0x02)
 
 
        #define    UART4_GET_TX_FLAG()    (S4CON & 0x02)
 
 
        #define    UART1_CLEAR_TX_FLAG()  do{SCON  &= 0xFD;}while(0)
 
 
        #define    UART2_CLEAR_TX_FLAG()  do{S2CON &= 0xFD;}while(0)
 
 
        #define    UART3_CLEAR_TX_FLAG()  do{S3CON &= 0xFD;}while(0)
 
 
        #define    UART4_CLEAR_TX_FLAG()  do{S4CON &= 0xFD;}while(0)
 
 
        FSCSTATE NVIC_UART1_Init(NVICPri_Type pri,BOOL run);
 
 
        FSCSTATE NVIC_UART2_Init(NVICPri_Type pri,BOOL run);
 
 
        #if (PER_LIB_MCU_MUODEL == STC8Ax || PER_LIB_MCU_MUODEL == STC8Fx)
            
            FSCSTATE NVIC_UART3_Init(BOOL run);
            
            FSCSTATE NVIC_UART4_Init(BOOL run);
 
        #elif (PER_LIB_MCU_MUODEL == STC8Cx || PER_LIB_MCU_MUODEL == STC8Gx || PER_LIB_MCU_MUODEL == STC8Hx)
 
            FSCSTATE NVIC_UART3_Init(NVICPri_Type pri,BOOL run);
            
            
            FSCSTATE NVIC_UART4_Init(NVICPri_Type pri,BOOL run);
 
        #endif
 
 
        #define    NVIC_UART1_CTRL(run)     do{ ES = run; }while(0)
 
 
        #define    NVIC_UART2_CTRL(run)     do{ IE2 = (IE2 & 0xFE) | (run); }while(0)
 
 
        #define    NVIC_UART3_CTRL(run)     do{ IE2 = (IE2 & 0xF7) | (run << 3); }while(0)
 
 
        #define    NVIC_UART4_CTRL(run)     do{ IE2 = (IE2 & 0xEF) | (run << 4); }while(0)
 
 
        #define NVIC_UART1_PRI(pri)                   \
        do{                                           \
            IPH = (IPH & 0xEF) | ((pri & 0x02) << 3); \
            IP  = (IP  & 0xEF) | ((pri & 0x01) << 4); \
        }while(0)
 
 
        #define NVIC_UART2_PRI(pri)                     \
        do{                                             \
            IP2H = (IP2H & 0xFE) | ((pri & 0x02) >> 1); \
            IP2  = (IP2  & 0xFE) | (pri & 0x01);        \
        }while(0)
 
        #if (PER_LIB_MCU_MUODEL == STC8Cx || PER_LIB_MCU_MUODEL == STC8Gx || PER_LIB_MCU_MUODEL == STC8Hx)
 
            #define NVIC_UART3_PRI(pri)                     \
            do{                                             \
                IP3H = (IP3H & 0xFE) | ((pri & 0x02) >> 1); \
                IP3  = (IP3  & 0xFE) | (pri & 0x01);        \
            }while(0)
 
            
            #define NVIC_UART4_PRI(pri)                    \
            do{                                            \
                IP3H = (IP3H & 0xFD) | (pri & 0x02);       \
                IP3  = (IP3  & 0xFD) | (pri & 0x01) << 1;  \
            }while(0)
            
        #endif
            
    #endif
    
    #if (PER_LIB_UART_WORK_CTRL == 1)
            
        FSCSTATE GPIO_UART1_SWPort(GPIOSWPort_Type port);
            
            
        FSCSTATE GPIO_UART2_SWPort(GPIOSWPort_Type port);
 
 
        FSCSTATE GPIO_UART3_SWPort(GPIOSWPort_Type port);
 
 
        FSCSTATE GPIO_UART4_SWPort(GPIOSWPort_Type port);
 
 
        extern uint8_t G_Uart_Busy_Flg;     
 
 
        #define      UART1_GET_BUSY_FLAG()    (G_Uart_Busy_Flg & 0x01)
 
 
        #define      UART2_GET_BUSY_FLAG()    (G_Uart_Busy_Flg & 0x02)
 
 
        #define      UART3_GET_BUSY_FLAG()    (G_Uart_Busy_Flg & 0x04)
 
 
        #define      UART4_GET_BUSY_FLAG()    (G_Uart_Busy_Flg & 0x08)
 
        #define      UART1_SET_BUSY_FLAG()    do{G_Uart_Busy_Flg |= 0x01;}while(0)
 
 
        #define      UART2_SET_BUSY_FLAG()    do{G_Uart_Busy_Flg |= 0x02;}while(0)
 
 
        #define      UART3_SET_BUSY_FLAG()    do{G_Uart_Busy_Flg |= 0x04;}while(0)
 
 
        #define      UART4_SET_BUSY_FLAG()    do{G_Uart_Busy_Flg |= 0x08;}while(0)
 
 
        #define    UART1_CLEAR_BUSY_FLAG()    do{G_Uart_Busy_Flg &= 0xFE;}while(0)
 
        
        #define    UART2_CLEAR_BUSY_FLAG()    do{G_Uart_Busy_Flg &= 0xFD;}while(0)
 
 
        #define    UART3_CLEAR_BUSY_FLAG()    do{G_Uart_Busy_Flg &= 0xFB;}while(0)
 
        
        #define    UART4_CLEAR_BUSY_FLAG()    do{G_Uart_Busy_Flg &= 0xF7;}while(0)
 
 
        #define UART1_RECEIVE_BYTE(byte) do{byte = SBUF;}while(0)
 
 
        #define UART2_RECEIVE_BYTE(byte) do{byte = S2BUF;}while(0)
 
 
        #define UART3_RECEIVE_BYTE(byte) do{byte = S3BUF;}while(0)
 
 
        #define UART4_RECEIVE_BYTE(byte) do{byte = S4BUF;}while(0)
 
        void UART1_Isr_Send_Byte(uint8_t dat);
 
        void UART2_Isr_Send_Byte(uint8_t dat);
 
 
        void UART3_Isr_Send_Byte(uint8_t dat);
            
            
        void UART4_Isr_Send_Byte(uint8_t dat);
        
 
        void UART1_Isr_Send_String(const uint8_t *str);
 
 
        void UART2_Isr_Send_String(const uint8_t *str);
 
 
        void UART3_Isr_Send_String(const uint8_t *str);
 
 
        void UART4_Isr_Send_String(const uint8_t *str);
 
        void UART1_Isr_Send_Array(const uint8_t *str,uint16_t len);
 
 
        void UART2_Isr_Send_Array(const uint8_t *str,uint16_t len);
 
 
        void UART3_Isr_Send_Array(const uint8_t *str,uint16_t len);
 
 
        void UART4_Isr_Send_Array(const uint8_t *str,uint16_t len);
    
    #endif
    
#endif
 
/*-----------------------------------------------------------------------
|                   END OF FLIE.  (C) COPYRIGHT zeweni                  |
-----------------------------------------------------------------------*/
#endif