嵌入式系统原理考试复习(4)

发表于 更新于 分类于 阅读次数： 本文字数： 3.9k 阅读时长 ≈ 10 分钟

这里是主观题的程序设计题复习资料

程序设计题

五、程序设计题

1.【程序设计题】请基于已有代码架构完成STM32CubeIDE风格的代码补写，实现LED1再快速闪烁三次后以1s一次间隔闪烁的功能

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
int main(void)
{

  /* USER CODE BEGIN 1 */
  int i = 0;
  /* USER CODE END 1 */

  /* MCU Configuration--------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

  /* USER CODE BEGIN Init */

  /* USER CODE END Init */

  /* Configure the system clock */
  SystemClock_Config();

  /* USER CODE BEGIN SysInit */

  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  /* USER CODE BEGIN 2 */
  for(i=0;i<6;i++)
  {
    HAL_GPIO_TogglePin(LED1_GPIO_Port,LED1_Pin);
    HAL_Delay(500);/
  }
  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    /* USER CODE END WHILE */
//在这里写下你的代码
    /* USER CODE BEGIN 3 */
  }
  /* USER CODE END 3 */
}

答案：  HAL_GPIO_TogglePin(LED1_GPIO_Port,LED1_Pin);
  HAL_Delay(1000);

2.【程序设计题】请基于已有代码架构完成STM32CubeIDE风格的代码补写，实现按下按键K1松开后，LED2熄灭，再按下按键K2松开后，LED2亮起（默认LED2初始状态为亮）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
//实例
While(1)
{
HAL_GPIO_TogglePin(LED1_GPIO_Port,LED1_Pin);
HAL_Delay(1000);

if(HAL_GPIO_ReadPin(K1_GPIO_Port,K1_Pin))
{
while(HAL_GPIO_ReadPin(K1_GPIO_Port,K1_Pin));
HAL_GPIO_TogglePin(LED2_GPIO_Port,LED2_Pin);
}
}

//代码实现
While(1)
{
HAL_GPIO_TogglePin(LED1_GPIO_Port,LED1_Pin);
HAL_Delay(1000);
//在这里写下你的代码
}

答案：
if(HAL_GPIO_ReadPin(K1_GPIO_Port,K1_Pin))
{
while(HAL_GPIO_ReadPin(K1_GPIO_Port,K1_Pin));
HAL_GPIO_TogglePin(LED2_GPIO_Port,LED2_Pin);
}
if(HAL_GPIO_ReadPin(K2_GPIO_Port,K2_Pin))
{
while(HAL_GPIO_ReadPin(K2_GPIO_Port,K2_Pin));
HAL_GPIO_TogglePin(LED2_GPIO_Port,LED2_Pin);
}

3.【程序设计题】请基于已有代码架构完成STM32CubeIDE风格的代码补写，实现按下按键K1的瞬间，LED1状态翻转，再按下按键K2的瞬间，LED2状态翻转。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//实例
While(1)
{
if(HAL_GPIO_ReadPin(K2_GPIO_Port,K2_Pin))
{
while(HAL_GPIO_ReadPin(K2_GPIO_Port,K2_Pin));
HAL_GPIO_TogglePin(LED2_GPIO_Port,LED2_Pin);
}
if(GPIO_Pin == K1_Pin)
{
HAL_GPIO_TogglePin(LED1_GPIO_Port,LED1_Pin);
}
}
//代码实现
While(1)
{
//在下面写下你的代码
}

答案：
if(GPIO_Pin == K1_Pin)
{
HAL_GPIO_TogglePin(LED1_GPIO_Port,LED1_Pin);
}
if(GPIO_Pin == K2_Pin)
{
HAL_GPIO_TogglePin(LED2_GPIO_Port,LED2_Pin);
}
4. 【程序设计题】当我们在使用邮箱进行线程间通信时，一般有四个步骤，定义邮箱句柄，主线程创建邮箱，发送邮箱，以及接收邮箱，根据下面实例完成带代码补写

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
//实例：
void ti1_entry(void* paramenter)
{
int a = 100;
char b = “hello RTT!”;
rt_mb_send(dmb,(rt_ubase_t) a));
rt_mb_send(dmb,(rt_ubase_t) b);
}
void tid2_entry(void* paramenter)
{
int a;
char b[15];
rt_mb_recv(dmb,(rt_ubase_t*)&a.RT_WAITING_FOREVER);
rt_mb_recv(dmb,(rt_ubase_t*)b.RT_WAITING_FOREVER);
}
int main（void）
{
rt_thread_t tid1,tid2;

dmb = rt_mb_create(“dmb”,10,RT_IPC_FLAG_FIFO);

//在这里写下你的代码
rt_thread_startup(tid1);
rt_thread_startup(tid2);

}

答案：
tid1 = rt_thread_create(“tid1”,tid1_entry,RT_NULL,1024,10,10);
tid2 = rt_thread_create(“tid2”,tid2_entry,RT_NULL,1024,10,10);

5.【程序设计题】当我们在使用邮箱进行线程间通信时，一般有四个步骤，定义邮箱句柄，主线程创建邮箱，发送邮箱，以及接收邮箱，根据下面实例完成带代码补写

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
//实例：
void ti1_entry(void* paramenter)
{
int a = 100;
char b = “hello RTT!”;
//在这里写下你的代码
}
void tid2_entry(void* paramenter)
{
int a;
char b[15];
rt_mb_recv(dmb,(rt_ubase_t*)&a.RT_WAITING_FOREVER);
rt_mb_recv(dmb,(rt_ubase_t*)b.RT_WAITING_FOREVER);
}
int main（void）
{
rt_thread_t tid1,tid2;

dmb = rt_mb_create(“dmb”,10,RT_IPC_FLAG_FIFO);

tid1 = rt_thread_create(“tid1”,tid1_entry,RT_NULL,1024,10,10);
tid2 = rt_thread_create(“tid2”,tid2_entry,RT_NULL,1024,10,10);

rt_thread_startup(tid1);
rt_thread_startup(tid2);

}

答案：
rt_mb_send(dmb,(rt_ubase_t) a);
rt_mb_send(dmb,(rt_ubase_t) b);

6.【程序设计题】当我们在使用邮箱进行线程间通信时，一般有四个步骤，定义邮箱句柄，主线程创建邮箱，发送邮箱，以及接收邮箱，根据下面实例完成带代码补写

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
//实例：
void ti1_entry(void* paramenter)
{
int a = 100;
char b = “hello RTT!”;
rt_mb_send（dmb,(rt_ubase_t) a));
rt_mb_send(dmb,(rt_ubase_t) b);
}
void tid2_entry(void* paramenter)
{
int a;
char b[15];
//在这里写下你的代码
}
int main（void）
{
rt_thread_t tid1,tid2;

dmb = rt_mb_create(“dmb”,10,RT_IPC_FLAG_FIFO);

tid1 = rt_thread_create(“tid1”,tid1_entry,RT_NULL,1024,10,10);
tid2 = rt_thread_create(“tid2”,tid2_entry,RT_NULL,1024,10,10);

rt_thread_startup(tid1);
rt_thread_startup(tid2);

}

答案：
rt_mb_recv(dmb,(rt_ubase_t*)&a.RT_WAITING_FOREVER);
rt_mb_recv(dmb,(rt_ubase_t*)b.RT_WAITING_FOREVER);

7.【程序设计题】当我们在使用邮箱进行线程间通信时，一般有四个步骤，定义邮箱句柄，主线程创建邮箱，发送邮箱，以及接收邮箱，根据下面实例完成带代码补写

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
//实例：
void ti1_entry(void* paramenter)
{
int a = 100;
char b = “hello RTT!”;
rt_mb_sendc(dmb,(rt_ubase_t) a));
rt_mb_send(dmb,(rt_ubase_t) b);
}
void tid2_entry(void* paramenter)
{
int a;
char b[15];
rt_mb_recv(dmb,(rt_ubase_t*)&a.RT_WAITING_FOREVER);
rt_mb_recv(dmb,(rt_ubase_t*)b.RT_WAITING_FOREVER);
}
int main（void）
{
rt_thread_t tid1,tid2;

dmb = rt_mb_create(“dmb”,10,RT_IPC_FLAG_FIFO);

tid1 = rt_thread_create(“tid1”,tid1_entry,RT_NULL,1024,10,10);
tid2 = rt_thread_create(“tid2”,tid2_entry,RT_NULL,1024,10,10);

//在这里写下你的代码
}

答案：
rt_thread_startup(tid1);
rt_thread_startup(tid2);

补充复习资料

1.创建2个线程，在线程切换时打印线程信息。（直接写线程函数和主函数）
答案：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
void tid1_entry(void* parameter)
{
    rt_kprintf("1");
    rt_thread_mdelay(100);
}
 void tid2_entry(void *parameter)
 {
     rt_kprintf("2");
     rt_thread_mdelay(100);
 }
int main(void)
{
    rt_thread_t tid1,tid2;
    tid1 = rt_thread_create("tid1",tid1_entry,RT_NULL,1024,10,10);
    tid2 = rt_thread_create("tid2",tid2_entry,RT_NULL,1024,10,10);
    
    rt_thread_startup(tid1);
    rt_thread_startup(tid2);
    
    return RT_EOK;
}

2.创建3个线程，其中2个线程优先级相同，另1个线程优先级较高，编程分析3个线程的运行情况。（直接写线程函数和主函数）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
void tid1_entry(void *parameter)
{
    rt_kprintf("1");
    rt_thread_mdelay(100);
}

void tid2_entry(void *parameter)
{
    rt_kprintf("2");
    rt_thread_mdelay(100);
}

void tid3_entry(void *parameter)
{
    rt_kprintf("3");
    rt_thread_mdelay(100);
}

int main(void)
{
	rt_thread_t tid1,tid2,tid3;
    
    tid1 = rt_thread_create("tid1",tid1_entry,RT_NULL,1024,10,10);
    tid2 = rt_thread_create("tid2",tid2_entry,RT_NULL,1024,10,10);
    
    tid3 = rt_thread_create("tid3",tid3_entry,RT_NULL,1024,5,10);
    
    rt_thread_startup(tid1);
    rt_thread_startup(tid2);
    rt_threat_startup(tid3);
}

3.创建2个线程，2个线程共用1个线程入口函数，通过参数控制LED1和LED2分别间隔1s和0.5s闪烁。（直接写线程函数和主函数）
#include <rtthread.h>
#include <rtdevice.h>
#include <board.h>

#define LED1 GET_PIN (A,0)
#define LED2 GET_PIN (A,1)

rt_pin_mode(LED1_PIN, PIN_MODE_OUTPUT);
rt_pin_mode(LED2_PIN, PIN_MODE_OUTPUT);
rt_pin_write(LED1_PIN, PIN_LOW);
rt_pin_write(LED2_PIN, PIN_LOW);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
void led_entry(void * parameter)
{
    rt_uint32_t led_pin = (rt_uint32_t)parameter;
    rt_uint32_t delay_time = (led_pin == LED1)?1000:500;
    
    while(1)
    {
        rt_pin_write(led_pin, ! rt_pin_read(led_pin));
        rt_thread_mdelay(delay_time);
    }
}
int main(void)
{
    rt_thread_t led1,led2;
    
    led1 = rt_thread_create("led1",led_entry,(void*)LED1,1024,10,10);
    led2 = rt_thread_create("led2",led_entry,(void*)LED2,1024,10,10);
    
    rt_thread_startup(led1);
    rt-thread_startip(led2);
    
    return RT_EOK;
}

4.创建3个线程，分别用于控制LED1、LED2和LED3.（1）LED1间隔0.5s闪烁；（2）LED2在LED1闪烁3次后，开始间隔1s闪烁；（3）LED3在LED1和LED2都闪烁5次后，开始间隔2s闪烁。（直接写线程函数和主函数）

#include <rtthread.h>
#include <rtdevice.h>
#include <board.h>

#define LED1 GET_PIN (A,0)
#define LED2 GET_PIN (A,1)
#define LED3 GET_PIN (A,4)

#define E_LED1 ( 1 << 3 )
#define E_LED2 ( 1 << 5 )

rt_sem_t sled12;
rt_event_t eled123;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
void led1_entry(void *parameter)
{
    int count =0;
    
    while(1)
    {
        rt_pin_write(LED1, !rt_pin_read(LED1));
        rt_thread_mdealy(500);//0.5s
        
        if(++count == 6 && sled12 != RT_NULL)
        {
            rt_sem_release(sled12);
        }
        if(++count == 10 && eled123 != RT_NULL)
        {
            rt_event_send(eled123,E1);
        }
    }
}

void led2_entry(void *parameter)
{
    int count = 0;
    rt_sem_take(sled12,RT_WAITING_FOREVER);
    rt_sem_delete(sled12);
    
    
    while(1)
    {
        rt_pin_write(LED2,!rt_pin_read(read));
        rt_thread_mdelay(1000);
        
        if(count++ == 10)
        {
            rt_event_send(eled123,E2);
        }
    }
}

void led3_entry (void * parameter)
{
    rt_uint32_t e;
    rt_event_recv(eled123,E1| E2,RT_EVENT_FLAG_AND |RT_EVENT_FLAG_CLEAR,RT_WAITING_FOREVER,&e);
    rt_event_delete(eled123);
    while(1)
    {
        rt_pin_write(LED3,!rt_pin_read(LED3));
        rt_thread_mdelay(2000);
    }
}

int main(void)
{
    rt_thread_t led1,led2,led3;
    
    sled12 = rt_sem_create("sled12",0,RT_IPC_FLAG_FIFO);
    sled123 = rt_event_create("sled123",RT_IPC_FLAG_FIFO);
    
    led1 = rt_thread_create("led1",led1_entry,RT_NULL,1024,10,10);
    led2 = rt_thread_create("led2",led1_entry,RT_NULL,1024,11,10);
    led3 = rt_thread_create("led3",led1_entry,RT_NULL,1024,12,10);
    
    rt_thread_startup(led1);
    rt_thread_startup(led2);
    rt_thread_startup(led3);
    
    return RT_EOK;
}

5.创建线程t_data_get1和t_data_get2用于获取温湿度信息，温湿度信息可以用随机数模拟；创建线程t_data_print用于接收并打印温湿度信息；创建消息队列q_get_print,线程t_data_get1和线程t_data_get2发送消息至消息队列，线程t_data_print从消息队列中获取消息（直接写线程函数和主函数）

#include <rtthread.h>
#include <stdlib.h>

struct data_ht{
int id;
int humi;
int temp;
};

rt_mq_t q_get_print;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
void t_data_get1_entry(void* parameter)
{
    struct data_ht datra;
    while(1)
    {
        data.id = 1;
        data.humi = rand()%100;
        data.temp = rand()%100;
        
        rt_mq_send(q_get_print,&data,sizeof(data));
        rt_thread_mdelay(1000);
    }
  
}

void t_data_get2_entry(void* parameter)
{
    struct data_ht data;
    while(1)
    {
        data.id = 2;
        data.humi = rand()%100;
        data.temp = rand()%100;
        
        rt_mq_send(q_get_print,&data,sizeof(data));
        rt_thread_mdelay(1000);
    }
    
}

void t_data_print_entry(void* parameter)
{
    struct data_ht data;
    while(1)
    {
        rt_mq_recv(q_get_print,&data,sizeof(data),RT_WAITING_FOREVER);
        rt_kprint("id:%d,humi:%d,temp:%d\n",data.id,data.humi,data.temp);
    }
}

int main(void)
{
    rt_thread_t t_data_get1,t_data_get2,t_data_print;
    rt_mq_t q_get_print;
    
    t_data_get1 = rt_thread_create("t_data_get1",t_data_get1_entry,RT_NULL,1024,10,10,10);
    t_data_get2 = rt_thread_create("t_data_get2",t_data_get2_entry,RT_NULL,1024,10,10,10);
    t_data_print = rt_thread_create("t_data_print",t_data_print_entry,RT_NULL,1024,10,10,10);
    
    q_get_print = rt_mq_create("q_get_print",sizeof(data_ht),10,RT_IPC_FLAG_FIFO);
    
    rt_thread_startup(t_data_get1);
    rt_thread_startup(t_data_get2);
    rt_thread_startup(t_data_print);
    
    retuen RT_EOK;
}

6.创建3个线程，分别用于控制LED1、LED2和LED3.（1）LED1间隔1s闪烁；（2）LED2在LED1闪烁3次后，开始间隔0.5s闪烁；（3）LED3在LED1和LED2都闪烁3次后，开始间隔1s闪烁。（直接写线程函数和主函数）

#include <rtthread.h>
#include <rtdevice.h>
#include <board.h>

#define LED1 GET_PIN (A,0)
#define LED2 GET_PIN (A,1)
#define LED3 GET_PIN (A,4)

#define E_LED1 ( 1 << 3 )
#define E_LED2 ( 1 << 5 )

rt_sem_t sled12;
Rt_event_t eled123;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
void tid1_entry(void* parameter)
{
    int count = 0;
    while(1)
    {
        rt_pin_write(LED1,!rt_pin_read(LED1));
        rt_thread_mdelay(1000);
        
        if(++count == 6 && slem12 != RT_NULL)
        {
            rt_sem_release(sled12);
            rt_event_send(eled123,E_LED1);
        }
    }
}

void tid2_entry(void* parameter)
{
    int count = 0;
    rt_sem_take(sled12,RT_WAITING_FOREVER);
    rt_sem_delete(sled12);
    while(1)
    {
        rt_pin_write(LED2,!rt_pin_read(LED2));
        rt_thread_mdelay(500);
        
        if(count == 6 && eled123 != RT_NULL)
        {
            rt_event_send(eled123,E_LED2);
        }
    }
}

void tid3_entry(void* parameter)
{
    rt_uint32_t e;
    rt_event_recv(eled123,E_LED1|E_LED2,RT_EVENT_FLAG_AND|RT_EVENT_FLAG_CLEAR,RT_WAITING_FOREVER,&e);
    rt_event_delete(eled123);
    while(1)
    {
        rt_pin_write(LED3,!rt_pin_read(LED3));
        rt_thread_mdelay(1000);
    }
}
int main(void)
{
    rt_thread_t tid1,tid2,tid3;
    
    sled12 = rt_sem_create(sled12,0,RT_IPC_FLAG_FIFO);
    eled123 = rt_event_create(eled123,RT_IPC_FLAG_FIFO);
    tid1 = rt_thread_create("tid1",tid1_entry,RT_NULL,1024,10,10);
    tid2 = rt_thread_create("tid2",tid2_entry,RT_NULL,1024,11,10);
    tid3 = rt_thread_create("tid3",tid3-entry,RT_NULL,1024,12,10);
    
    rt_thread_startup(tid1);
    rt_thread_startup(tid2);
    rt_thread_startup(tid3);
    
	return RT_EOK;
}

7.创建3个线程，分别用于控制LED1、LED2和LED3.（1）LED1间隔1s闪烁；（2）LED2在LED1闪烁5次后，开始间隔1s闪烁；（3）LED3在LED1和LED2都闪烁3次后，开始间隔1s闪烁。（直接写线程函数和主函数）
#include <rtthread.h>
#include <rtdevice.h>
#include <board.h>

#define LED1 GET_PIN (A,0)
#define LED2 GET_PIN (A,1)
#define LED3 GET_PIN (A,4)

#define E_LED1 ( 1 << 3 )
#define E_LED2 ( 1 << 5 )

rt_sem_t sled12;
Rt_event_t eled123;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
void tid1_entry(void* parameter)
{
    int count = 0;
    while(1)
    {
        rt_pin_write(LED1,!rt_pin_read(LED1));
        rt_thread_mdelay(1000);
        if(++count == 6 && eled123 != RT_NULL)
        {
            rt_event_send(eled123,E_LED1);
        }
        if(++count ==10 && sled12 != RT_NULL)
        {
            rt_sem_release(sled12);
        }
    }
}

void tid2_entry(void* parameter)
{
    int count ==0;
    rt_sem_take(sled12,RT_WAITING_FOREVER);
    rt_sem_delete(sled12);
    while(1)
    {
        rt_pin_write(LED2,!rt_pin_read(LED2));
        rt_thread_mdelay(1000);
        
        if(++count == 6 && eled123 != RT_NULL )
        {
            rt_event_send(eled123,E_LED2);
        }
    }
}

void tid3_entry(void* parameter)
{
    rt_uint32_t e;
    rt_event_recv(eled123,LED1_E|LED2_E,RT_FLGA_AND|RT_FLGA_CLEAR,RT_WAITING_FOREVER,&e);
    rt_event_delete(eled123);
    while(1)
    {
        rt_pin_write(LED3,rt_pin_read(LED3));
        rt_thread_mdelay(1000);    
    }
}
int mian(void)
{
	rt_thread_t tid1,tid2,tid3;
    
    sled12 = rt_sem_create(sled12,0,RT_IPC_FLAG_FIFO);
    eled123 = rt_event_create(eled123,RT_IPC_FLAG_FIFO);
    tid1 = rt_thread_create("tid1",tid1_entry,RT_NULL,1024,10,10);
    tid2 = rt_thread_create("tid2",tid2_entry,RT_NULL,1024,11,10);
    tid3 = rt_thread_create("tid3",tid3_entry,RT_NULL,1024,12,10);
    
    rt_thread_startup(tid1);
    rt_thread_startup(tid2);
    rt_thread_startup(tid3);
    
	return RT_EOK;
}

8.创建2个线程，2个线程共用1个线程入口函数，通过参数控制LED1和LED2分别间隔1s和2s闪烁。（直接写线程函数和主函数）
#include <rtthread.h>
#include <rtdevice.h>
#include <board.h>

#define LED1 GET_PIN (A,0)
#define LED2 GET_PIN (A,1)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
void tid_entry(void* parameter)
{
    rt_uint32_t led_pin = (rt_uint32_t) parameter;
    rt_uint32_t time_delay = (led_pin==LED1)?1000:2000;
    
    while(1)
    {
        rt_pin_write(led_pin,!rt_pin_read(led_pin));
        rt_thread_mdelay(time_delay);
    }
}

int main(void)
{
    rt_thread_t tid1,tid2;
    
    tid1 = rt_threat_create("tid1",tid_entry,(void*)LED1,1024,10,10);
    tid2 = rt_threat_create("tid2",tid_entry,(void*)LED2,1024,10,10);
    
    rt_threat_startup(tid1);
    rt_threat_startup(tid2);
}

9.创建2个线程，2个线程共用1个线程入口函数，通过参数控制LED1和LED2分别间隔1s和0.5s闪烁。（直接写线程函数和主函数）
#include <rtthread.h>
#include <rtdevice.h>
#include <board.h>

#define LED1 GET_PIN (A,0)
#define LED2 GET_PIN (A,1)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
void tid_entry(void* parameter)
{
    rt_uint32_t led_pin = (rt_uint32_t)parameter;
    rt_uint32_t time_delay = (led_pin== LED1)?1000:500;
    while(1)
    {
        rt_pin_write(led_pin,!rt_pin_read(led_pin));
        rt_thread_mdelay(time_delay);
    }
}
int main(void)
{
    rt_thread_t tid1,tid2;
    
    tid1 = rt_thread_create("tid1",tid_entry,(void*)LED1,1024,10,10);
    tid2 = rt_thread_create("tid2",tid_entry,(void*)LED2,1024,10,10);
    
    rt_thread_startup(tid1);
    rt_thread_startup(tid2);
}

10.编写信号量应用示例程序。
答案：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
void tid1_entry(void* parameter)
{
    rt_sem_release(dsem);
}
void tid2_entry(void* parameter)
{
    rt_sem_take(dsem);
}
int main(void)
{
    rt_sem_t dsem;
    rt_thread_t tid1,tid2;
    
    dsem = rt_sem_create("dsem",0,RT_FLAG_FIFO);
    tid1 = rt_thread_create("tid1",tid1_entry,RT_NULL,1024,10,10);
    tid2 = rt_thread_create("tid2",tid2_entry,RT_NULL,1024,10,10);
    
    rt_thread_startup(tid1);
    rt_thread_startup(tid2);
    return RT_EOK;
}

11.【应用设计题】编写互斥量应用示例程序。
答案：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
void tid1_entry(void* parameter)
{
    rt_mutex_take(dmutex,RT_WAITING_FOREVER);
    rt_mutex_release(dmutex);
    rt_thread(dmutex);
    rt_thread_mdelay(100);
}
void tid2_entry(void* parameter)
{
    rt_mutex_take(dmutex,RT_WAITING_FOREVER);
    rt_mutex_release(dmutex);
    rt_thread(dmutex);
    rt_thread_mdelay(100);
}
int main(void)
{
	rt_mutex_t dmutex;
    rt_thread_t tid1,tid2;
    
    dmutex = rt_mutex_create("dmutex",RT_IPC_FLAG_FIFO);
    tid1 = rt_thread_create("tid1",tid1_entry,RT_NULL,1024,10,10);
    tid1 = rt_thread_create("tid2",tid2_entry,RT_NULL,1024,10,10);
    
    rt_thread_start(tid1);
    rt_thread_start(tid2);
    return RT_EOK;
}

12.编写事件集应用示例程序。

#define E2 ( 1 << 2 )
#define E29 ( 1 << 29 )

rt_event_t e_t12;
rt_thread_t tid1,tid2;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
void tid1_entry(void* parameter)
{
    rt_event_send(e_t12,E2);
    rt_event_send(e_t12,E29);
}
void tid2_entry(void* parameter)
{
    rt_uint32_t e;
    rt_event_recev(e_12,E2|E29,RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR,RT_WAITING_FOREVER.&e);
}
int main(void)
{
    rt_event_t e_t12;
    rt_thread_t tid1,tid2;
    
    e_t12 = rt_event_create("e_t12",RT_IPC_FLAG_FIFO);
    tid1 = rt_thread_create("tid1",tid1_entry,RT_NULL,1024,10,10);
    tid2 = rt_thread_create("tid2",tid1_entry,RT_NULL,1024,10,10);
    
    rt_thread_startup(tid1);
    rt_thread_startup(tid2);
    return RT_EOK;
}

13.编写邮箱应用示例程序。
答案：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
void tid1_entry(void* parameter)
{
    int a = 400;
    char b = [Hello RTT.];
    rt_mb_send(dmb,(rt_ubase)a);
    rt_mb_send(dmb,(rt_ubase)b);
    rt_thread_mdelay(100);
}
voud tid2_entry(vois *parameter)
{
    int a;
    char b[15];
    rt_mb_recv(dmb,(rt_ubase*) &a,RT_WAITING_FOREVER);
    rt_mb_revc(dmb,(rt_ubase*) b,RT_WAITING_FOREVER);
}
int main(void)
{
    rt_mailbox_t dmb;
    rt_thread_t tid1,tid2;
    
    dmb = rt_mailbox_create(dmb,10,RT_IPC_FLAG_FIFO);
    tid1 = rt_thread_create("tid1",tid1_entry,RT_NULL,1024,10,10);
    tid2 = rt_thread_create("tid2",tid2_entry,RT_NULL,1024,10,10);
    
    rt_thread_startup(tid1);
    rt_thread_startup(tid2);
    
    return RT_EOK;
}

14.编写消息队列应用示例程序。
答案：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
void tid1_entry(void* parameter)
{
    int a =100;
    char b[] = "hello RTT.";
    
    rt_mq_send(dmq,&a,4);
    rt_mq_send(dmq,&b,sizeof(b));
}

void tid1_entry(void* parameter)
{
    int a;
    char b[15];

    
    rt_mq_recv(dmq,&a,4,RT_WAITING_FOREVER);
    rt_mq_recv(dmq,&b,sizeof(b),RT_WAITING_FOREVER);
}

int main(void)
{
    rt_mq_t dmq;
    rt_thread_t tid1,tid2;
    
    dmq = rt_mq_create(dmq,10,RT_IPC_FLAG_FIFO);
    tid1 = rt_thread_create("tid1",tid1_entry,RT_NULL,1024,10,10);
    tid2 = rt_thread_create("tid2",tid2_entry,RT_NULL,1024,10,10);
    
    rt_thread_startup(tid1);
    rt_thread_startup(tid2);
    
    return RT_EOK;
}

15.编写信号应用示例程序。
答案：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
void tid1_signal_handler(int sig)
{
    rt_kprintf("%d\n",sig);
}
void tid1_entry(void* parameter)
{
    rt_signal_install(SIGUSR1,tid1_signal_handler);
    
    rt_signal_unmask(SIGUSR1);
}

void tid1_entry(void* parameter)
{
	rt_thread_kill(SIGUSR1);
}


int main(void)
{
    
    rt_thread_t tid1,tid2;
    
    tid1 = rt_thread_create("tid1",tid1_entry,RT_NULL,1024,10,10);
    tid2 = rt_thread_create("tid2",tid2_entry,RT_NULL,1024,10,10);
    
    rt_thread_startup(tid1);
    rt_thread_startup(tid2);
    return RT_EOK;
}