1
void thread_entry(void* paramenter)
2
{
3
    while (1)
4
    {
5
    /* 等待事件的发生 */
6

7
    /* 对事件进行服务、进行处理 */
8
    }
9
}

1
static void thread_entry(void* parameter)
2
{
3
    /* 处理事务 #1 */
4
    …
5
    /* 处理事务 #2 */
6
    …
7
    /* 处理事务 #3 */
8
}

1
#define RT_EOK           0 /* 无错误     */
2
#define RT_ERROR         1 /* 普通错误     */
3
#define RT_ETIMEOUT      2 /* 超时错误     */
4
#define RT_EFULL         3 /* 资源已满     */
5
#define RT_EEMPTY        4 /* 无资源     */
6
#define RT_ENOMEM        5 /* 无内存     */
7
#define RT_ENOSYS        6 /* 系统不支持     */
8
#define RT_EBUSY         7 /* 系统忙     */
9
#define RT_EIO           8 /* IO 错误       */
10
#define RT_EINTR         9 /* 中断系统调用   */
11
#define RT_EINVAL       10 /* 非法参数      */

1
rt_err_t rt_thread_init(struct rt_thread* thread,
2
                        const char* name,
3
                        void (*entry)(void* parameter), void* parameter,
4
                        void* stack_start, rt_uint32_t stack_size,
5
                        rt_uint8_t priority, rt_uint32_t tick);复制错误复制成功

1
rt_err_t rt_thread_detach (rt_thread_t thread);复制错误复制成功

1
rt_err_t rt_thread_control(rt_thread_t thread, rt_uint8_t cmd, void* arg);复制错误复制成功

1
rt_err_t rt_thread_idle_sethook(void (*hook)(void));
2
rt_err_t rt_thread_idle_delhook(void (*hook)(void));复制错误复制成功

1
/*
2
 * 程序清单：这是一个 串口 设备使用例程
3
 * 例程导出了 uart_sample 命令到控制终端
4
 * 命令调用格式：uart_sample uart2
5
 * 命令解释：命令第二个参数是要使用的串口设备名称，为空则使用默认的串口设备
6
 * 程序功能：通过串口输出字符串"hello RT-Thread!"，然后错位输出输入的字符
7
*/
8

9
#include <rtthread.h>
10

11
#define SAMPLE_UART_NAME       "uart2"
12

13
/* 用于接收消息的信号量 */
14
static struct rt_semaphore rx_sem;
15
static rt_device_t serial;
16

17
/* 接收数据回调函数 */
18
static rt_err_t uart_input(rt_device_t dev, rt_size_t size)
19
{
20
    /* 串口接收到数据后产生中断，调用此回调函数，然后发送接收信号量 */
21
    rt_sem_release(&rx_sem);
22

23
    return RT_EOK;
24
}
25

26
static void serial_thread_entry(void *parameter)
27
{
28
    char ch;
29

30
    while (1)
31
    {
32
        /* 从串口读取一个字节的数据，没有读取到则等待接收信号量 */
33
        while (rt_device_read(serial, -1, &ch, 1) != 1)
34
        {
35
            /* 阻塞等待接收信号量，等到信号量后再次读取数据 */
36
            rt_sem_take(&rx_sem, RT_WAITING_FOREVER);
37
        }
38
        /* 读取到的数据通过串口错位输出 */
39
        ch = ch + 1;
40
        rt_device_write(serial, 0, &ch, 1);
41
    }
42
}
43

44
static int uart_sample(int argc, char *argv[])
45
{
46
    rt_err_t ret = RT_EOK;
47
    char uart_name[RT_NAME_MAX];
48
    char str[] = "hello RT-Thread!\r\n";
49

50
    if (argc == 2)
51
    {
52
        rt_strncpy(uart_name, argv[1], RT_NAME_MAX);
53
    }
54
    else
55
    {
56
        rt_strncpy(uart_name, SAMPLE_UART_NAME, RT_NAME_MAX);
57
    }
58

59
    /* 查找系统中的串口设备 */
60
    serial = rt_device_find(uart_name);
61
    if (!serial)
62
    {
63
        rt_kprintf("find %s failed!\n", uart_name);
64
        return RT_ERROR;
65
    }
66

67
    /* 初始化信号量 */
68
    rt_sem_init(&rx_sem, "rx_sem", 0, RT_IPC_FLAG_FIFO);
69
    /* 以中断接收及轮询发送模式打开串口设备 */
70
    rt_device_open(serial, RT_DEVICE_FLAG_INT_RX);
71
    /* 设置接收回调函数 */
72
    rt_device_set_rx_indicate(serial, uart_input);
73
    /* 发送字符串 */
74
    rt_device_write(serial, 0, str, (sizeof(str) - 1));
75

76
    /* 创建 serial 线程 */
77
    rt_thread_t thread = rt_thread_create("serial", serial_thread_entry, RT_NULL, 1024, 25, 10);
78
    /* 创建成功则启动线程 */
79
    if (thread != RT_NULL)
80
    {
81
        rt_thread_startup(thread);
82
    }
83
    else
84
    {
85
        ret = RT_ERROR;
86
    }
87

88
    return ret;
89
}
90
/* 导出到 msh 命令列表中 */
91
MSH_CMD_EXPORT(uart_sample, uart device sample);

1
/*
2
 * 程序清单：这是一个串口设备 DMA 接收使用例程
3
 * 例程导出了 uart_dma_sample 命令到控制终端
4
 * 命令调用格式：uart_dma_sample uart3
5
 * 命令解释：命令第二个参数是要使用的串口设备名称，为空则使用默认的串口设备
6
 * 程序功能：通过串口输出字符串"hello RT-Thread!"，并通过串口输出接收到的数据，然后打印接收到的数据。
7
*/
8

9
#include <rtthread.h>
10

11
#define SAMPLE_UART_NAME       "uart3"      /* 串口设备名称 */
12

13
/* 串口接收消息结构*/
14
struct rx_msg
15
{
16
    rt_device_t dev;
17
    rt_size_t size;
18
};
19
/* 串口设备句柄 */
20
static rt_device_t serial;
21
/* 消息队列控制块 */
22
static struct rt_messagequeue rx_mq;
23

24
/* 接收数据回调函数 */
25
static rt_err_t uart_input(rt_device_t dev, rt_size_t size)
26
{
27
    struct rx_msg msg;
28
    rt_err_t result;
29
    msg.dev = dev;
30
    msg.size = size;
31

32
    result = rt_mq_send(&rx_mq, &msg, sizeof(msg));
33
    if ( result == -RT_EFULL)
34
    {
35
        /* 消息队列满 */
36
        rt_kprintf("message queue full！\n");
37
    }
38
    return result;
39
}
40

41
static void serial_thread_entry(void *parameter)
42
{
43
    struct rx_msg msg;
44
    rt_err_t result;
45
    rt_uint32_t rx_length;
46
    static char rx_buffer[RT_SERIAL_RB_BUFSZ + 1];
47

48
    while (1)
49
    {
50
        rt_memset(&msg, 0, sizeof(msg));
51
        /* 从消息队列中读取消息*/
52
        result = rt_mq_recv(&rx_mq, &msg, sizeof(msg), RT_WAITING_FOREVER);
53
        if (result > 0)
54
        {
55
            /* 从串口读取数据*/
56
            rx_length = rt_device_read(msg.dev, 0, rx_buffer, msg.size);
57
            rx_buffer[rx_length] = '\0';
58
            /* 通过串口设备 serial 输出读取到的消息 */
59
            rt_device_write(serial, 0, rx_buffer, rx_length);
60
            /* 打印数据 */
61
            rt_kprintf("%s\n",rx_buffer);
62
        }
63
    }
64
}
65

66
static int uart_dma_sample(int argc, char *argv[])
67
{
68
    rt_err_t ret = RT_EOK;
69
    char uart_name[RT_NAME_MAX];
70
    static char msg_pool[256];
71
    char str[] = "hello RT-Thread!\r\n";
72

73
    if (argc == 2)
74
    {
75
        rt_strncpy(uart_name, argv[1], RT_NAME_MAX);
76
    }
77
    else
78
    {
79
        rt_strncpy(uart_name, SAMPLE_UART_NAME, RT_NAME_MAX);
80
    }
81

82
    /* 查找串口设备 */
83
    serial = rt_device_find(uart_name);
84
    if (!serial)
85
    {
86
        rt_kprintf("find %s failed!\n", uart_name);
87
        return RT_ERROR;
88
    }
89

90
    /* 初始化消息队列 */
91
    rt_mq_init(&rx_mq, "rx_mq",
92
               msg_pool,                 /* 存放消息的缓冲区 */
93
               sizeof(struct rx_msg),    /* 一条消息的最大长度 */
94
               sizeof(msg_pool),         /* 存放消息的缓冲区大小 */
95
               RT_IPC_FLAG_FIFO);        /* 如果有多个线程等待，按照先来先得到的方法分配消息 */
96

97
    /* 以 DMA 接收及轮询发送方式打开串口设备 */
98
    rt_device_open(serial, RT_DEVICE_FLAG_DMA_RX);
99
    /* 设置接收回调函数 */
100
    rt_device_set_rx_indicate(serial, uart_input);
101
    /* 发送字符串 */
102
    rt_device_write(serial, 0, str, (sizeof(str) - 1));
103

104
    /* 创建 serial 线程 */
105
    rt_thread_t thread = rt_thread_create("serial", serial_thread_entry, RT_NULL, 1024, 25, 10);
106
    /* 创建成功则启动线程 */
107
    if (thread != RT_NULL)
108
    {
109
        rt_thread_startup(thread);
110
    }
111
    else
112
    {
113
        ret = RT_ERROR;
114
    }
115

116
    return ret;
117
}
118
/* 导出到 msh 命令列表中 */
119
MSH_CMD_EXPORT(uart_dma_sample, uart device dma sample);

1
/*
2
 * 程序清单：这是一个串口设备接收不定长数据的示例代码
3
 * 例程导出了 uart_dma_sample 命令到控制终端
4
 * 命令调用格式：uart_dma_sample uart2
5
 * 命令解释：命令第二个参数是要使用的串口设备名称，为空则使用默认的串口设备
6
 * 程序功能：通过串口 uart2 输出字符串"hello RT-Thread!"，并通过串口 uart2 输入一串字符（不定长），再通过数据解析后，使用控制台显示有效数据。
7
*/
8

9
#include <rtthread.h>
10

11
#define SAMPLE_UART_NAME                 "uart2"
12
#define DATA_CMD_END                     '\r'       /* 结束位设置为 \r，即回车符 */
13
#define ONE_DATA_MAXLEN                  20         /* 不定长数据的最大长度 */
14

15
/* 用于接收消息的信号量 */
16
static struct rt_semaphore rx_sem;
17
static rt_device_t serial;
18

19
/* 接收数据回调函数 */
20
static rt_err_t uart_rx_ind(rt_device_t dev, rt_size_t size)
21
{
22
    /* 串口接收到数据后产生中断，调用此回调函数，然后发送接收信号量 */
23
    if (size > 0)
24
    {
25
        rt_sem_release(&rx_sem);
26
    }
27
    return RT_EOK;
28
}
29

30
static char uart_sample_get_char(void)
31
{
32
    char ch;
33

34
    while (rt_device_read(serial, 0, &ch, 1) == 0)
35
    {
36
        rt_sem_control(&rx_sem, RT_IPC_CMD_RESET, RT_NULL);
37
        rt_sem_take(&rx_sem, RT_WAITING_FOREVER);
38
    }
39
    return ch;
40
}
41

42
/* 数据解析线程 */
43
static void data_parsing(void)
44
{
45
    char ch;
46
    char data[ONE_DATA_MAXLEN];
47
    static char i = 0;
48

49
    while (1)
50
    {
51
        ch = uart_sample_get_char();
52
        rt_device_write(serial, 0, &ch, 1);
53
        if(ch == DATA_CMD_END)
54
        {
55
            data[i++] = '\0';
56
            rt_kprintf("data=%s\r\n",data);
57
            i = 0;
58
            continue;
59
        }
60
        i = (i >= ONE_DATA_MAXLEN-1) ? ONE_DATA_MAXLEN-1 : i;
61
        data[i++] = ch;
62
    }
63
}
64

65
static int uart_data_sample(int argc, char *argv[])
66
{
67
    rt_err_t ret = RT_EOK;
68
    char uart_name[RT_NAME_MAX];
69
    char str[] = "hello RT-Thread!\r\n";
70

71
    if (argc == 2)
72
    {
73
        rt_strncpy(uart_name, argv[1], RT_NAME_MAX);
74
    }
75
    else
76
    {
77
        rt_strncpy(uart_name, SAMPLE_UART_NAME, RT_NAME_MAX);
78
    }
79

80
    /* 查找系统中的串口设备 */
81
    serial = rt_device_find(uart_name);
82
    if (!serial)
83
    {
84
        rt_kprintf("find %s failed!\n", uart_name);
85
        return RT_ERROR;
86
    }
87

88
    /* 初始化信号量 */
89
    rt_sem_init(&rx_sem, "rx_sem", 0, RT_IPC_FLAG_FIFO);
90
    /* 以中断接收及轮询发送模式打开串口设备 */
91
    rt_device_open(serial, RT_DEVICE_FLAG_INT_RX);
92
    /* 设置接收回调函数 */
93
    rt_device_set_rx_indicate(serial, uart_rx_ind);
94
    /* 发送字符串 */
95
    rt_device_write(serial, 0, str, (sizeof(str) - 1));
96

97
    /* 创建 serial 线程 */
98
    rt_thread_t thread = rt_thread_create("serial", (void (*)(void *parameter))data_parsing, RT_NULL, 1024, 25, 10);
99
    /* 创建成功则启动线程 */
100
    if (thread != RT_NULL)
101
    {
102
        rt_thread_startup(thread);
103
    }
104
    else
105
    {
106
        ret = RT_ERROR;
107
    }
108

109
    return ret;
110
}
111

112
/* 导出到 msh 命令列表中 */
113
MSH_CMD_EXPORT(uart_data_sample, uart device sample);

1
rt_device_t rt_device_find(const char* name);

1
#define ADC_DEV_NAME        "adc1"  /* ADC 设备名称 */
2
rt_adc_device_t adc_dev;            /* ADC 设备句柄 */
3
/* 查找设备 */
4
adc_dev = (rt_adc_device_t)rt_device_find(ADC_DEV_NAME);

1
rt_err_t rt_adc_enable(rt_adc_device_t dev, rt_uint32_t channel);

1
#define ADC_DEV_NAME        "adc1"  /* ADC 设备名称 */
2
#define ADC_DEV_CHANNEL     5       /* ADC 通道 */
3
rt_adc_device_t adc_dev;            /* ADC 设备句柄 */
4
/* 查找设备 */
5
adc_dev = (rt_adc_device_t)rt_device_find(ADC_DEV_NAME);
6
/* 使能设备 */
7
rt_adc_enable(adc_dev, ADC_DEV_CHANNEL);

1
rt_uint32_t rt_adc_read(rt_adc_device_t dev, rt_uint32_t channel);

1
#define ADC_DEV_NAME        "adc1"  /* ADC 设备名称 */
2
#define ADC_DEV_CHANNEL     5       /* ADC 通道 */
3
#define REFER_VOLTAGE       330         /* 参考电压 3.3V,数据精度乘以100保留2位小数*/
4
#define CONVERT_BITS        (1 << 12)   /* 转换位数为12位 */
5

6
rt_adc_device_t adc_dev;            /* ADC 设备句柄 */
7
rt_uint32_t value, vol;
8
/* 查找设备 */
9
adc_dev = (rt_adc_device_t)rt_device_find(ADC_DEV_NAME);
10
/* 使能设备 */
11
rt_adc_enable(adc_dev, ADC_DEV_CHANNEL);
12
/* 读取采样值 */
13
value = rt_adc_read(adc_dev, ADC_DEV_CHANNEL);
14
/* 转换为对应电压值 */
15
vol = value * REFER_VOLTAGE / CONVERT_BITS;
16
rt_kprintf("the voltage is :%d.%02d \n", vol / 100, vol % 100);

1
rt_err_t rt_adc_disable(rt_adc_device_t dev, rt_uint32_t channel);

1
#define ADC_DEV_NAME        "adc1"  /* ADC 设备名称 */
2
#define ADC_DEV_CHANNEL     5       /* ADC 通道 */
3
rt_adc_device_t adc_dev;            /* ADC 设备句柄 */
4
rt_uint32_t value；
5
/* 查找设备 */
6
adc_dev = (rt_adc_device_t)rt_device_find(ADC_DEV_NAME);
7
/* 使能设备 */
8
rt_adc_enable(adc_dev, ADC_DEV_CHANNEL);
9
/* 读取采样值 */
10
value = rt_adc_read(adc_dev, ADC_DEV_CHANNEL);
11
/* 转换为对应电压值 */
12
vol = value * REFER_VOLTAGE / CONVERT_BITS;
13
rt_kprintf("the voltage is :%d.%02d \n", vol / 100, vol % 100);
14
/* 关闭通道 */
15
rt_adc_disable(adc_dev, ADC_DEV_CHANNEL);

1
msh >adc probe adc1
2
probe adc1 success

1
msh >adc enable 5
2
adc1 channel 5 enables success

1
msh >adc read 5
2
adc1 channel 5  read value is 0x00000FFF
3
msh >

1
msh >adc disable 5
2
adc1 channel 5 disable success
3
msh >

1
( 注： C10_b表示C10取反 )