TI's CC3100 websocket camera demo with Arducam mini ov5642 and freertos. Should work with other M3's. Work in progress test demo.
osi_freertos.c
00001 //***************************************************************************** 00002 // osi_freertos.c 00003 // 00004 // Interface APIs for free-rtos function calls 00005 // 00006 // Copyright (C) 2014 Texas Instruments Incorporated - http://www.ti.com/ 00007 // 00008 // 00009 // Redistribution and use in source and binary forms, with or without 00010 // modification, are permitted provided that the following conditions 00011 // are met: 00012 // 00013 // Redistributions of source code must retain the above copyright 00014 // notice, this list of conditions and the following disclaimer. 00015 // 00016 // Redistributions in binary form must reproduce the above copyright 00017 // notice, this list of conditions and the following disclaimer in the 00018 // documentation and/or other materials provided with the 00019 // distribution. 00020 // 00021 // Neither the name of Texas Instruments Incorporated nor the names of 00022 // its contributors may be used to endorse or promote products derived 00023 // from this software without specific prior written permission. 00024 // 00025 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 00026 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 00027 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 00028 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 00029 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 00030 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 00031 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 00032 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 00033 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 00034 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 00035 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 00036 // 00037 //***************************************************************************** 00038 00039 00040 #include <stdio.h> 00041 #include <stdlib.h> 00042 #include <string.h> 00043 #include "FreeRTOS.h" 00044 #include "task.h" 00045 #include "semphr.h" 00046 #include "portmacro.h" 00047 #include <osi.h> 00048 00049 00050 00051 portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE; 00052 //Local function definition 00053 static void vSimpleLinkSpawnTask( void *pvParameters ); 00054 //Queue Handler 00055 xQueueHandle xSimpleLinkSpawnQueue = NULL; 00056 xTaskHandle xSimpleLinkSpawnTaskHndl = NULL; 00057 // Queue size 00058 #define slQUEUE_SIZE ( 3 ) 00059 00060 00061 00062 00063 00064 /*! 00065 \brief This function creates a sync object 00066 00067 The sync object is used for synchronization between different thread or ISR and 00068 a thread. 00069 00070 \param pSyncObj - pointer to the sync object control block 00071 00072 \return upon successful creation the function should return 0 00073 Otherwise, a negative value indicating the error code shall be returned 00074 \note 00075 \warning 00076 */ 00077 OsiReturnVal_e osi_SyncObjCreate(OsiSyncObj_t* pSyncObj) 00078 { 00079 //Check for NULL 00080 if(NULL == pSyncObj) 00081 { 00082 return OSI_INVALID_PARAMS; 00083 } 00084 xSemaphoreHandle *pl_SyncObj = (xSemaphoreHandle *)pSyncObj; 00085 00086 *pl_SyncObj = xSemaphoreCreateBinary(); 00087 00088 if((xSemaphoreHandle)(*pSyncObj) != NULL) 00089 { 00090 return OSI_OK; 00091 } 00092 else 00093 { 00094 return OSI_OPERATION_FAILED; 00095 } 00096 } 00097 00098 /*! 00099 \brief This function deletes a sync object 00100 00101 \param pSyncObj - pointer to the sync object control block 00102 00103 \return upon successful deletion the function should return 0 00104 Otherwise, a negative value indicating the error code shall be returned 00105 \note 00106 \warning 00107 */ 00108 OsiReturnVal_e osi_SyncObjDelete(OsiSyncObj_t* pSyncObj) 00109 { 00110 //Check for NULL 00111 if(NULL == pSyncObj) 00112 { 00113 return OSI_INVALID_PARAMS; 00114 } 00115 vSemaphoreDelete(*pSyncObj ); 00116 return OSI_OK; 00117 } 00118 00119 /*! 00120 \brief This function generates a sync signal for the object. 00121 00122 All suspended threads waiting on this sync object are resumed 00123 00124 \param pSyncObj - pointer to the sync object control block 00125 00126 \return upon successful signaling the function should return 0 00127 Otherwise, a negative value indicating the error code shall be returned 00128 \note the function could be called from ISR context 00129 \warning 00130 */ 00131 OsiReturnVal_e osi_SyncObjSignal(OsiSyncObj_t* pSyncObj) 00132 { 00133 //Check for NULL 00134 if(NULL == pSyncObj) 00135 { 00136 return OSI_INVALID_PARAMS; 00137 } 00138 00139 if(pdTRUE != xSemaphoreGive( *pSyncObj )) 00140 { 00141 //In case of Semaphore, you are expected to get this if multiple sem 00142 // give is called before sem take 00143 return OSI_OK; 00144 } 00145 00146 return OSI_OK; 00147 } 00148 /*! 00149 \brief This function generates a sync signal for the object 00150 from ISR context. 00151 00152 All suspended threads waiting on this sync object are resumed 00153 00154 \param pSyncObj - pointer to the sync object control block 00155 00156 \return upon successful signalling the function should return 0 00157 Otherwise, a negative value indicating the error code shall be returned 00158 \note the function is called from ISR context 00159 \warning 00160 */ 00161 OsiReturnVal_e osi_SyncObjSignalFromISR(OsiSyncObj_t* pSyncObj) 00162 { 00163 //Check for NULL 00164 if(NULL == pSyncObj) 00165 { 00166 return OSI_INVALID_PARAMS; 00167 } 00168 xHigherPriorityTaskWoken = pdFALSE; 00169 if(pdTRUE == xSemaphoreGiveFromISR( *pSyncObj, &xHigherPriorityTaskWoken )) 00170 { 00171 if( xHigherPriorityTaskWoken ) 00172 { 00173 taskYIELD (); 00174 } 00175 return OSI_OK; 00176 } 00177 else 00178 { 00179 //In case of Semaphore, you are expected to get this if multiple sem 00180 // give is called before sem take 00181 return OSI_OK; 00182 } 00183 } 00184 00185 /*! 00186 \brief This function waits for a sync signal of the specific sync object 00187 00188 \param pSyncObj - pointer to the sync object control block 00189 \param Timeout - numeric value specifies the maximum number of mSec to 00190 stay suspended while waiting for the sync signal 00191 Currently, the simple link driver uses only two values: 00192 - OSI_WAIT_FOREVER 00193 - OSI_NO_WAIT 00194 00195 \return upon successful reception of the signal within the timeout window return 0 00196 Otherwise, a negative value indicating the error code shall be returned 00197 \note 00198 \warning 00199 */ 00200 OsiReturnVal_e osi_SyncObjWait(OsiSyncObj_t* pSyncObj , OsiTime_t Timeout) 00201 { 00202 //Check for NULL 00203 if(NULL == pSyncObj) 00204 { 00205 return OSI_INVALID_PARAMS; 00206 } 00207 if(pdTRUE == xSemaphoreTake( (xSemaphoreHandle)*pSyncObj, ( portTickType )(Timeout/portTICK_RATE_MS) )) 00208 { 00209 return OSI_OK; 00210 } 00211 else 00212 { 00213 return OSI_OPERATION_FAILED; 00214 } 00215 } 00216 00217 /*! 00218 \brief This function clears a sync object 00219 00220 \param pSyncObj - pointer to the sync object control block 00221 00222 \return upon successful clearing the function should return 0 00223 Otherwise, a negative value indicating the error code shall be returned 00224 \note 00225 \warning 00226 */ 00227 OsiReturnVal_e osi_SyncObjClear(OsiSyncObj_t* pSyncObj) 00228 { 00229 //Check for NULL 00230 if(NULL == pSyncObj) 00231 { 00232 return OSI_INVALID_PARAMS; 00233 } 00234 00235 if (OSI_OK == osi_SyncObjWait(pSyncObj,0) ) 00236 { 00237 return OSI_OK; 00238 } 00239 else 00240 { 00241 return OSI_OPERATION_FAILED; 00242 } 00243 } 00244 00245 /*! 00246 \brief This function creates a locking object. 00247 00248 The locking object is used for protecting a shared resources between different 00249 threads. 00250 00251 \param pLockObj - pointer to the locking object control block 00252 00253 \return upon successful creation the function should return 0 00254 Otherwise, a negative value indicating the error code shall be returned 00255 \note 00256 \warning 00257 */ 00258 OsiReturnVal_e osi_LockObjCreate(OsiLockObj_t* pLockObj) 00259 { 00260 //Check for NULL 00261 if(NULL == pLockObj) 00262 { 00263 return OSI_INVALID_PARAMS; 00264 } 00265 *pLockObj = (OsiLockObj_t)xSemaphoreCreateMutex(); 00266 if(pLockObj != NULL) 00267 { 00268 return OSI_OK; 00269 } 00270 else 00271 { 00272 return OSI_OPERATION_FAILED; 00273 } 00274 } 00275 00276 /*! 00277 \brief This function creates a Task. 00278 00279 Creates a new Task and add it to the last of tasks that are ready to run 00280 00281 \param pEntry - pointer to the Task Function 00282 \param pcName - Task Name String 00283 \param usStackDepth - Stack Size in bytes 00284 \param pvParameters - pointer to structure to be passed to the Task Function 00285 \param uxPriority - Task Priority 00286 00287 \return upon successful creation the function should return 0 00288 Otherwise, a negative value indicating the error code shall be returned 00289 \note 00290 \warning 00291 */ 00292 OsiReturnVal_e osi_TaskCreate(P_OSI_TASK_ENTRY pEntry,const signed char * const pcName, 00293 unsigned short usStackDepth, void *pvParameters, 00294 uint32_t uxPriority,OsiTaskHandle* pTaskHandle) 00295 { 00296 if(pdPASS == xTaskCreate( pEntry, (const char *)pcName, 00297 (usStackDepth/(sizeof( portSTACK_TYPE ))), 00298 pvParameters,(unsigned portBASE_TYPE)uxPriority, 00299 (xTaskHandle*)pTaskHandle )) 00300 { 00301 return OSI_OK; 00302 } 00303 00304 return OSI_OPERATION_FAILED; 00305 } 00306 00307 00308 /*! 00309 \brief This function Deletes a Task. 00310 00311 Deletes a Task and remove it from list of running task 00312 00313 \param pTaskHandle - Task Handle 00314 00315 \note 00316 \warning 00317 */ 00318 void osi_TaskDelete(OsiTaskHandle* pTaskHandle) 00319 { 00320 vTaskDelete((xTaskHandle)*pTaskHandle); 00321 } 00322 00323 00324 00325 /*! 00326 \brief This function deletes a locking object. 00327 00328 \param pLockObj - pointer to the locking object control block 00329 00330 \return upon successful deletion the function should return 0 00331 Otherwise, a negative value indicating the error code shall be returned 00332 \note 00333 \warning 00334 */ 00335 OsiReturnVal_e osi_LockObjDelete(OsiLockObj_t* pLockObj) 00336 { 00337 vSemaphoreDelete((xSemaphoreHandle)*pLockObj ); 00338 return OSI_OK; 00339 } 00340 00341 /*! 00342 \brief This function locks a locking object. 00343 00344 All other threads that call this function before this thread calls 00345 the osi_LockObjUnlock would be suspended 00346 00347 \param pLockObj - pointer to the locking object control block 00348 \param Timeout - numeric value specifies the maximum number of mSec to 00349 stay suspended while waiting for the locking object 00350 Currently, the simple link driver uses only two values: 00351 - OSI_WAIT_FOREVER 00352 - OSI_NO_WAIT 00353 00354 00355 \return upon successful reception of the locking object the function should return 0 00356 Otherwise, a negative value indicating the error code shall be returned 00357 \note 00358 \warning 00359 */ 00360 OsiReturnVal_e osi_LockObjLock(OsiLockObj_t* pLockObj , OsiTime_t Timeout) 00361 { 00362 //Check for NULL 00363 if(NULL == pLockObj) 00364 { 00365 return OSI_INVALID_PARAMS; 00366 } 00367 //Take Semaphore 00368 if(pdTRUE == xSemaphoreTake( *pLockObj, ( portTickType ) (Timeout/portTICK_RATE_MS) )) 00369 { 00370 return OSI_OK; 00371 } 00372 else 00373 { 00374 return OSI_OPERATION_FAILED; 00375 } 00376 } 00377 00378 /*! 00379 \brief This function unlock a locking object. 00380 00381 \param pLockObj - pointer to the locking object control block 00382 00383 \return upon successful unlocking the function should return 0 00384 Otherwise, a negative value indicating the error code shall be returned 00385 \note 00386 \warning 00387 */ 00388 OsiReturnVal_e osi_LockObjUnlock(OsiLockObj_t* pLockObj) 00389 { 00390 //Check for NULL 00391 if(NULL == pLockObj) 00392 { 00393 return OSI_INVALID_PARAMS; 00394 } 00395 //Release Semaphore 00396 if(pdTRUE == xSemaphoreGive( *pLockObj )) 00397 { 00398 return OSI_OK; 00399 } 00400 else 00401 { 00402 return OSI_OPERATION_FAILED; 00403 } 00404 } 00405 00406 00407 /*! 00408 \brief This function call the pEntry callback from a different context 00409 00410 \param pEntry - pointer to the entry callback function 00411 00412 \param pValue - pointer to any type of memory structure that would be 00413 passed to pEntry callback from the execution thread. 00414 00415 \param flags - execution flags - reserved for future usage 00416 00417 \return upon successful registration of the spawn the function should return 0 00418 (the function is not blocked till the end of the execution of the function 00419 and could be returned before the execution is actually completed) 00420 Otherwise, a negative value indicating the error code shall be returned 00421 \note 00422 \warning 00423 */ 00424 00425 OsiReturnVal_e osi_Spawn(P_OSI_SPAWN_ENTRY pEntry , void* pValue , uint32_t flags) 00426 { 00427 00428 tSimpleLinkSpawnMsg Msg; 00429 Msg.pEntry = pEntry; 00430 Msg.pValue = pValue; 00431 xHigherPriorityTaskWoken = pdFALSE; 00432 00433 if(pdTRUE == xQueueSendFromISR( xSimpleLinkSpawnQueue, &Msg, &xHigherPriorityTaskWoken )) 00434 { 00435 if( xHigherPriorityTaskWoken ) 00436 { 00437 taskYIELD (); 00438 } 00439 00440 return OSI_OK; 00441 } 00442 return OSI_OPERATION_FAILED; 00443 } 00444 00445 00446 /*! 00447 \brief This is the simplelink spawn task to call SL callback from a different context 00448 00449 \param pvParameters - pointer to the task parameter 00450 00451 \return void 00452 \note 00453 \warning 00454 */ 00455 void vSimpleLinkSpawnTask(void *pvParameters) 00456 { 00457 tSimpleLinkSpawnMsg Msg; 00458 portBASE_TYPE ret=pdFAIL; 00459 00460 for(;;) 00461 { 00462 ret = xQueueReceive( xSimpleLinkSpawnQueue, &Msg, portMAX_DELAY ); 00463 if(ret == pdPASS) 00464 { 00465 Msg.pEntry(Msg.pValue); 00466 } 00467 } 00468 } 00469 00470 /*! 00471 \brief This is the API to create SL spawn task and create the SL queue 00472 00473 \param uxPriority - task priority 00474 00475 \return void 00476 \note 00477 \warning 00478 */ 00479 OsiReturnVal_e VStartSimpleLinkSpawnTask(unsigned portBASE_TYPE uxPriority) 00480 { 00481 xSimpleLinkSpawnQueue = xQueueCreate( slQUEUE_SIZE, sizeof( tSimpleLinkSpawnMsg ) ); 00482 if(0 == xSimpleLinkSpawnQueue) 00483 { 00484 return OSI_OPERATION_FAILED; 00485 } 00486 if(pdPASS == xTaskCreate( vSimpleLinkSpawnTask, /*( portCHAR * )*/ "SLSPAWN",\ 00487 (512/sizeof( portSTACK_TYPE )), NULL, uxPriority, &xSimpleLinkSpawnTaskHndl )) 00488 { 00489 return OSI_OK; 00490 } 00491 00492 return OSI_OPERATION_FAILED; 00493 } 00494 00495 /*! 00496 \brief This is the API to delete SL spawn task and delete the SL queue 00497 00498 \param none 00499 00500 \return void 00501 \note 00502 \warning 00503 */ 00504 void VDeleteSimpleLinkSpawnTask( void ) 00505 { 00506 if(0 != xSimpleLinkSpawnTaskHndl) 00507 { 00508 vTaskDelete( xSimpleLinkSpawnTaskHndl ); 00509 xSimpleLinkSpawnTaskHndl = 0; 00510 } 00511 00512 if(0 !=xSimpleLinkSpawnQueue) 00513 { 00514 vQueueDelete( xSimpleLinkSpawnQueue ); 00515 xSimpleLinkSpawnQueue = 0; 00516 } 00517 } 00518 00519 /*! 00520 \brief This function is used to create the MsgQ 00521 00522 \param pMsgQ - pointer to the message queue 00523 \param pMsgQName - msg queue name 00524 \param MsgSize - size of message on the queue 00525 \param MaxMsgs - max. number of msgs that the queue can hold 00526 00527 \return - OsiReturnVal_e 00528 \note 00529 \warning 00530 */ 00531 OsiReturnVal_e osi_MsgQCreate(OsiMsgQ_t* pMsgQ , 00532 char* pMsgQName, 00533 uint32_t MsgSize, 00534 uint32_t MaxMsgs) 00535 { 00536 //Check for NULL 00537 if(NULL == pMsgQ) 00538 { 00539 return OSI_INVALID_PARAMS; 00540 } 00541 00542 xQueueHandle handle =0; 00543 00544 //Create Queue 00545 handle = xQueueCreate( MaxMsgs, MsgSize ); 00546 if (handle==0) 00547 { 00548 return OSI_OPERATION_FAILED; 00549 } 00550 00551 *pMsgQ = (OsiMsgQ_t)handle; 00552 return OSI_OK; 00553 } 00554 /*! 00555 \brief This function is used to delete the MsgQ 00556 00557 \param pMsgQ - pointer to the message queue 00558 00559 \return - OsiReturnVal_e 00560 \note 00561 \warning 00562 */ 00563 OsiReturnVal_e osi_MsgQDelete(OsiMsgQ_t* pMsgQ) 00564 { 00565 //Check for NULL 00566 if(NULL == pMsgQ) 00567 { 00568 return OSI_INVALID_PARAMS; 00569 } 00570 vQueueDelete((xQueueHandle) *pMsgQ ); 00571 return OSI_OK; 00572 } 00573 /*! 00574 \brief This function is used to write data to the MsgQ 00575 00576 \param pMsgQ - pointer to the message queue 00577 \param pMsg - pointer to the Msg strut to read into 00578 \param Timeout - timeout to wait for the Msg to be available 00579 00580 \return - OsiReturnVal_e 00581 \note 00582 \warning 00583 */ 00584 00585 OsiReturnVal_e osi_MsgQWrite(OsiMsgQ_t* pMsgQ, void* pMsg , OsiTime_t Timeout) 00586 { 00587 //Check for NULL 00588 if(NULL == pMsgQ) 00589 { 00590 return OSI_INVALID_PARAMS; 00591 } 00592 00593 if(pdPASS == xQueueSendFromISR((xQueueHandle) *pMsgQ, pMsg, &xHigherPriorityTaskWoken )) 00594 { 00595 taskYIELD (); 00596 return OSI_OK; 00597 } 00598 else 00599 { 00600 return OSI_OPERATION_FAILED; 00601 } 00602 } 00603 /*! 00604 \brief This function is used to read data from the MsgQ 00605 00606 \param pMsgQ - pointer to the message queue 00607 \param pMsg - pointer to the Msg strut to read into 00608 \param Timeout - timeout to wait for the Msg to be available 00609 00610 \return - OsiReturnVal_e 00611 \note 00612 \warning 00613 */ 00614 00615 OsiReturnVal_e osi_MsgQRead(OsiMsgQ_t* pMsgQ, void* pMsg , OsiTime_t Timeout) 00616 { 00617 //Check for NULL 00618 if(NULL == pMsgQ) 00619 { 00620 printf("OSI_INVALID_PARAMS\r\n"); 00621 return OSI_INVALID_PARAMS; 00622 } 00623 00624 if ( Timeout == (OsiTime_t) OSI_WAIT_FOREVER ) 00625 { 00626 Timeout = portMAX_DELAY ; 00627 } 00628 00629 //Receive Item from Queue 00630 if( pdTRUE == xQueueReceive((xQueueHandle)*pMsgQ,pMsg,Timeout) ) 00631 { 00632 return OSI_OK; 00633 } 00634 else 00635 { 00636 return OSI_OPERATION_FAILED; 00637 } 00638 } 00639 00640 /*! 00641 \brief This function to call the memory de-allocation function of the FREERTOS 00642 00643 \param Size - size of memory to alloc in bytes 00644 00645 \return - void * 00646 \note 00647 \warning 00648 */ 00649 00650 void * mem_Malloc(uint32_t Size) 00651 { 00652 00653 return ( void * ) pvPortMalloc( (size_t)Size ); 00654 } 00655 00656 /*! 00657 \brief This function to call the memory de-allocation function of the FREERTOS 00658 00659 \param pMem - pointer to the memory which needs to be freed 00660 00661 \return - void 00662 \note 00663 \warning 00664 */ 00665 void mem_Free(void *pMem) 00666 { 00667 vPortFree( pMem ); 00668 } 00669 00670 /*! 00671 \brief This function call the memset function 00672 \param pBuf - pointer to the memory to be fill 00673 \param Val - Value to be fill 00674 \param Size - Size of the memory which needs to be fill 00675 \return - void 00676 \note 00677 \warning 00678 */ 00679 00680 void mem_set(void *pBuf,int Val,size_t Size) 00681 { 00682 memset( pBuf,Val,Size); 00683 00684 } 00685 00686 /*! 00687 \brief This function call the memcopy function 00688 \param pDst - pointer to the destination 00689 \param pSrc - pointer to the source 00690 \param Size - Size of the memory which needs to be copy 00691 00692 \return - void 00693 \note 00694 \warning 00695 */ 00696 void mem_copy(void *pDst, void *pSrc,size_t Size) 00697 { 00698 memcpy(pDst,pSrc,Size); 00699 } 00700 00701 00702 /*! 00703 \brief This function use to entering into critical section 00704 \param void 00705 \return - void 00706 \note 00707 \warning 00708 */ 00709 00710 uint32_t osi_EnterCritical(void) 00711 { 00712 portENTER_CRITICAL(); 00713 return 0; 00714 } 00715 00716 /*! 00717 \brief This function use to exit critical section 00718 \param void 00719 \return - void 00720 \note 00721 \warning 00722 */ 00723 00724 void osi_ExitCritical(uint32_t ulKey) 00725 { 00726 portENTER_CRITICAL(); 00727 } 00728 /*! 00729 \brief This function used to start the scheduler 00730 \param void 00731 \return - void 00732 \note 00733 \warning 00734 */ 00735 void osi_start() 00736 { 00737 vTaskStartScheduler(); 00738 } 00739 /*! 00740 \brief This function used to suspend the task for the specified number of milli secs 00741 \param MilliSecs - Time in millisecs to suspend the task 00742 \return - void 00743 \note 00744 \warning 00745 */ 00746 void osi_Sleep(unsigned int MilliSecs) 00747 { 00748 portTickType xDelay = MilliSecs / portTICK_RATE_MS; 00749 vTaskDelay(xDelay); 00750 } 00751 00752 00753 /*! 00754 \brief This function used to disable the tasks 00755 \param - void 00756 \return - Key with the suspended tasks 00757 \note 00758 \warning 00759 */ 00760 uint32_t osi_TaskDisable(void) 00761 { 00762 vTaskSuspendAll(); 00763 00764 return OSI_OK; 00765 } 00766 00767 00768 /*! 00769 \brief This function used to resume all the tasks 00770 \param key - returned from suspend tasks 00771 \return - void 00772 \note 00773 \warning 00774 */ 00775 void osi_TaskEnable(uint32_t key) 00776 { 00777 xTaskResumeAll(); 00778 } 00779 00780 /*! 00781 \brief This function used to save the OS context before sleep 00782 \param void 00783 \return - void 00784 \note 00785 \warning 00786 */ 00787 void osi_ContextSave() 00788 { 00789 00790 } 00791 /*! 00792 \brief This function used to restore the OS context after sleep 00793 \param void 00794 \return - void 00795 \note 00796 \warning 00797 */ 00798 void osi_ContextRestore() 00799 { 00800 00801 } 00802
Generated on Wed Jul 13 2022 15:58:45 by 1.7.2