#include "sr_sunrise.h"

static osMutexId_t mutexId;
static int gNumber = 0;

#ifdef SR_USE_OS
/*************OS环境写法*******************/
static SR_THD_RET MutexThread1(void *argv)
{
	int result = 0;

	/*创建互斥量*/
	osMutexAttr_t mutexAttr = {
		"mutex1",
		osMutexRecursive, // 支持递归，同一线程可多次获取释放
		SR_NULL,		  // memory for control block，SR_NULL动态创建
		0U				  // size for control block
	};

	mutexId = osMutexNew(&mutexAttr);
	if (mutexId == SR_NULL) goto _EXIT;
	SR_LOG(INFO, "thd1:mutex creat ok\r\n");

	while (gShellThreadRun)
	{
		// 获取互斥量
		result = osMutexAcquire(mutexId, osWaitForever);
		SR_LOG(INFO, "thd1:mutex lock,result=%d\r\n", result);

		// 修改共享变量
		if (result == 0) gNumber++;

		// 占用互斥量一段时间
		osDelay(2000);

		// 释放互斥量
		result = osMutexRelease(mutexId);
		SR_LOG(INFO, "thd1:mutex unlock,result=%d\r\n", result);

		osDelay(10);
	}

_EXIT:
	SR_LOG(INFO, "thd1 exit\r\n");
	if (SR_NULL != mutexId) osMutexDelete(mutexId); // 删除
	osThreadExit();	// 退出线程
}

static SR_THD_RET MutexThread2(void *argv)
{
	int result = 0;

	osDelay(200); // 等待线程1先运行

	while (gShellThreadRun)
	{
		// 获取互斥量
		result = osMutexAcquire(mutexId, osWaitForever);
		SR_LOG(INFO, "thd2:mutex get lock,result=%d\r\n", result);

		SR_LOG(INFO, "thd2: gNumber=%d\r\n", gNumber);

		// 释放互斥量
		result = osMutexRelease(mutexId);
		SR_LOG(INFO, "thd2:mutex release,result=%d\r\n", result);

		osDelay(100);
	}

_EXIT:
	SR_LOG(INFO, "thd2 exit\r\n");
	osThreadExit(); // 退出线程
}
#else

static SR_THD_RET MutexThread1(void *argv)
{
	int result = 0;

	SR_GET_CT(); // 获取当前上下文
	SR_CT_BEGIN();			   // 上下文环境起始

	/*创建互斥量*/
	osMutexAttr_t mutexAttr = {
		"mutex1",
		osMutexRecursive, // 支持递归，同一线程可多次获取释放
		SR_NULL,		  // memory for control block，SR_NULL动态创建
		0U				  // size for control block
	};

	mutexId = osMutexNew(&mutexAttr);
	if (mutexId == SR_NULL) goto _EXIT;
	SR_LOG(INFO, "thd1:mutex creat ok\r\n");

	while (gShellThreadRun)
	{
		// 获取互斥量
		osMutexAcquire(mutexId, osWaitForever);  // 注：这是一个宏，无法直接获取返回值
		result = SR_CT_GET_RET();  // 使用该宏获取上个函数的返回值
		SR_LOG(INFO, "thd1:mutex lock,result=%d\r\n\r\n", result);

		// 修改共享变量
		if (result == 0)  gNumber++;

		// 占用互斥量一段时间
		osDelay(2000);

		// 释放互斥量
		result = osMutexRelease(mutexId);
		SR_LOG(INFO, "thd1:mutex unlock,result=%d\r\n", result);

		osDelay(10);
	}

_EXIT:
	SR_LOG(INFO, "thd1 exit\r\n");
	if (SR_NULL != mutexId) osMutexDelete(mutexId); // 删除
	osThreadExit();				// 退出线程

	SR_CT_END(); // 上下文环境结束
}

static SR_THD_RET MutexThread2(void *argv)
{
	int result = 0;

	SR_GET_CT(); // 获取当前上下文
	SR_CT_BEGIN();			   // 上下文环境起始

	osDelay(200); // 等待线程1先运行

	while (gShellThreadRun)
	{
		// 获取互斥量
		osMutexAcquire(mutexId, osWaitForever);  // 注：这是一个宏，无法直接获取返回值
		result = SR_CT_GET_RET();  // 使用该宏获取上个函数的返回值
		SR_LOG(INFO, "thd2:mutex get lock,result=%d\r\n", result);

		SR_LOG(INFO, "thd2: gNumber=%d\r\n", gNumber);

		// 释放互斥量
		result = osMutexRelease(mutexId);
		SR_LOG(INFO, "thd2:mutex release,result=%d\r\n", result);

		osDelay(100);
	}

_EXIT:
	SR_LOG(INFO, "thd2 exit\r\n");
	osThreadExit(); // 退出线程

	SR_CT_END(); // 上下文环境结束
}


#endif

static int MutexExample(int argc, char *argv[])
{
	gShellThreadRun = 1;

	// 创建线程
	osThreadNew(MutexThread1, SR_NULL, SR_NULL);
	osThreadNew(MutexThread2, SR_NULL, SR_NULL);

	return 0;
}
SR_SHELL_CMD_EXPORT(mutexExmp, MutexExample);

#if 0
SR_MUTX_T srMutex=SR_NULL;
static void SrMutexThd1(void *argv)
{
   int result=0;

   /*创建互斥量*/
   srMutex = SR_OsMutexCreate();
   if (srMutex == SR_NULL)  goto _EXIT;
   SR_LOG(INFO,"thd1:mutex creat ok\r\n");

   while(gShellThreadRun)
	{
	    //获取互斥量
		result = SR_OsMutexTake(srMutex,OS_WAIT_FOREVER);
		SR_LOG(INFO,"thd1:mutex lock,result=%d\r\n",result);

		 //修改共享变量
		if(result == 0) gNumber++;	

		//占用互斥量一段时间
        SR_OsDelay(2000);

		//释放互斥量
		result = SR_OsMutexRelease(srMutex);
		SR_LOG(INFO,"thd1:mutex unlock,result=%d\r\n",result);
		
		SR_OsDelay(10);
	}


_EXIT:
	SR_LOG(INFO,"thd1 exit\r\n");
	if(SR_NULL != srMutex) SR_OsMutexDelete(srMutex);  //删除
	osThreadExit(); //退出线程

}


static void SrMutexThd2(void *argv)
{
	int result=0;

	while(gShellThreadRun)
	{
		//获取互斥量
		result = SR_OsMutexTake(srMutex,OS_WAIT_FOREVER);
		SR_LOG(INFO,"thd2:mutex get lock,result=%d\r\n",result);
			
		SR_LOG(INFO,"thd2: gNumber=%d\r\n",gNumber);
	  
		//释放互斥量
		result = SR_OsMutexRelease(srMutex);
		SR_LOG(INFO,"thd2:mutex release,result=%d\r\n",result);	

		SR_OsDelay(100);
	}

_EXIT:
	SR_LOG(INFO,"thd2 exit\r\n");
	osThreadExit(); //退出线程
}
static int SrMutexExample(int argc, char *argv[])
{
	
	gShellThreadRun =1;

	//创建线程
    osThreadNew(SrMutexThd1, SR_NULL,SR_NULL);
	osDelay(200);
	osThreadNew(SrMutexThd2, SR_NULL,SR_NULL);

	return 0;
}
SR_SHELL_CMD_EXPORT(srMutexExmp, SrMutexExample);

#endif