RT-Thread-RTT15天---第三天&第四天RT-Thread问答社区

RTT15天---第三天&第四天

发布于 2018-05-29 11:17:18 浏览：1338 订阅该版

* 本帖最后由 gch 于 2018-5-29 11:22 编辑 *

之前手上事情太大，接着学习，

第三天：线程的创建和删除

线程的组成
     线程代码
     线程控制块
     线程堆栈
 
线程的代码形式：
                无限循环形式：线程里有死循环，线程里需要有函数让出CPU使用权

顺序执行形式：没有死循环，执行完代码后退出，退出后，会由空闲线程踢出调度队列，回收相关资源
线程创建：
                  优先级数字越小，优先级越高

当优先级相同时，使用时间片轮调度法来调度

堆栈：可以先设置的大一点，可以通过查看最大堆栈使用量，来设置合理的堆栈大小

线程的穿件分为动态的和静态的，二者的API函数不同，方式也不同

静态的：
首先申请一个线程控制块：static struct rt_thread  led0_thread;
然后设置线程栈的大小：static rt_uint8_t  rt_led0_thread_stack[1024];
创建静态线程：rt_thread_init（）
启动线程：rt_thread_startup（）
删除线程：rt_thread_detach（）

动态的：
创建动态线程：tid1 = rt_thread_create（）   if（RT_OK==tid1）  这样写的目的是防止手误，常量放在前面可以进行判断的时候更加准确，
启动线程：rt_thread_startup(tid1)
删除线程：rt_thread_delete(tid1)

某一个线程在让出CPU之后，会立刻切换到另一个动作，不是说要等待几个系统时钟之后采取执行

```static struct rt_thread led0_thread;//Ïß³Ì¿ØÖÆ¿é
static struct rt_thread led1_thread;//Ïß³Ì¿ØÖÆ¿é
ALIGN(RT_ALIGN_SIZE)
static rt_uint8_t rt_led0_thread_stack[1024];//Ïß³ÌÕ»
static rt_uint8_t rt_led1_thread_stack[1024];//Ïß³ÌÕ»
 
//Ïß³ÌLED0
static void led0_thread_entry(void* parameter)
{
 rt_uint32_t count = 0;
	
 while (1)
 {
 LED0=0; //×¢Òâ£ºF7²»Ö§³ÖÎ»´ø²Ù×÷£¬LED²Ù×÷Çë²Î¿¼´úÂëÐÞ¸Ä
 rt_thread_delay(500); //ÑÓÊ±500¸ötick
 
 LED0=1; 
 rt_thread_delay(500); //ÑÓÊ±500¸ötick
				 		
		rt_kprintf("thread led0 count: %d ", count ++); /* ´òÓ¡Ïß³Ì¼ÆÊýÖµÊä³ö */
 }
}
 
//Ïß³ÌLED1
static void led1_thread_entry(void* parameter)
{
 rt_err_t err;
	rt_uint32_t count = 0;
	
 while (1)
 {
		LED1=0; 
		rt_thread_delay(100); //ÑÓÊ±100¸ötick

LED1=1; 
		rt_thread_delay(100); //ÑÓÊ±100¸ötick
							 
		rt_kprintf("thread led1 count: %d ", count ++);/* ´òÓ¡Ïß³Ì¼ÆÊýÖµÊä³ö */

if (count == 20)
		{
			err = rt_thread_detach(&led0_thread);

if (err == RT_EOK)
			{
				rt_kprintf("thread led0 detached ok! ");
			}
			else
			{
				rt_kprintf("thread led0 detached error! ");
			}
		}
 }
}
 
int main(void)
{
 // ´´½¨¾²Ì¬Ïß³Ì
 rt_thread_init(&led0_thread, //Ïß³Ì¿ØÖÆ¿é
 "led0", //Ïß³ÌÃû×Ö£¬ÔÚshellÀïÃæ¿ÉÒÔ¿´µ½
 led0_thread_entry, //Ïß³ÌÈë¿Úº¯Êý
 RT_NULL, //Ïß³ÌÈë¿Úº¯Êý²ÎÊý
 &rt_led0_thread_stack[0], //Ïß³ÌÕ»ÆðÊ¼µØÖ·
 sizeof(rt_led0_thread_stack), //Ïß³ÌÕ»´óÐ¡
 3, //Ïß³ÌµÄÓÅÏÈ¼¶
 20); //Ïß³ÌÊ±¼äÆ¬
 
 rt_thread_startup(&led0_thread); //Æô¶¯Ïß³Ìled0_thread£¬¿ªÆôµ÷¶È
									 
 // ´´½¨¾²Ì¬Ïß³Ì 
	rt_thread_init(&led1_thread, //Ïß³Ì¿ØÖÆ¿é
				 "led1", //Ïß³ÌÃû×Ö£¬ÔÚshellÀïÃæ¿ÉÒÔ¿´µ½
				 led1_thread_entry, //Ïß³ÌÈë¿Úº¯Êý
				 RT_NULL, //Ïß³ÌÈë¿Úº¯Êý²ÎÊý
				 &rt_led1_thread_stack[0], //Ïß³ÌÕ»ÆðÊ¼µØÖ·
				 sizeof(rt_led1_thread_stack), //Ïß³ÌÕ»´óÐ¡
				 3, //Ïß³ÌµÄÓÅÏÈ¼¶
				 20); 
 
 rt_thread_startup(&led1_thread); //Æô¶¯Ïß³Ìled1_thread£¬¿ªÆôµ÷¶È
 
}```

```static rt_thread_t tid1 = RT_NULL, tid2 = RT_NULL;

/* Ïß³Ì1µÄÈë¿Úº¯Êý */
static void thread1_entry(void* parameter)
{
	rt_uint32_t count = 0;
	while (1)
	{
		/* Ïß³Ì1²ÉÓÃµÍÓÅÏÈ¼¶ÔËÐÐ£¬Ò»Ö±´òÓ¡¼ÆÊýÖµ */
		rt_kprintf("thread1 count: %d ", count ++);
		rt_thread_delay(20);
	}
}

/* Ïß³Ì2µÄÈë¿Úº¯Êý */
static void thread2_entry(void* parameter)
{
	rt_err_t rt_err;

/* Ïß³Ì2ÓµÓÐ½Ï¸ßµÄÓÅÏÈ¼¶£¬ÒÔÇÀÕ¼Ïß³Ì1¶ø»ñµÃÖ´ÐÐ */
	/* Ïß³Ì2Æô¶¯ºóÏÈË¯Ãß10¸öOS Tick */
	rt_thread_delay(10);
	/*
	* Ïß³Ì2»½ÐÑºóÖ±½ÓÉ¾³ýÏß³Ì1£¬É¾³ýÏß³Ì1ºó£¬Ïß³Ì1×Ô¶¯ÍÑÀë¾ÍÐ÷Ïß³Ì
	* ¶ÓÁÐ
	*/
	rt_err=rt_thread_delete(tid1);
	if(rt_err!=RT_EOK)
	{
		rt_kprintf(" thread1 delete failed! ");
	}
	else
	{
		rt_kprintf(" thread1 delete successed! ");
	}
	tid1 = RT_NULL;
	/*
	* Ïß³Ì2¼ÌÐøÐÝÃß100¸öOS TickÈ»ºóÍË³ö£¬Ïß³Ì2ÐÝÃßºóÓ¦ÇÐ»»µ½idleÏß³Ì
	* idleÏß³Ì½«Ö´ÐÐÕæÕýµÄÏß³Ì1¿ØÖÆ¿éºÍÏß³ÌÕ»µÄÉ¾³ý
	*/
	rt_thread_delay(100);
	/*
	* Ïß³Ì2ÔËÐÐ½áÊøºóÒ²½«×Ô¶¯±»É¾³ý(Ïß³Ì¿ØÖÆ¿éºÍÏß³ÌÕ»ÒÀÈ»ÔÚidleÏß
	* ³ÌÖÐÊÍ·Å)
	*/
	tid2 = RT_NULL;
}

int main()
{
	//´´½¨Ïß³Ì1 
    tid1 = rt_thread_create("t1", //Ïß³Ì1µÄÃû³ÆÊÇt1 
							thread1_entry, RT_NULL, //Èë¿ÚÊÇthread1_entry£¬²ÎÊýÊÇRT_NULL 
							512, //Ïß³Ì¶ÑÕ»´óÐ¡
							2, //Ïß³ÌÓÅÏÈ¼¶
							20);//Ê±¼äÆ¬tick

if (tid1 != RT_NULL) //Èç¹û»ñµÃÏß³Ì¿ØÖÆ¿é£¬Æô¶¯Õâ¸öÏß³Ì
			rt_thread_startup(tid1);
	else
			rt_kprintf("create thread 1 failed! ");
		
	//´´½¨Ïß³Ì2
	tid2 = rt_thread_create("t2", //Ïß³Ì1µÄÃû³ÆÊÇt2 
							thread2_entry, RT_NULL, //Èë¿ÚÊÇthread2_entry£¬²ÎÊýÊÇRT_NULL 
							512, //Ïß³Ì¶ÑÕ»´óÐ¡
							1, //Ïß³ÌÓÅÏÈ¼¶
							20);//Ê±¼äÆ¬tick
	
	if (tid2 != RT_NULL) // Èç¹û»ñµÃÏß³Ì¿ØÖÆ¿é£¬Æô¶¯Õâ¸öÏß³Ì 
			rt_thread_startup(tid2);
	else
			rt_kprintf("create thread 2 failed! ");
	
	return 0;
}```

第四天：空闲任务及其钩子函数
1、空闲任务的作用：
       CPU是不可能停下来的，它是要一直工作的，没事做的时候就执行空闲任务
2、空闲任务的优先级：
       空闲任务的优先级是最低的，最简单的任务都要有堆栈
3、空闲任务的钩子函数：
       就是在空闲的时候顺便干点啥（我们的例子是算出CPU的占用率）
          /* set idle thread hook */
          rt_thread_idle_sethook(cpu_usage_idle_hook);
4、CPU使用率统计的实现原理
     CPU使用率=100-CPU空闲率
    
      rt_enter_critical();进入临界区
                                                     这二个函数之间是临界区，独享CPU
      rt_exit_critical();退出临界区
 
      对时间要求特别严格的时候会使用到这个。
      进入临界区的时候，高速操作系统，不要奇幻任务了，100%干这个事情，临界区的内容不希望被中断
      
      count++没有存放在临界区中，只有在空闲的时候才会++，所以他就是空闲率

系统的时钟频率修改，会对CPU的使用率有影响