kunlun/dtest/dtest3/kl3_ledc_test/kl3_ledc_test.c

#include "iot_bitops.h"
#include "dtest_printf.h"
#include "cpu.h"
#include "ahb.h"

#if HW_PLATFORM > HW_PLATFORM_SIMU
#include "dbg_io.h"
#endif

#include "chip_reg_base.h"
#include "ahb_rf_s.h"

#include "uart.h"
#include "strformat.h"
#include "uart_e.h"

#include "iot_irq.h"
#include "apb.h"
#include "gpio_mtx.h"
#include "ledc_hw.h"


void register_print_by_addr(uint32_t addr, int num);
void delay_sometime(void);

void ledc_interrrupt_cb(uint8_t port)
{
    iot_printf("port%d done\r\n", port);
}

//25M
int main(void)
{
    uint8_t ch = 0;

    uint8_t div = 24;
    uint16_t h2l = 1000;  // h2l must large than l2h
    uint16_t l2h = 500;
    uint16_t phase1_blink_times = 10;
    uint16_t phase2_blink_times = 15;
    uint16_t thrs = 1000;

    uint8_t phase_num = PHASE_NUM_TWO;

    uint8_t phase1_mode = PHASE_MODE_FIXED_DUTY;//PHASE_MODE_DECREASE
    uint8_t phase2_mode = PHASE_MODE_DECREASE;

    uint8_t phase1_scale = 100;
    uint8_t phase2_scale = 100;

    uint8_t cycle_times = 1;
    uint8_t loop_times = 7;

    uint16_t nop_num = 200;

    dbg_uart_init();
    iot_interrupt_init();

    ledc_ena_rst();
    ledc_gpio_config(ch, 26);

    //1
    ledc_cnt_ena(ch, LEDC_ENA_DISABLE);

    //中断初始化
    ledc_interrupt_init(ch, NULL);

    //2
    ledc_timer_rst(ch);
    ledc_timer_init(ch, div); // 24 --> 1M
    ledc_timer_ctrl(ch, TIMER_CTRL_START);

    //3
    ledc_polarity_sel(ch, OUT_POL_ORIGINAL);
    ledc_idle_level_sel(ch, IDLE_LEVEL_LOW);

    //4
    ledc_h2l_point_set(ch, h2l);
    ledc_l2h_point_set(ch, l2h);

    //5
    ledc_phase1_blink_times_set(ch, phase1_blink_times); // thrs/scale
    ledc_phase2_blink_times_set(ch, phase2_blink_times);

    //6

    ledc_duty_cnt_sel(ch, DUTY_CNT_OWN);
    ledc_thrs_set(ch, thrs); // 1000 -> 1k

    //7
    ledc_phase_opt_sel(ch, DUTY_OPT_MODE_NEW);

    ledc_phase_num_sel(ch, phase_num);

    ledc_phase1_mode_sel(ch,  phase1_mode);
    ledc_phase2_mode_sel(ch,  phase2_mode);

    ledc_phase1_scale_set(ch, phase1_scale);
    ledc_phase2_scale_set(ch, phase2_scale);

    ledc_cycle_times_set(ch, cycle_times);
    ledc_loop_times_set(ch, loop_times);

    ledc_nop_num_set(ch, nop_num);

    //
    ledc_cnt_ena(ch, LEDC_ENA_ENABLE);
    //1.5.3

////////////////////////////////////////////////////////////////////////
    ch = 2;
    ledc_gpio_config(ch, 27);

    //1
    ledc_cnt_ena(ch, LEDC_ENA_DISABLE);
    //中断初始化
    ledc_interrupt_init(ch, NULL);

    //2
    ledc_timer_rst(ch);
    ledc_timer_init(ch, 4); // 24 --> 1M
    ledc_timer_ctrl(ch, TIMER_CTRL_START);

    //3
    ledc_polarity_sel(ch, OUT_POL_ORIGINAL);
    ledc_idle_level_sel(ch, IDLE_LEVEL_LOW);

    //4
    ledc_h2l_point_set(ch, 500);
    ledc_l2h_point_set(ch, 250);

    //5
    ledc_phase1_blink_times_set(ch, 50); // thrs/scale
    ledc_phase2_blink_times_set(ch, 50);

    //6
    ledc_duty_cnt_sel(ch, DUTY_CNT_OWN);
    ledc_thrs_set(ch, 1000); // 1000 -> 500hz

    //7
    ledc_phase_opt_sel(ch, DUTY_OPT_MODE_NEW);

    ledc_phase_num_sel(ch, PHASE_NUM_TWO);

    ledc_phase1_mode_sel(ch, PHASE_MODE_INCREASE);
    ledc_phase2_mode_sel(ch,  PHASE_MODE_FIXED_DUTY);

    ledc_phase1_scale_set(ch, 10);
    ledc_phase2_scale_set(ch, 20);

    ledc_cycle_times_set(ch, 10);
    ledc_loop_times_set(ch, 10);

    ledc_nop_num_set(ch, 200);

    //
    ledc_cnt_ena(ch, LEDC_ENA_ENABLE);

    while(1)
    {
        delay_sometime();
        delay_sometime();
        //LEDC0->ledc0_conf._b.ledc0_idle_lv = 1;
        delay_sometime();
        delay_sometime();
        //LEDC0->ledc0_conf._b.ledc0_idle_lv = 0;
        register_print_by_addr(LEDC_REG_BASEADDR | (0x200 << 0), 8);
        register_print_by_addr(LEDC_REG_BASEADDR | (0x600 << 0), 4);
    }
    return 0;
}

int main2(void)
{
    uint8_t ch = 0;

    uint8_t div = 24;
    uint16_t h2l[4] = {997, 998, 999, 1000};
    uint16_t l2h[4] = {497, 498, 499, 500};
    uint16_t phase1_blink_times[4] = {10, 10, 10, 10};
    uint16_t phase2_blink_times[4] = {5, 5, 5, 5};
    uint16_t thrs = 1000;

    uint8_t phase_num[4] = {PHASE_NUM_ONE,
                            PHASE_NUM_ONE,
                            PHASE_NUM_ONE,
                            PHASE_NUM_ONE};

    uint8_t phase1_mode[4] = {PHASE_MODE_FIXED_DUTY,
                              PHASE_MODE_FIXED_DUTY,
                              PHASE_MODE_FIXED_DUTY,
                              PHASE_MODE_FIXED_DUTY};
    uint8_t phase2_mode[4] = {PHASE_MODE_DECREASE,
                              PHASE_MODE_DECREASE,
                              PHASE_MODE_DECREASE,
                              PHASE_MODE_DECREASE};

    uint8_t phase1_scale[4] = {100, 100, 100, 100};
    uint8_t phase2_scale[4] = {100, 100, 100, 100};

    uint8_t cycle_times[4] = {1, 1, 1, 1};
    uint8_t loop_times[4] = {7, 7, 7, 7};

    uint16_t nop_num[4]= {200, 200, 200, 200};

    dbg_uart_init();

    ledc_ena_rst();

    //2
    int common_timer = 0;
    ledc_timer_rst(common_timer);
    ledc_timer_init(common_timer, div); // 24 --> 1M
    ledc_timer_ctrl(common_timer, TIMER_CTRL_START);

    common_timer = 1;
    ledc_timer_rst(common_timer);
    ledc_timer_init(common_timer, div * 2); // 24 --> 1M
    ledc_timer_ctrl(common_timer, TIMER_CTRL_START);

    ledc_common_cnt_ena(LEDC_ENA_DISABLE);

    for (ch = 0; ch <=3; ch++) {
        ledc_gpio_config(ch, 26 + ch);

        //1
        ledc_cnt_ena(ch, LEDC_ENA_DISABLE);

        //3
        ledc_polarity_sel(ch, OUT_POL_ORIGINAL);
        ledc_idle_level_sel(ch, IDLE_LEVEL_LOW);

        //4
        ledc_h2l_point_set(ch, h2l[ch]);
        ledc_l2h_point_set(ch, l2h[ch]);

        //5
        ledc_phase1_blink_times_set(ch, phase1_blink_times[ch]); // thrs/scale
        ledc_phase2_blink_times_set(ch, phase2_blink_times[ch]);

        //6
        ledc_duty_cnt_sel(ch, DUTY_CNT_COMMON);
        ledc_thrs_set(ch, thrs); // 1000 -> 1k

        //7
        ledc_phase_opt_sel(ch, DUTY_OPT_MODE_NEW);

        ledc_phase_num_sel(ch, phase_num[ch]);

        ledc_phase1_mode_sel(ch,  phase1_mode[ch]);
        ledc_phase2_mode_sel(ch,  phase2_mode[ch]);

        ledc_phase1_scale_set(ch, phase1_scale[ch]);
        ledc_phase2_scale_set(ch, phase2_scale[ch]);

        ledc_cycle_times_set(ch, cycle_times[ch]);
        ledc_loop_times_set(ch, loop_times[ch]);

        ledc_nop_num_set(ch, nop_num[ch]);

        //
        ledc_cnt_ena(ch, LEDC_ENA_ENABLE);
        delay_sometime();
    }
    ledc_common_thrs_set(thrs);
    ledc_common_timer_sel(COMMON_TIMER_SEL_0);
    ledc_common_cnt_ena(LEDC_ENA_ENABLE);

    while(1) {
        delay_sometime();
        delay_sometime();
        delay_sometime();
        delay_sometime();
        register_print_by_addr(LEDC_REG_BASEADDR               , 3);
        register_print_by_addr(LEDC_REG_BASEADDR | (0x200 << 0), 8);
        register_print_by_addr(LEDC_REG_BASEADDR | (0x600 << 0), 4);
    }
}

void register_print_by_addr(uint32_t addr, int num)
{
    volatile uint32_t *p_addr = (volatile uint32_t *)addr;

    iot_printf("base=%08x:", addr);
    for(int i = 0; i < num; i++)
    {
        iot_printf("%02x=%08x,", (uint32_t)p_addr & 0xff, *p_addr);
        p_addr ++;
    }
    iot_printf("\r\n");
}

void delay_sometime(void) {
    uint32_t loop;
    loop = 0;
    while(loop++ < 1000000) __asm volatile ("nop\n");
}