关于新塘NUC131输出BPWM波的问题

发表于 2018-12-4 16:53

为何用示波器测不到波形，跟着《玩转新塘M0》来玩的呀？有没有用过131的大神？？？

发表于 2018-12-4 16:55

对不起，不知道为啥，图片看不了，有用过的可分享点直接点的代码吗。。。。。。。

发表于 2018-12-4 17:48

本帖最后由 IoTCatcher 于 2018-12-4 17:50 编辑

1. 首先, 我想吐槽下你这个图片为什么不是截图, 你这么搞看的人很难受.
2. 其次, 我觉得像楼主这种问题, 不算特别复杂, 官网提供的样例代码跑一下应该就可以.
3. 最后, 以下代码拷贝自官方样例代码:

复制

<pre style="color: rgb(0, 0, 0); white-space: pre-wrap;">/**************************************************************************//**

 * [url=home.php?mod=space&uid=288409]@file[/url]     main.c

 * [url=home.php?mod=space&uid=895143]@version[/url]  V1.00

 * $Revision: 5 $

 * $Date: 15/01/15 1:34p $

 * [url=home.php?mod=space&uid=247401]@brief[/url]    Change duty cycle and period of output waveform by BPWM Double Buffer function.

 * @note

 * Copyright (C) 2014 Nuvoton Technology Corp. All rights reserved.

 *

 ******************************************************************************/

#include <stdio.h>

#include "NUC131.h"



/*---------------------------------------------------------------------------------------------------------*/

/* Macro, type and constant definitions                                                                    */

/*---------------------------------------------------------------------------------------------------------*/



#define PLLCON_SETTING      CLK_PLLCON_50MHz_HXT

#define PLL_CLOCK           50000000





/*---------------------------------------------------------------------------------------------------------*/

/* Global variables                                                                                        */

/*---------------------------------------------------------------------------------------------------------*/



/**

 * @brief       BPWM0 IRQ Handler

 *

 * @param       None

 *

 * [url=home.php?mod=space&uid=266161]@return[/url]      None

 *

 * [url=home.php?mod=space&uid=1543424]@Details[/url]     ISR to handle BPWM0 interrupt event

 */

void BPWM0_IRQHandler(void)

{

    static int toggle = 0;



    // Update BPWM0 channel 0 period and duty

    if(toggle == 0)

    {

        BPWM_SET_CNR(BPWM0, 0, 99);

        BPWM_SET_CMR(BPWM0, 0, 39);

    }

    else

    {

        BPWM_SET_CNR(BPWM0, 0, 399);

        BPWM_SET_CMR(BPWM0, 0, 199);

    }

    toggle ^= 1;

    // Clear channel 0 period interrupt flag

    BPWM_ClearPeriodIntFlag(BPWM0, 0);

}



void SYS_Init(void)

{

    /*---------------------------------------------------------------------------------------------------------*/

    /* Init System Clock                                                                                       */

    /*---------------------------------------------------------------------------------------------------------*/



    /* Enable Internal RC clock */

    CLK_EnableXtalRC(CLK_PWRCON_OSC22M_EN_Msk);



    /* Waiting for IRC22M clock ready */

    CLK_WaitClockReady(CLK_CLKSTATUS_OSC22M_STB_Msk);



    /* Switch HCLK clock source to Internal RC and HCLK source divide 1 */

    CLK_SetHCLK(CLK_CLKSEL0_HCLK_S_HIRC, CLK_CLKDIV_HCLK(1));



    /* Enable external 12MHz XTAL, internal 22.1184MHz */

    CLK_EnableXtalRC(CLK_PWRCON_XTL12M_EN_Msk | CLK_PWRCON_OSC22M_EN_Msk);



    /* Enable PLL and Set PLL frequency */

    CLK_SetCoreClock(PLL_CLOCK);



    /* Waiting for clock ready */

    CLK_WaitClockReady(CLK_CLKSTATUS_PLL_STB_Msk | CLK_CLKSTATUS_XTL12M_STB_Msk | CLK_CLKSTATUS_OSC22M_STB_Msk);



    /* Switch HCLK clock source to PLL, STCLK to HCLK/2 */

    CLK_SetHCLK(CLK_CLKSEL0_HCLK_S_PLL, CLK_CLKDIV_HCLK(2));



    /* Enable UART module clock */

    CLK_EnableModuleClock(UART0_MODULE);



    /* Select UART module clock source */

    CLK_SetModuleClock(UART0_MODULE, CLK_CLKSEL1_UART_S_HXT, CLK_CLKDIV_UART(1));



    /* Enable BPWM0 clock source */

    CLK_EnableModuleClock(BPWM0_MODULE);



    /* Select BPWM module clock source */

    //CLK_SetModuleClock(BPWM0_MODULE, CLK_CLKSEL3_BPWM0_S_HClK, 0);

    CLK_SetModuleClock(BPWM0_MODULE, CLK_CLKSEL3_BPWM0_S_PLL, 0);



    /* Reset BPWM0 */

    SYS_ResetModule(BPWM0_RST);



    /* Update System Core Clock */

    /* User can use SystemCoreClockUpdate() to calculate PllClock, SystemCoreClock and CycylesPerUs automatically. */

    //SystemCoreClockUpdate();

    PllClock        = PLL_CLOCK;            // PLL

    SystemCoreClock = PLL_CLOCK / 1;        // HCLK

    CyclesPerUs     = PLL_CLOCK / 1000000;  // For SYS_SysTickDelay()



    /*---------------------------------------------------------------------------------------------------------*/

    /* Init I/O Multi-function                                                                                 */

    /*---------------------------------------------------------------------------------------------------------*/

    /* Set GPB multi-function pins for UART0 RXD and TXD */

    SYS->GPB_MFP &= ~(SYS_GPB_MFP_PB0_Msk | SYS_GPB_MFP_PB1_Msk);

    SYS->GPB_MFP |= (SYS_GPB_MFP_PB0_UART0_RXD | SYS_GPB_MFP_PB1_UART0_TXD);

    /* Set GPC multi-function pins for BPWM0 Channel 0 */

    SYS->GPC_MFP &= ~(SYS_GPC_MFP_PC0_Msk);

    SYS->GPC_MFP |= SYS_GPC_MFP_PC0_BPWM0_CH0;

    SYS->ALT_MFP3 &= ~(SYS_ALT_MFP3_PC0_Msk);

    SYS->ALT_MFP3 |= SYS_ALT_MFP3_PC0_BPWM0_CH0;

}



void UART0_Init()

{

    /*---------------------------------------------------------------------------------------------------------*/

    /* Init UART                                                                                               */

    /*---------------------------------------------------------------------------------------------------------*/

    /* Reset IP */

    SYS_ResetModule(UART0_RST);



    /* Configure UART0 and set UART0 Baudrate */

    UART_Open(UART0, 115200);

}



/*---------------------------------------------------------------------------------------------------------*/

/*  Main Function                                                                                          */

/*---------------------------------------------------------------------------------------------------------*/

int32_t main(void)

{

    /* Unlock protected registers */

    SYS_UnlockReg();



    /* Init System, IP clock and multi-function I/O */

    SYS_Init();



    /* Lock protected registers */

    SYS_LockReg();



    /* Init UART to 115200-8n1 for print message */

    UART0_Init();

    printf("+------------------------------------------------------------------------+\n");

    printf("|                          BPWM Driver Sample Code                        |\n");

    printf("|                                                                        |\n");

    printf("+------------------------------------------------------------------------+\n");

    printf("  This sample code will use BPWM0 channel 0 to output waveform\n");

    printf("  I/O configuration:\n");

    printf("    waveform output pin: BPWM0 channel 0(PC.0)\n");

    printf("\nUse double buffer feature.\n");



    /*

        BPWM0 channel 0 waveform of this sample shown below:



        |<-        CNR + 1  clk     ->|  CNR + 1 = 399 + 1 CLKs

                       |<-CMR+1 clk ->|  CMR + 1 = 199 + 1 CLKs

                                      |<-   CNR + 1  ->|  CNR + 1 = 99 + 1 CLKs

                                               |<CMR+1>|  CMR + 1 = 39 + 1 CLKs



      __                ______________          _______

        |______200_____|     200      |____60__|   40  |_____BPWM waveform



    */





    /*

      Configure BPWM0 channel 0 init period and duty.

      Period is __HXT / (prescaler * clock divider * (CNR + 1))

      Duty ratio = (CMR + 1) / (CNR + 1)

      Period = 12 MHz / (2 * 1 * (199 + 1)) =  30000 Hz

      Duty ratio = (99 + 1) / (199 + 1) = 50%

    */

    // BPWM0 channel 0 frequency is 100Hz, duty 30%,

    BPWM_ConfigOutputChannel(BPWM0, 0, 30000, 30);



    // Enable output of BPWM0 channel 0

    BPWM_EnableOutput(BPWM0, BPWM_CH_0_MASK);



    // Enable BPWM0 channel 0 period interrupt, use channel 0 to measure time.

    BPWM_EnablePeriodInt(BPWM0, 0, 0);

    NVIC_EnableIRQ(BPWM0_IRQn);



    // Start

    BPWM_Start(BPWM0, BPWM_CH_0_MASK);



    while(1);



}







</pre><pre style="color: rgb(0, 0, 0); white-space: pre-wrap;">

</pre><pre style="color: rgb(0, 0, 0); white-space: pre-wrap;"><pre style="white-space: pre-wrap;">/**************************************************************************//**

 * @file     main.c

 * @version  V1.00

 * $Revision: 4 $

 * $Date: 15/01/15 1:34p $

 * @brief    Capture the BPWM1 Channel 0 waveform by BPWM0 Channel 0.

 * @note

 * Copyright (C) 2014 Nuvoton Technology Corp. All rights reserved.

 *

 ******************************************************************************/

#include <stdio.h>

#include "NUC131.h"



/*---------------------------------------------------------------------------------------------------------*/

/* Macro, type and constant definitions                                                                    */

/*---------------------------------------------------------------------------------------------------------*/



#define PLLCON_SETTING      CLK_PLLCON_50MHz_HXT

#define PLL_CLOCK           50000000





/*---------------------------------------------------------------------------------------------------------*/

/* Global variables                                                                                        */

/*---------------------------------------------------------------------------------------------------------*/



/**

 * @brief       BPWM0 IRQ Handler

 *

 * @param       None

 *

 * @return      None

 *

 * @details     ISR to handle BPWM0 interrupt event

 */

void BPWM0_IRQHandler(void)

{

    if(BPWM_GetCaptureIntFlag(BPWM0, 0) > 1)

    {

        BPWM_ClearCaptureIntFlag(BPWM0, 0, BPWM_CAPTURE_INT_FALLING_LATCH);

    }

}



/*--------------------------------------------------------------------------------------*/

/* Capture function to calculate the input waveform information                         */

/* u32Count[4] : Keep the internal counter value when input signal rising / falling     */

/*               happens                                                                */

/*                                                                                      */

/* time    A    B     C     D                                                           */

/*           ___   ___   ___   ___   ___   ___   ___   ___                              */

/*      ____|   |_|   |_|   |_|   |_|   |_|   |_|   |_|   |_____                        */

/* index              0 1   2 3                                                         */

/*                                                                                      */

/* The capture internal counter down count from 0x10000, and reload to 0x10000 after    */

/* input signal falling happens (Time B/C/D)                                            */

/*--------------------------------------------------------------------------------------*/

void CalPeriodTime(BPWM_T *BPWM, uint32_t u32Ch)

{

    uint16_t u32Count[4];

    uint32_t u32i;

    uint16_t u16RisingTime, u16FallingTime, u16HighPeroid, u16LowPeroid, u16TotalPeroid;



    /* Clear Capture Falling Indicator (Time A) */

    BPWM_ClearCaptureIntFlag(BPWM, u32Ch, BPWM_CAPTURE_INT_FALLING_LATCH | BPWM_CAPTURE_INT_RISING_LATCH);



    /* Wait for Capture Falling Indicator  */

    while(BPWM_GetCaptureIntFlag(BPWM, u32Ch) < 2);



    /* Clear Capture Falling Indicator (Time B)*/

    BPWM_ClearCaptureIntFlag(BPWM, u32Ch, BPWM_CAPTURE_INT_FALLING_LATCH);



    u32i = 0;



    while(u32i < 4)

    {

        /* Wait for Capture Falling Indicator */

        while(BPWM_GetCaptureIntFlag(BPWM, u32Ch) < 2);



        /* Clear Capture Falling and Rising Indicator */

        BPWM_ClearCaptureIntFlag(BPWM, u32Ch, BPWM_CAPTURE_INT_FALLING_LATCH | BPWM_CAPTURE_INT_RISING_LATCH);



        /* Get Capture Falling Latch Counter Data */

        u32Count[u32i++] = BPWM_GET_CAPTURE_FALLING_DATA(BPWM, u32Ch);



        /* Wait for Capture Rising Indicator */

        while(BPWM_GetCaptureIntFlag(BPWM, u32Ch) < 1);



        /* Clear Capture Rising Indicator */

        BPWM_ClearCaptureIntFlag(BPWM, u32Ch, BPWM_CAPTURE_INT_RISING_LATCH);



        /* Get Capture Rising Latch Counter Data */

        u32Count[u32i++] = BPWM_GET_CAPTURE_RISING_DATA(BPWM, u32Ch);

    }



    u16RisingTime = u32Count[1];



    u16FallingTime = u32Count[0];



    u16HighPeroid = u32Count[1] - u32Count[2];



    u16LowPeroid = 0x10000 - u32Count[1];



    u16TotalPeroid = 0x10000 - u32Count[2];



    printf("\nBPWM generate: \nHigh Period=7199 ~ 7201, Low Period=16799 ~ 16801, Total Period=23999 ~ 24001\n");

    printf("\nCapture Result: Rising Time = %d, Falling Time = %d \nHigh Period = %d, Low Period = %d, Total Period = %d.\n\n",

           u16RisingTime, u16FallingTime, u16HighPeroid, u16LowPeroid, u16TotalPeroid);

    if((u16HighPeroid < 7199) || (u16HighPeroid > 7201) || (u16LowPeroid < 16799) || (u16LowPeroid > 16801) || (u16TotalPeroid < 23999) || (u16TotalPeroid > 24001))

        printf("Capture Test Fail!!\n");

    else

        printf("Capture Test Pass!!\n");

}



void SYS_Init(void)

{

    /*---------------------------------------------------------------------------------------------------------*/

    /* Init System Clock                                                                                       */

    /*---------------------------------------------------------------------------------------------------------*/



    /* Enable Internal RC clock */

    CLK_EnableXtalRC(CLK_PWRCON_OSC22M_EN_Msk);



    /* Waiting for IRC22M clock ready */

    CLK_WaitClockReady(CLK_CLKSTATUS_OSC22M_STB_Msk);



    /* Switch HCLK clock source to Internal RC and HCLK source divide 1 */

    CLK_SetHCLK(CLK_CLKSEL0_HCLK_S_HIRC, CLK_CLKDIV_HCLK(1));



    /* Enable external 12MHz XTAL, internal 22.1184MHz */

    CLK_EnableXtalRC(CLK_PWRCON_XTL12M_EN_Msk | CLK_PWRCON_OSC22M_EN_Msk);



    /* Enable PLL and Set PLL frequency */

    CLK_SetCoreClock(PLL_CLOCK);



    /* Waiting for clock ready */

    CLK_WaitClockReady(CLK_CLKSTATUS_PLL_STB_Msk | CLK_CLKSTATUS_XTL12M_STB_Msk | CLK_CLKSTATUS_OSC22M_STB_Msk);



    /* Switch HCLK clock source to PLL, STCLK to HCLK/2 */

    //CLK_SetHCLK(CLK_CLKSEL0_HCLK_S_PLL, CLK_CLKDIV_HCLK(2));

    CLK_SetHCLK(CLK_CLKSEL0_HCLK_S_HXT, CLK_CLKDIV_HCLK(1));



    /* Enable UART module clock */

    CLK_EnableModuleClock(UART0_MODULE);



    /* Enable BPWM module clock */

    CLK_EnableModuleClock(BPWM0_MODULE);

    CLK_EnableModuleClock(BPWM1_MODULE);



    /* Select UART module clock source */

    CLK_SetModuleClock(UART0_MODULE, CLK_CLKSEL1_UART_S_HXT, CLK_CLKDIV_UART(1));



    /* Select BPWM module clock source */

    CLK_SetModuleClock(BPWM0_MODULE, CLK_CLKSEL3_BPWM0_S_PCLK, 0);

    CLK_SetModuleClock(BPWM1_MODULE, CLK_CLKSEL3_BPWM1_S_PCLK, 0);



    /* Reset BPWM0 and BPWM1 */

    SYS_ResetModule(BPWM0_RST);

    SYS_ResetModule(BPWM1_RST);



    /* Update System Core Clock */

    /* User can use SystemCoreClockUpdate() to calculate PllClock, SystemCoreClock and CycylesPerUs automatically. */

    //SystemCoreClockUpdate();

    PllClock        = PLL_CLOCK;            // PLL

    SystemCoreClock = PLL_CLOCK / 1;        // HCLK

    CyclesPerUs     = PLL_CLOCK / 1000000;  // For SYS_SysTickDelay()



    /*---------------------------------------------------------------------------------------------------------*/

    /* Init I/O Multi-function                                                                                 */

    /*---------------------------------------------------------------------------------------------------------*/

    /* Set GPB multi-function pins for UART0 RXD and TXD */

    SYS->GPB_MFP &= ~(SYS_GPB_MFP_PB0_Msk | SYS_GPB_MFP_PB1_Msk);

    SYS->GPB_MFP |= (SYS_GPB_MFP_PB0_UART0_RXD | SYS_GPB_MFP_PB1_UART0_TXD);



    /* Set GPC and GPD multi-function pins for BPWM0 Channel 0 and BPWM1 channel 0 */

    SYS->GPC_MFP &= ~(SYS_GPC_MFP_PC0_Msk);

    SYS->GPC_MFP |= SYS_GPC_MFP_PC0_BPWM0_CH0;

    SYS->ALT_MFP3 &= ~(SYS_ALT_MFP3_PC0_Msk);

    SYS->ALT_MFP3 |= SYS_ALT_MFP3_PC0_BPWM0_CH0;



    SYS->GPD_MFP &= ~(SYS_GPD_MFP_PD7_Msk);

    SYS->GPD_MFP |= SYS_GPD_MFP_PD7_BPWM1_CH0;

    SYS->ALT_MFP3 &= ~(SYS_ALT_MFP3_PD7_Msk);

    SYS->ALT_MFP3 |= SYS_ALT_MFP3_PD7_BPWM1_CH0;

}



void UART0_Init()

{

    /*---------------------------------------------------------------------------------------------------------*/

    /* Init UART                                                                                               */

    /*---------------------------------------------------------------------------------------------------------*/

    /* Reset IP */

    SYS_ResetModule(UART0_RST);



    /* Configure UART0 and set UART0 Baudrate */

    UART_Open(UART0, 115200);

}



/*---------------------------------------------------------------------------------------------------------*/

/*  Main Function                                                                                          */

/*---------------------------------------------------------------------------------------------------------*/

int32_t main(void)

{

    /* Unlock protected registers */

    SYS_UnlockReg();



    /* Init System, IP clock and multi-function I/O */

    SYS_Init();



    /* Lock protected registers */

    SYS_LockReg();



    /* Init UART0 for printf */

    UART0_Init();



    printf("+------------------------------------------------------------------------+\n");

    printf("|                          BPWM Driver Sample Code                        |\n");

    printf("|                                                                        |\n");

    printf("+------------------------------------------------------------------------+\n");

    printf("  This sample code will use BPWM0 channel 0 to capture\n  the signal from BPWM1 channel 0.\n");

    printf("  I/O configuration:\n");

    printf("    BPWM0_CH0(PC.0 BPWM0 channel 0) <--> BPWM1_CH0(PD.7 BPWM1 channel 0)\n\n");

    printf("Use BPWM0 Channel 0(PC.0) to capture the BPWM1 Channel 0(PD.7) Waveform\n");



    while(1)

    {

        printf("Press any key to start BPWM Capture Test\n");

        getchar();



        /*--------------------------------------------------------------------------------------*/

        /* Set the BPWM1 Channel 0 as BPWM output function.                                       */

        /*--------------------------------------------------------------------------------------*/



        /* Assume BPWM output frequency is 250Hz and duty ratio is 30%, user can calculate BPWM settings by follows.

           duty ratio = (CMR+1)/(CNR+1)

           cycle time = CNR+1

           High level = CMR+1

           BPWM clock source frequency = __HXT = 12000000

           (CNR+1) = BPWM clock source frequency/prescaler/clock source divider/BPWM output frequency

                   = 12000000/2/1/250 = 24000

           (Note: CNR is 16 bits, so if calculated value is larger than 65536, user should increase prescale value.)

           CNR = 23999

           duty ratio = 30% ==> (CMR+1)/(CNR+1) = 30%

           CMR = 7199

           Prescale value is 1 : prescaler= 2

           Clock divider is BPWM_CSR_DIV1 : clock divider =1

        */



        /* set BPWM1 channel 0 output configuration */

        BPWM_ConfigOutputChannel(BPWM1, 0, 250, 30);



        /* Enable BPWM Output path for BPWM1 channel 0 */

        BPWM_EnableOutput(BPWM1, BPWM_CH_0_MASK);



        /* Enable Timer for BPWM1 channel 0 */

        BPWM_Start(BPWM1, BPWM_CH_0_MASK);



        /*--------------------------------------------------------------------------------------*/

        /* Set the BPWM0 channel 0 for capture function                                          */

        /*--------------------------------------------------------------------------------------*/



        /* If input minimum frequency is 250Hz, user can calculate capture settings by follows.

           Capture clock source frequency = __HXT = 12000000 in the sample code.

           (CNR+1) = Capture clock source frequency/prescaler/clock source divider/minimum input frequency

                   = 12000000/2/1/250 = 24000

           (Note: CNR is 16 bits, so if calculated value is larger than 65536, user should increase prescale value.)

           CNR = 0xFFFF

           (Note: In capture mode, user should set CNR to 0xFFFF to increase capture frequency range.)

        */



        /* set BPWM0 channel 0 capture configuration */

        BPWM_ConfigCaptureChannel(BPWM0, 0, 166, 0);



        /* Enable capture falling edge interrupt for BPWM0 channel 0 */

        //BPWM_EnableCaptureInt(BPWM0, 0, BPWM_CAPTURE_INT_FALLING_LATCH);



        /* Enable BPWM0 NVIC interrupt */

        //NVIC_EnableIRQ(BPWM0_IRQn);



        /* Enable Timer for BPWM0 channel 0 */

        BPWM_Start(BPWM0, BPWM_CH_0_MASK);



        /* Enable Capture Function for BPWM0 channel 0 */

        BPWM_EnableCapture(BPWM0, BPWM_CH_0_MASK);



        /* Enable falling capture reload */

        BPWM0->CAPCTL |= BPWM_CAPCTL_FCRLDEN0_Msk;



        /* Wait until BPWM0 channel 0 Timer start to count */

        while((BPWM0->CNT) == 0);



        /* Capture the Input Waveform Data */

        CalPeriodTime(BPWM0, 0);

        /*---------------------------------------------------------------------------------------------------------*/

        /* Stop BPWM1 channel 0 (Recommended procedure method 1)                                                    */

        /* Set BPWM Timer loaded value(Period) as 0. When BPWM internal counter(CNT) reaches to 0, disable BPWM Timer */

        /*---------------------------------------------------------------------------------------------------------*/



        /* Set BPWM1 channel 0 loaded value as 0 */

        BPWM_Stop(BPWM1, BPWM_CH_0_MASK);



        /* Wait until BPWM1 channel 0 Timer Stop */

        while((BPWM1->CNT & BPWM_CNT_CNT_Msk) != 0);



        /* Disable Timer for BPWM1 channel 0 */

        BPWM_ForceStop(BPWM1, BPWM_CH_0_MASK);



        /* Disable BPWM Output path for BPWM1 channel 0 */

        BPWM_DisableOutput(BPWM1, BPWM_CH_0_MASK);



        /*---------------------------------------------------------------------------------------------------------*/

        /* Stop BPWM0 channel 0 (Recommended procedure method 1)                                                    */

        /* Set BPWM Timer loaded value(Period) as 0. When BPWM internal counter(CNT) reaches to 0, disable BPWM Timer */

        /*---------------------------------------------------------------------------------------------------------*/



        /* Disable BPWM0 NVIC */

        //NVIC_DisableIRQ(BPWM0_IRQn);



        /* Set loaded value as 0 for BPWM0 channel 0 */

        BPWM_Stop(BPWM0, BPWM_CH_0_MASK);



        /* Wait until BPWM0 channel 0 current counter reach to 0 */

        while((BPWM0->CNT & BPWM_CNT_CNT_Msk) != 0);



        /* Disable Timer for BPWM0 channel 0 */

        BPWM_ForceStop(BPWM0, BPWM_CH_0_MASK);



        /* Disable Capture Function and Capture Input path for BPWM0 channel 0 */

        BPWM_DisableCapture(BPWM0, BPWM_CH_0_MASK);



        /* Clear Capture Interrupt flag for BPWM0 channel 0 */

        BPWM_ClearCaptureIntFlag(BPWM0, 0, BPWM_CAPTURE_INT_FALLING_LATCH);

    }

}







</pre></pre>

发表于 2018-12-4 19:36

IoTCatcher 发表于 2018-12-4 17:48
1. 首先, 我想吐槽下你这个图片为什么不是截图, 你这么搞看的人很难受.
2. 其次, 我觉得像楼主这种问题, 不 ...

官方样例能否给个网址大哥。。。。

发表于 2018-12-4 22:11

楼主，你怎么拍照啊，不截图？

发表于 2018-12-4 22:14

官方例子的下载地址
https://www.nuvoton.com/hq/resource-download.jsp?tp_GUID=SW0120141104104958

发表于 2018-12-5 00:14

598330983 发表于 2018-12-4 22:14
官方例子的下载地址
https://www.nuvoton.com/hq/resource-download.jsp?tp_GUID=SW0120141104104958 ...

是NUC131的例子吗？我现在玩的是131的！

发表于 2018-12-5 08:22

haunghua 发表于 2018-12-5 00:14
是NUC131的例子吗？我现在玩的是131的！

#include "NUC131.h"

发表于 2018-12-5 08:23

本帖最后由 IoTCatcher 于 2018-12-5 08:25 编辑

haunghua 发表于 2018-12-4 19:36
官方样例能否给个网址大哥。。。。

码云: https://gitee.com/OpenNuvoton
包含新唐各大主流芯片you will love it !

[技术问答] 关于新塘NUC131输出BPWM波的问题

相关帖子

浏览过的版块

技术新星奖章

湍急之河流

社区建设奖章

经常做客