mirror of
https://gitee.com/beecue/fastbee.git
synced 2025-12-18 00:45:55 +08:00
323 lines
8.0 KiB
C
323 lines
8.0 KiB
C
/*
|
|
* ESPRESSIF MIT License
|
|
*
|
|
* Copyright (c) 2019 <ESPRESSIF SYSTEMS (SHANGHAI) PTE LTD>
|
|
*
|
|
* Permission is hereby granted for use on all ESPRESSIF SYSTEMS products, in which case,
|
|
* it is free of charge, to any person obtaining a copy of this software and associated
|
|
* documentation files (the "Software"), to deal in the Software without restriction, including
|
|
* without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
* and/or sell copies of the Software, and to permit persons to whom the Software is furnished
|
|
* to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in all copies or
|
|
* substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
|
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
|
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
|
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
*
|
|
*/
|
|
|
|
#include "wrappers_defs.h"
|
|
#include <sys/time.h>
|
|
#include "freertos/FreeRTOS.h"
|
|
#include "freertos/task.h"
|
|
#include "freertos/semphr.h"
|
|
#include "freertos/timers.h"
|
|
|
|
#include "pthread.h"
|
|
#include "esp_wifi.h"
|
|
#include "esp_log.h"
|
|
|
|
static const char *TAG = "os";
|
|
|
|
#ifdef CONFIG_IDF_TARGET_ESP8266
|
|
#if __has_include("esp_idf_version.h")
|
|
#include "esp_idf_version.h"
|
|
#else
|
|
/** Major version number (X.x.x) */
|
|
#define ESP_IDF_VERSION_MAJOR 3
|
|
/** Minor version number (x.X.x) */
|
|
#define ESP_IDF_VERSION_MINOR 2
|
|
/** Patch version number (x.x.X) */
|
|
#define ESP_IDF_VERSION_PATCH 0
|
|
#define ESP_IDF_VERSION_VAL(major, minor, patch) ((major << 16) | (minor << 8) | (patch))
|
|
#define ESP_IDF_VERSION ESP_IDF_VERSION_VAL(ESP_IDF_VERSION_MAJOR, \
|
|
ESP_IDF_VERSION_MINOR, \
|
|
ESP_IDF_VERSION_PATCH)
|
|
#endif
|
|
|
|
#if ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(3, 3, 0)
|
|
// notes: pthread_exit has already defined on ESP-IDF
|
|
void pthread_exit(void *value_ptr)
|
|
{
|
|
ESP_LOGE(TAG, "%s: esp82666 not supported!", __FUNCTION__);
|
|
}
|
|
#endif
|
|
#endif
|
|
|
|
static long long os_time_get(void)
|
|
{
|
|
struct timeval tv;
|
|
long long ms;
|
|
gettimeofday(&tv, NULL);
|
|
ms = tv.tv_sec * 1000LL + tv.tv_usec / 1000;
|
|
return ms;
|
|
}
|
|
|
|
static long long delta_time = 0;
|
|
|
|
void HAL_UTC_Set(long long ms)
|
|
{
|
|
delta_time = ms - os_time_get();
|
|
}
|
|
|
|
long long HAL_UTC_Get(void)
|
|
{
|
|
return delta_time + os_time_get();
|
|
}
|
|
|
|
/**
|
|
* @brief Create a mutex.
|
|
*
|
|
* @retval NULL : Initialize mutex failed.
|
|
* @retval NOT_NULL : The mutex handle.
|
|
* @see None.
|
|
* @note None.
|
|
*/
|
|
void *HAL_MutexCreate(void)
|
|
{
|
|
return (void *)xSemaphoreCreateMutex();
|
|
}
|
|
|
|
/**
|
|
* @brief Destroy the specified mutex object, it will release related resource.
|
|
*
|
|
* @param [in] mutex @n The specified mutex.
|
|
* @return None.
|
|
* @see None.
|
|
* @note None.
|
|
*/
|
|
void HAL_MutexDestroy(void *mutex)
|
|
{
|
|
if (mutex) {
|
|
vSemaphoreDelete((SemaphoreHandle_t)mutex);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief Waits until the specified mutex is in the signaled state.
|
|
*
|
|
* @param [in] mutex @n the specified mutex.
|
|
* @return None.
|
|
* @see None.
|
|
* @note None.
|
|
*/
|
|
void HAL_MutexLock(void *mutex)
|
|
{
|
|
if (mutex) {
|
|
xSemaphoreTake((SemaphoreHandle_t)mutex, portMAX_DELAY);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief Releases ownership of the specified mutex object..
|
|
*
|
|
* @param [in] mutex @n the specified mutex.
|
|
* @return None.
|
|
* @see None.
|
|
* @note None.
|
|
*/
|
|
void HAL_MutexUnlock(void *mutex)
|
|
{
|
|
if (mutex) {
|
|
xSemaphoreGive((SemaphoreHandle_t)mutex);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief create a semaphore
|
|
*
|
|
* @return semaphore handle.
|
|
* @see None.
|
|
* @note The recommended value of maximum count of the semaphore is 255.
|
|
*/
|
|
void *HAL_SemaphoreCreate(void)
|
|
{
|
|
return (void *)xSemaphoreCreateCounting(CONFIG_HAL_SEM_MAX_COUNT, CONFIG_HAL_SEM_INIT_COUNT);
|
|
}
|
|
|
|
/**
|
|
* @brief destory a semaphore
|
|
*
|
|
* @param[in] sem @n the specified sem.
|
|
* @return None.
|
|
* @see None.
|
|
* @note None.
|
|
*/
|
|
void HAL_SemaphoreDestroy(void *sem)
|
|
{
|
|
if (sem) {
|
|
vSemaphoreDelete((SemaphoreHandle_t)sem);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief signal thread wait on a semaphore
|
|
*
|
|
* @param[in] sem @n the specified semaphore.
|
|
* @return None.
|
|
* @see None.
|
|
* @note None.
|
|
*/
|
|
void HAL_SemaphorePost(void *sem)
|
|
{
|
|
if (sem) {
|
|
xSemaphoreGive((SemaphoreHandle_t)sem);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief wait on a semaphore
|
|
*
|
|
* @param[in] sem @n the specified semaphore.
|
|
* @param[in] timeout_ms @n timeout interval in millisecond.
|
|
If timeout_ms is PLATFORM_WAIT_INFINITE, the function will return only when the semaphore is signaled.
|
|
* @return
|
|
@verbatim
|
|
= 0: The state of the specified object is signaled.
|
|
= -1: The time-out interval elapsed, and the object's state is nonsignaled.
|
|
@endverbatim
|
|
* @see None.
|
|
* @note None.
|
|
*/
|
|
int HAL_SemaphoreWait(void *sem, uint32_t timeout_ms)
|
|
{
|
|
if (pdPASS == xSemaphoreTake((SemaphoreHandle_t)sem, timeout_ms)) {
|
|
return SUCCESS_RETURN;
|
|
}
|
|
|
|
return FAIL_RETURN;
|
|
}
|
|
|
|
/**
|
|
* @brief create a thread
|
|
*
|
|
* @param[out] thread_handle @n The new thread handle, memory allocated before thread created and return it, free it after thread joined or exit.
|
|
* @param[in] start_routine @n A pointer to the application-defined function to be executed by the thread.
|
|
This pointer represents the starting address of the thread.
|
|
* @param[in] arg @n A pointer to a variable to be passed to the start_routine.
|
|
* @param[in] hal_os_thread_param @n A pointer to stack params.
|
|
* @param[out] stack_used @n if platform used stack buffer, set stack_used to 1, otherwise set it to 0.
|
|
* @return
|
|
@verbatim
|
|
= 0: on success.
|
|
= -1: error occur.
|
|
@endverbatim
|
|
* @see None.
|
|
* @note None.
|
|
*/
|
|
int HAL_ThreadCreate(
|
|
void **thread_handle,
|
|
void *(*work_routine)(void *),
|
|
void *arg,
|
|
hal_os_thread_param_t *hal_os_thread_param,
|
|
int *stack_used)
|
|
{
|
|
int ret = -1;
|
|
pthread_attr_t attr = {0};
|
|
|
|
if (!thread_handle || !work_routine ||
|
|
!hal_os_thread_param || !stack_used) {
|
|
return NULL_VALUE_ERROR;
|
|
}
|
|
|
|
*stack_used = 0;
|
|
printf("task name is %s\n", hal_os_thread_param->name);
|
|
|
|
if (hal_os_thread_param->stack_size == 0) {
|
|
ret = pthread_create((pthread_t *)thread_handle, NULL, work_routine, arg);
|
|
} else {
|
|
attr.stacksize = hal_os_thread_param->stack_size;
|
|
ret = pthread_create((pthread_t *)thread_handle, &attr, work_routine, arg);
|
|
}
|
|
return ret;
|
|
|
|
}
|
|
|
|
void HAL_ThreadDelete(void *thread_handle)
|
|
{
|
|
if (NULL == thread_handle) {
|
|
pthread_exit(0);
|
|
} else {
|
|
/*main thread delete child thread*/
|
|
pthread_cancel((pthread_t) thread_handle);
|
|
pthread_join((pthread_t) thread_handle, 0);
|
|
}
|
|
|
|
}
|
|
|
|
void HAL_ThreadDetach(void *thread_handle)
|
|
{
|
|
pthread_detach((pthread_t)thread_handle);
|
|
}
|
|
|
|
void *HAL_Timer_Create(const char *name, void (*func)(void *), void *user_data)
|
|
{
|
|
TimerHandle_t timer_handle = NULL;
|
|
timer_handle = xTimerCreate(name, portMAX_DELAY, pdFALSE, NULL, (TimerCallbackFunction_t)func);
|
|
|
|
return (void *)timer_handle;
|
|
}
|
|
|
|
int HAL_Timer_Delete(void *timer)
|
|
{
|
|
if (!timer) {
|
|
return FAIL_RETURN;
|
|
}
|
|
|
|
if (pdTRUE == xTimerDelete((TimerHandle_t)timer, portMAX_DELAY)) {
|
|
return SUCCESS_RETURN;
|
|
}
|
|
|
|
return FAIL_RETURN;
|
|
}
|
|
|
|
int HAL_Timer_Start(void *timer, int ms)
|
|
{
|
|
if (!timer) {
|
|
return FAIL_RETURN;
|
|
}
|
|
|
|
uint32_t ticks = ms / portTICK_PERIOD_MS;
|
|
if (ticks == 0) {
|
|
ticks = 1;
|
|
}
|
|
|
|
if (xTimerChangePeriod(timer, ticks, portMAX_DELAY) != pdTRUE) {
|
|
return FAIL_RETURN;
|
|
}
|
|
if (xTimerStart((TimerHandle_t)timer, portMAX_DELAY) != pdTRUE) {
|
|
return FAIL_RETURN;
|
|
}
|
|
|
|
return SUCCESS_RETURN;
|
|
}
|
|
|
|
int HAL_Timer_Stop(void *timer)
|
|
{
|
|
if (!timer) {
|
|
return FAIL_RETURN;
|
|
}
|
|
|
|
if (pdTRUE == xTimerStop((TimerHandle_t)timer, portMAX_DELAY)) {
|
|
return SUCCESS_RETURN;
|
|
}
|
|
|
|
return FAIL_RETURN;
|
|
}
|