NXP S32K146 FREERTOS信号量分析

最新推荐文章于 2023-12-21 23:29:30 发布
最新推荐文章于 2023-12-21 23:29:30 发布
阅读量544 收藏 1
点赞数 1
分类专栏： NXP S32K1 文章标签： 单片机 stm32 arm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/woshinibaba321/article/details/122258154
版权

分析一下原工程中使用FREERTOS的流程，在hal层运行系统freertos，hw层用任务链表+定时器，hal层生成.a库文件给上层hw调用
贴上部分源码分析

  1. 首先是计数型信号量的创建
//uart相关结构体
typedef struct
{  
//########略
    void* rb_tx_sem;                /* 消息发送信号量 */
} hal_uart_contex_t;
hal_uart_contex_t* ctx;

//Log函数之前分析了
#define FAIL_RETURN_GOTO(f, label) do { \
    if (!(f)) {\
        LOGW("failed(%s)", #f); \
        goto label; \
    } \
} while(0)

//hal_uart_open函数调用下边
 FAIL_RETURN_GOTO((ctx->rb_tx_sem = os_sem_create(0)) != NULL, __end);//返回一个句柄是否创建信号量成功，不成功goto label
 
 //封装了一下
 void* os_sem_create(INT8U init_value)
{
    return xSemaphoreCreateCounting(255, init_value);
}

//semphr.h声明
#define xSemaphoreCreateCounting( uxMaxCount, uxInitialCount ) 
xQueueCreateCountingSemaphore( ( uxMaxCount ), ( uxInitialCount )

//queue.c实现
//参数 uxMaxCount： 计数信号量最大计数值，当信号量值等于此值的时候释放信号量就会失败。
//参数 uxInitialCount： 计数信号量初始值。
	QueueHandle_t xQueueCreateCountingSemaphore( const \UBaseType_t uxMaxCount, 
	const UBaseType_t uxInitialCount )
	{
	QueueHandle_t xHandle;
	configASSERT( uxMaxCount != 0 );
	configASSERT( uxInitialCount <= uxMaxCount );
//创建了一个计数型信号量
	xHandle = xQueueGenericCreate( uxMaxCount, queueSEMAPHORE_QUEUE_ITEM_LENGTH, queueQUEUE_TYPE_COUNTING_SEMAPHORE);
//将计数信号量的初始值来设置uxMessagesWaiting
		if( xHandle != NULL )
		{
			( ( Queue_t * ) xHandle )->uxMessagesWaiting = uxInitialCount;
			traceCREATE_COUNTING_SEMAPHORE();
		}
		else
		{
			traceCREATE_COUNTING_SEMAPHORE_FAILED();
		}
		return xHandle;
	}
	
//通用队列创建函数
//参数uxQueueLength：队列项数目
//参数uxItemSize：每个队列项的大小
//参数ucQueueType：类型
	QueueHandle_t xQueueGenericCreate( const UBaseType_t uxQueueLength, \
	const UBaseType_t uxItemSize, const uint8_t ucQueueType )
	{
	Queue_t *pxNewQueue;
	size_t xQueueSizeInBytes;
	uint8_t *pucQueueStorage;
//断言判断一下队列长度是否大于0
		configASSERT( uxQueueLength > ( UBaseType_t ) 0 );
		if( uxItemSize == ( UBaseType_t ) 0 )
		{
		    //队列项为0即没有为队列项申请空间
			xQueueSizeInBytes = ( size_t ) 0;
		}
		else
		{
		    //为最大队列长度的队列项分配内存空间 长度*队列项
			xQueueSizeInBytes = ( size_t ) ( uxQueueLength * uxItemSize ); 
		}
       //分配队列结构体和队列项存储空间
		pxNewQueue = ( Queue_t * ) pvPortMalloc( sizeof( Queue_t ) + xQueueSizeInBytes );
		if( pxNewQueue != NULL )
		{
			/* 跳过队列结构，查找队列存储区域的位置. */
			pucQueueStorage = ( ( uint8_t * ) pxNewQueue ) + sizeof( Queue_t );
			#if( configSUPPORT_STATIC_ALLOCATION == 1 )
			{
				/* 队列既可以静态创建，也可以动态创建，因此请注意此任务是动态创建的，以防稍后删除。 . */
				pxNewQueue->ucStaticallyAllocated = pdFALSE;
			}
			#endif 
              //prvInitialiseNewQueue实现pcHead初始化uxLength/uxItemSize初始化
              //uxItemSize为0只需将phead设置为在内存映射中已知的一个良性值来指向队列  
			prvInitialiseNewQueue( uxQueueLength, uxItemSize, pucQueueStorage, ucQueueType, pxNewQueue );
		}
		else
		{
			traceQUEUE_CREATE_FAILED( ucQueueType );
		}
		return pxNewQueue;
	}
//到这我对于计数型信号量的理解就是，我创建一个队列但是不为队列项分配内存空间
//只为结构体分配内存空间，因为要用到Queue_t 结构体的成员uxMessagesWaiting作为计数，结构体的 phead也不能指向NULL因为互斥信号量要用到NULL，指向了队列结构体本身。
  1. 其次是互斥型信号量的创建
//创建互斥信号量的实现
	QueueHandle_t xQueueCreateMutex( const uint8_t ucQueueType )
	{
	//和计数型型号量的区别就是少了两句断言
	Queue_t *pxNewQueue;
	//区别在于互斥信号量的长度为1
	const UBaseType_t uxMutexLength = ( UBaseType_t ) 1, uxMutexSize = ( UBaseType_t ) 0;
		pxNewQueue = ( Queue_t * ) xQueueGenericCreate( uxMutexLength, uxMutexSize, ucQueueType );
		//区别在于这个函数实现用于入队操作
		prvInitialiseMutex( pxNewQueue );
		return pxNewQueue;
	}
  1. 然后是计数信号量的其他处理
//根据架构在HW层的调用的发送接口
BOOLEAN hal_uart_write(UART_CH_E ch, INT8U* pdata, INT16U len)
{
    INT32S left = len;
    hal_uart_contex_t* ctx;
    //tx_mutex上锁
    ASSERT(os_mutex_lock(ctx->tx_mutex, 10000) == TRUE);
    while (left > 0 )
    {
        //rb_tx_mutex上锁
        ASSERT(os_mutex_lock(ctx->rb_tx_mutex, 1000) == TRUE);
        if (!ringbuf_is_full(ctx->rb_tx))
        {
            //环形队列写入
            len = ringbuf_write(ctx->rb_tx, pdata, MIN(ringbuf_free_size(ctx->rb_tx), left));
            if (len > 0)
            {
                left -= len;
                pdata += len;
            }
            //解锁rb_tx_mutex
            os_mutex_unlock(ctx->rb_tx_mutex);
            os_sem_post(ctx->rb_tx_sem);
        }
        else
        {
            os_mutex_unlock(ctx->rb_tx_mutex);
            os_sem_post(ctx->rb_tx_sem);
            os_task_sleep(2);
        }
    }
    //tx_mutex解锁
    os_mutex_unlock(ctx->tx_mutex);
}

//hal层封装
BOOLEAN os_sem_post(void* hdl)
{
    ASSERT(hdl != NULL);
    return xSemaphoreGive(hdl) == pdFALSE ? FALSE : TRUE;
}

//声明宏定义
#define xSemaphoreGive( xSemaphore )		xQueueGenericSend( ( QueueHandle_t ) ( xSemaphore ), NULL, semGIVE_BLOCK_TIME, queueSEND_TO_BACK )

//xQueueGenericSend函数实现   
//这个函数用于入队操作，绝不可以用在中断服务程序中

BaseType_t xQueueGenericSend( QueueHandle_t xQueue, const void * const pvItemToQueue, TickType_t xTicksToWait, const BaseType_t xCopyPosition )
{
BaseType_t xEntryTimeSet = pdFALSE, xYieldRequired;
TimeOut_t xTimeOut;
Queue_t * const pxQueue = ( Queue_t * ) xQueue;
//三个断言根据函数封装来判断
	configASSERT( pxQueue );
	configASSERT( !( ( pvItemToQueue == NULL ) && ( pxQueue->uxItemSize != ( UBaseType_t ) 0U ) ) );
	configASSERT( !( ( xCopyPosition == queueOVERWRITE ) && ( pxQueue->uxLength != 1 ) ) );
	#if ( ( INCLUDE_xTaskGetSchedulerState == 1 ) || ( configUSE_TIMERS == 1 ) )
	{
		configASSERT( !( ( xTaskGetSchedulerState() == taskSCHEDULER_SUSPENDED ) && ( xTicksToWait != 0 ) ) );
	}
	#endif

	for( ;; )
	{
		taskENTER_CRITICAL();
		{
//队列还有空闲?正在运行的任务一定要比等待访问队列的任务优先级高.
//如果使用覆盖式入队,则不需要关注队列是否满
			if( ( pxQueue->uxMessagesWaiting < pxQueue->uxLength ) || ( xCopyPosition == queueOVERWRITE ) )
			{
				traceQUEUE_SEND( pxQueue );
///*完成数据拷贝工作,分为从队列尾入队,从队列首入队和覆盖式入队*/
				xYieldRequired = prvCopyDataToQueue( pxQueue, pvItemToQueue, xCopyPosition );
//注 prvCopyDataToQueue 实现
//第一种是队列项大小为0时（即队列结构体成员uxItemSize为0，
//比如二进制信号量和计数信号量），不进行数据拷贝工作，
//而是将队列项计数器加1（即队列结构体成员uxMessagesWaiting+=1）
				#if ( configUSE_QUEUE_SETS == 1 )
				{
					if( pxQueue->pxQueueSetContainer != NULL )
					{
						if( prvNotifyQueueSetContainer( pxQueue, xCopyPosition ) != pdFALSE )
						{
							queueYIELD_IF_USING_PREEMPTION();
						}
						else
						{
							mtCOVERAGE_TEST_MARKER();
						}
					}
					else
					{
/* 如果有任务在此等待队列数据到来,则将该任务解除阻塞*/
						if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToReceive ) ) == pdFALSE )
						{
/*有任务因等待出队而阻塞,则将任务从队列等待接收列表中删除,
然后加入到就绪列表*/
							if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToReceive ) ) != pdFALSE )
							{
/* 解除阻塞的任务有更高的优先级,则当前任务要让出CPU,因此触发一个上下文切换.又因为现在还在临界区,
要等退出临界区后,才会执行上下文切换.*/
								queueYIELD_IF_USING_PREEMPTION();
							}
							else
							{
								mtCOVERAGE_TEST_MARKER();
							}
						}
						else if( xYieldRequired != pdFALSE )
						{
							queueYIELD_IF_USING_PREEMPTION();
						}
						else
						{
							mtCOVERAGE_TEST_MARKER();
						}
					}
				}
				#else /* configUSE_QUEUE_SETS */
				{
					if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToReceive ) ) == pdFALSE )
					{
						if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToReceive ) ) != pdFALSE )
						{
							queueYIELD_IF_USING_PREEMPTION();
						}
						else
						{
							mtCOVERAGE_TEST_MARKER();
						}
					}
					else if( xYieldRequired != pdFALSE )
					{
						queueYIELD_IF_USING_PREEMPTION();
					}
					else
					{
						mtCOVERAGE_TEST_MARKER();
					}
				}
				#endif /* configUSE_QUEUE_SETS */

				taskEXIT_CRITICAL();
				return pdPASS;
			}
			else
			{
				if( xTicksToWait == ( TickType_t ) 0 )
				{
					taskEXIT_CRITICAL();
					traceQUEUE_SEND_FAILED( pxQueue );
					return errQUEUE_FULL;
				}
				else if( xEntryTimeSet == pdFALSE )
				{
					vTaskInternalSetTimeOutState( &xTimeOut );
					xEntryTimeSet = pdTRUE;
				}
				else
				{
					mtCOVERAGE_TEST_MARKER();
				}
			}
		}
		taskEXIT_CRITICAL();
		vTaskSuspendAll();
		prvLockQueue( pxQueue );
		if( xTaskCheckForTimeOut( &xTimeOut, &xTicksToWait ) == pdFALSE )
		{
			if( prvIsQueueFull( pxQueue ) != pdFALSE )
			{
				traceBLOCKING_ON_QUEUE_SEND( pxQueue );
				vTaskPlaceOnEventList( &( pxQueue->xTasksWaitingToSend ), xTicksToWait );
				prvUnlockQueue( pxQueue );
				if( xTaskResumeAll() == pdFALSE )
				{
					portYIELD_WITHIN_API();
				}
			}
			else
			{
				/* Try again. */
				prvUnlockQueue( pxQueue );
				( void ) xTaskResumeAll();
			}
		}
		else
		{
			/* The timeout has expired. */
			prvUnlockQueue( pxQueue );
			( void ) xTaskResumeAll();

			traceQUEUE_SEND_FAILED( pxQueue );
			return errQUEUE_FULL;
		}
	}
}

有关于xQueueGenericSend这个函数的具体分析请参考

//freertos创建的UART发送任务（部分）
 if (os_sem_wait(ctx->rb_tx_sem, HAL_UART_TX_WAIT_TIMEOUT))
 {
            ASSERT(os_mutex_lock(ctx->rb_tx_mutex, 1000) == TRUE);
            //略 发送处理！！！！
            os_mutex_unlock(ctx->rb_tx_mutex);
 }
//封装
BOOLEAN os_sem_wait(void* hdl, INT16U waitms)
{
    ASSERT(hdl != NULL);
    return xSemaphoreTake(hdl, waitms / portTICK_PERIOD_MS) == pdFALSE ? FALSE : TRUE;
}
//宏定义声明
#define xSemaphoreTake( xSemaphore, xBlockTime )		xQueueSemaphoreTake( ( xSemaphore ), ( xBlockTime ) )

//函数实现
//xQueueSemaphoreTake实现
BaseType_t xQueueSemaphoreTake( QueueHandle_t xQueue, TickType_t xTicksToWait )
{
BaseType_t xEntryTimeSet = pdFALSE;
TimeOut_t xTimeOut;
Queue_t * const pxQueue = ( Queue_t * ) xQueue;

#if( configUSE_MUTEXES == 1 )
	BaseType_t xInheritanceOccurred = pdFALSE;
#endif

	configASSERT( ( pxQueue ) );
	configASSERT( pxQueue->uxItemSize == 0 );
	#if ( ( INCLUDE_xTaskGetSchedulerState == 1 ) || ( configUSE_TIMERS == 1 ) )
	{
		configASSERT( !( ( xTaskGetSchedulerState() == taskSCHEDULER_SUSPENDED ) && ( xTicksToWait != 0 ) ) );
	}
	#endif
	for( ;; )
	{
		taskENTER_CRITICAL();
		{
		    //计数赋值
			const UBaseType_t uxSemaphoreCount = pxQueue->uxMessagesWaiting;
			//判断是否有计数
			if( uxSemaphoreCount > ( UBaseType_t ) 0 )
			{
				traceQUEUE_RECEIVE( pxQueue );
			//拿走减与上边计数器加1对应
				pxQueue->uxMessagesWaiting = uxSemaphoreCount - ( UBaseType_t ) 1;
				#if ( configUSE_MUTEXES == 1 )
				{
					if( pxQueue->uxQueueType == queueQUEUE_IS_MUTEX )
					{
						pxQueue->pxMutexHolder = ( int8_t * ) pvTaskIncrementMutexHeldCount();
					}
					else
					{
						mtCOVERAGE_TEST_MARKER();
					}
				}
				#endif /* configUSE_MUTEXES */
				if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToSend ) ) == pdFALSE )
				{
					if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToSend ) ) != pdFALSE )
					{
						queueYIELD_IF_USING_PREEMPTION();
					}
					else
					{
						mtCOVERAGE_TEST_MARKER();
					}
				}
				else
				{
					mtCOVERAGE_TEST_MARKER();
				}

				taskEXIT_CRITICAL();
				return pdPASS;
			}
			else//计数器没值判断是否有阻塞时间
			{
				if( xTicksToWait == ( TickType_t ) 0 )
				{
					#if( configUSE_MUTEXES == 1 )
					{
						configASSERT( xInheritanceOccurred == pdFALSE );
					}
					#endif /* configUSE_MUTEXES */
					taskEXIT_CRITICAL();
					traceQUEUE_RECEIVE_FAILED( pxQueue );
					return errQUEUE_EMPTY;
				}
				else if( xEntryTimeSet == pdFALSE )
				{
					vTaskInternalSetTimeOutState( &xTimeOut );
					xEntryTimeSet = pdTRUE;
				}
				else
				{
					/* Entry time was already set. */
					mtCOVERAGE_TEST_MARKER();
				}
			}
		}
		taskEXIT_CRITICAL();
		vTaskSuspendAll();
		prvLockQueue( pxQueue );

		/* Update the timeout state to see if it has expired yet. */
		if( xTaskCheckForTimeOut( &xTimeOut, &xTicksToWait ) == pdFALSE )
		{
			if( prvIsQueueEmpty( pxQueue ) != pdFALSE )
			{
				traceBLOCKING_ON_QUEUE_RECEIVE( pxQueue );

				#if ( configUSE_MUTEXES == 1 )
				{
					if( pxQueue->uxQueueType == queueQUEUE_IS_MUTEX )
					{
						taskENTER_CRITICAL();
						{
							xInheritanceOccurred = xTaskPriorityInherit( ( void * ) pxQueue->pxMutexHolder );
						}
						taskEXIT_CRITICAL();
					}
					else
					{
						mtCOVERAGE_TEST_MARKER();
					}
				}
				#endif

				vTaskPlaceOnEventList( &( pxQueue->xTasksWaitingToReceive ), xTicksToWait );
				prvUnlockQueue( pxQueue );
				if( xTaskResumeAll() == pdFALSE )
				{
					portYIELD_WITHIN_API();
				}
				else
				{
					mtCOVERAGE_TEST_MARKER();
				}
			}
			else
			{
				prvUnlockQueue( pxQueue );
				( void ) xTaskResumeAll();
			}
		}
		else
		{
			/* Timed out. */
			prvUnlockQueue( pxQueue );
			( void ) xTaskResumeAll();
			if( prvIsQueueEmpty( pxQueue ) != pdFALSE )
			{
				#if ( configUSE_MUTEXES == 1 )
				{
					if( xInheritanceOccurred != pdFALSE )
					{
						taskENTER_CRITICAL();
						{
							UBaseType_t uxHighestWaitingPriority;
							uxHighestWaitingPriority = prvGetDisinheritPriorityAfterTimeout( pxQueue );
							vTaskPriorityDisinheritAfterTimeout( ( void * ) pxQueue->pxMutexHolder, uxHighestWaitingPriority );
						}
						taskEXIT_CRITICAL();
					}
				}
				#endif /* configUSE_MUTEXES */

				traceQUEUE_RECEIVE_FAILED( pxQueue );
				return errQUEUE_EMPTY;
			}
			else
			{
				mtCOVERAGE_TEST_MARKER();
			}
		}
	}
}

有关于xQueueSemaphoreTake这个函数的具体分析请参考
总结：
一、通过函数 xQueueCreateCountingSemaphore()建队列，uxMessagesWaiting =初始值。（先初始化计数信号量）
二、函数中通过函数 xQueueGenericSend()释放信号量，因此信号量（uxMessagesWaiting +=1)变为有效。
三、任务 Task 通过函数 xQueueSemaphoreTake()获取信号量，但是当计数信号量无效时(uxMessagesWaiting =0)，任务 Task 进入阻塞态。当计数信号量有效时(uxMessagesWaiting >0)，任务 Task 获取信号量成功，任务从阻塞态解除，开始执行相关的处理过程（即发送循环队列buf）。

nininiccccc
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
S32K144 AUTOSAR RTD2.0.0 使用FreeRTOS指南 cpu clock =0 解决方案
aiamia的博客
06-21 249
我最开始是先下载了2.0.0-D2308的版本，安装后发现没有例程，于是我自己添加freertos的组件，这时问题出现了，cpu clock =0，继续运行发现任务只能运行一次，解决方案手动修改FreeRTOSConfig.h--->#define configCPU_CLOCK_HZ ( 48000000UL ),这时可以正常运行。安装1.0.1-D2205,安装后神奇的事情发生了，D2308的例程出现了，现在我明白了，NXP把这几个版本放上去都是有其含义的，也许是弄巧成拙吧。
s32k_freertos_test1.zip
12-06
S32K148的FreeRTOS工程, 使用S32 Design Studio for ARM, SDK3.0, PE配置, 创建两个任务. 详见我的博客: FreeRTOS S32K148
S32K144 FreeRTOSConfig.h
10-03
该文件为S32K144的FreeRTOSConfig.h，主要是关于S32K144的FreeRTOS的配置内容，搭配https://blog.csdn.net/q921374795/article/details/82921601 教程使用
S32K144_FreeRTOS_Fatfs
10-31
S32K144 外设测试程序, 移植了FreeRTOS和Fatfs,支持3路UART和3路CAN接口,以及通过SPI读取SD卡文件系统.
基于S32K144芯片移植的FreeRTOS
07-01
参考我的文章： https://blog.csdn.net/weixin_42814402/article/details/125471634?spm=1001.2014.3001.5502 不懂的可以在文章下留言 基于S32K144芯片移植的FreeRTOS，创建了几个os task，示例代码工程。
S32K+FreeRTOS学习笔记.pdf
03-18
该问主要是FreeRTOS使用过程中的学习笔记。是FreeRTOS的核心要点提取。
基于S32K144移植的FreeRTOS工程，可直接编译运行调试，板子基于品智科技的S32K144开发板，兼容S32K144官方
06-01
在本文中，我们将深入探讨如何基于NXP的S32K144微控制器移植并运行FreeRTOS操作系统。S32K144是一款高性能、低功耗的微控制器，常用于汽车电子、工业控制以及物联网应用。FreeRTOS则是一个轻量级、实时操作系统...
基于freertos的S32K144
10-17
标题 "基于FreeRTOS的S32K144" 暗示了本文将深入探讨如何在NXP的S32K144微控制器上使用FreeRTOS操作系统。FreeRTOS是一个实时操作系统（RTOS），适用于小型嵌入式系统，提供任务调度、同步、内存管理等核心功能，以...
S32K144_MDK_Projet1_Freertos LED.zip_S32K144 Freertos_S32K144 KE
07-14
通过对项目代码的分析和学习，我们可以掌握FreeRTOS的使用方法，提升在嵌入式系统中的实时操作能力，同时也能加深对S32K144硬件特性的理解。对于想要在嵌入式领域特别是汽车电子方面发展的工程师来说，这样的实践...
S32K144芯片基于FreeRTOS的I2C
11-20
在实际应用中，开发者需要了解FreeRTOS的任务调度机制，如何编写中断服务程序，以及如何利用FreeRTOS的同步机制（如信号量、互斥锁）来保护共享资源，避免在并发环境中出现数据竞争问题。同时，对S32K144的硬件特性...
s32ds 路径_S32DS中使用SystemView分析FreeRTOS
weixin_39653717的博客
01-17 815
S32K144作为NXP推出车规级ARM Cortex M4内核MCU，在很多领域开始被广泛的应用，在其开发过程中，官方支持的S32 Design Studio IDE开发工具可以免费使用，并且集成了ProcessorExpert ，可以很方便的初始化外设并生成驱动。FreeRTOS作为免费的RTOS应用更是广泛，那么在S32DS中开发使用FreeRTOS的项目，很多情况下需要对OS的运行情况进行...
S32K144芯片基于FreeRTOS的低功耗
11-20
S32K144芯片基于FreeRTOS的低功耗，有问题可以联系我。
S32K144芯片基于FreeRTOS的SPI通信
11-20
S32K144芯片基于FreeRTOS的SPI通信，有问题可以联系我
S32K144在FreeRTOS下串口输出
09-12
S32K144在FreeRTOS下串口输出，依赖本地库文件，需要在工作空间内打开编译
268_S32K144_FreeRTOS的队列
小灰笔记
02-22 1333
完整的S32K144的学习汇总如下： https://github.com/GreyZhang/g_s32k144 继续学习S32K144，结合这个芯片学习一下FreeRTOS的实际应用。这一次，我想先学习一下队列的应用。 按照文档的解读，这个队列其实确实是有着一个先后关系的意思。但是，这个队列的作用更多的是一个消息传递。今天，我需要做的工作如下： 使能FreeRTOS中的...
S32K在FreeRTOS下的外设中断设置
2hi9uo的博客
03-28 2094
在调用外设blocking数据传输接口时（比如LPSPI_DRV_MasterTransferBlocking），需要在外设中断产生时调用操作系统的信号量接口来传递传输状态，这里面其实存在一个中断优先级的问题。
【S32DS RTD实战】-1.4-基于S32K3创建配置FreeRTOS工程-控制GPIO点亮LED
最新发布
「汽车电子助手」的博客
12-21 3391
【S32DS RTD实战】-1.4-基于S32K3创建配置FreeRTOS工程-控制GPIO点亮LED
NXP S32K144学习系列3----基于FreeRTOS进行多个ms级任务的创建
weixin_42814402的博客
06-26 3865
FreeRTOS的集成以及一些横展知识的介绍
NXP S32K
weixin_30699831的博客
10-11 4035
S32K144是NXP推出的基于ARM Cortex-M4F内核的汽车级通用MCU系列S32K1xx的第一颗高性能单片机。 本文首先简要介绍S32K系列MCU的内核和片上资源信息，然后列出S32K软件开发和硬件设计FAQ，供大家参考。 一、 S32K系列MCU概览 S32K1xx是S32K系列MCU的第一代产品，其中S32K11x系列的内核...
NXP S32K系列MCU应用开发指南
"本文档是关于NXP S32K系列微控制器的详细应用开发指南，由资深应用工程师胡恩伟编写，包含了S32K系列的介绍、内核和外设使用、硬件设计要点、软件开发工具以及常见问题解答。文档提供了完整的目录，适合智能车赛和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值