!86 fix some bugs and update libraries

Merge pull request !86 from 刘泓研/gitee_master
2026-11-08 14:43:04 +08:00 · 2020-12-19 15:12:44 +08:00
commit c1fa39a821
@@ -86,6 +86,22 @@ msh >

 2. 输入`menuconfig`命令配置工程，配置好之后保存退出。

+    a）如果需要使用内核用例，先配置rt-thread内核，如图：
+
+    ![kernel_config](figures/k_conf.jpg)
+
+    然后配置内核用例，如图：
+
+    ![kernel_samples](figures/k_ex.jpg)
+
+    b）如果需要使用驱动用例：先使能驱动，如图：
+
+    ![driver_config](figures/drv_conf.jpg)
+
+     然后配置驱动用例，如图：
+
+    ![driver_sample](figures/drv_ex.jpg)
+
 3. 输入`pkgs --update`命令更新软件包。

 4. 输入`scons --target=mdk5/iar` 命令重新生成工程。
@@ -94,7 +110,7 @@ msh >

 ## 4. 联系人信息

- [wangyongquan](https://github.com/wangyq2018) 
+- [liuhongyan](https://gitee.com/liuhongyan98) 

 ## 5. 参考

@@ -127,4 +127,50 @@ menu "Hardware Drivers Config"

    endmenu

+
+    menu "Peripheral Drivers test example"
+
+        config BSP_USING_EXAMPLE_ADC_VOL
+            bool "BSP_USING_EXAMPLE_ADC_VOL"
+            default n
+        
+        config BSP_USING_EXAMPLE_HWTIMER
+            bool "BSP_USING_EXAMPLE_HWTIMER"
+            default n
+
+        config BSP_USING_EXAMPLE_I2C
+            bool "BSP_USING_EXAMPLE_I2C"
+            default n
+
+        config BSP_USING_EXAMPLE_LED_BLINK
+            bool "BSP_USING_EXAMPLE_LED_BLINK"
+            default y
+
+        config BSP_USING_EXAMPLE_PIN_BEEP
+            bool "BSP_USING_EXAMPLE_PIN_BEEP"
+            default y
+
+        config BSP_USING_EXAMPLE_PWM_LED
+            bool "BSP_USING_EXAMPLE_PWM_LED"
+            default n
+
+        config BSP_USING_EXAMPLE_RTC
+            bool "BSP_USING_EXAMPLE_RTC"
+            default n
+
+        config BSP_USING_EXAMPLE_SPI
+            bool "BSP_USING_EXAMPLE_SPI"
+            default n
+
+        config BSP_USING_EXAMPLE_UART
+            bool "BSP_USING_EXAMPLE_UART"
+            default y
+
+        config BSP_USING_EXAMPLE_PM
+            bool "BSP_USING_EXAMPLE_PM"
+            default n
+
+
+    endmenu
+
 endmenu
@@ -2,6 +2,8 @@ from building import *

 cwd = GetCurrentDir()

+objs = []
+
 # add the general drivers.
 src = Split('''
 board.c
@@ -50,5 +52,43 @@ if GetDepend(['BSP_USING_ADC']):

 CPPPATH = [cwd]
 group = DefineGroup('Drivers', src, depend = [''], CPPPATH = CPPPATH)
+objs = objs + group

-Return('group')
+src   = []
+cwd   = GetCurrentDir()
+include_path = [cwd]
+
+if GetDepend('BSP_USING_EXAMPLE_ADC_VOL'):
+    src += ['bsp_driver_example/adc_vol_sample.c']
+
+if GetDepend('BSP_USING_EXAMPLE_HWTIMER'):
+    src += ['bsp_driver_example/hwtimer_sample.c']
+
+if GetDepend('BSP_USING_EXAMPLE_I2C'):
+    src += ['bsp_driver_example/i2c_sample.c']
+
+if GetDepend('BSP_USING_EXAMPLE_LED_BLINK'):
+    src += ['bsp_driver_example/led_blink_sample.c']
+
+if GetDepend('BSP_USING_EXAMPLE_PIN_BEEP'):
+    src += ['bsp_driver_example/pin_beep_sample.c']
+
+if GetDepend('BSP_USING_EXAMPLE_PWM_LED'):
+    src += ['bsp_driver_example/pwm_led_sample.c']
+
+if GetDepend('BSP_USING_EXAMPLE_RTC'):
+    src += ['bsp_driver_example/rtc_sample.c']
+
+if GetDepend('BSP_USING_EXAMPLE_UART'):
+    src += ['bsp_driver_example/uart_sample.c']
+
+if GetDepend('BSP_USING_EXAMPLE_SPI'):
+    src += ['bsp_driver_example/spi_sample.c']
+
+if GetDepend('BSP_USING_EXAMPLE_PM'):
+    src += ['bsp_driver_example/pm_sample.c']
+
+group = DefineGroup('bsp-drivers-test-samples', src, depend = [''], CPPPATH = include_path)
+
+objs = objs + group
+Return('objs')
@@ -0,0 +1,52 @@
+# Prerequisites
+*.d
+
+# Object files
+*.o
+*.ko
+*.obj
+*.elf
+
+# Linker output
+*.ilk
+*.map
+*.exp
+
+# Precompiled Headers
+*.gch
+*.pch
+
+# Libraries
+*.lib
+*.a
+*.la
+*.lo
+
+# Shared objects (inc. Windows DLLs)
+*.dll
+*.so
+*.so.*
+*.dylib
+
+# Executables
+*.exe
+*.out
+*.app
+*.i*86
+*.x86_64
+*.hex
+
+# Debug files
+*.dSYM/
+*.su
+*.idb
+*.pdb
+
+# Kernel Module Compile Results
+*.mod*
+*.cmd
+.tmp_versions/
+modules.order
+Module.symvers
+Mkfile.old
+dkms.conf
@@ -0,0 +1,47 @@
+# 外设驱动测试用例
+
+## 1、介绍
+
+这个软件包包含一些外设设备操作的例程。
+
+### 1.1 例程说明
+
+| 文件             | 说明                            |
+| ---------------- | ------------------------------- |
+| adc_vol_sample.c       | 使用 ADC 设备转换电压数据 |
+| can_sample.c | 通过 CAN 设备发送一帧，并创建一个线程接收数据然后打印输出。 |
+| hwtimer_sample.c       | 使用 硬件定时器定时 |
+| i2c_sample.c     | 使用 i2c 设备进行读写 |
+| pm.c | 反复进入不同程度的睡眠。 |
+| led_blink_sample.c     |  使用 pin 设备控制 LED 闪烁 |
+| pin_beep_sample.c      | 使用 pin 设备控制蜂鸣器 |
+| pwm_led_sample.c       | 使用 pwm 设备控制 LED 的亮度 |
+| rtc_sample.c           | 使用 rtc 设备设置年月日时分秒信息 |
+| spi_sample.c     | 使用 spi 设备进行读写 |
+| uart_sample.c          | 使用 serial 设备中断接收及轮询发送模式收发数据 |
+
+### 1.2 依赖
+
+依赖设备管理模块提供的设备驱动。
+
+## 2、如何打开 外设驱动测试用例
+
+使用 外设驱动测试用例 需要在 RT-Thread 的menuconfig中选择它，具体路径如下：
+
+```
+Hardware Driver Config --->
+    Peripheral Driver test example--->
+```
+
+## 3、使用 外设驱动测试用例
+
+在打开 Peripheral Driver test example 后，当进行 BSP 编译时，选择的软件包相关源代码会被加入到 BSP 工程中进行编译。
+
+## 4、注意事项
+
+暂无。
+
+## 5、联系方式 & 感谢
+
+* 维护：[misonyo](https://github.com/misonyo)
+* 主页：https://github.com/RT-Thread-packages/peripheral-sample
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2006-2018, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2018-11-29     misonyo      first implementation.
+ */
+/*
+ * 程序清单： ADC 设备使用例程
+ * 例程导出了 adc_sample 命令到控制终端
+ * 命令调用格式：adc_sample
+ * 程序功能：通过 ADC 设备采样电压值并转换为数值。
+ *           示例代码参考电压为3.3V,转换位数为12位。
+*/
+
+#include <rtthread.h>
+#include <rtdevice.h>
+
+#define ADC_DEV_NAME        "adc0"      /* ADC 设备名称 */
+#define ADC_DEV_CHANNEL     5           /* PA1 ADC 通道 */
+#define REFER_VOLTAGE       330         /* 参考电压 3.3V,数据精度乘以100保留2位小数*/
+#define CONVERT_BITS        (1 << 12)   /* 转换位数为12位 */
+
+static int adc_vol_sample(int argc, char *argv[])
+{
+    rt_adc_device_t adc_dev;
+    rt_uint32_t value, vol;
+    rt_err_t ret = RT_EOK;
+
+    /* 查找设备 */
+    adc_dev = (rt_adc_device_t)rt_device_find(ADC_DEV_NAME);
+    if (adc_dev == RT_NULL)
+    {
+        rt_kprintf("adc sample run failed! can't find %s device!\n", ADC_DEV_NAME);
+        return RT_ERROR;
+    }
+
+    /* 使能设备 */
+    ret = rt_adc_enable(adc_dev, ADC_DEV_CHANNEL);
+
+    /* 读取采样值 */
+    value = rt_adc_read(adc_dev, ADC_DEV_CHANNEL);
+    rt_kprintf("the value is :%d \n", value);
+
+    /* 转换为对应电压值 */
+    vol = value * REFER_VOLTAGE / CONVERT_BITS;
+    rt_kprintf("the voltage is :%d.%02d \n", vol / 100, vol % 100);
+
+    /* 关闭通道 */
+    ret = rt_adc_disable(adc_dev, ADC_DEV_CHANNEL);
+
+    return ret;
+}
+/* 导出到 msh 命令列表中 */
+MSH_CMD_EXPORT(adc_vol_sample, adc voltage convert sample);
@@ -0,0 +1,144 @@
+/*
+ * Copyright (c) 2006-2018, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2019-06-25     misonyo      first implementation.
+ */
+/*
+ * 程序清单：这是一个 CAN 设备使用例程
+ * 例程导出了 can_sample 命令到控制终端
+ * 命令调用格式：can_sample can2
+ * 命令解释：命令第二个参数是要使用的 CAN 设备名称，为空则使用默认的 CAN 设备
+ * 程序功能：通过 CAN 设备发送一帧，并创建一个线程接收数据然后打印输出。
+*/
+
+#include <rtthread.h>
+#include "rtdevice.h"
+
+#define CAN_DEV_NAME       "can2"      /* CAN 设备名称 */
+
+static struct rt_semaphore rx_sem;     /* 用于接收消息的信号量 */
+static rt_device_t can_dev;            /* CAN 设备句柄 */
+
+/* 接收数据回调函数 */
+static rt_err_t can_rx_call(rt_device_t dev, rt_size_t size)
+{
+    /* CAN 接收到数据后产生中断，调用此回调函数，然后发送接收信号量 */
+    rt_sem_release(&rx_sem);
+
+    return RT_EOK;
+}
+
+static void can_rx_thread(void *parameter)
+{
+    int i;
+    struct rt_can_msg rxmsg = {0};
+
+    /* 设置接收回调函数 */
+    rt_device_set_rx_indicate(can_dev, can_rx_call);
+
+#ifdef RT_CAN_USING_HDR
+    
+    rt_err_t res;
+    
+    struct rt_can_filter_item items[5] =
+    {
+        RT_CAN_FILTER_ITEM_INIT(0x100, 0, 0, 0, 0x700, RT_NULL, RT_NULL), /* std,match ID:0x100~0x1ff，hdr为-1，设置默认过滤表 */
+        RT_CAN_FILTER_ITEM_INIT(0x300, 0, 0, 0, 0x700, RT_NULL, RT_NULL), /* std,match ID:0x300~0x3ff，hdr为-1 */
+        RT_CAN_FILTER_ITEM_INIT(0x211, 0, 0, 0, 0x7ff, RT_NULL, RT_NULL), /* std,match ID:0x211，hdr为-1 */
+        RT_CAN_FILTER_STD_INIT(0x486, RT_NULL, RT_NULL),                  /* std,match ID:0x486，hdr为-1 */
+        {0x555, 0, 0, 0, 0x7ff, 7,}                                       /* std,match ID:0x555，hdr为7，指定设置7号过滤表 */
+    };
+    struct rt_can_filter_config cfg = {5, 1, items}; /* 一共有5个过滤表 */
+    /* 设置硬件过滤表 */
+    res = rt_device_control(can_dev, RT_CAN_CMD_SET_FILTER, &cfg);
+    RT_ASSERT(res == RT_EOK);
+#endif
+
+    while (1)
+    {
+        /* hdr值为-1，表示直接从uselist链表读取数据 */
+        rxmsg.hdr = -1;
+        /* 阻塞等待接收信号量 */
+        rt_sem_take(&rx_sem, RT_WAITING_FOREVER);
+        /* 从CAN读取一帧数据 */
+        rt_device_read(can_dev, 0, &rxmsg, sizeof(rxmsg));
+        /* 打印数据ID及内容 */
+        rt_kprintf("ID:%x  ", rxmsg.id);
+        for (i = 0; i < 8; i++)
+        {
+            rt_kprintf("%2x ", rxmsg.data[i]);
+        }
+
+        rt_kprintf("\n");
+    }
+}
+
+int can_sample(int argc, char *argv[])
+{
+    struct rt_can_msg msg = {0};
+    rt_err_t res;
+    rt_size_t  size;
+    rt_thread_t thread;
+    char can_name[RT_NAME_MAX];
+    
+    if (argc == 2)
+    {
+        rt_strncpy(can_name, argv[1], RT_NAME_MAX);
+    }
+    else
+    {
+        rt_strncpy(can_name, CAN_DEV_NAME, RT_NAME_MAX);
+    }
+
+    can_dev = rt_device_find(can_name);
+    if (!can_dev)
+    {
+        rt_kprintf("find %s failed!\n", can_name);
+        return RT_ERROR;
+    }
+
+    /* 初始化CAN接收信号量 */
+    rt_sem_init(&rx_sem, "rx_sem", 0, RT_IPC_FLAG_FIFO);
+
+    /* 以中断接收及发送方式打开CAN设备 */
+    res = rt_device_open(can_dev, RT_DEVICE_FLAG_INT_TX | RT_DEVICE_FLAG_INT_RX);
+    RT_ASSERT(res == RT_EOK);
+
+    thread = rt_thread_create("can_rx", can_rx_thread, RT_NULL, 1024, 25, 10);
+    if (thread != RT_NULL)
+    {
+        rt_thread_startup(thread);
+    }
+    else
+    {
+        rt_kprintf("create can_rx thread failed!\n");
+    }
+
+    msg.id = 0x78;              /* ID为0x78 */
+    msg.ide = RT_CAN_STDID;     /* 标准格式 */
+    msg.rtr = RT_CAN_DTR;       /* 数据帧 */
+    msg.len = 8;                /* 数据长度为8 */
+    /* 待发送的8字节数据 */
+    msg.data[0] = 0x00;
+    msg.data[1] = 0x11;
+    msg.data[2] = 0x22;
+    msg.data[3] = 0x33;
+    msg.data[4] = 0x44;
+    msg.data[5] = 0x55;
+    msg.data[6] = 0x66;
+    msg.data[7] = 0x77;
+    /* 发送一帧CAN数据 */
+    size = rt_device_write(can_dev, 0, &msg, sizeof(msg));
+    if (size == 0)
+    {
+        rt_kprintf("can dev write data failed!\n");
+    }
+    
+    return res;
+}
+/* 导出到 msh 命令列表中 */
+MSH_CMD_EXPORT(can_sample, can device sample);
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) 2006-2018, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2018-11-30     misonyo      first implementation.
+ */
+/*
+ * 程序清单：这是一个 hwtimer 设备使用例程
+ * 例程导出了 hwtimer_sample 命令到控制终端
+ * 命令调用格式：hwtimer_sample
+ * 程序功能：硬件定时器超时回调函数周期性的打印当前tick值，2次tick值之差换算为时间等同于定时时间值。
+*/
+
+#include <rtthread.h>
+#include <rtdevice.h>
+
+#define HWTIMER_DEV_NAME   "timer0"     /* 定时器名称 */
+
+/* 定时器超时回调函数 */
+static rt_err_t timeout_cb(rt_device_t dev, rt_size_t size)
+{
+    rt_kprintf("tick is :%d !\n", rt_tick_get());
+
+    return 0;
+}
+
+static int hwtimer_sample(int argc, char *argv[])
+{
+    rt_err_t ret = RT_EOK;
+    rt_hwtimerval_t timeout_s;      /* 定时器超时值 */
+    rt_device_t hw_dev = RT_NULL;   /* 定时器设备句柄 */
+    rt_hwtimer_mode_t mode;         /* 定时器模式 */
+
+    /* 查找定时器设备 */
+    hw_dev = rt_device_find(HWTIMER_DEV_NAME);
+    if (hw_dev == RT_NULL)
+    {
+        rt_kprintf("hwtimer sample run failed! can't find %s device!\n", HWTIMER_DEV_NAME);
+        return RT_ERROR;
+    }
+
+    /* 以读写方式打开设备 */
+    ret = rt_device_open(hw_dev, RT_DEVICE_OFLAG_RDWR);
+    if (ret != RT_EOK)
+    {
+        rt_kprintf("open %s device failed!\n", HWTIMER_DEV_NAME);
+        return ret;
+    }
+
+    /* 设置超时回调函数 */
+    rt_device_set_rx_indicate(hw_dev, timeout_cb);
+
+    /* 设置模式为周期性定时器 */
+    mode = HWTIMER_MODE_PERIOD;
+    ret = rt_device_control(hw_dev, HWTIMER_CTRL_MODE_SET, &mode);
+    if (ret != RT_EOK)
+    {
+        rt_kprintf("set mode failed! ret is :%d\n", ret);
+        return ret;
+    }
+
+    /* 设置定时器超时值为5s并启动定时器 */
+    timeout_s.sec = 5;      /* 秒 */
+    timeout_s.usec = 0;     /* 微秒 */
+
+    if (rt_device_write(hw_dev, 0, &timeout_s, sizeof(timeout_s)) != sizeof(timeout_s))
+    {
+        rt_kprintf("set timeout value failed\n");
+        return RT_ERROR;
+    }
+
+    /* 延时3500ms */
+    rt_thread_mdelay(3500);
+
+    /* 读取定时器当前值 */
+    rt_device_read(hw_dev, 0, &timeout_s, sizeof(timeout_s));
+    rt_kprintf("Read: Sec = %d, Usec = %d\n", timeout_s.sec, timeout_s.usec);
+
+    return ret;
+}
+/* 导出到 msh 命令列表中 */
+MSH_CMD_EXPORT(hwtimer_sample, hwtimer sample);
@@ -0,0 +1,97 @@
+/*
+ * Copyright (C) 2018 Shanghai Eastsoft Microelectronics Co., Ltd.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2020-12-15     liuhy       first implementation.
+ */
+/*
+ * 程序清单：这是一个 I2C 设备使用例程
+ * 例程导出了 i2c_io_sample 命令到控制终端
+ * 命令调用格式：i2c_io_sample
+ * 命令解释：使用默认的I2C总线设备
+ * 程序功能：通过 I2C 设备接收数据并打印，然后将接收的字符加1输出。
+*/
+
+#include <rtthread.h>
+#include <rtdevice.h>
+
+#define I2C_BUS_NAME          "i2c1"  /* I2C总线设备名称 */
+#define SLAVE_ADDR                  0x2D    /* 从机地址 */
+#define STR_LEN                       16    /* 接收发送的数据长度 */
+
+static void i2c_io_sample(int argc, char *argv[])
+{
+    
+    struct rt_i2c_bus_device *i2c_bus = RT_NULL;     /* I2C总线设备句柄 */
+    struct rt_i2c_msg temp_msg;                             /* I2C消息 */
+    rt_uint8_t buffer[STR_LEN] = { 0U }; 
+    rt_uint32_t i,num_msg;
+    rt_size_t s_stat;
+    
+    i2c_bus = (struct rt_i2c_bus_device *)rt_device_find(I2C_BUS_NAME);    /* 通过名字获取I2C总线设备的句柄 */
+    
+    if( i2c_bus == RT_NULL)
+    {
+        rt_kprintf("can't find i2c device :%s !\n",I2C_BUS_NAME);
+        
+        return;
+    }
+    
+        /*初始化消息*/
+        temp_msg.addr = SLAVE_ADDR;  /* 从机地址 */
+        temp_msg.len  = STR_LEN;     /* 传输的数据长度 */
+        temp_msg.buf = buffer;       /* 读写缓存器 */
+    
+        num_msg = 1;             /* 传输一条消息 */
+    
+        temp_msg.flags = RT_I2C_RD;             /* I2C读 */
+        s_stat = rt_i2c_transfer(i2c_bus,&temp_msg,num_msg);   /* 传输消息 */
+        
+        rt_thread_mdelay(400); 
+        
+        if( s_stat == num_msg )
+        {
+            rt_kprintf("receive successful. \n receive messege : %s \n:",buffer);
+            
+            for( i = 0 ; i < STR_LEN ; i++)
+            rt_kprintf(" %x",(unsigned int)buffer[i]);
+            
+            rt_kprintf("\n");
+        }
+        else
+        {
+            rt_kprintf("device s% recieve fail \n buffer : s%\n",I2C_BUS_NAME,buffer);
+            return;
+        }
+        
+        for( i = 0 ; i < STR_LEN ; i++)
+        buffer[i]++;
+    
+        temp_msg.flags = RT_I2C_WR;             /* I2C写 */
+        s_stat = rt_i2c_transfer(i2c_bus,&temp_msg,num_msg);   /* 传输一条 */
+        
+        rt_thread_mdelay(400);
+        
+        if( s_stat == num_msg )
+        {
+            rt_kprintf(" send successful \n messege : %s \n:",buffer);
+            
+            for( i = 0 ; i < STR_LEN ; i++)
+            rt_kprintf(" %x",(unsigned int)buffer[i]);
+            
+            rt_kprintf("\n");
+        }
+        else
+        {
+            rt_kprintf("device s% send fail \n",I2C_BUS_NAME);
+            return;
+        }
+        
+        return;
+    
+}
+/* 导出到 msh 命令列表中 */
+MSH_CMD_EXPORT(i2c_io_sample, i2c io sample);
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) 2006-2018, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2018-09-25     misonyo      first edition.
+ */
+/*
+ * 程序清单：这是一个通过PIN脚控制LED亮灭的使用例程
+ * 例程导出了 led_sample 命令到控制终端
+ * 命令调用格式：led_sample 
+ * 命令解释：命令第二个参数是要使用的PIN脚编号，为空则使用例程默认的引脚编号。
+ * 程序功能：程序创建一个led线程，线程每隔1000ms改变PIN脚状态，达到控制led灯
+ *            亮灭的效果。
+*/
+
+#include <rtthread.h>
+#include <rtdevice.h>
+#include <stdlib.h>
+
+/* PIN脚编号，查看驱动文件drv_gpio.c确定 */
+#define LED_PIN_NUM    45  /*PA12*/
+static int pin_num;
+
+static void led_entry(void *parameter)
+{
+    int count = 0;
+    /* 设置PIN脚模式为输出 */
+    rt_pin_mode(pin_num, PIN_MODE_OUTPUT);
+
+    while (1)
+    {
+        count++;
+        rt_kprintf("thread run count : %d\r\n", count);
+        /* 拉低PIN脚 */
+        rt_pin_write(pin_num, PIN_LOW);
+        rt_kprintf("led on!\r\n");
+        /* 延时1000ms */
+        rt_thread_mdelay(1000);
+
+        /* 拉高PIN脚 */
+        rt_pin_write(pin_num, PIN_HIGH);
+        rt_kprintf("led off!\r\n");
+        rt_thread_mdelay(1000);
+    }
+}
+
+static int led_sample(int argc, char *argv[])
+{
+    rt_thread_t tid;
+    rt_err_t ret = RT_EOK;
+
+    /* 判断命令行参数是否给定了PIN脚编号 */
+    if (argc == 2)
+    {
+        pin_num = atoi(argv[1]);
+    }
+    else
+    {
+        pin_num = LED_PIN_NUM;
+    }
+
+    tid = rt_thread_create("led",
+                           led_entry,
+                           RT_NULL,
+                           512,
+                           RT_THREAD_PRIORITY_MAX / 3,
+                           20);
+    if (tid != RT_NULL)
+    {
+        rt_thread_startup(tid);
+    }
+    else
+    {
+        ret = RT_ERROR;
+    }
+
+    return ret;
+}
+/* 导出到 msh 命令列表中 */
+MSH_CMD_EXPORT(led_sample, led sample);
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 2006-2018, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2018-08-15     misonyo      first implementation.
+ */
+/*
+ * 程序清单：这是一个 PIN 设备使用例程
+ * 例程导出了 pin_beep_sample 命令到控制终端
+ * 命令调用格式：pin_beep_sample
+ * 程序功能：通过按键控制蜂鸣器对应引脚的电平状态控制蜂鸣器
+*/
+
+#include <rtthread.h>
+#include <rtdevice.h>
+
+/* 引脚编号，通过查看驱动文件drv_gpio.c确定 */
+#ifndef BEEP_PIN_NUM
+    #define BEEP_PIN_NUM            45  /* PA12 */
+#endif
+#ifndef KEY0_PIN_NUM
+    #define KEY0_PIN_NUM            18  /* PF0 */
+#endif
+#ifndef KEY1_PIN_NUM
+    #define KEY1_PIN_NUM            19  /* PF1 */
+#endif
+
+void beep_on(void *args)
+{
+    rt_kprintf("turn on beep!\n");
+
+    rt_pin_write(BEEP_PIN_NUM, PIN_HIGH);
+}
+
+void beep_off(void *args)
+{
+    rt_kprintf("turn off beep!\n");
+
+    rt_pin_write(BEEP_PIN_NUM, PIN_LOW);
+}
+
+static void pin_beep_sample(void)
+{
+    /* 蜂鸣器引脚为输出模式 */
+    rt_pin_mode(BEEP_PIN_NUM, PIN_MODE_OUTPUT);
+    /* 默认低电平 */
+    rt_pin_write(BEEP_PIN_NUM, PIN_LOW);
+
+    /* 按键0引脚为输入模式 */
+    rt_pin_mode(KEY0_PIN_NUM, PIN_MODE_INPUT_PULLUP);
+    /* 绑定中断，下降沿模式，回调函数名为beep_on */
+    rt_pin_attach_irq(KEY0_PIN_NUM, PIN_IRQ_MODE_FALLING, beep_on, RT_NULL);
+    /* 使能中断 */
+    rt_pin_irq_enable(KEY0_PIN_NUM, PIN_IRQ_ENABLE);
+
+    /* 按键1引脚为输入模式 */
+    rt_pin_mode(KEY1_PIN_NUM, PIN_MODE_INPUT_PULLUP);
+    /* 绑定中断，下降沿模式，回调函数名为beep_off */
+    rt_pin_attach_irq(KEY1_PIN_NUM, PIN_IRQ_MODE_FALLING, beep_off, RT_NULL);
+    /* 使能中断 */
+    rt_pin_irq_enable(KEY1_PIN_NUM, PIN_IRQ_ENABLE);
+}
+/* 导出到 msh 命令列表中 */
+MSH_CMD_EXPORT(pin_beep_sample, pin beep sample);
@@ -0,0 +1,182 @@
+/*
+ * Copyright (C) 2018 Shanghai Eastsoft Microelectronics Co., Ltd.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2020-12-15     liuhy       first implementation.
+ */
+/*
+ * 程序清单：这是一个 pm睡眠唤醒的使用例程
+ * 例程导出了 pm_sample 命令到控制终端
+ * 命令调用格式：pm_sample
+ * 命令解释：进入不同的睡眠模式，然后用按键唤醒
+ * 程序功能：通过串口输出字符串，告知进入睡眠和唤醒睡眠的情况。
+*/
+
+#include <rtthread.h>
+#include <rtdevice.h>
+
+#define PM_NAME       "pm"      /* 设备名称 */
+#define WAKE_UP_PIN     18      /* 唤醒源 */
+#define SLEEP_TIMES     12      /* 进入睡眠次数，轮流进入不同的睡眠模式，包括无睡眠模式 */
+
+struct pm_callback_t
+{
+     volatile int in_fun_times;   /*进入函数的次数*/
+     volatile char flag;          /*标志*/
+     volatile int mode;           /*需要打印的模式*/
+};
+
+volatile struct pm_callback_t g_pm_data;
+
+/*进入睡眠前，睡眠唤醒后，都会进入。*/
+/*函数打印睡眠相关的信息*/
+void sleep_in_out_callback(rt_uint8_t event, rt_uint8_t mode, void *data)
+{
+    /*没有标志，不处理*/
+    if(!(g_pm_data.flag))
+    {
+        return;
+    }
+    
+    /*标志不正常，清空标志*/
+    if((g_pm_data.flag) > 2)
+    {
+        (g_pm_data.flag) = 0;
+        return;
+    }
+    
+    /*模式不匹配*/
+    if(g_pm_data.mode != mode )
+    {
+        return;
+    }
+ 
+    /*进入的事件*/
+    switch(event)
+    {
+        /*进入睡眠前*/
+        case RT_PM_ENTER_SLEEP: g_pm_data.flag = 1;
+                                rt_kprintf("\n\r##%d :  ENTER  ",g_pm_data.in_fun_times);
+                                g_pm_data.in_fun_times++;     /*进入睡眠次数+1*/
+                                break;
+        /*睡眠唤醒后*/
+        case RT_PM_EXIT_SLEEP:  g_pm_data.flag = 0;  /*睡眠唤醒后*/
+                                rt_kprintf("\n\rEXIT\n\r");
+                                rt_pm_release(mode);   /*释放休眠模式*/
+                                return;
+        
+        default: break;
+        
+    };
+    
+    /*当前的睡眠模式*/
+    switch(mode)
+    {
+        case PM_SLEEP_MODE_NONE: rt_kprintf("PM_SLEEP_MODE_NONE\n\r");
+                                break;
+        case PM_SLEEP_MODE_IDLE:  rt_kprintf("PM_SLEEP_MODE_IDLE\n\r");
+                                break;
+        case PM_SLEEP_MODE_LIGHT: rt_kprintf("PM_SLEEP_MODE_LIGHT\n\r");
+                                break;
+        case PM_SLEEP_MODE_DEEP:  rt_kprintf("PM_SLEEP_MODE_DEEP\n\r");
+                                break;
+        case PM_SLEEP_MODE_STANDBY: rt_kprintf("PM_SLEEP_MODE_STANDBY\n\r");
+                                break;
+        case PM_SLEEP_MODE_SHUTDOWN:  rt_kprintf("PM_SLEEP_MODE_SHUTDOWN\n\r");
+                                break;      
+        case PM_SLEEP_MODE_MAX:  rt_kprintf("PM_SLEEP_MODE_MAX\n\r");
+                                break;
+        default: break;           
+    }
+    
+}
+
+/* pm测试函数 */
+static void pm_test(void *parameter)
+{
+    int in_mode[7],i = 0;
+    
+        g_pm_data.in_fun_times = 0;
+        g_pm_data.flag = 0;
+    
+        in_mode[0] = PM_SLEEP_MODE_NONE;
+        in_mode[1] = PM_SLEEP_MODE_IDLE;
+        in_mode[2] = PM_SLEEP_MODE_LIGHT;
+        in_mode[3] = PM_SLEEP_MODE_DEEP;
+        in_mode[4] = PM_SLEEP_MODE_STANDBY;
+        in_mode[5] = PM_SLEEP_MODE_SHUTDOWN;
+        in_mode[6] = PM_SLEEP_MODE_MAX;
+    
+    /*设置回调函数和私有数据*/
+    rt_pm_notify_set(sleep_in_out_callback,RT_NULL);
+       
+    while(i < SLEEP_TIMES)
+   {
+       
+       g_pm_data.mode = in_mode[i%6];
+       
+       /*无休眠模式，不赋予标志*/
+       if(g_pm_data.mode != PM_SLEEP_MODE_NONE)
+       {
+            g_pm_data.flag = 2;  
+       
+       }
+       
+       /*请求选择的休眠模式*/
+       rt_pm_request(in_mode[i%6]);
+
+       rt_thread_mdelay(500);
+       
+       /*无休眠模式，不需要额外的等待*/
+       while(( g_pm_data.flag != 0 )&&(g_pm_data.mode != PM_SLEEP_MODE_NONE))
+       {
+           rt_thread_mdelay(500);
+       }
+       
+       /*释放选择的休眠模式*/
+       rt_pm_release(in_mode[i%6]);
+       
+       i++;
+       
+   }
+      /*清除回调函数和私有数据*/
+    rt_pm_notify_set(RT_NULL,RT_NULL);
+   rt_kprintf("thread pm_test close\n\r");
+}
+
+/*按键唤醒的回调函数*/
+void wake_by_pin(void *args)
+{
+
+}
+
+static int pm_sample(int argc, char *argv[])
+{
+    rt_thread_t thread;
+    
+    /* 按键引脚为输入模式 */
+    rt_pin_mode(WAKE_UP_PIN, PIN_MODE_INPUT_PULLUP);
+    
+    /* 绑定中断，下降沿模式，回调函数名为wake_by_pin */
+    rt_pin_attach_irq(WAKE_UP_PIN, PIN_IRQ_MODE_RISING, wake_by_pin, RT_NULL);
+    /* 使能中断 */
+    rt_pin_irq_enable(WAKE_UP_PIN, PIN_IRQ_ENABLE);
+    
+    thread = rt_thread_create("pm_test", pm_test, RT_NULL, 1024, 25, 10);
+    
+    if (thread != RT_NULL)
+    {
+        rt_thread_startup(thread);
+    }
+    else
+    {
+        rt_kprintf("create pm_test thread failed!\n\r");
+    }
+    
+    return RT_EOK;
+}
+/* 导出到 msh 命令列表中 */
+MSH_CMD_EXPORT(pm_sample, pm sample);
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 2006-2018, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2018-11-25     misonyo      first implementation.
+ */
+/*
+ * 程序清单：这是一个 PWM 设备使用例程
+ * 例程导出了 pwm_led_sample 命令到控制终端
+ * 命令调用格式：pwm_led_sample
+ * 程序功能：通过 PWM 设备控制 LED 灯的亮度，可以看到LED不停的由暗变到亮，然后又从亮变到暗。
+*/
+
+#include <rtthread.h>
+#include <rtdevice.h>
+
+#define LED_PIN_NUM         45      /* PA12 LED PIN脚编号，查看驱动文件drv_gpio.c确定 */
+#define PWM_DEV_NAME        "pwm0"  /* PWM设备名称 */
+#define PWM_DEV_CHANNEL     2       /* PA9 PWM通道 */
+
+struct rt_device_pwm *pwm_dev;      /* PWM设备句柄 */
+
+static int pwm_led_sample(int argc, char *argv[])
+{
+    rt_uint32_t period, pulse, dir;
+
+    period = 500000;    /* 周期为0.5ms，单位为纳秒ns */
+    dir = 1;            /* PWM脉冲宽度值的增减方向 */
+    pulse = 0;          /* PWM脉冲宽度值，单位为纳秒ns */
+
+    /* 查找设备 */
+    pwm_dev = (struct rt_device_pwm *)rt_device_find(PWM_DEV_NAME);
+    if (pwm_dev == RT_NULL)
+    {
+        rt_kprintf("pwm sample run failed! can't find %s device!\n", PWM_DEV_NAME);
+        return RT_ERROR;
+    }
+
+    /* 设置PWM周期和脉冲宽度默认值 */
+    rt_pwm_set(pwm_dev, PWM_DEV_CHANNEL, period, pulse);
+    /* 使能设备 */
+    rt_pwm_enable(pwm_dev, PWM_DEV_CHANNEL);
+    
+    while (1)
+    {
+        rt_thread_mdelay(50);
+        if (dir)
+        {
+            pulse += 5000;      /* 从0值开始每次增加5000ns */
+        }
+        else
+        {
+            pulse -= 5000;      /* 从最大值开始每次减少5000ns */
+        }
+        if (pulse >= period)
+        {
+            dir = 0;
+        }
+        if (0 == pulse)
+        {
+            dir = 1;
+        }
+
+        /* 设置PWM周期和脉冲宽度 */
+        rt_pwm_set(pwm_dev, PWM_DEV_CHANNEL, period, pulse);
+    }
+}
+/* 导出到 msh 命令列表中 */
+MSH_CMD_EXPORT(pwm_led_sample, pwm sample);
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2006-2018, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2018-11-30     misonyo      first implementation.
+ */
+/*
+ * 程序清单：这是一个 RTC 设备使用例程
+ * 例程导出了 rtc_sample 命令到控制终端
+ * 命令调用格式：rtc_sample
+ * 程序功能：设置RTC设备的日期和时间，延时一段时间后获取当前时间并打印显示。
+*/
+
+#include <rtthread.h>
+#include <rtdevice.h>
+
+static int rtc_sample(int argc, char *argv[])
+{
+    rt_err_t ret = RT_EOK;
+    time_t now;
+
+    /* 设置日期 */
+    ret = set_date(2018, 12, 3);
+    if (ret != RT_EOK)
+    {
+        rt_kprintf("set RTC date failed\n");
+        return ret;
+    }
+
+    /* 设置时间 */
+    ret = set_time(11, 15, 50);
+    if (ret != RT_EOK)
+    {
+        rt_kprintf("set RTC time failed\n");
+        return ret;
+    }
+
+    /* 延时3秒 */
+    rt_thread_mdelay(3000);
+
+    /* 获取时间 */
+    now = time(RT_NULL);
+    rt_kprintf("%s\n", ctime(&now));
+
+    return ret;
+}
+/* 导出到 msh 命令列表中 */
+MSH_CMD_EXPORT(rtc_sample, rtc sample);
@@ -0,0 +1,152 @@
+/*
+ * Copyright (C) 2018 Shanghai Eastsoft Microelectronics Co., Ltd.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2020-12-15     liuhy       first implementation.
+ */
+/*
+ * 程序清单：这是一个 SPI 设备使用例程
+ * 例程导出了 spi_io_sample 命令到控制终端
+ * 命令调用格式：spi_io_sample
+ * 程序功能：通过SPI设备先读取数据，然后每个字符加1后输出。
+*/
+
+#include <rtthread.h>
+#include <rtdevice.h>
+
+#define SPI_DEVICE_NAME     "spi00"
+#define BUF_LEN             16
+
+static void spi_io_sample(int argc, char *argv[])
+{
+    struct rt_spi_device * spi_dev;          /* spi设备的句柄 */
+    struct rt_spi_configuration spi_config;
+    rt_uint8_t i,buffer[BUF_LEN] = { 0U };
+    rt_err_t s_stat;
+    rt_err_t result;
+    
+     /* 查找 spi设备 获取spi设备句柄 */
+    spi_dev = (struct rt_spi_device *)rt_device_find(SPI_DEVICE_NAME);
+    
+    if (spi_dev == RT_NULL)
+    {
+        rt_kprintf("spi sample run failed! can't find %s device!\n", SPI_DEVICE_NAME);
+        return;
+    }
+    
+    
+    /* 清空配置结构体 */
+    rt_memset(&spi_config,0,sizeof(struct rt_spi_configuration));
+    
+    spi_config.mode &= ~RT_SPI_SLAVE; /* 主机模式 */
+    spi_config.mode &= ~RT_SPI_3WIRE; /* 4线，双向传输 */
+    spi_config.mode |= RT_SPI_CPHA;   /* 第二边沿采样 */
+    spi_config.mode |= RT_SPI_CPOL;   /* 空闲高电平 */
+    spi_config.mode |= RT_SPI_NO_CS;  /* 禁用软件从机选择管理 */
+    spi_config.mode |= RT_SPI_MSB;    /* 高位在前 */
+    
+    spi_config.data_width = 8;        /* 数据长度：8 */
+    
+    spi_config.max_hz = 2000000;      /* 最快时钟频率 */
+    
+    /* 配置SPI设备 */
+    s_stat = rt_spi_configure(spi_dev,&spi_config);
+    
+    if(s_stat != RT_EOK)
+    {
+        rt_kprintf(" spi config fail !\n ");
+        return;
+    }
+    
+    
+    /* 获取总线 ，防止总线被多个线程同时使用 */
+    result = rt_spi_take_bus(spi_dev);
+    
+    if (result != RT_EOK)
+    {
+        rt_kprintf(" %s take spi bus  failed! \n", SPI_DEVICE_NAME);
+        return;
+    }
+    
+    /* 选中片选 */
+    result = rt_spi_take(spi_dev);
+    
+    if (result != RT_EOK)
+    {
+        rt_kprintf(" %s take spi cs  failed! \n", SPI_DEVICE_NAME);
+        return;
+    }
+    
+    
+    /*接收一次数据*/
+    result = rt_spi_recv(spi_dev,buffer,BUF_LEN);
+    
+    if(result != BUF_LEN)
+    {
+        rt_kprintf("receive fail. \n buffer is : %s \n:",buffer);
+            
+        for( i = 0 ; i < BUF_LEN ; i++)
+         rt_kprintf(" %x",(unsigned int)buffer[i]);
+            
+        rt_kprintf("\n");
+        
+        return;
+    }
+    
+    rt_kprintf("receive successful. \n buffer is : %s \n:",buffer);
+            
+    for( i = 0 ; i < BUF_LEN ; i++)
+    rt_kprintf(" %x",(unsigned int)buffer[i]);
+            
+    rt_kprintf("\n");
+    
+    /* 将接收到的数据加1 */
+    for( i = 0 ; i < BUF_LEN ; i++)
+      buffer[i]++;
+    
+    /*发送数据*/
+    result = rt_spi_send(spi_dev,buffer,BUF_LEN);
+    
+    if(result != BUF_LEN)
+    {
+        rt_kprintf("send fail. \n buffer is : %s \n:",buffer);
+            
+        for( i = 0 ; i < BUF_LEN ; i++)
+         rt_kprintf(" %x",(unsigned int)buffer[i]);
+            
+        rt_kprintf("\n");
+        
+        return;
+    }
+    
+    rt_kprintf("send successful. \n buffer is : %s \n:",buffer);
+            
+    for( i = 0 ; i < BUF_LEN ; i++)
+    rt_kprintf(" %x",(unsigned int)buffer[i]);
+            
+    rt_kprintf("\n");
+   
+    /* 释放片选 */
+    result = rt_spi_release(spi_dev);
+    
+    if (result != RT_EOK)
+    {
+        rt_kprintf(" %s release spi cs failed! \n", SPI_DEVICE_NAME);
+        return;
+    } 
+    
+    /* 释放总线 */
+    result = rt_spi_release_bus(spi_dev);
+    
+    if (result != RT_EOK)
+    {
+        rt_kprintf(" %s release spi bus  failed! \n", SPI_DEVICE_NAME);
+        return;
+    }
+    
+}
+/* 导出到 msh 命令列表中 */
+MSH_CMD_EXPORT(spi_io_sample, spi  sample);
@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) 2006-2018, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2018-08-15     misonyo      first implementation.
+ */
+/*
+ * 程序清单：这是一个 串口 设备使用例程
+ * 例程导出了 uart_sample 命令到控制终端
+ * 命令调用格式：uart_sample uart2
+ * 命令解释：命令第二个参数是要使用的串口设备名称，为空则使用默认的串口设备
+ * 程序功能：通过串口输出字符串"hello RT-Thread!"，然后错位输出输入的字符
+*/
+
+#include <rtthread.h>
+
+#define SAMPLE_UART_NAME       "uart1"      /* 串口设备名称 */
+
+/* 用于接收消息的信号量 */
+static struct rt_semaphore rx_sem;
+static rt_device_t serial;
+
+/* 接收数据回调函数 */
+static rt_err_t uart_input(rt_device_t dev, rt_size_t size)
+{
+    /* 串口接收到数据后产生中断，调用此回调函数，然后发送接收信号量 */
+    rt_sem_release(&rx_sem);
+
+    return RT_EOK;
+}
+
+static void serial_thread_entry(void *parameter)
+{
+    char ch;
+
+    while (1)
+    {
+        /* 从串口读取一个字节的数据，没有读取到则等待接收信号量 */
+        while (rt_device_read(serial, -1, &ch, 1) != 1)
+        {
+            /* 阻塞等待接收信号量，等到信号量后再次读取数据 */
+            rt_sem_take(&rx_sem, RT_WAITING_FOREVER);
+        }
+        /* 读取到的数据通过串口错位输出 */
+        ch = ch + 1;
+        rt_device_write(serial, 0, &ch, 1);
+    }
+}
+
+static int uart_sample(int argc, char *argv[])
+{
+    rt_err_t ret = RT_EOK;
+    char uart_name[RT_NAME_MAX];
+    char str[] = "hello RT-Thread!\r\n";
+
+    if (argc == 2)
+    {
+        rt_strncpy(uart_name, argv[1], RT_NAME_MAX);
+    }
+    else
+    {
+        rt_strncpy(uart_name, SAMPLE_UART_NAME, RT_NAME_MAX);
+    }
+
+    /* 查找串口设备 */
+    serial = rt_device_find(uart_name);
+    if (!serial)
+    {
+        rt_kprintf("find %s failed!\n", uart_name);
+        return RT_ERROR;
+    }
+
+    /* 初始化信号量 */
+    rt_sem_init(&rx_sem, "rx_sem", 0, RT_IPC_FLAG_FIFO);
+    /* 以中断接收及轮询发送方式打开串口设备 */
+    rt_device_open(serial, RT_DEVICE_FLAG_INT_RX);
+    /* 设置接收回调函数 */
+    rt_device_set_rx_indicate(serial, uart_input);
+    /* 发送字符串 */
+    rt_device_write(serial, 0, str, (sizeof(str) - 1));
+
+    /* 创建 serial 线程 */
+    rt_thread_t thread = rt_thread_create("serial", serial_thread_entry, RT_NULL, 1024, 25, 10);
+    /* 创建成功则启动线程 */
+    if (thread != RT_NULL)
+    {
+        rt_thread_startup(thread);
+    }
+    else
+    {
+        ret = RT_ERROR;
+    }
+
+    return ret;
+}
+/* 导出到 msh 命令列表中 */
+MSH_CMD_EXPORT(uart_sample, uart device sample);
@@ -146,9 +146,9 @@ static rt_err_t es32f0_get_adc_value(struct rt_adc_device *device, rt_uint32_t c
    RT_ASSERT(value != RT_NULL);

    /* config adc channel */
-    nm_config.channel       = es32f0_adc_get_channel(channel);
-    nm_config.rank          = ADC_NCH_RANK_1;
-    nm_config.samp_time = ADC_SAMPLETIME_4;
+    nm_config.ch       = es32f0_adc_get_channel(channel);
+    nm_config.idx          = ADC_NCH_IDX_1;
+    nm_config.samp = ADC_SAMPLETIME_4;
    ald_adc_normal_channel_config(_hadc, &nm_config);

    ald_adc_normal_start(_hadc);
@@ -172,16 +172,16 @@ int rt_hw_adc_init(void)

    /* adc function initialization */
    _h_adc0.perh = ADC0;
-    _h_adc0.init.data_align = ADC_DATAALIGN_RIGHT;
-    _h_adc0.init.scan_mode = DISABLE;
-    _h_adc0.init.cont_mode = DISABLE;
-    _h_adc0.init.disc_mode = ADC_ALL_DISABLE;
-    _h_adc0.init.disc_nbr = ADC_DISC_NBR_1;
-    _h_adc0.init.conv_res = ADC_CONV_RES_10;
-    _h_adc0.init.clk_div = ADC_CKDIV_128;
+    _h_adc0.init.align = ADC_DATAALIGN_RIGHT;
+    _h_adc0.init.scan = DISABLE;
+    _h_adc0.init.cont = DISABLE;
+    _h_adc0.init.disc = ADC_ALL_DISABLE;
+    _h_adc0.init.disc_nr = ADC_DISC_NR_1;
+    _h_adc0.init.data_bit = ADC_CONV_BIT_12;
+    _h_adc0.init.div = ADC_CKDIV_128;
    _h_adc0.init.nche_sel = ADC_NCHESEL_MODE_ALL;
-    _h_adc0.init.neg_ref = ADC_NEG_REF_VSS;
-    _h_adc0.init.pos_ref = ADC_POS_REF_VDD;
+    _h_adc0.init.n_ref = ADC_NEG_REF_VSS;
+    _h_adc0.init.p_ref = ADC_POS_REF_VDD;
    ald_adc_init(&_h_adc0);

    rt_hw_adc_register(&_device_adc0, "adc0", &es32f0_adc_ops, &_h_adc0);
@@ -7,6 +7,7 @@
 * Date           Author        Notes
 * 2019-03-19     wangyq        the first version
 * 2019-11-01     wangyq        update libraries
+ * 2020-12-15     liuhy         update libraries
 */

 #include <rtthread.h>
@@ -29,7 +30,7 @@ static void _i2c_init(void)

    /* Initialize I2C Pin */
    gpio_instruct.mode = GPIO_MODE_OUTPUT;
-    gpio_instruct.odos = GPIO_PUSH_PULL;
+    gpio_instruct.odos = GPIO_OPEN_DRAIN;
    gpio_instruct.pupd = GPIO_PUSH_UP;
    gpio_instruct.odrv = GPIO_OUT_DRIVE_NORMAL;
    gpio_instruct.flt  = GPIO_FILTER_DISABLE;
@@ -8,7 +8,7 @@
 * 2019-04-08     wangyq        the first version
 * 2019-11-01     wangyq        adapt to the new power management interface
 */
-
+#include <rthw.h>
 #include <board.h>
 #include <rtdevice.h>
 #include <drv_lptim.h>
@@ -24,6 +24,21 @@ static void uart_console_reconfig(void)
    rt_device_control(rt_console_get_device(), RT_DEVICE_CTRL_CONFIG, &config);
 }

+static void delay(void)
+{
+    long i;
+    rt_base_t level;
+
+    level = rt_hw_interrupt_disable();
+    i = 0;
+    do{
+        i++;
+    }
+    while (i < 10000); 
+    
+    rt_hw_interrupt_enable(level);
+}
+
 /**
 * This function will put ES32F033x into sleep mode.
 *
@@ -50,22 +65,26 @@ static void sleep(struct rt_pm *pm, uint8_t mode)
        {
            /* Enter SLEEP Mode, Main regulator is ON */
            ald_pmu_stop1_enter();
+            delay();
        }
        break;

    case PM_SLEEP_MODE_DEEP:
        /* Enter STOP 2 mode  */
        ald_pmu_stop2_enter();
+        delay();
        break;

    case PM_SLEEP_MODE_STANDBY:
        /* Enter STANDBY mode */
        ald_pmu_stop2_enter();
+        delay();
        break;

    case PM_SLEEP_MODE_SHUTDOWN:
        /* Enter SHUTDOWNN mode */
        ald_pmu_stop2_enter();
+        delay();
        break;

    default:
@@ -35,44 +35,44 @@ extern "C" {
 /** @defgroup BKPC_Public_Macros BKPC Public Macros
  * @{
  */
-#define BKPC_LOCK()		(WRITE_REG(BKPC->PROT, 0))
-#define BKPC_UNLOCK()		(WRITE_REG(BKPC->PROT, 0x9669AA55))
+#define BKPC_LOCK()		(WRITE_REG(BKPC->PROT, 0U))
+#define BKPC_UNLOCK()		(WRITE_REG(BKPC->PROT, 0x9669AA55U))
 #define BKPC_LRC_ENABLE()			\
-    do {						\
-        BKPC_UNLOCK();				\
-        SET_BIT(BKPC->CR, BKPC_CR_LRCEN_MSK);	\
-        BKPC_LOCK();				\
-    } while (0)
+do {						\
+	BKPC_UNLOCK();				\
+	SET_BIT(BKPC->CR, BKPC_CR_LRCEN_MSK);	\
+	BKPC_LOCK();				\
+} while (0)
 #define BKPC_LRC_DISABLE()			\
-    do {						\
-        BKPC_UNLOCK();				\
-        CLEAR_BIT(BKPC->CR, BKPC_CR_LRCEN_MSK);	\
-        BKPC_LOCK();				\
-    } while (0)
+do {						\
+	BKPC_UNLOCK();				\
+	CLEAR_BIT(BKPC->CR, BKPC_CR_LRCEN_MSK);	\
+	BKPC_LOCK();				\
+} while (0)
 #define BKPC_LOSM_ENABLE()			\
-    do {						\
-        BKPC_UNLOCK();				\
-        SET_BIT(BKPC->CR, BKPC_CR_LOSMEN_MSK);	\
-        BKPC_LOCK();				\
-    } while (0)
+do {						\
+	BKPC_UNLOCK();				\
+	SET_BIT(BKPC->CR, BKPC_CR_LOSMEN_MSK);	\
+	BKPC_LOCK();				\
+} while (0)
 #define BKPC_LOSM_DISABLE()			\
-    do {						\
-        BKPC_UNLOCK();				\
-        CLEAR_BIT(BKPC->CR, BKPC_CR_LOSMEN_MSK);\
-        BKPC_LOCK();				\
-    } while (0)
+do {						\
+	BKPC_UNLOCK();				\
+	CLEAR_BIT(BKPC->CR, BKPC_CR_LOSMEN_MSK);\
+	BKPC_LOCK();				\
+} while (0)
 #define BKPC_LOSC_ENABLE()			\
-    do {						\
-        BKPC_UNLOCK();				\
-        SET_BIT(BKPC->CR, BKPC_CR_LOSCEN_MSK);	\
-        BKPC_LOCK();				\
-    } while (0)
+do {						\
+	BKPC_UNLOCK();				\
+	SET_BIT(BKPC->CR, BKPC_CR_LOSCEN_MSK);	\
+	BKPC_LOCK();				\
+} while (0)
 #define BKPC_LOSC_DISABLE()			\
-    do {						\
-        BKPC_UNLOCK();				\
-        CLEAR_BIT(BKPC->CR, BKPC_CR_LOSCEN_MSK);\
-        BKPC_LOCK();				\
-    } while (0)
+do {						\
+	BKPC_UNLOCK();				\
+	CLEAR_BIT(BKPC->CR, BKPC_CR_LOSCEN_MSK);\
+	BKPC_LOCK();				\
+} while (0)
 /**
  * @}
  */
@@ -83,37 +83,31 @@ extern "C" {
 /**
  * @brief BKPC ldo output select
  */
-typedef enum
-{
-    BKPC_LDO_OUTPUT_1_6 = 0x0,	/**< 1.6V */
-    BKPC_LDO_OUTPUT_1_3 = 0x1,	/**< 1.3V */
-    BKPC_LDO_OUTPUT_1_4 = 0x2,	/**< 1.4V */
-    BKPC_LDO_OUTPUT_1_5 = 0x4,	/**< 1.5V */
+typedef enum {
+	BKPC_LDO_OUTPUT_1_6 = 0x0U,	/**< 1.6V */
+	BKPC_LDO_OUTPUT_1_3 = 0x1U,	/**< 1.3V */
+	BKPC_LDO_OUTPUT_1_4 = 0x2U,	/**< 1.4V */
+	BKPC_LDO_OUTPUT_1_5 = 0x4U,	/**< 1.5V */
 } bkpc_ldo_output_t;

 /**
-  * @brief BKPC BOR voltage select
+  * @brief Standby wakeup port select
  */
-typedef enum
-{
-    BKPC_BOR_VOL_1_7  = 0x0,	/**< 1.7V */
-    BKPC_BOR_VOL_2_0  = 0x1,	/**< 2.0V */
-    BKPC_BOR_VOL_2_1  = 0x2,	/**< 2.1V */
-    BKPC_BOR_VOL_2_2  = 0x3,	/**< 2.2V */
-    BKPC_BOR_VOL_2_3  = 0x4,	/**< 2.3V */
-    BKPC_BOR_VOL_2_4  = 0x5,	/**< 2.4V */
-    BKPC_BOR_VOL_2_5  = 0x6,	/**< 2.5V */
-    BKPC_BOR_VOL_2_6  = 0x7,	/**< 2.6V */
-    BKPC_BOR_VOL_2_8  = 0x8,	/**< 2.8V */
-    BKPC_BOR_VOL_3_0  = 0x9,	/**< 3.0V */
-    BKPC_BOR_VOL_3_1  = 0xA,	/**< 3.1V */
-    BKPC_BOR_VOL_3_3  = 0xB,	/**< 3.3V */
-    BKPC_BOR_VOL_3_6  = 0xC,	/**< 3.6V */
-    BKPC_BOR_VOL_3_7  = 0xD,	/**< 3.7V */
-    BKPC_BOR_VOL_4_0  = 0xE,	/**< 4.0V */
-    BKPC_BOR_VOL_4_3  = 0xF,	/**< 4.3V */
-} bkpc_bor_vol_t;
+typedef enum {
+	PMU_STANDBY_PORT_SEL_PA0  = 0x0U,	/**< Wakeup by PA0 */
+	PMU_STANDBY_PORT_SEL_PA1  = 0x1U,	/**< Wakeup by PA1 */
+	PMU_STANDBY_PORT_SEL_PA2  = 0x2U,	/**< Wakeup by PA2 */
+	PMU_STANDBY_PORT_SEL_PA3  = 0x3U,	/**< Wakeup by PA3 */
+	PMU_STANDBY_PORT_SEL_NONE = 0xFU,	/**< Wakeup by other source */
+} bkpc_wakeup_port_t;

+/**
+  * @brief Standby wakeup level
+  */
+typedef enum {
+	PMU_STANDBY_LEVEL_HIGH = 0x0U,	/**< High level */
+	PMU_STANDBY_LEVEL_LOW  = 0x1U,	/**< Low level */
+} bkpc_wakeup_level_t;
 /**
  * @}
  */
@@ -126,22 +120,13 @@ typedef enum
                                 ((x) == BKPC_LDO_OUTPUT_1_3) || \
                                 ((x) == BKPC_LDO_OUTPUT_1_4) || \
                                 ((x) == BKPC_LDO_OUTPUT_1_5))
-#define IS_BKPC_BOR_VOL(x)	(((x) == BKPC_BOR_VOL_1_7) || \
-                             ((x) == BKPC_BOR_VOL_2_0) || \
-                             ((x) == BKPC_BOR_VOL_2_1) || \
-                             ((x) == BKPC_BOR_VOL_2_2) || \
-                             ((x) == BKPC_BOR_VOL_2_3) || \
-                             ((x) == BKPC_BOR_VOL_2_4) || \
-                             ((x) == BKPC_BOR_VOL_2_5) || \
-                             ((x) == BKPC_BOR_VOL_2_6) || \
-                             ((x) == BKPC_BOR_VOL_2_8) || \
-                             ((x) == BKPC_BOR_VOL_3_0) || \
-                             ((x) == BKPC_BOR_VOL_3_1) || \
-                             ((x) == BKPC_BOR_VOL_3_3) || \
-                             ((x) == BKPC_BOR_VOL_3_6) || \
-                             ((x) == BKPC_BOR_VOL_3_7) || \
-                             ((x) == BKPC_BOR_VOL_4_0) || \
-                             ((x) == BKPC_BOR_VOL_4_3))
+#define IS_BKPC_WAKEUP_PORT(x)	(((x) == PMU_STANDBY_PORT_SEL_PA0) || \
+                                 ((x) == PMU_STANDBY_PORT_SEL_PA1) || \
+                                 ((x) == PMU_STANDBY_PORT_SEL_PA2) || \
+                                 ((x) == PMU_STANDBY_PORT_SEL_PA3) || \
+                                 ((x) == PMU_STANDBY_PORT_SEL_NONE))
+#define IS_BKPC_WAKEUP_LEVEL(x)	(((x) == PMU_STANDBY_LEVEL_HIGH) || \
+                                 ((x) == PMU_STANDBY_LEVEL_LOW))
 #define IS_BKPC_RAM_IDX(x)	((x) < 32)
 /**
  * @}
@@ -154,8 +139,8 @@ typedef enum
  * @{
  */
 /* control functions */
+extern void ald_bkpc_standby_wakeup_config(bkpc_wakeup_port_t port, bkpc_wakeup_level_t level);
 extern void ald_bkpc_ldo_config(bkpc_ldo_output_t output, type_func_t state);
-extern void ald_bkpc_bor_config(bkpc_bor_vol_t vol, type_func_t state);
 /**
  * @}
  */
@@ -18,7 +18,7 @@
 #define __ALD_CRC_H__

 #ifdef __cplusplus
-extern "C" {
+ extern "C" {
 #endif

 #include "utils.h"
@@ -39,75 +39,69 @@ extern "C" {
 /**
  * @brief CRC mode
  */
-typedef enum
-{
-    CRC_MODE_CCITT = 0,	/**< Ccitt */
-    CRC_MODE_8     = 1,	/**< Crc8 */
-    CRC_MODE_16    = 2,	/**< Crc16 */
-    CRC_MODE_32    = 3,	/**< Crc32 */
+typedef enum {
+	CRC_MODE_CCITT = 0U,	/**< Ccitt */
+	CRC_MODE_8     = 1U,	/**< Crc8 */
+	CRC_MODE_16    = 2U,	/**< Crc16 */
+	CRC_MODE_32    = 3U,	/**< Crc32 */
 } crc_mode_t;

 /**
  * @brief CRC input length
  */
-typedef enum
-{
-    CRC_LEN_AUTO    = 0,	/**< Auto */
-    CRC_DATASIZE_8  = 1,	/**< Byte */
-    CRC_DATASIZE_16 = 2,	/**< Half word */
-    CRC_DATASIZE_32 = 3,	/**< Word */
+typedef enum {
+	CRC_LEN_AUTO    = 0U,	/**< Auto */
+	CRC_DATASIZE_8  = 1U,	/**< Byte */
+	CRC_DATASIZE_16 = 2U,	/**< Half word */
+	CRC_DATASIZE_32 = 3U,	/**< Word */
 } crc_datasize_t;

 /**
  * @brief CRC whether write error or no
  */
-typedef enum
-{
-    CRC_WERR_NO  = 0,	/**< No error */
-    CRC_WERR_ERR = 1,	/**< Error */
+typedef enum {
+	CRC_WERR_NO  = 0U,	/**< No error */
+	CRC_WERR_ERR = 1U,	/**< Error */
 } crc_werr_t;

 /**
  * @brief CRC state structures definition
  */
-typedef enum
-{
-    CRC_STATE_RESET = 0x0,	/**< Peripheral is not initialized */
-    CRC_STATE_READY = 0x1,	/**< Peripheral Initialized and ready for use */
-    CRC_STATE_BUSY  = 0x2,	/**< An internal process is ongoing */
-    CRC_STATE_ERROR = 0x4,	/**< Error */
+typedef enum {
+	CRC_STATE_RESET = 0x0U,	/**< Peripheral is not initialized */
+	CRC_STATE_READY = 0x1U,	/**< Peripheral Initialized and ready for use */
+	CRC_STATE_BUSY  = 0x2U,	/**< An internal process is ongoing */
+	CRC_STATE_ERROR = 0x4U,	/**< Error */
 } crc_state_t;

 /**
  * @brief CRC init structure definition
  */
-typedef struct
-{
-    crc_mode_t mode;	/**< CRC mode */
-    type_func_t data_rev;	/**< CRC data reverse or no */
-    type_func_t data_inv;	/**< CRC data inverse or no */
-    type_func_t chs_rev; 	/**< CRC check sum reverse or no */
-    type_func_t chs_inv; 	/**< CRC check sum inverse or no */
-    uint32_t seed;		/**< CRC seed */
+typedef struct {
+	crc_mode_t mode;	/**< CRC mode */
+	type_func_t data_rev;	/**< CRC data reverse or no */
+	type_func_t data_inv;	/**< CRC data inverse or no */
+	type_func_t chs_rev; 	/**< CRC check sum reverse or no */
+	type_func_t chs_inv; 	/**< CRC check sum inverse or no */
+	uint32_t seed;		/**< CRC seed */
 } crc_init_t;

 /**
  * @brief  CRC Handle Structure definition
  */
-typedef struct crc_handle_s
-{
-    CRC_TypeDef *perh;	/**< Register base address */
-    crc_init_t init;  	/**< CRC required parameters */
-    uint8_t *cal_buf; 	/**< The pointer of preparing buffer */
-    uint32_t *cal_res;	/**< The pointer of result */
+typedef struct crc_handle_s {
+	CRC_TypeDef *perh;	/**< Register base address */
+	crc_init_t init;  	/**< CRC required parameters */
+	uint8_t *cal_buf; 	/**< The pointer of preparing buffer */
+	uint32_t *cal_res;	/**< The pointer of result */
 #ifdef ALD_DMA
-    dma_handle_t hdma;	/**< CRC DMA handle parameters */
+	dma_handle_t hdma;	/**< CRC DMA handle parameters */
 #endif
-    lock_state_t lock;	/**< Locking object */
-    crc_state_t state;	/**< CRC operation state */
+	lock_state_t lock;	/**< Locking object */
+	crc_state_t state;	/**< CRC operation state */

-    void (*cal_cplt_cbk)(struct crc_handle_s *arg);	/**< Calculate completed callback */
-    void (*err_cplt_cbk)(struct crc_handle_s *arg);	/**< Calculate error callback */
+	void (*cal_cplt_cbk)(struct crc_handle_s *arg);	/**< Calculate completed callback */
+	void (*err_cplt_cbk)(struct crc_handle_s *arg);	/**< Calculate error callback */
 } crc_handle_t;
 /**
  * @}
@@ -131,9 +125,9 @@ typedef struct crc_handle_s
  */
 #define IS_CRC(x) 	((x) == CRC)
 #define IS_CRC_MODE(x) 	(((x) == CRC_MODE_CCITT) || \
-                         ((x) == CRC_MODE_8)     || \
-                         ((x) == CRC_MODE_16)    || \
-                         ((x) == CRC_MODE_32))
+			 ((x) == CRC_MODE_8)     || \
+			 ((x) == CRC_MODE_16)    || \
+			 ((x) == CRC_MODE_32))
 /**
  * @}
  */
@@ -18,7 +18,7 @@
 #define __ALD_DBGC_H__

 #ifdef __cplusplus
-extern "C" {
+ extern "C" {
 #endif

 #include "utils.h"
@@ -41,34 +41,32 @@ extern "C" {
 /**
  * @brief Debug mode select
  */
-typedef enum
-{
-    DEBC_MODE_SLEEP   = (1u << 0),	/**< Sleep mode */
-    DEBC_MODE_STOP1   = (1u << 1),	/**< STOP1 mode */
-    DEBC_MODE_STOP2   = (1u << 2),	/**< STOP2 mode */
-    DEBC_MODE_STANDBY = (1u << 3),	/**< Standby mode */
+typedef enum {
+	DEBC_MODE_SLEEP   = (1U << 0),	/**< Sleep mode */
+	DEBC_MODE_STOP1   = (1U << 1),	/**< STOP1 mode */
+	DEBC_MODE_STOP2   = (1U << 2),	/**< STOP2 mode */
+	DEBC_MODE_STANDBY = (1U << 3),	/**< Standby mode */
 } dbgc_mode_t;

 /**
  * @brief Debug peripheral select
  */
-typedef enum
-{
-    DEBC_PERH_TIMER0  = (1u << 0),			/**< AD16C4T0 */
-    DEBC_PERH_TIMER1  = (1u << 1),			/**< BS16T0 */
-    DEBC_PERH_TIMER2  = (1u << 2),			/**< GP16C2T0 */
-    DEBC_PERH_TIMER3  = (1u << 3),			/**< GP16C2T1 */
-    DEBC_PERH_TIMER4  = (1u << 4),			/**< BS16T1 */
-    DEBC_PERH_TIMER5  = (1u << 5),			/**< BS16T2 */
-    DEBC_PERH_TIMER6  = (1u << 6),			/**< GP16C4T0 */
-    DEBC_PERH_TIMER7  = (1u << 7),			/**< BS16T3 */
-    DEBC_PERH_I2C0    = (1u << 8),			/**< I2C0 SMBUS */
-    DEBC_PERH_I2C1    = (1u << 9),			/**< I2C1 SMBUS */
-    DEBC_PERH_CAN     = (1u << 12),			/**< CAN */
-    DEBC_PERH_LPTIM0  = (1u << 0)  | (1u << 16),	/**< LPTIM0 */
-    DEBC_PERH_IWDT    = (1u << 8)  | (1u << 16),	/**< IWDT */
-    DEBC_PERH_WWDT    = (1u << 9)  | (1u << 16),	/**< WWDT */
-    DEBC_PERH_RTC     = (1u << 10) | (1u << 16),	/**< RTC */
+typedef enum {
+	DEBC_PERH_TIMER0  = (1U << 0),			/**< AD16C4T0 */
+	DEBC_PERH_TIMER1  = (1U << 1),			/**< BS16T0 */
+	DEBC_PERH_TIMER2  = (1U << 2),			/**< GP16C2T0 */
+	DEBC_PERH_TIMER3  = (1U << 3),			/**< GP16C2T1 */
+	DEBC_PERH_TIMER4  = (1U << 4),			/**< BS16T1 */
+	DEBC_PERH_TIMER5  = (1U << 5),			/**< BS16T2 */
+	DEBC_PERH_TIMER6  = (1U << 6),			/**< GP16C4T0 */
+	DEBC_PERH_TIMER7  = (1U << 7),			/**< BS16T3 */
+	DEBC_PERH_I2C0    = (1U << 8),			/**< I2C0 SMBUS */
+	DEBC_PERH_I2C1    = (1U << 9),			/**< I2C1 SMBUS */
+	DEBC_PERH_CAN     = (1U << 12),			/**< CAN */
+	DEBC_PERH_LPTIM0  = (1U << 0)  | (1U << 16),	/**< LPTIM0 */
+	DEBC_PERH_IWDT    = (1U << 8)  | (1U << 16),	/**< IWDT */
+	DEBC_PERH_WWDT    = (1U << 9)  | (1U << 16),	/**< WWDT */
+	DEBC_PERH_RTC     = (1U << 10) | (1U << 16),	/**< RTC */
 } dbgc_perh_t;
 /**
  * @}
@@ -83,7 +81,7 @@ typedef enum
  */
 __INLINE uint32_t ald_dbgc_get_rev_id(void)
 {
-    return (DBGC->IDCODE >> 16);
+	return (DBGC->IDCODE >> 16);
 }

 /**
@@ -92,7 +90,7 @@ __INLINE uint32_t ald_dbgc_get_rev_id(void)
  */
 __INLINE uint32_t ald_dbgc_get_core_id(void)
 {
-    return (DBGC->IDCODE >> 12) & 0xF;
+	return (DBGC->IDCODE >> 12) & 0xF;
 }

 /**
@@ -101,7 +99,7 @@ __INLINE uint32_t ald_dbgc_get_core_id(void)
  */
 __INLINE uint32_t ald_dbgc_get_device_id(void)
 {
-    return DBGC->IDCODE & 0xFFF;
+	return DBGC->IDCODE & 0xFFF;
 }

 /**
@@ -112,10 +110,10 @@ __INLINE uint32_t ald_dbgc_get_device_id(void)
  */
 __INLINE void ald_dbgc_mode_config(dbgc_mode_t mode, type_func_t state)
 {
-    if (state)
-        SET_BIT(DBGC->CR, mode);
-    else
-        CLEAR_BIT(DBGC->CR, mode);
+	if (state)
+		SET_BIT(DBGC->CR, mode);
+	else
+		CLEAR_BIT(DBGC->CR, mode);
 }

 /**
@@ -126,20 +124,18 @@ __INLINE void ald_dbgc_mode_config(dbgc_mode_t mode, type_func_t state)
  */
 __INLINE void ald_dbgc_perh_config(dbgc_perh_t perh, type_func_t state)
 {
-    if ((perh >> 16) & 0x1)
-    {
-        if (state)
-            SET_BIT(DBGC->APB2FZ, perh);
-        else
-            CLEAR_BIT(DBGC->APB2FZ, perh);
-    }
-    else
-    {
-        if (state)
-            SET_BIT(DBGC->APB1FZ, perh);
-        else
-            CLEAR_BIT(DBGC->APB1FZ, perh);
-    }
+	if ((perh >> 16) & 0x1) {
+		if (state)
+			SET_BIT(DBGC->APB2FZ, perh);
+		else
+			CLEAR_BIT(DBGC->APB2FZ, perh);
+	}
+	else {
+		if (state)
+			SET_BIT(DBGC->APB1FZ, perh);
+		else
+			CLEAR_BIT(DBGC->APB1FZ, perh);
+	}
 }
 /**
  * @}
@@ -36,21 +36,21 @@ extern "C" {
  * @{
  */
 #define FLASH_REG_UNLOCK()				\
-    do {							\
-        if (op_cmd == OP_FLASH)	 {			\
-            WRITE_REG(MSC->FLASHKEY, 0x8ACE0246);	\
-            WRITE_REG(MSC->FLASHKEY, 0x9BDF1357);	\
-        }						\
-        else {						\
-            WRITE_REG(MSC->INFOKEY, 0x7153BFD9);	\
-            WRITE_REG(MSC->INFOKEY, 0x0642CEA8);	\
-        }						\
-    } while (0)
+do {							\
+	if (op_cmd == OP_FLASH)	 {			\
+		WRITE_REG(MSC->FLASHKEY, 0x8ACE0246U);	\
+		WRITE_REG(MSC->FLASHKEY, 0x9BDF1357U);	\
+	}						\
+	else {						\
+		WRITE_REG(MSC->INFOKEY, 0x7153BFD9U);	\
+		WRITE_REG(MSC->INFOKEY, 0x0642CEA8U);	\
+	}						\
+} while (0)
 #define FLASH_REQ()			(SET_BIT(MSC->FLASHCR, MSC_FLASHCR_FLASHREQ_MSK))
 #define FLASH_REQ_FIN()			(CLEAR_BIT(MSC->FLASHCR, MSC_FLASHCR_FLASHREQ_MSK))
 #define FLASH_IAP_ENABLE()		(SET_BIT(MSC->FLASHCR, MSC_FLASHCR_IAPEN_MSK))
 #define FLASH_IAP_DISABLE()		(CLEAR_BIT(MSC->FLASHCR, MSC_FLASHCR_IAPEN_MSK))
-#define FLASH_BASE_ADDR			0x00000000
+#define FLASH_BASE_ADDR			0x00000000U
 #define	FLASH_PAGE_SIZE			1024UL
 #define FLASH_WORD_SIZE			8UL
 #define FLASH_TOTAL_SIZE		256UL
@@ -67,9 +67,9 @@ extern "C" {
 #define INFO_PAGE_ADDR(ADDR)		((ADDR) & (~INFO_PAGE_MASK))

 #ifdef USE_FLASH_FIFO
-#define	FLASH_FIFO 1
+	#define	FLASH_FIFO 1
 #else
-#define	FLASH_FIFO 0
+	#define	FLASH_FIFO 0
 #endif
 /**
  * @}
@@ -78,24 +78,22 @@ extern "C" {
 /** @defgroup FLASH_Private_Types FLASH Private Types
  * @{
  */
-typedef enum
-{
-    FLASH_CMD_AE     = 0x000051AE,	/**< Program area erase all */
-    FLASH_CMD_PE     = 0x00005EA1,	/**< Page erase  */
-    FLASH_CMD_WP     = 0x00005DA2,	/**< Word program */
-    FLASH_CMD_DATAPE = 0x00005BA4,	/**< Data flash page page erase */
-    FLASH_CMD_DATAWP = 0x00005AA5,	/**< Data flash word program */
+typedef enum {
+	FLASH_CMD_AE     = 0x000051AEU,	/**< Program area erase all */
+	FLASH_CMD_PE     = 0x00005EA1U,	/**< Page erase  */
+	FLASH_CMD_WP     = 0x00005DA2U,	/**< Word program */
+	FLASH_CMD_DATAPE = 0x00005BA4U,	/**< Data flash page page erase */
+	FLASH_CMD_DATAWP = 0x00005AA5U,	/**< Data flash word program */
 } flash_cmd_type;

-typedef enum
-{
-    OP_FLASH = 0,	/**< Operate Pragram area */
-    OP_INFO  = 1,	/**< Operate info area */
+typedef enum {
+	OP_FLASH = 0U,	/**< Operate Pragram area */
+	OP_INFO  = 1U,	/**< Operate info area */
 } op_cmd_type;

 /**
  * @}
-  */
+  */ 
 /** @addtogroup Flash_Private_Functions
  * @{
  */
@@ -36,10 +36,10 @@ extern "C" {
  * @defgroup IAP_Private_Macros IAP Private Macros
  * @{
  */
-#define IAP_WSP_ADDR	0x10000000
-#define IAP_PE_ADDR	0x10000004
-#define IAP_WP_ADDR	0x10000008
-#define IAP_DWP_ADDR	0x1000000c
+#define IAP_WSP_ADDR	0x10000000U
+#define IAP_PE_ADDR	0x10000004U
+#define IAP_WP_ADDR	0x10000008U
+#define IAP_DWP_ADDR	0x1000000cU
 /**
  * @}
  */
@@ -18,7 +18,7 @@
 #define __ALD_SYSCFG_H__

 #ifdef __cplusplus
-extern "C" {
+ extern "C" {
 #endif

 #include "utils.h"
@@ -36,33 +36,33 @@ extern "C" {
 /** @defgroup SYSCFG_Public_Macros SYSCFG Public Macros
  * @{
  */
-#define SYSCFG_LOCK()  		WRITE_REG(SYSCFG->PROT, 0x0)
-#define SYSCFG_UNLOCK()		WRITE_REG(SYSCFG->PROT, 0x55AA6996)
+#define SYSCFG_LOCK()  		WRITE_REG(SYSCFG->PROT, 0x0U)
+#define SYSCFG_UNLOCK()		WRITE_REG(SYSCFG->PROT, 0x55AA6996U)
 #define GET_SYSCFG_LOCK()	READ_BIT(SYSCFG->PROT, SYSCFG_PROT_PROT_MSK)

 #define BOOT_FROM_BOOT_ROM()					\
-    do {								\
-        SYSCFG_UNLOCK();					\
-        SET_BIT(SYSCFG->MEMRMP, SYSCFG_MEMRMP_BRRMPEN_MSK);	\
-        CLEAR_BIT(SYSCFG->MEMRMP, SYSCFG_MEMRMP_BFRMPEN_MSK);	\
-        SYSCFG_LOCK();						\
-    } while (0)
+do {								\
+	SYSCFG_UNLOCK();					\
+	SET_BIT(SYSCFG->MEMRMP, SYSCFG_MEMRMP_BRRMPEN_MSK);	\
+	CLEAR_BIT(SYSCFG->MEMRMP, SYSCFG_MEMRMP_BFRMPEN_MSK);	\
+	SYSCFG_LOCK();						\
+} while (0)

 #define BOOT_FROM_BOOT_FLASH()					\
-    do {								\
-        SYSCFG_UNLOCK();					\
-        CLEAR_BIT(SYSCFG->MEMRMP, SYSCFG_MEMRMP_BRRMPEN_MSK);	\
-        SET_BIT(SYSCFG->MEMRMP, SYSCFG_MEMRMP_BFRMPEN_MSK);	\
-        SYSCFG_LOCK();						\
-    } while (0)
+do {								\
+	SYSCFG_UNLOCK();					\
+	CLEAR_BIT(SYSCFG->MEMRMP, SYSCFG_MEMRMP_BRRMPEN_MSK);	\
+	SET_BIT(SYSCFG->MEMRMP, SYSCFG_MEMRMP_BFRMPEN_MSK);	\
+	SYSCFG_LOCK();						\
+} while (0)

 #define BOOT_FROM_FLASH()					\
-    do {								\
-        SYSCFG_UNLOCK();					\
-        CLEAR_BIT(SYSCFG->MEMRMP, SYSCFG_MEMRMP_BRRMPEN_MSK);	\
-        CLEAR_BIT(SYSCFG->MEMRMP, SYSCFG_MEMRMP_BFRMPEN_MSK);	\
-        SYSCFG_LOCK();						\
-    } while (0)
+do {								\
+	SYSCFG_UNLOCK();					\
+	CLEAR_BIT(SYSCFG->MEMRMP, SYSCFG_MEMRMP_BRRMPEN_MSK);	\
+	CLEAR_BIT(SYSCFG->MEMRMP, SYSCFG_MEMRMP_BFRMPEN_MSK);	\
+	SYSCFG_LOCK();						\
+} while (0)
 /**
  * @}
  */
@@ -73,20 +73,18 @@ extern "C" {
  */
 __STATIC_INLINE__ void ald_vtor_config(uint32_t offset, type_func_t status)
 {
-    SYSCFG_UNLOCK();
+	SYSCFG_UNLOCK();

-    if (status)
-    {
-        MODIFY_REG(SYSCFG->VTOR, SYSCFG_VTOR_VTO_MSK, (offset & ~0x3F));
-        SET_BIT(SYSCFG->MEMRMP, SYSCFG_MEMRMP_VTOEN_MSK);
-    }
-    else
-    {
-        CLEAR_BIT(SYSCFG->MEMRMP, SYSCFG_MEMRMP_VTOEN_MSK);
-    }
+	if (status) {
+		MODIFY_REG(SYSCFG->VTOR, SYSCFG_VTOR_VTO_MSK, (offset & ~0x3FU));
+		SET_BIT(SYSCFG->MEMRMP, SYSCFG_MEMRMP_VTOEN_MSK);
+	}
+	else {
+		CLEAR_BIT(SYSCFG->MEMRMP, SYSCFG_MEMRMP_VTOEN_MSK);
+	}

-    SYSCFG_LOCK();
-    return;
+	SYSCFG_LOCK();
+	return;
 }
 /**
  * @}
@@ -38,93 +38,85 @@ extern "C" {
 /**
  * @brief Data width
  */
-typedef enum
-{
-    TRNG_DSEL_1B  = 0x0,	/**< 1-bit */
-    TRNG_DSEL_8B  = 0x1,	/**< 8-bit */
-    TRNG_DSEL_16B = 0x2,	/**< 16-bit */
-    TRNG_DSEL_32B = 0x3,	/**< 32-bit */
+typedef enum {
+	TRNG_DSEL_1B  = 0x0U,	/**< 1-bit */
+	TRNG_DSEL_8B  = 0x1U,	/**< 8-bit */
+	TRNG_DSEL_16B = 0x2U,	/**< 16-bit */
+	TRNG_DSEL_32B = 0x3U,	/**< 32-bit */
 } trng_data_width_t;

 /**
  * @brief seed type
  */
-typedef enum
-{
-    TRNG_SEED_TYPE_0    = 0x0,	/**< Using 0 as seed */
-    TRNG_SEED_TYPE_1    = 0x1,	/**< Using 1 as seed */
-    TRNG_SEED_TYPE_LAST = 0x2,	/**< Using last seed */
-    TRNG_SEED_TYPE_SEED = 0x3,	/**< Using value of register */
+typedef enum {
+	TRNG_SEED_TYPE_0    = 0x0U,	/**< Using 0 as seed */
+	TRNG_SEED_TYPE_1    = 0x1U,	/**< Using 1 as seed */
+	TRNG_SEED_TYPE_LAST = 0x2U,	/**< Using last seed */
+	TRNG_SEED_TYPE_SEED = 0x3U,	/**< Using value of register */
 } trng_seed_type_t;

 /**
  * @brief TRNG init structure definition
  */
-typedef struct
-{
-    trng_data_width_t data_width;	/**< The width of data */
-    trng_seed_type_t seed_type;	/**< The seed type */
-    uint32_t seed;			/**< The value of seed */
-    uint16_t t_start;		/**< T(start) = T(hclk) * (t_start + 1), T(start) > 1ms */
-    uint8_t adjc;			/**< Adjust parameter */
-    type_func_t posten;		/**< Data back handle function  */
+typedef struct {
+	trng_data_width_t data_width;	/**< The width of data */
+	trng_seed_type_t seed_type;	/**< The seed type */
+	uint32_t seed;			/**< The value of seed */
+	uint16_t t_start;		/**< T(start) = T(trng) * 2 ^ (t_start + 1), T(start) > 1ms */
+	uint8_t adjc;			/**< Adjust parameter */
+	type_func_t posten;		/**< Data back handle function  */
 } trng_init_t;

 /**
  * @brief TRNG state structures definition
  */
-typedef enum
-{
-    TRNG_STATE_RESET = 0x0,	/**< Peripheral is not initialized */
-    TRNG_STATE_READY = 0x1,	/**< Peripheral Initialized and ready for use */
-    TRNG_STATE_BUSY  = 0x2,	/**< An internal process is ongoing */
-    TRNG_STATE_ERROR = 0x4,	/**< Error */
+typedef enum {
+	TRNG_STATE_RESET = 0x0U,	/**< Peripheral is not initialized */
+	TRNG_STATE_READY = 0x1U,	/**< Peripheral Initialized and ready for use */
+	TRNG_STATE_BUSY  = 0x2U,	/**< An internal process is ongoing */
+	TRNG_STATE_ERROR = 0x4U,	/**< Error */
 } trng_state_t;

 /**
  * @brief State type
  */
-typedef enum
-{
-    TRNG_STATUS_START = (1U << 0),	/**< Start state */
-    TRNG_STATUS_DAVLD = (1U << 1),	/**< Data valid state */
-    TRNG_STATUS_SERR  = (1U << 2),	/**< Error state */
+typedef enum {
+	TRNG_STATUS_START = (1U << 0),	/**< Start state */
+	TRNG_STATUS_DAVLD = (1U << 1),	/**< Data valid state */
+	TRNG_STATUS_SERR  = (1U << 2),	/**< Error state */
 } trng_status_t;

 /**
  * @brief Interrupt type
  */
-typedef enum
-{
-    TRNG_IT_START = (1U << 0),	/**< Start */
-    TRNG_IT_DAVLD = (1U << 1),	/**< Data valid */
-    TRNG_IT_SERR  = (1U << 2),	/**< Error */
+typedef enum {
+	TRNG_IT_START = (1U << 0),	/**< Start */
+	TRNG_IT_DAVLD = (1U << 1),	/**< Data valid */
+	TRNG_IT_SERR  = (1U << 2),	/**< Error */
 } trng_it_t;

 /**
  * @brief Interrupt flag type
  */
-typedef enum
-{
-    TRNG_IF_START = (1U << 0),	/**< Start */
-    TRNG_IF_DAVLD = (1U << 1),	/**< Data valid */
-    TRNG_IF_SERR  = (1U << 2),	/**< Error */
+typedef enum {
+	TRNG_IF_START = (1U << 0),	/**< Start */
+	TRNG_IF_DAVLD = (1U << 1),	/**< Data valid */
+	TRNG_IF_SERR  = (1U << 2),	/**< Error */
 } trng_flag_t;

 /**
  * @brief  TRNG Handle Structure definition
  */
-typedef struct trng_handle_s
-{
-    TRNG_TypeDef *perh;	/**< Register base address */
-    trng_init_t init;	/**< TRNG required parameters */
-    uint32_t data;		/**< result data */
-    lock_state_t lock; 	/**< Locking object */
-    trng_state_t state;	/**< TRNG operation state */
+typedef struct trng_handle_s {
+	TRNG_TypeDef *perh;	/**< Register base address */
+	trng_init_t init;	/**< TRNG required parameters */
+	uint32_t data;		/**< result data */
+	lock_state_t lock; 	/**< Locking object */
+	trng_state_t state;	/**< TRNG operation state */

-    void (*trng_cplt_cbk)(struct trng_handle_s *arg); /**< Trng completed callback */
-    void (*err_cplt_cbk)(struct trng_handle_s *arg);  /**< Trng error callback */
-    void (*init_cplt_cbk)(struct trng_handle_s *arg); /**< Trng init completed callback */
+	void (*trng_cplt_cbk)(struct trng_handle_s *arg); /**< Trng completed callback */
+	void (*err_cplt_cbk)(struct trng_handle_s *arg);  /**< Trng error callback */
+	void (*init_cplt_cbk)(struct trng_handle_s *arg); /**< Trng init completed callback */
 } trng_handle_t;
 /**
  * @}
@@ -154,15 +146,16 @@ typedef struct trng_handle_s
                                 ((x) == TRNG_SEED_TYPE_LAST) || \
                                 ((x) == TRNG_SEED_TYPE_SEED))
 #define IS_TRNG_STATUS(x)	(((x) == TRNG_STATUS_START)  || \
-                             ((x) == TRNG_STATUS_DAVLD)  || \
-                             ((x) == TRNG_STATUS_SERR))
-#define IS_TRNG_IT(x)	(((x) == TRNG_IT_START)  || \
-                         ((x) == TRNG_IT_DAVLD)  || \
-                         ((x) == TRNG_IT_SERR))
-#define IS_TRNG_FLAG(x)	(((x) == TRNG_IF_START)  || \
-                         ((x) == TRNG_IF_DAVLD)  || \
-                         ((x) == TRNG_IF_SERR))
-#define IS_TRNG_ADJC(x)	((x) < 4)
+                                 ((x) == TRNG_STATUS_DAVLD)  || \
+                                 ((x) == TRNG_STATUS_SERR))
+#define IS_TRNG_IT(x)		(((x) == TRNG_IT_START)  || \
+                                 ((x) == TRNG_IT_DAVLD)  || \
+                                 ((x) == TRNG_IT_SERR))
+#define IS_TRNG_FLAG(x)		(((x) == TRNG_IF_START)  || \
+                                 ((x) == TRNG_IF_DAVLD)  || \
+                                 ((x) == TRNG_IF_SERR))
+#define IS_TRNG_ADJC(x)		((x) < 4)
+#define IS_TRNG_T_START(x)	((x) < 8)
 /**
  * @}
  */
@@ -38,12 +38,11 @@ extern "C" {
 /**
  * @brief Wwdt no dog window
  */
-typedef enum
-{
-    WWDT_WIN_25 = 0x0,	/**< No dog window size: 25% */
-    WWDT_WIN_50 = 0x1,	/**< No dog window size: 50% */
-    WWDT_WIN_75 = 0x2,	/**< No dog window size: 75% */
-    WWDT_WIN_00 = 0x3,	/**< No dog window size: 0% */
+typedef enum {
+	WWDT_WIN_25 = 0x0U,	/**< No dog window size: 25% */
+	WWDT_WIN_50 = 0x1U,	/**< No dog window size: 50% */
+	WWDT_WIN_75 = 0x2U,	/**< No dog window size: 75% */
+	WWDT_WIN_00 = 0x3U,	/**< No dog window size: 0% */
 } wwdt_win_t;

 /**
@@ -54,10 +53,10 @@ typedef enum
 * @defgroup WDT_Private_Macros WDT Private Macros
 * @{
 */
-#define WWDT_UNLOCK() {WRITE_REG(WWDT->LOCK, 0x1ACCE551);}
-#define WWDT_LOCK()   {WRITE_REG(WWDT->LOCK, 0xFFFFFFFF);}
-#define IWDT_UNLOCK() {WRITE_REG(IWDT->LOCK, 0x1ACCE551);}
-#define IWDT_LOCK()   {WRITE_REG(IWDT->LOCK, 0xFFFFFFFF);}
+#define WWDT_UNLOCK() {WRITE_REG(WWDT->LOCK, 0x1ACCE551U);}
+#define WWDT_LOCK()   {WRITE_REG(WWDT->LOCK, 0xFFFFFFFFU);}
+#define IWDT_UNLOCK() {WRITE_REG(IWDT->LOCK, 0x1ACCE551U);}
+#define IWDT_LOCK()   {WRITE_REG(IWDT->LOCK, 0xFFFFFFFFU);}

 /**
 * @}
@@ -72,7 +71,7 @@ typedef enum
                                 (x == WWDT_WIN_75) || \
                                 (x == WWDT_WIN_00))
 #define IS_FUNC_STATE(x)	(((x) == DISABLE) || \
-                             ((x) == ENABLE))
+				 ((x) == ENABLE))
 /**
 * @}
 */
@@ -34,41 +34,36 @@ extern "C" {

 #define __isr__

-typedef enum
-{
-    RESET = 0x0,
-    SET   = 0x1,
+typedef enum {
+	RESET = 0x0U,
+	SET   = 0x1U,
 } flag_status_t, it_status_t;

-typedef enum
-{
-    BIT_RESET = 0x0,
-    BIT_SET   = 0x1,
+typedef enum {
+	BIT_RESET = 0x0U,
+	BIT_SET   = 0x1U,
 } bit_status_t;

-typedef enum
-{
-    DISABLE = 0x0,
-    ENABLE  = 0x1,
+typedef enum {
+	DISABLE = 0x0U,
+	ENABLE  = 0x1U,
 } type_func_t;
 #define IS_FUNC_STATE(x)	(((x) == DISABLE) || ((x) == ENABLE))

-typedef enum
-{
-    FALSE = 0x0,
-    TRUE  = 0x1,
+typedef enum {
+	FALSE = 0x0U,
+	TRUE  = 0x1U,
 } type_bool_t;

-typedef enum
-{
-    UNLOCK = 0x0,
-    LOCK   = 0x1,
+typedef enum {
+	UNLOCK = 0x0U,
+	LOCK   = 0x1U,
 } lock_state_t;
 #define IS_LOCK_STATE(x)	(((x) == UNLOCK) || ((x) == LOCK))


 #define BIT(x)			((1U << (x)))
-#define BITS(s, e)		((0xffffffff << (s)) & (0xffffffff >> (31 - (e))))
+#define BITS(s, e)		((0xffffffffU << (s)) & (0xffffffffU >> (31 - (e))))
 #define SET_BIT(reg, bit)	((reg) |= (bit))
 #define CLEAR_BIT(reg, bit)	((reg) &= ~(bit))
 #define READ_BIT(reg, bit)	((reg) & (bit))
@@ -77,18 +72,18 @@ typedef enum
 #define WRITE_REG(reg, val)	((reg) = (val))
 #define READ_REG(reg)		((reg))
 #define MODIFY_REG(reg, clearmask, setmask)	\
-    WRITE_REG((reg), (((READ_REG(reg)) & (~(clearmask))) | (setmask)))
+	WRITE_REG((reg), (((READ_REG(reg)) & (~(clearmask))) | (setmask)))
 #define UNUSED(x)	((void)(x))

 #ifdef USE_ASSERT
 #define assert_param(x)			\
-    do {					\
-        if (!(x)) {			\
-            __disable_irq();	\
-            while (1)		\
-                ;		\
-        }				\
-    } while (0)
+do {					\
+	if (!(x)) {			\
+		__disable_irq();	\
+		while (1)		\
+			;		\
+	}				\
+} while (0)
 #else
 #define assert_param(x)
 #endif
@@ -101,23 +96,23 @@ typedef enum

 __STATIC_INLINE__ void BITBAND_PER(volatile uint32_t *addr, uint32_t bit, uint32_t val)
 {
-    uint32_t tmp = BITBAND_PER_BASE + (((uint32_t)addr - PER_MEM_BASE) << 5) + (bit << 2);
-    *((volatile uint32_t *)tmp) = (uint32_t)val;
+	uint32_t tmp = BITBAND_PER_BASE + (((uint32_t)addr - PER_MEM_BASE) << 5) + (bit << 2);
+	*((volatile uint32_t *)tmp) = (uint32_t)val;
 }

 __STATIC_INLINE__ void BITBAND_SRAM(uint32_t *addr, uint32_t bit, uint32_t val)
 {
-    uint32_t tmp = BITBAND_RAM_BASE + (((uint32_t)addr - RAM_MEM_BASE) << 5) + (bit << 2);
-    *((volatile uint32_t *)tmp) = (uint32_t)val;
+	uint32_t tmp = BITBAND_RAM_BASE + (((uint32_t)addr - RAM_MEM_BASE) << 5) + (bit << 2);
+	*((volatile uint32_t *)tmp) = (uint32_t)val;
 }

 #if defined ( __GNUC__ )
-#ifndef __weak
-#define __weak   __attribute__((weak))
-#endif	/* __weak */
-#ifndef __packed
-#define __packed __attribute__((__packed__))
-#endif	/* __packed */
+	#ifndef __weak
+		#define __weak   __attribute__((weak))
+	#endif	/* __weak */
+	#ifndef __packed
+		#define __packed __attribute__((__packed__))
+	#endif	/* __packed */
 #endif /* __GNUC__ */

 #ifdef __cplusplus
@@ -18,7 +18,7 @@
 #define __UTILS_H__

 #ifdef __cplusplus
-extern "C" {
+ extern "C" {
 #endif

 #include <stdlib.h>
@@ -46,23 +46,21 @@ extern uint32_t __systick_interval;
 /**
  * @brief  ALD Status structures definition
  */
-typedef enum
-{
-    OK      = 0x0,
-    ERROR   = 0x1,
-    BUSY    = 0x2,
-    TIMEOUT = 0x3
+typedef enum {
+	OK      = 0x0U,	/**< Status: OK */
+	ERROR   = 0x1U,	/**< Status: ERROR */
+	BUSY    = 0x2U,	/**< Status: BUSY */
+	TIMEOUT = 0x3U,	/**< Status: TIMEOUT */
 } ald_status_t;

 /**
  * @brief  SysTick interval definition
  */
-typedef enum
-{
-    SYSTICK_INTERVAL_1MS    = 1000,	/**< Interval is 1ms */
-    SYSTICK_INTERVAL_10MS   = 100,	/**< Interval is 10ms */
-    SYSTICK_INTERVAL_100MS  = 10,	/**< Interval is 100ms */
-    SYSTICK_INTERVAL_1000MS = 1,	/**< Interval is 1s */
+typedef enum {
+	SYSTICK_INTERVAL_1MS    = 1000U,	/**< Interval is 1ms */
+	SYSTICK_INTERVAL_10MS   = 100U,		/**< Interval is 10ms */
+	SYSTICK_INTERVAL_100MS  = 10U,		/**< Interval is 100ms */
+	SYSTICK_INTERVAL_1000MS = 1U,		/**< Interval is 1s */
 } systick_interval_t;
 /**
  * @}
@@ -71,25 +69,24 @@ typedef enum
 /** @defgroup ALD_Public_Macros Public Macros
  * @{
  */
-#define ALD_MAX_DELAY	0xFFFFFFFF
-
+#define ALD_MAX_DELAY	0xFFFFFFFFU
 #define IS_BIT_SET(reg, bit)	(((reg) & (bit)) != RESET)
 #define IS_BIT_CLR(reg, bit)	(((reg) & (bit)) == RESET)
 #define RESET_HANDLE_STATE(x)	((x)->state = 0)
 #define __LOCK(x)				\
-    do {					\
-        if ((x)->lock == LOCK) {	\
-            return BUSY;		\
-        }				\
-        else {				\
-            (x)->lock = LOCK;	\
-        }				\
-    } while (0)
+	do {					\
+		if ((x)->lock == LOCK) {	\
+			return BUSY;		\
+		}				\
+		else {				\
+			(x)->lock = LOCK;	\
+		}				\
+	} while (0)

 #define __UNLOCK(x)				\
-    do {					\
-        (x)->lock = UNLOCK;		\
-    } while (0)
+	do {					\
+		(x)->lock = UNLOCK;		\
+	} while (0)

 /**
  * @}
@@ -98,6 +95,10 @@ typedef enum
 /** @defgroup ALD_Private_Macros Private Macros
  * @{
  */
+#define MCU_UID0_ADDR	0x000403E0U
+#define MCU_UID1_ADDR	0x000403E8U
+#define MCU_UID2_ADDR	0x000403F0U
+#define MCU_CHIPID_ADDR	0x000403F8U
 #define IS_PRIO(x)	((x) < 4)
 #define IS_SYSTICK_INTERVAL(x)	(((x) == SYSTICK_INTERVAL_1MS)   || \
                                 ((x) == SYSTICK_INTERVAL_10MS)  || \
@@ -140,7 +141,8 @@ ald_status_t ald_wait_flag(uint32_t *reg, uint32_t bit, flag_status_t status, ui
 void ald_mcu_irq_config(IRQn_Type irq, uint8_t prio, type_func_t status);
 uint32_t ald_mcu_get_tick(void);
 uint32_t ald_mcu_get_cpu_id(void);
-
+void ald_mcu_get_uid(uint8_t *buf);
+uint32_t ald_mcu_get_chipid(void);
 /**
  * @}
  */
@@ -41,7 +41,7 @@
  ==============================================================================
  [..]  This section provides functions allowing to:
    (+) ald_bkpc_ldo_config() API can configure LDO in backup field.
-    (+) ald_bkpc_bor_config() API can configure BOR in backup field.
+    (+) ald_bkpc_standby_wakeup_config() API can configure STANDBY wakeup.

    @endverbatim
  * @{
@@ -55,40 +55,44 @@
  */
 void ald_bkpc_ldo_config(bkpc_ldo_output_t output, type_func_t state)
 {
-    assert_param(IS_BKPC_LDO_OUTPUT(output));
-    assert_param(IS_FUNC_STATE(state));
+	assert_param(IS_BKPC_LDO_OUTPUT(output));
+	assert_param(IS_FUNC_STATE(state));

-    BKPC_UNLOCK();
-    MODIFY_REG(BKPC->CR, BKPC_CR_MT_STDB_MSK, state << BKPC_CR_MT_STDB_POS);
+	BKPC_UNLOCK();
+	MODIFY_REG(BKPC->CR, BKPC_CR_MT_STDB_MSK, state << BKPC_CR_MT_STDB_POS);

-    if (state)
-        MODIFY_REG(BKPC->CR, BKPC_CR_LDO_VSEL_MSK, output << BKPC_CR_LDO_VSEL_POSS);
+	if (state)
+		MODIFY_REG(BKPC->CR, BKPC_CR_LDO_VSEL_MSK, output << BKPC_CR_LDO_VSEL_POSS);

-    BKPC_LOCK();
-    return;
+	BKPC_LOCK();
+	return;
 }

 /**
-  * @brief  Configure bor voltage in backup field
-  * @param  vol: Voltage select.
-  * @param  state: DISABLE/ENABLE.
+  * @brief  Configure standby wakeup in backup field
+  * @param  port: Wakeup port
+  * @param  level: HIGH/LOW.
  * @retval None
  */
-void ald_bkpc_bor_config(bkpc_bor_vol_t vol, type_func_t state)
+void ald_bkpc_standby_wakeup_config(bkpc_wakeup_port_t port, bkpc_wakeup_level_t level)
 {
-    assert_param(IS_BKPC_BOR_VOL(vol));
-    assert_param(IS_FUNC_STATE(state));
+	assert_param(IS_BKPC_WAKEUP_PORT(port));
+	assert_param(IS_BKPC_WAKEUP_LEVEL(level));

-    BKPC_UNLOCK();
-    MODIFY_REG(BKPC->PCR, BKPC_PCR_BOREN_MSK, state << BKPC_PCR_BOREN_POS);
-
-    if (state)
-        MODIFY_REG(BKPC->PCR, BKPC_PCR_BORS_MSK, vol << BKPC_PCR_BORS_POSS);
-
-    BKPC_LOCK();
-    return;
+	if (port == PMU_STANDBY_PORT_SEL_NONE) {
+		BKPC_UNLOCK();
+		CLEAR_BIT(BKPC->CR, BKPC_CR_WKPEN_MSK);
+		BKPC_LOCK();
+		return;
+	}

+	BKPC_UNLOCK();
+	SET_BIT(BKPC->CR, BKPC_CR_WKPEN_MSK);
+	MODIFY_REG(BKPC->CR, BKPC_CR_WKPS_MSK, port << BKPC_CR_WKPS_POSS);
+	MODIFY_REG(BKPC->CR, BKPC_CR_WKPOL_MSK, level << BKPC_CR_WKPOL_POS);
+	BKPC_LOCK();

+	return;
 }
 /**
  * @}
@@ -117,13 +121,13 @@ void ald_bkpc_bor_config(bkpc_bor_vol_t vol, type_func_t state)
  */
 void ald_bkpc_write_ram(uint8_t idx, uint32_t value)
 {
-    assert_param(IS_BKPC_RAM_IDX(idx));
+	assert_param(IS_BKPC_RAM_IDX(idx));

-    RTC_UNLOCK();
-    WRITE_REG(RTC->BKPR[idx], value);
-    RTC_LOCK();
+	RTC_UNLOCK();
+	WRITE_REG(RTC->BKPR[idx], value);
+	RTC_LOCK();

-    return;
+	return;
 }

 /**
@@ -133,9 +137,9 @@ void ald_bkpc_write_ram(uint8_t idx, uint32_t value)
  */
 uint32_t ald_bkpc_read_ram(uint8_t idx)
 {
-    assert_param(IS_BKPC_RAM_IDX(idx));
+	assert_param(IS_BKPC_RAM_IDX(idx));

-    return READ_REG(RTC->BKPR[idx]);
+	return READ_REG(RTC->BKPR[idx]);
 }
 /**
  * @}
@@ -45,16 +45,15 @@

 /**
  * @brief  Square root operation.
-  * @param  data: The data;
+  * @param  data: The radicand
  * @retval The value of square root.
  */
 uint32_t ald_calc_sqrt(uint32_t data)
 {
-    WRITE_REG(CALC->RDCND, data);
+	WRITE_REG(CALC->RDCND, data);
+	while (READ_BIT(CALC->SQRTSR, CALC_SQRTSR_BUSY_MSK));

-    while (READ_BIT(CALC->SQRTSR, CALC_SQRTSR_BUSY_MSK));
-
-    return READ_REG(CALC->SQRTRES);
+	return READ_REG(CALC->SQRTRES);
 }

 /**
@@ -66,15 +65,15 @@ uint32_t ald_calc_sqrt(uint32_t data)
  */
 uint32_t ald_calc_div(uint32_t dividend, uint32_t divisor, uint32_t *remainder)
 {
-    CLEAR_BIT(CALC->DIVCSR, CALC_DIVCSR_SIGN_MSK);
-    SET_BIT(CALC->DIVCSR, CALC_DIVCSR_TRM_MSK);
-    WRITE_REG(CALC->DIVDR, dividend);
-    WRITE_REG(CALC->DIVSR, divisor);
+	CLEAR_BIT(CALC->DIVCSR, CALC_DIVCSR_SIGN_MSK);
+	SET_BIT(CALC->DIVCSR, CALC_DIVCSR_TRM_MSK);
+	WRITE_REG(CALC->DIVDR, dividend);
+	WRITE_REG(CALC->DIVSR, divisor);

-    while (READ_BIT(CALC->DIVCSR, CALC_DIVCSR_BUSY_MSK));
+	while (READ_BIT(CALC->DIVCSR, CALC_DIVCSR_BUSY_MSK));

-    *remainder = READ_REG(CALC->DIVRR);
-    return READ_REG(CALC->DIVQR);
+	*remainder = READ_REG(CALC->DIVRR);
+	return READ_REG(CALC->DIVQR);
 }

 /**
@@ -86,15 +85,15 @@ uint32_t ald_calc_div(uint32_t dividend, uint32_t divisor, uint32_t *remainder)
  */
 int32_t ald_calc_div_sign(int32_t dividend, int32_t divisor, int32_t *remainder)
 {
-    SET_BIT(CALC->DIVCSR, CALC_DIVCSR_SIGN_MSK);
-    SET_BIT(CALC->DIVCSR, CALC_DIVCSR_TRM_MSK);
-    WRITE_REG(CALC->DIVDR, dividend);
-    WRITE_REG(CALC->DIVSR, divisor);
+	SET_BIT(CALC->DIVCSR, CALC_DIVCSR_SIGN_MSK);
+	SET_BIT(CALC->DIVCSR, CALC_DIVCSR_TRM_MSK);
+	WRITE_REG(CALC->DIVDR, dividend);
+	WRITE_REG(CALC->DIVSR, divisor);

-    while (READ_BIT(CALC->DIVCSR, CALC_DIVCSR_BUSY_MSK));
+	while (READ_BIT(CALC->DIVCSR, CALC_DIVCSR_BUSY_MSK));

-    *remainder = READ_REG(CALC->DIVRR);
-    return READ_REG(CALC->DIVQR);
+	*remainder = READ_REG(CALC->DIVRR);
+	return READ_REG(CALC->DIVQR);
 }

 /**
@@ -103,10 +102,10 @@ int32_t ald_calc_div_sign(int32_t dividend, int32_t divisor, int32_t *remainder)
  */
 flag_status_t ald_calc_get_dz_status(void)
 {
-    if (READ_BIT(CALC->DIVCSR, CALC_DIVCSR_DZ_MSK))
-        return SET;
+	if (READ_BIT(CALC->DIVCSR, CALC_DIVCSR_DZ_MSK))
+		return SET;

-    return RESET;
+	return RESET;
 }

 /**
@@ -51,14 +51,14 @@
  */
 uint32_t ald_iap_erase_page(uint32_t addr)
 {
-    uint32_t status;
-    IAP_PE iap_pe = (IAP_PE)(*(uint32_t *)IAP_PE_ADDR);
+	uint32_t status;
+	IAP_PE iap_pe = (IAP_PE)(*(uint32_t *)IAP_PE_ADDR);

-    __disable_irq();
-    status = (*iap_pe)(addr);
-    __enable_irq();
+	__disable_irq();
+	status = (*iap_pe)(addr);
+	__enable_irq();

-    return !status;
+	return !status;
 }

 /**
@@ -72,17 +72,17 @@ uint32_t ald_iap_erase_page(uint32_t addr)
  */
 uint32_t ald_iap_program_word(uint32_t addr, uint32_t data)
 {
-    uint32_t status;
-    IAP_WP iap_wp = (IAP_WP)(*(uint32_t *)IAP_WP_ADDR);
+	uint32_t status;
+	IAP_WP iap_wp = (IAP_WP)(*(uint32_t *)IAP_WP_ADDR);

-    if (addr & 0x3)
-        return 1;
+	if (addr & 0x3)
+		return 1;

-    __disable_irq();
-    status = (*iap_wp)(addr, data);
-    __enable_irq();
+	__disable_irq();
+	status = (*iap_wp)(addr, data);
+	__enable_irq();

-    return !status;
+	return !status;
 }

 /**
@@ -97,17 +97,17 @@ uint32_t ald_iap_program_word(uint32_t addr, uint32_t data)
  */
 uint32_t ald_iap_program_dword(uint32_t addr, uint32_t data_l, uint32_t data_h)
 {
-    uint32_t status;
-    IAP_DWP iap_dwp = (IAP_DWP)(*(uint32_t *)IAP_DWP_ADDR);
+	uint32_t status;
+	IAP_DWP iap_dwp = (IAP_DWP)(*(uint32_t *)IAP_DWP_ADDR);

-    if (addr & 0x3)
-        return 1;
+	if (addr & 0x3)
+		return 1;

-    __disable_irq();
-    status = (*iap_dwp)(addr, data_l, data_h);
-    __enable_irq();
+	__disable_irq();
+	status = (*iap_dwp)(addr, data_l, data_h);
+	__enable_irq();

-    return !status;
+	return !status;
 }

 /**
@@ -124,17 +124,17 @@ uint32_t ald_iap_program_dword(uint32_t addr, uint32_t data_l, uint32_t data_h)
  */
 uint32_t ald_iap_program_words(uint32_t addr, uint8_t *data, uint32_t len, uint32_t erase)
 {
-    uint32_t status;
-    IAP_WSP iap_wsp = (IAP_WSP)(*(uint32_t *)IAP_WSP_ADDR);
+	uint32_t status;
+	IAP_WSP iap_wsp = (IAP_WSP)(*(uint32_t *)IAP_WSP_ADDR);

-    if ((addr & 0x3) || (len & 0x3))
-        return 1;
+	if ((addr & 0x3) || (len & 0x3))
+		return 1;

-    __disable_irq();
-    status = (*iap_wsp)(addr, data, len, erase);
-    __enable_irq();
+	__disable_irq();
+	status = (*iap_wsp)(addr, data, len, erase);
+	__enable_irq();

-    return !status;
+	return !status;
 }
 /**
  * @}
@@ -40,41 +40,42 @@
  */
 void ald_rmu_bor_config(rmu_bor_filter_t flt, rmu_bor_vol_t vol, type_func_t state)
 {
-    assert_param(IS_FUNC_STATE(state));
+	assert_param(IS_FUNC_STATE(state));

-    SYSCFG_UNLOCK();
+	SYSCFG_UNLOCK();

-    if (state)
-    {
-        assert_param(IS_RMU_BORFLT(flt));
-        assert_param(IS_RMU_BORVOL(vol));
+	if (state) {
+		assert_param(IS_RMU_BORFLT(flt));
+		assert_param(IS_RMU_BORVOL(vol));

-        MODIFY_REG(RMU->CR, RMU_CR_BORFLT_MSK, flt << RMU_CR_BORFLT_POSS);
-        MODIFY_REG(RMU->CR, RMU_CR_BORVS_MSK, vol << RMU_CR_BORVS_POSS);
-        SET_BIT(RMU->CR, RMU_CR_BOREN_MSK);
-    }
-    else
-    {
-        CLEAR_BIT(RMU->CR, RMU_CR_BOREN_MSK);
-    }
+		MODIFY_REG(RMU->CR, RMU_CR_BORFLT_MSK, flt << RMU_CR_BORFLT_POSS);
+		MODIFY_REG(RMU->CR, RMU_CR_BORVS_MSK, vol << RMU_CR_BORVS_POSS);
+		SET_BIT(RMU->CR, RMU_CR_BOREN_MSK);
+	}
+	else {
+		CLEAR_BIT(RMU->CR, RMU_CR_BOREN_MSK);
+	}

-    SYSCFG_LOCK();
-    return;
+	SYSCFG_LOCK();
+	return;
 }

 /**
  * @brief  Get specified reset status
  * @param  state: Speicifies the type of the reset,
-  * @retval The status: SET/RESET.
+  * @retval The status.
  */
-flag_status_t ald_rmu_get_reset_status(rmu_state_t state)
+uint32_t ald_rmu_get_reset_status(rmu_state_t state)
 {
-    assert_param(IS_RMU_STATE(state));
+	assert_param(IS_RMU_STATE(state));

-    if (READ_BIT(RMU->RSTSR, state))
-        return SET;
+	if (state == RMU_RST_ALL)
+		return RMU->RSTSR;

-    return RESET;
+	if (READ_BIT(RMU->RSTSR, state))
+		return SET;
+
+	return RESET;
 }

 /**
@@ -84,13 +85,13 @@ flag_status_t ald_rmu_get_reset_status(rmu_state_t state)
  */
 void ald_rmu_clear_reset_status(rmu_state_t state)
 {
-    assert_param(IS_RMU_STATE_CLEAR(state));
+	assert_param(IS_RMU_STATE_CLEAR(state));

-    SYSCFG_UNLOCK();
-    WRITE_REG(RMU->CRSTSR, state);
-    SYSCFG_LOCK();
+	SYSCFG_UNLOCK();
+	WRITE_REG(RMU->CRSTSR, state);
+	SYSCFG_LOCK();

-    return;
+	return;
 }
 /**
  * @brief  Reset peripheral device
@@ -99,38 +100,37 @@ void ald_rmu_clear_reset_status(rmu_state_t state)
  */
 void ald_rmu_reset_periperal(rmu_peripheral_t perh)
 {
-    uint32_t idx, pos;
+	uint32_t idx, pos;

-    assert_param(IS_RMU_PERH(perh));
+	assert_param(IS_RMU_PERH(perh));

-    idx = (perh >> 27) & 0x7;
-    pos = perh & ~(0x7 << 27);
-    SYSCFG_UNLOCK();
+	idx = ((uint32_t)perh >> 27) & 0x7;
+	pos = perh & ~(0x7 << 27);
+	SYSCFG_UNLOCK();

-    switch (idx)
-    {
-        case 0:
-            WRITE_REG(RMU->AHB1RSTR, pos);
-            break;
+	switch (idx) {
+	case 0:
+		WRITE_REG(RMU->AHB1RSTR, pos);
+		break;

-        case 1:
-            WRITE_REG(RMU->AHB2RSTR, pos);
-            break;
+	case 1:
+		WRITE_REG(RMU->AHB2RSTR, pos);
+		break;

-        case 2:
-            WRITE_REG(RMU->APB1RSTR, pos);
-            break;
+	case 2:
+		WRITE_REG(RMU->APB1RSTR, pos);
+		break;

-        case 4:
-            WRITE_REG(RMU->APB2RSTR, pos);
-            break;
+	case 4:
+		WRITE_REG(RMU->APB2RSTR, pos);
+		break;

-        default:
-            break;
-    }
+	default:
+		break;
+	}

-    SYSCFG_LOCK();
-    return;
+	SYSCFG_LOCK();
+	return;
 }

 /**
@@ -46,18 +46,18 @@
 */
 void ald_wwdt_init(uint32_t load, wwdt_win_t win, type_func_t interrupt)
 {
-    assert_param(IS_WWDT_WIN_TYPE(win));
-    assert_param(IS_FUNC_STATE(interrupt));
+	assert_param(IS_WWDT_WIN_TYPE(win));
+	assert_param(IS_FUNC_STATE(interrupt));

-    WWDT_UNLOCK();
-    WRITE_REG(WWDT->LOAD, load);
-    MODIFY_REG(WWDT->CON, WWDT_CON_WWDTWIN_MSK, win << WWDT_CON_WWDTWIN_POSS);
-    SET_BIT(WWDT->CON, WWDT_CON_CLKS_MSK);
-    SET_BIT(WWDT->CON, WWDT_CON_RSTEN_MSK);
-    MODIFY_REG(WWDT->CON, WWDT_CON_IE_MSK, interrupt << WWDT_CON_IE_POS);
-    WWDT_LOCK();
+	WWDT_UNLOCK();
+	WRITE_REG(WWDT->LOAD, load);
+	MODIFY_REG(WWDT->CON, WWDT_CON_WWDTWIN_MSK, win << WWDT_CON_WWDTWIN_POSS);
+	SET_BIT(WWDT->CON, WWDT_CON_CLKS_MSK);
+	SET_BIT(WWDT->CON, WWDT_CON_RSTEN_MSK);
+	MODIFY_REG(WWDT->CON, WWDT_CON_IE_MSK, interrupt << WWDT_CON_IE_POS);
+	WWDT_LOCK();

-    return;
+	return;
 }

 /**
@@ -66,11 +66,11 @@ void ald_wwdt_init(uint32_t load, wwdt_win_t win, type_func_t interrupt)
 */
 void ald_wwdt_start(void)
 {
-    WWDT_UNLOCK();
-    SET_BIT(WWDT->CON, WWDT_CON_EN_MSK);
-    WWDT_LOCK();
+	WWDT_UNLOCK();
+	SET_BIT(WWDT->CON, WWDT_CON_EN_MSK);
+	WWDT_LOCK();

-    return;
+	return;
 }

 /**
@@ -79,7 +79,7 @@ void ald_wwdt_start(void)
 */
 uint32_t ald_wwdt_get_value(void)
 {
-    return WWDT->VALUE;
+	return WWDT->VALUE;
 }

 /**
@@ -88,10 +88,10 @@ uint32_t ald_wwdt_get_value(void)
 */
 it_status_t ald_wwdt_get_flag_status(void)
 {
-    if (READ_BIT(WWDT->RIS, WWDT_RIS_WWDTIF_MSK))
-        return SET;
+	if (READ_BIT(WWDT->RIS, WWDT_RIS_WWDTIF_MSK))
+		return SET;

-    return RESET;
+	return RESET;
 }

 /**
@@ -100,8 +100,8 @@ it_status_t ald_wwdt_get_flag_status(void)
 */
 void ald_wwdt_clear_flag_status(void)
 {
-    WRITE_REG(WWDT->INTCLR, 1);
-    return;
+	WRITE_REG(WWDT->INTCLR, 1);
+	return;
 }

 /**
@@ -110,11 +110,11 @@ void ald_wwdt_clear_flag_status(void)
 */
 void ald_wwdt_feed_dog(void)
 {
-    WWDT_UNLOCK();
-    WRITE_REG(WWDT->INTCLR, 0x1);
-    WWDT_LOCK();
+	WWDT_UNLOCK();
+	WRITE_REG(WWDT->INTCLR, 0x1);
+	WWDT_LOCK();

-    return;
+	return;
 }
 /**
 * @}
@@ -132,16 +132,16 @@ void ald_wwdt_feed_dog(void)
 */
 void ald_iwdt_init(uint32_t load, type_func_t interrupt)
 {
-    assert_param(IS_FUNC_STATE(interrupt));
+	assert_param(IS_FUNC_STATE(interrupt));

-    IWDT_UNLOCK();
-    WRITE_REG(IWDT->LOAD, load);
-    SET_BIT(IWDT->CON, IWDT_CON_CLKS_MSK);
-    SET_BIT(IWDT->CON, IWDT_CON_RSTEN_MSK);
-    MODIFY_REG(IWDT->CON, IWDT_CON_IE_MSK, interrupt << IWDT_CON_IE_POS);
-    IWDT_LOCK();
+	IWDT_UNLOCK();
+	WRITE_REG(IWDT->LOAD, load);
+	SET_BIT(IWDT->CON, IWDT_CON_CLKS_MSK);
+	SET_BIT(IWDT->CON, IWDT_CON_RSTEN_MSK);
+	MODIFY_REG(IWDT->CON, IWDT_CON_IE_MSK, interrupt << IWDT_CON_IE_POS);
+	IWDT_LOCK();

-    return;
+	return;
 }

 /**
@@ -150,11 +150,11 @@ void ald_iwdt_init(uint32_t load, type_func_t interrupt)
 */
 void ald_iwdt_start(void)
 {
-    IWDT_UNLOCK();
-    SET_BIT(IWDT->CON, IWDT_CON_EN_MSK);
-    IWDT_LOCK();
+	IWDT_UNLOCK();
+	SET_BIT(IWDT->CON, IWDT_CON_EN_MSK);
+	IWDT_LOCK();

-    return;
+	return;
 }

 /**
@@ -163,7 +163,7 @@ void ald_iwdt_start(void)
 */
 uint32_t ald_iwdt_get_value(void)
 {
-    return IWDT->VALUE;
+	return IWDT->VALUE;
 }

 /**
@@ -172,10 +172,10 @@ uint32_t ald_iwdt_get_value(void)
 */
 it_status_t ald_iwdt_get_flag_status(void)
 {
-    if (READ_BIT(IWDT->RIS, IWDT_RIS_WDTIF_MSK))
-        return SET;
+	if (READ_BIT(IWDT->RIS, IWDT_RIS_WDTIF_MSK))
+		return SET;

-    return RESET;
+	return RESET;
 }

 /**
@@ -184,8 +184,8 @@ it_status_t ald_iwdt_get_flag_status(void)
 */
 void ald_iwdt_clear_flag_status(void)
 {
-    WRITE_REG(IWDT->INTCLR, 1);
-    return;
+	WRITE_REG(IWDT->INTCLR, 1);
+	return;
 }

 /**
@@ -194,11 +194,11 @@ void ald_iwdt_clear_flag_status(void)
 */
 void ald_iwdt_feed_dog(void)
 {
-    IWDT_UNLOCK();
-    WRITE_REG(IWDT->INTCLR, 1);
-    IWDT_LOCK();
+	IWDT_UNLOCK();
+	WRITE_REG(IWDT->INTCLR, 1);
+	IWDT_LOCK();

-    return;
+	return;
 }
 /**
 * @}
@@ -39,7 +39,7 @@
 #define RT_USING_CONSOLE
 #define RT_CONSOLEBUF_SIZE 128
 #define RT_CONSOLE_DEVICE_NAME "uart1"
-#define RT_VER_NUM 0x40002
+#define RT_VER_NUM 0x40003

 /* RT-Thread Components */

@@ -76,7 +76,15 @@
 #define RT_PIPE_BUFSZ 512
 #define RT_USING_SERIAL
 #define RT_SERIAL_RB_BUFSZ 64
+#define RT_USING_HWTIMER
+#define RT_USING_I2C
+#define RT_USING_I2C_BITOPS
 #define RT_USING_PIN
+#define RT_USING_ADC
+#define RT_USING_PWM
+#define RT_USING_PM
+#define RT_USING_RTC
+#define RT_USING_SPI

 /* Using USB */

@@ -180,6 +188,8 @@

 /* Offboard Peripheral Drivers */

+/* Peripheral Drivers test example */
+
 #define SOC_ES32F0334LT

 #endif
@@ -101,7 +101,9 @@
        <sRunDeb>0</sRunDeb>
        <sLrtime>0</sLrtime>
        <bEvRecOn>1</bEvRecOn>
-        <nTsel>2</nTsel>
+        <bSchkAxf>0</bSchkAxf>
+        <bTchkAxf>0</bTchkAxf>
+        <nTsel>3</nTsel>
        <sDll></sDll>
        <sDllPa></sDllPa>
        <sDlgDll></sDlgDll>
@@ -170,6 +172,10 @@
      <pszMrule></pszMrule>
      <pSingCmds></pSingCmds>
      <pMultCmds></pMultCmds>
+      <pMisraNamep></pMisraNamep>
+      <pszMrulep></pszMrulep>
+      <pSingCmdsp></pSingCmdsp>
+      <pMultCmdsp></pMultCmdsp>
    </TargetOption>
  </Target>

@@ -10,11 +10,12 @@
      <TargetName>rt-thread</TargetName>
      <ToolsetNumber>0x4</ToolsetNumber>
      <ToolsetName>ARM-ADS</ToolsetName>
+      <uAC6>0</uAC6>
      <TargetOption>
        <TargetCommonOption>
          <Device>ES32F0334LT</Device>
          <Vendor>Eastsoft</Vendor>
-          <PackID>Eastsoft.ES32_DFP.1.0.1</PackID>
+          <PackID>Eastsoft.ES32_DFP.7.2350</PackID>
          <PackURL>http://www.essemi.com</PackURL>
          <Cpu>IRAM(0x20000000,0x00008000) IROM(0x00000000,0x00040000) CPUTYPE("Cortex-M0") CLOCK(12000000) ELITTLE</Cpu>
          <FlashUtilSpec></FlashUtilSpec>
@@ -182,6 +183,7 @@
            <hadXRAM>0</hadXRAM>
            <uocXRam>0</uocXRam>
            <RvdsVP>0</RvdsVP>
+            <RvdsMve>0</RvdsMve>
            <hadIRAM2>0</hadIRAM2>
            <hadIROM2>0</hadIROM2>
            <StupSel>8</StupSel>
@@ -322,6 +324,7 @@
            <uThumb>0</uThumb>
            <uSurpInc>0</uSurpInc>
            <uC99>1</uC99>
+            <uGnu>0</uGnu>
            <useXO>0</useXO>
            <v6Lang>1</v6Lang>
            <v6LangP>1</v6LangP>
@@ -90,6 +90,24 @@ msh >

 2. 输入`menuconfig`命令配置工程，配置好之后保存退出。

+    a）如果需要使用内核用例，先配置rt-thread内核，如图：
+
+    ![kernel_config](figures/k_conf.jpg)
+
+    然后配置内核用例，如图：
+
+    ![kernel_sample](figures/k_ex.jpg)
+
+    b）如果需要使用驱动用例：先使能驱动，如图：
+
+    ![driver_config](figures/d_conf.jpg)
+
+    然后配置驱动用例，如图：
+
+    ![driver_sample](figures/d_ex.jpg)
+
+    
+
 3. 输入`pkgs --update`命令更新软件包。

 4. 输入`scons --target=mdk5/iar` 命令重新生成工程。
@@ -98,7 +116,7 @@ msh >

 ## 4. 联系人信息

- [wangyongquan](https://github.com/wangyq2018) 
+- [liuhongyan](https://gitee.com/liuhongyan98) 

 ## 5. 参考

@@ -148,4 +148,53 @@ menu "Hardware Drivers Config"

    endmenu

+
+    menu "Peripheral Drivers test example"
+
+        config BSP_USING_EXAMPLE_ADC_VOL
+            bool "BSP_USING_EXAMPLE_ADC_VOL"
+            default n
+        
+        config BSP_USING_EXAMPLE_HWTIMER
+            bool "BSP_USING_EXAMPLE_HWTIMER"
+            default n
+
+        config BSP_USING_EXAMPLE_I2C
+            bool "BSP_USING_EXAMPLE_I2C"
+            default n
+
+        config BSP_USING_EXAMPLE_LED_BLINK
+            bool "BSP_USING_EXAMPLE_LED_BLINK"
+            default y
+
+        config BSP_USING_EXAMPLE_PIN_BEEP
+            bool "BSP_USING_EXAMPLE_PIN_BEEP"
+            default y
+
+        config BSP_USING_EXAMPLE_PWM_LED
+            bool "BSP_USING_EXAMPLE_PWM_LED"
+            default n
+
+        config BSP_USING_EXAMPLE_RTC
+            bool "BSP_USING_EXAMPLE_RTC"
+            default n
+
+        config BSP_USING_EXAMPLE_SPI
+            bool "BSP_USING_EXAMPLE_SPI"
+            default n
+
+        config BSP_USING_EXAMPLE_UART
+            bool "BSP_USING_EXAMPLE_UART"
+            default y
+
+        config BSP_USING_EXAMPLE_CAN
+            bool "BSP_USING_EXAMPLE_CAN"
+            default n
+
+        config BSP_USING_EXAMPLE_PM
+            bool "BSP_USING_EXAMPLE_PM"
+            default n
+
+    endmenu
+
 endmenu
@@ -2,6 +2,8 @@ from building import *

 cwd = GetCurrentDir()

+objs = []
+
 # add the general drivers.
 src = Split('''
 board.c
@@ -53,5 +55,47 @@ if GetDepend(['BSP_USING_ADC']):

 CPPPATH = [cwd]
 group = DefineGroup('Drivers', src, depend = [''], CPPPATH = CPPPATH)
+objs = objs + group
+
+src   = []
+cwd   = GetCurrentDir()
+include_path = [cwd]
+
+if GetDepend('BSP_USING_EXAMPLE_ADC_VOL'):
+    src += ['bsp_driver_example/adc_vol_sample.c']
+
+if GetDepend('BSP_USING_EXAMPLE_HWTIMER'):
+    src += ['bsp_driver_example/hwtimer_sample.c']
+
+if GetDepend('BSP_USING_EXAMPLE_I2C'):
+    src += ['bsp_driver_example/i2c_sample.c']
+
+if GetDepend('BSP_USING_EXAMPLE_LED_BLINK'):
+    src += ['bsp_driver_example/led_blink_sample.c']
+
+if GetDepend('BSP_USING_EXAMPLE_PIN_BEEP'):
+    src += ['bsp_driver_example/pin_beep_sample.c']
+
+if GetDepend('BSP_USING_EXAMPLE_PWM_LED'):
+    src += ['bsp_driver_example/pwm_led_sample.c']
+
+if GetDepend('BSP_USING_EXAMPLE_RTC'):
+    src += ['bsp_driver_example/rtc_sample.c']
+
+if GetDepend('BSP_USING_EXAMPLE_UART'):
+    src += ['bsp_driver_example/uart_sample.c']
+
+if GetDepend('BSP_USING_EXAMPLE_SPI'):
+    src += ['bsp_driver_example/spi_sample.c']
+
+if GetDepend('BSP_USING_EXAMPLE_CAN'):
+    src += ['bsp_driver_example/can_sample.c']
+
+if GetDepend('BSP_USING_EXAMPLE_PM'):
+    src += ['bsp_driver_example/pm_sample.c']
+
+group = DefineGroup('bsp-drivers-test-samples', src, depend = [''], CPPPATH = include_path)
+
+objs = objs + group
+Return('objs')

-Return('group')
@@ -0,0 +1,52 @@
+# Prerequisites
+*.d
+
+# Object files
+*.o
+*.ko
+*.obj
+*.elf
+
+# Linker output
+*.ilk
+*.map
+*.exp
+
+# Precompiled Headers
+*.gch
+*.pch
+
+# Libraries
+*.lib
+*.a
+*.la
+*.lo
+
+# Shared objects (inc. Windows DLLs)
+*.dll
+*.so
+*.so.*
+*.dylib
+
+# Executables
+*.exe
+*.out
+*.app
+*.i*86
+*.x86_64
+*.hex
+
+# Debug files
+*.dSYM/
+*.su
+*.idb
+*.pdb
+
+# Kernel Module Compile Results
+*.mod*
+*.cmd
+.tmp_versions/
+modules.order
+Module.symvers
+Mkfile.old
+dkms.conf
@@ -0,0 +1,47 @@
+# 外设驱动测试用例
+
+## 1、介绍
+
+这个软件包包含一些外设设备操作的例程。
+
+### 1.1 例程说明
+
+| 文件             | 说明                            |
+| ---------------- | ------------------------------- |
+| adc_vol_sample.c       | 使用 ADC 设备转换电压数据 |
+| can_sample.c | 通过 CAN 设备发送一帧，并创建一个线程接收数据然后打印输出。 |
+| hwtimer_sample.c       | 使用 硬件定时器定时 |
+| i2c_sample.c     | 使用 i2c 设备进行读写 |
+| pm.c | 反复进入不同程度的睡眠。 |
+| led_blink_sample.c     |  使用 pin 设备控制 LED 闪烁 |
+| pin_beep_sample.c      | 使用 pin 设备控制蜂鸣器 |
+| pwm_led_sample.c       | 使用 pwm 设备控制 LED 的亮度 |
+| rtc_sample.c           | 使用 rtc 设备设置年月日时分秒信息 |
+| spi_sample.c     | 使用 spi 设备进行读写 |
+| uart_sample.c          | 使用 serial 设备中断接收及轮询发送模式收发数据 |
+
+### 1.2 依赖
+
+依赖设备管理模块提供的设备驱动。
+
+## 2、如何打开 外设驱动测试用例
+
+使用 外设驱动测试用例 需要在 RT-Thread 的menuconfig中选择它，具体路径如下：
+
+```
+Hardware Driver Config --->
+    Peripheral Driver test example--->
+```
+
+## 3、使用 外设驱动测试用例
+
+在打开 Peripheral Driver test example 后，当进行 BSP 编译时，选择的软件包相关源代码会被加入到 BSP 工程中进行编译。
+
+## 4、注意事项
+
+暂无。
+
+## 5、联系方式 & 感谢
+
+* 维护：[misonyo](https://github.com/misonyo)
+* 主页：https://github.com/RT-Thread-packages/peripheral-sample
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2006-2018, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2018-11-29     misonyo      first implementation.
+ */
+/*
+ * 程序清单： ADC 设备使用例程
+ * 例程导出了 adc_sample 命令到控制终端
+ * 命令调用格式：adc_sample
+ * 程序功能：通过 ADC 设备采样电压值并转换为数值。
+ *           示例代码参考电压为3.3V,转换位数为12位。
+*/
+
+#include <rtthread.h>
+#include <rtdevice.h>
+
+#define ADC_DEV_NAME        "adc0"      /* ADC 设备名称 */
+#define ADC_DEV_CHANNEL     5           /* PA1 ADC 通道 */
+#define REFER_VOLTAGE       330         /* 参考电压 3.3V,数据精度乘以100保留2位小数*/
+#define CONVERT_BITS        (1 << 12)   /* 转换位数为12位 */
+
+static int adc_vol_sample(int argc, char *argv[])
+{
+    rt_adc_device_t adc_dev;
+    rt_uint32_t value, vol;
+    rt_err_t ret = RT_EOK;
+
+    /* 查找设备 */
+    adc_dev = (rt_adc_device_t)rt_device_find(ADC_DEV_NAME);
+    if (adc_dev == RT_NULL)
+    {
+        rt_kprintf("adc sample run failed! can't find %s device!\n", ADC_DEV_NAME);
+        return RT_ERROR;
+    }
+
+    /* 使能设备 */
+    ret = rt_adc_enable(adc_dev, ADC_DEV_CHANNEL);
+
+    /* 读取采样值 */
+    value = rt_adc_read(adc_dev, ADC_DEV_CHANNEL);
+    rt_kprintf("the value is :%d \n", value);
+
+    /* 转换为对应电压值 */
+    vol = value * REFER_VOLTAGE / CONVERT_BITS;
+    rt_kprintf("the voltage is :%d.%02d \n", vol / 100, vol % 100);
+
+    /* 关闭通道 */
+    ret = rt_adc_disable(adc_dev, ADC_DEV_CHANNEL);
+
+    return ret;
+}
+/* 导出到 msh 命令列表中 */
+MSH_CMD_EXPORT(adc_vol_sample, adc voltage convert sample);
@@ -0,0 +1,144 @@
+/*
+ * Copyright (c) 2006-2018, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2019-06-25     misonyo      first implementation.
+ */
+/*
+ * 程序清单：这是一个 CAN 设备使用例程
+ * 例程导出了 can_sample 命令到控制终端
+ * 命令调用格式：can_sample can2
+ * 命令解释：命令第二个参数是要使用的 CAN 设备名称，为空则使用默认的 CAN 设备
+ * 程序功能：通过 CAN 设备发送一帧，并创建一个线程接收数据然后打印输出。
+*/
+
+#include <rtthread.h>
+#include "rtdevice.h"
+
+#define CAN_DEV_NAME       "can"      /* CAN 设备名称 */
+
+static struct rt_semaphore rx_sem;     /* 用于接收消息的信号量 */
+static rt_device_t can_dev;            /* CAN 设备句柄 */
+
+/* 接收数据回调函数 */
+static rt_err_t can_rx_call(rt_device_t dev, rt_size_t size)
+{
+    /* CAN 接收到数据后产生中断，调用此回调函数，然后发送接收信号量 */
+    rt_sem_release(&rx_sem);
+
+    return RT_EOK;
+}
+
+static void can_rx_thread(void *parameter)
+{
+    int i;
+    struct rt_can_msg rxmsg = {0};
+
+    /* 设置接收回调函数 */
+    rt_device_set_rx_indicate(can_dev, can_rx_call);
+
+#ifdef RT_CAN_USING_HDR
+    
+    rt_err_t res;
+    
+    struct rt_can_filter_item items[5] =
+    {
+        RT_CAN_FILTER_ITEM_INIT(0x100, 0, 0, 0, 0x700, RT_NULL, RT_NULL), /* std,match ID:0x100~0x1ff，hdr为-1，设置默认过滤表 */
+        RT_CAN_FILTER_ITEM_INIT(0x300, 0, 0, 0, 0x700, RT_NULL, RT_NULL), /* std,match ID:0x300~0x3ff，hdr为-1 */
+        RT_CAN_FILTER_ITEM_INIT(0x211, 0, 0, 0, 0x7ff, RT_NULL, RT_NULL), /* std,match ID:0x211，hdr为-1 */
+        RT_CAN_FILTER_STD_INIT(0x486, RT_NULL, RT_NULL),                  /* std,match ID:0x486，hdr为-1 */
+        {0x555, 0, 0, 0, 0x7ff, 7,}                                       /* std,match ID:0x555，hdr为7，指定设置7号过滤表 */
+    };
+    struct rt_can_filter_config cfg = {5, 1, items}; /* 一共有5个过滤表 */
+    /* 设置硬件过滤表 */
+    res = rt_device_control(can_dev, RT_CAN_CMD_SET_FILTER, &cfg);
+    RT_ASSERT(res == RT_EOK);
+#endif
+
+    while (1)
+    {
+        /* hdr值为-1，表示直接从uselist链表读取数据 */
+        rxmsg.hdr = -1;
+        /* 阻塞等待接收信号量 */
+        rt_sem_take(&rx_sem, RT_WAITING_FOREVER);
+        /* 从CAN读取一帧数据 */
+        rt_device_read(can_dev, 0, &rxmsg, sizeof(rxmsg));
+        /* 打印数据ID及内容 */
+        rt_kprintf("ID:%x  ", rxmsg.id);
+        for (i = 0; i < 8; i++)
+        {
+            rt_kprintf("%2x ", rxmsg.data[i]);
+        }
+
+        rt_kprintf("\n");
+    }
+}
+
+int can_sample(int argc, char *argv[])
+{
+    struct rt_can_msg msg = {0};
+    rt_err_t res;
+    rt_size_t  size;
+    rt_thread_t thread;
+    char can_name[RT_NAME_MAX];
+    
+    if (argc == 2)
+    {
+        rt_strncpy(can_name, argv[1], RT_NAME_MAX);
+    }
+    else
+    {
+        rt_strncpy(can_name, CAN_DEV_NAME, RT_NAME_MAX);
+    }
+
+    can_dev = rt_device_find(can_name);
+    if (!can_dev)
+    {
+        rt_kprintf("find %s failed!\n", can_name);
+        return RT_ERROR;
+    }
+
+    /* 初始化CAN接收信号量 */
+    rt_sem_init(&rx_sem, "rx_sem", 0, RT_IPC_FLAG_FIFO);
+
+    /* 以中断接收及发送方式打开CAN设备 */
+    res = rt_device_open(can_dev, RT_DEVICE_FLAG_INT_TX | RT_DEVICE_FLAG_INT_RX);
+    RT_ASSERT(res == RT_EOK);
+
+    thread = rt_thread_create("can_rx", can_rx_thread, RT_NULL, 1024, 25, 10);
+    if (thread != RT_NULL)
+    {
+        rt_thread_startup(thread);
+    }
+    else
+    {
+        rt_kprintf("create can_rx thread failed!\n");
+    }
+
+    msg.id = 0x78;              /* ID为0x78 */
+    msg.ide = RT_CAN_STDID;     /* 标准格式 */
+    msg.rtr = RT_CAN_DTR;       /* 数据帧 */
+    msg.len = 8;                /* 数据长度为8 */
+    /* 待发送的8字节数据 */
+    msg.data[0] = 0x00;
+    msg.data[1] = 0x11;
+    msg.data[2] = 0x22;
+    msg.data[3] = 0x33;
+    msg.data[4] = 0x44;
+    msg.data[5] = 0x55;
+    msg.data[6] = 0x66;
+    msg.data[7] = 0x77;
+    /* 发送一帧CAN数据 */
+    size = rt_device_write(can_dev, 0, &msg, sizeof(msg));
+    if (size == 0)
+    {
+        rt_kprintf("can dev write data failed!\n");
+    }
+    
+    return res;
+}
+/* 导出到 msh 命令列表中 */
+MSH_CMD_EXPORT(can_sample, can device sample);
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) 2006-2018, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2018-11-30     misonyo      first implementation.
+ */
+/*
+ * 程序清单：这是一个 hwtimer 设备使用例程
+ * 例程导出了 hwtimer_sample 命令到控制终端
+ * 命令调用格式：hwtimer_sample
+ * 程序功能：硬件定时器超时回调函数周期性的打印当前tick值，2次tick值之差换算为时间等同于定时时间值。
+*/
+
+#include <rtthread.h>
+#include <rtdevice.h>
+
+#define HWTIMER_DEV_NAME   "timer0"     /* 定时器名称 */
+
+/* 定时器超时回调函数 */
+static rt_err_t timeout_cb(rt_device_t dev, rt_size_t size)
+{
+    rt_kprintf("tick is :%d !\n", rt_tick_get());
+
+    return 0;
+}
+
+static int hwtimer_sample(int argc, char *argv[])
+{
+    rt_err_t ret = RT_EOK;
+    rt_hwtimerval_t timeout_s;      /* 定时器超时值 */
+    rt_device_t hw_dev = RT_NULL;   /* 定时器设备句柄 */
+    rt_hwtimer_mode_t mode;         /* 定时器模式 */
+
+    /* 查找定时器设备 */
+    hw_dev = rt_device_find(HWTIMER_DEV_NAME);
+    if (hw_dev == RT_NULL)
+    {
+        rt_kprintf("hwtimer sample run failed! can't find %s device!\n", HWTIMER_DEV_NAME);
+        return RT_ERROR;
+    }
+
+    /* 以读写方式打开设备 */
+    ret = rt_device_open(hw_dev, RT_DEVICE_OFLAG_RDWR);
+    if (ret != RT_EOK)
+    {
+        rt_kprintf("open %s device failed!\n", HWTIMER_DEV_NAME);
+        return ret;
+    }
+
+    /* 设置超时回调函数 */
+    rt_device_set_rx_indicate(hw_dev, timeout_cb);
+
+    /* 设置模式为周期性定时器 */
+    mode = HWTIMER_MODE_PERIOD;
+    ret = rt_device_control(hw_dev, HWTIMER_CTRL_MODE_SET, &mode);
+    if (ret != RT_EOK)
+    {
+        rt_kprintf("set mode failed! ret is :%d\n", ret);
+        return ret;
+    }
+
+    /* 设置定时器超时值为5s并启动定时器 */
+    timeout_s.sec = 5;      /* 秒 */
+    timeout_s.usec = 0;     /* 微秒 */
+
+    if (rt_device_write(hw_dev, 0, &timeout_s, sizeof(timeout_s)) != sizeof(timeout_s))
+    {
+        rt_kprintf("set timeout value failed\n");
+        return RT_ERROR;
+    }
+
+    /* 延时3500ms */
+    rt_thread_mdelay(3500);
+
+    /* 读取定时器当前值 */
+    rt_device_read(hw_dev, 0, &timeout_s, sizeof(timeout_s));
+    rt_kprintf("Read: Sec = %d, Usec = %d\n", timeout_s.sec, timeout_s.usec);
+
+    return ret;
+}
+/* 导出到 msh 命令列表中 */
+MSH_CMD_EXPORT(hwtimer_sample, hwtimer sample);