M051怎么用IO模拟串口？

ude "NuMicro.h"

#define RXBUFSIZE   1024

/*---------------------------------------------------------------------------------*/
/* Define functions prototype                                                      */
/*---------------------------------------------------------------------------------*/
void SYS_Init(void);
void UART0_Init(void);
void TIMER0_Init(void);
void AdcContScanModeTest(void);

/*---------------------------------------------------------------------------------*/
/* Define global variables and constants                                           */
/*---------------------------------------------------------------------------------*/
volatile uint8_t comRbuf[RXBUFSIZE];
volatile uint16_t comRbytes = 0;   /* Available receiving bytes */
volatile uint16_t comRhead  = 0;
volatile uint16_t comRtail  = 0;
volatile int32_t g_bWait    = TRUE;
volatile uint32_t g_u32AdcIntFlag;

/*---------------------------------------------------------------------------------*/
/*  MAIN function                                                                   */
/*---------------------------------------------------------------------------------*/
int main(void)
{
    uint8_t u8Item;

    /* Unlock protected registers */
    SYS_UnlockReg();

    /* Init system clock and multi-function I/O */
    SYS_Init();

    /* Init UART0 to 115200-8n1 for testing */
    UART0_Init();

    /* Init TIMER0 for ADC continuous scan mode test */
    TIMER0_Init();

    printf("n");
    printf("+------------------------------------------------------------------------+n");
    printf("|                         Timer Driver Sample Code                        |n");
    printf("+------------------------------------------------------------------------+n");
    printf("  This sample code will use TM0_CNT to trigger ADC conversion and print n");
    printf("  the conversion result of channel 6(GPA.6) on console.n");
    printf("  Example target : M051 Series MCUn");
    printf("  * Please prepare a jumper wire on GPA.6 and AGND before running the      *n");
    printf("  * sample code.                                                            *n");
    printf("+------------------------------------------------------------------------+nn");

    while(1)
    {
        printf("+------------------------------------------------------------------------+n");
        printf("|                            Timer Control Menu                            |n");
        printf("+------------------------------------------------------------------------+n");
        printf("| [1] Timer0 continuous counting and trigger ADC for channel 6(GPA.6)    |n");
        printf("| [2] Quit test                                                           |n");
        printf("+------------------------------------------------------------------------+n");
        u8Item = getchar();

        switch(u8Item)
        {
            case '1':
                g_bWait = TRUE;
                NVIC_EnableIRQ(ADC_IRQn);
                AdcContScanModeTest();
                break;

            default:
                break;
        }

        if(u8Item == '2')
            break;
    }

    /* Disable ADC IP clock */
    CLK_DisableModuleClock(ADC_MODULE);

    printf("Exit Timer test.n");

    /* Disable Timer0 IP clock */
    CLK_DisableModuleClock(TMR0_MODULE);

    /* Disable UART0 IP clock */
    CLK_DisableModuleClock(UART0_MODULE);

    /* Disable External Interrupt */
    NVIC_DisableIRQ(EINT0_IRQn);

    /* Disable NVIC ADC interrupt */
    NVIC_DisableIRQ(ADC_IRQn);

    /* Lock protected registers */
    SYS_LockReg();

    printf("Sample code end.n");

    while(1);
}

/*---------------------------------------------------------------------------------*/
/*  ADC continuous scan mode test                                                 */
/*---------------------------------------------------------------------------------*/
void AdcContScanModeTest(void)
{
    uint8_t  u8Option;
    int32_t  i32ConversionData[8] = {0};

    printf("Conversion result of channel 6(GPA.6) will be printed continuously.n");
    printf("Exit with ESC key.nn");

    /* Enable ADC IP clock */
    CLK_EnableModuleClock(ADC_MODULE);

    /* ADC clock source is HIRC, set divider to 1, ADC clock is HIRC/1. */
    CLK_SetModuleClock(ADC_MODULE, CLK_CLKSEL2_ADCSEL_HIRC, CLK_CLKDIV_ADC(1));

    /* Set GPB multi-function pin for ADC channel 6 */
    SYS->GPB_MFP &= ~SYS_GPB_MFP_PB1_Msk;
    SYS->GPB_MFP |= SYS_GPB_MFP_PB1_ADC_CH6;

    /* Power on ADC module */
    ADC_POWER_ON(ADC);

    /* Set the channel 6 input mode as single-end, and select channel 6 */
    ADC_Open(ADC, ADC_INPUT_MODE_SINGLE_END, ADC_OPERATION_MODE_CONTINUOUS, ADC_CH_6_MASK);

    /* Set timer0 frequency to 1HZ */
    TIMER_SET_CMP_VALUE(TIMER0, 48000000 / 2);

    /* Enable timer counter and interrupt */
    TIMER_Start(TIMER0);

    /* Clear conversion finished flag for ADC channel 6 */
    ADC_CLR_INT_FLAG(ADC, ADC_ADF_INT);

    while(1)
    {
        /* Wait conversion finished */
        while(!ADC_GET_INT_FLAG(ADC, ADC_ADF_INT));

        /* Clear conversion finished flag */
        ADC_CLR_INT_FLAG(ADC, ADC_ADF_INT);

        /* Start next conversion */
        ADC_START_CONV(ADC);

        /* Get the conversion result of the channel 6 */
        i32ConversionData[6] = ADC_GET_CONVERSION_DATA(ADC, 6);
        printf("Conversion result of channel 6: %dn", i32ConversionData[6]);

        if(!g_bWait)
            break;

        /* Check whether ESC key is pressed */
        u8Option = getchar();
        if(u8Option == 27)
        {
            printf("nnESC is pressed, exit continuous scan testn");
            break;
        }
    }

    /* Disable timer counter and interrupt */
    TIMER_Stop(TIMER0);

    /* Disable ADC IP clock */
    CLK_DisableModuleClock(ADC_MODULE);
}

/*---------------------------------------------------------------------------------*/
/*  Init UART0                                                                       */
/*---------------------------------------------------------------------------------*/
void UART0_Init(void)
{
    /*---------------------------------------------------------------------------------------------------------*/
    /* Init UART                                                                                               */
    /*---------------------------------------------------------------------------------------------------------*/
    /* Select UART function mode */
    UART0->FUNCSEL = UART_FUNCSEL_UART;

    /* Set UART line configuration */
    UART_Open(UART0, 115200);

    /* Enable UART Interrupt */
    UART_EnableInt(UART0, UART_IER_RDA_IEN_Msk);
    NVIC_EnableIRQ(UART0_IRQn);
}

/*---------------------------------------------------------------------------------*/
/*  UART Callback function                                                                              */
/*---------------------------------------------------------------------------------*/
void UART0_IRQHandler(void)
{
    uint8_t u8InChar=0xFF;
    int32_t i32Idx;

    /* Rx Ready or Time-out INT */
    if(UART_GET_INT_FLAG(UART0, UART_ISR_RDA_INT_Msk) || UART_GET_INT_FLAG(UART0, UART_ISR_TOUT_INT_Msk))
    {
        /* Get all the input characters */
        while(UART_GET_INT_FLAG(UART0, UART_ISR_RDA_INT_Msk) || UART_GET_INT_FLAG(UART0, UART_ISR_TOUT_INT_Msk))
        {
            /* Get the character from UART Buffer */
            u8InChar = UART_READ(UART0);

            /* Check if buffer full */
            if(comRbytes < RXBUFSIZE)
            {
                /* Enqueue the character */
                comRbuf[comRtail++] = u8InChar;
                if(comRtail >= RXBUFSIZE)
                    comRtail = 0;
                comRbytes++;
            }
            else
            {
                /* FIFO over run */
            }
        }
    }
}

/*---------------------------------------------------------------------------------*/
/*  Init TIMER0                                                                    */
/*---------------------------------------------------------------------------------*/
void TIMER0_Init(void)
{
    /* Set TIMER0 to operate in the mode of continuous counting */
    TIMER_Open(TIMER0, TIMER_PERIODIC_MODE, 1);

    /* Set TIMER0 timeout period to 0.5 seconds */
    TIMER_SET_CMP_VALUE(TIMER0, SYS_CLK/2);

    /* Enable TIMER0 interrupt */
    TIMER_EnableInt(TIMER0);
    NVIC_EnableIRQ(TMR0_IRQn);
}

/*---------------------------------------------------------------------------------*/
/*  Timer0 IRQ Handler                                                              */
/*---------------------------------------------------------------------------------*/
void TMR0_IRQHandler(void)
{
    /* Clear TIMER0 interrupt flag */
    TIMER_ClearIntFlag(TIMER1);

    /* Start ADC conversion */
    ADC_START_CONV(ADC);
}

void SYS_Init(void)
{
    /*---------------------------------------------------------------------------------------------------------*/
    /* Init System Clock                                                                                       */
    /*---------------------------------------------------------------------------------------------------------*/

    /* Enable external 12MHz XTAL */
    CLK_EnableXtalRC(CLK_PWRCTL_HXT_EN_Msk);

    /* Waiting for 12MHz clock ready */
    CLK_WaitClockReady(CLK_STATUS_HXT_STB_Msk);

    /* Switch HCLK clock source to HXT and set HCLK divider to 1 */
    CLK_SetHCLK(CLK_CLKSEL0_HCLKSEL_HXT, CLK_CLKDIV_HCLK(1));

    /* Enable UART and ADC module clock */
    CLK_EnableModuleClock(UART0_MODULE);
    CLK_EnableModuleClock(ADC_MODULE);

    /* Select UART module clock source from HXT (UART0 is pre-selected) and set UART module clock divider to 1 */
    CLK_SetModuleClock(UART0_MODULE, CLK_CLKSEL1_UARTSEL_HXT, CLK_CLKDIV_UART(1));

    /* Select ADC module clock source from HIRC (default) and set CLKDIV = 1 */
    CLK_SetModuleClock(ADC_MODULE, CLK_CLKSEL2_ADCSEL_HIRC, CLK_CLKDIV_ADC(1));

    /*---------------------------------------------------------------------------------------------------------*/
    /* Init I/O Multi-function                                                                                 */
    /*---------------------------------------------------------------------------------------------------------*/

    /* Set GPB multi-function pins for UART0 RXD and TXD  */
    Uart0DefaultMPF();

    /* Set GPB multi-function pin for ADC channel 6 */
    SYS->GPB_MFP |= SYS_GPB_MFP_PB1_ADC_CH6;
}