db0f9732b2
custom board driver ma120x0 is broken esp dsp is now IDF managed component mdns is now IDF managed component Signed-off-by: Karl Osterseher <karli_o@gmx.at>
524 lines
16 KiB
C
524 lines
16 KiB
C
/*
|
|
* ESPRESSIF MIT License
|
|
*
|
|
* Copyright (c) 2018 <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.
|
|
*
|
|
*/
|
|
|
|
#ifndef _ESP_PERIPHERALS_H_
|
|
#define _ESP_PERIPHERALS_H_
|
|
|
|
#include "audio_common.h"
|
|
#include "audio_error.h"
|
|
#include "audio_event_iface.h"
|
|
#include "freertos/event_groups.h"
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
/**
|
|
* @brief Peripheral Identify, this must be unique for each peripheral added to
|
|
* the peripherals list
|
|
*/
|
|
typedef enum {
|
|
PERIPH_ID_BUTTON = AUDIO_ELEMENT_TYPE_PERIPH + 1,
|
|
PERIPH_ID_TOUCH = AUDIO_ELEMENT_TYPE_PERIPH + 2,
|
|
PERIPH_ID_SDCARD = AUDIO_ELEMENT_TYPE_PERIPH + 3,
|
|
PERIPH_ID_WIFI = AUDIO_ELEMENT_TYPE_PERIPH + 4,
|
|
PERIPH_ID_FLASH = AUDIO_ELEMENT_TYPE_PERIPH + 5,
|
|
PERIPH_ID_AUXIN = AUDIO_ELEMENT_TYPE_PERIPH + 6,
|
|
PERIPH_ID_ADC = AUDIO_ELEMENT_TYPE_PERIPH + 7,
|
|
PERIPH_ID_CONSOLE = AUDIO_ELEMENT_TYPE_PERIPH + 8,
|
|
PERIPH_ID_BLUETOOTH = AUDIO_ELEMENT_TYPE_PERIPH + 9,
|
|
PERIPH_ID_LED = AUDIO_ELEMENT_TYPE_PERIPH + 10,
|
|
PERIPH_ID_SPIFFS = AUDIO_ELEMENT_TYPE_PERIPH + 11,
|
|
PERIPH_ID_ADC_BTN = AUDIO_ELEMENT_TYPE_PERIPH + 12,
|
|
PERIPH_ID_IS31FL3216 = AUDIO_ELEMENT_TYPE_PERIPH + 13,
|
|
PERIPH_ID_GPIO_ISR = AUDIO_ELEMENT_TYPE_PERIPH + 14,
|
|
PERIPH_ID_WS2812 = AUDIO_ELEMENT_TYPE_PERIPH + 15,
|
|
PERIPH_ID_AW2013 = AUDIO_ELEMENT_TYPE_PERIPH + 16,
|
|
PERIPH_ID_LCD = AUDIO_ELEMENT_TYPE_PERIPH + 17
|
|
} esp_periph_id_t;
|
|
|
|
/**
|
|
* @brief Peripheral working state
|
|
*/
|
|
typedef enum {
|
|
PERIPH_STATE_NULL,
|
|
PERIPH_STATE_INIT,
|
|
PERIPH_STATE_RUNNING,
|
|
PERIPH_STATE_PAUSE,
|
|
PERIPH_STATE_STOPPING,
|
|
PERIPH_STATE_ERROR,
|
|
PERIPH_STATE_STATUS_MAX,
|
|
} esp_periph_state_t;
|
|
|
|
typedef struct esp_periph_sets *esp_periph_set_handle_t;
|
|
typedef struct esp_periph *esp_periph_handle_t;
|
|
typedef esp_err_t (*esp_periph_func)(esp_periph_handle_t periph);
|
|
typedef esp_err_t (*esp_periph_run_func)(esp_periph_handle_t periph,
|
|
audio_event_iface_msg_t *msg);
|
|
typedef esp_err_t (*esp_periph_event_handle_t)(audio_event_iface_msg_t *event,
|
|
void *context);
|
|
typedef void (*timer_callback)(xTimerHandle tmr);
|
|
|
|
/**
|
|
* @brief Common peripherals configurations
|
|
*/
|
|
typedef struct {
|
|
int task_stack; /*!< >0 Service task stack size; =0 without task created */
|
|
int task_prio; /*!< Service task priority (based on freeRTOS priority) */
|
|
int task_core; /*!< Service task running in core (0 or 1) */
|
|
bool extern_stack; /*!< Service task stack allocate on extern ram */
|
|
} esp_periph_config_t;
|
|
|
|
/**
|
|
* @brief peripheral events
|
|
*/
|
|
typedef struct esp_periph_event {
|
|
void *user_ctx; /*!< peripheral context data */
|
|
esp_periph_event_handle_t cb; /*!< peripheral callback function */
|
|
audio_event_iface_handle_t iface; /*!< peripheral event */
|
|
} esp_periph_event_t;
|
|
|
|
#define DEFAULT_ESP_PERIPH_STACK_SIZE (4 * 1024)
|
|
#define DEFAULT_ESP_PERIPH_TASK_PRIO (5)
|
|
#define DEFAULT_ESP_PERIPH_TASK_CORE (0)
|
|
|
|
#define DEFAULT_ESP_PERIPH_SET_CONFIG() \
|
|
{ \
|
|
.task_stack = DEFAULT_ESP_PERIPH_STACK_SIZE, \
|
|
.task_prio = DEFAULT_ESP_PERIPH_TASK_PRIO, \
|
|
.task_core = DEFAULT_ESP_PERIPH_TASK_CORE, .extern_stack = false, \
|
|
}
|
|
|
|
/**
|
|
* @brief Initialize esp_peripheral sets, create empty peripherals list.
|
|
* Call this function before starting any peripherals (with
|
|
* `esp_periph_start`). This call will initialize the data needed for
|
|
* esp_peripherals to work, but does not actually create the task. The
|
|
* `event_handle` is optional if you want to receive events from this callback
|
|
* function. The esp_peripherals task will send all events out to event_iface,
|
|
* can be listen by event_iface by `esp_periph_get_event_iface`. The
|
|
* `user_context` will sent `esp_periph_event_handle_t` as *context parameter.
|
|
*
|
|
* @param[in] config The configurations
|
|
*
|
|
* @return The peripheral sets instance
|
|
*/
|
|
esp_periph_set_handle_t esp_periph_set_init(esp_periph_config_t *config);
|
|
|
|
/**
|
|
* @brief This function will stop and kill the monitor task, calling all
|
|
* destroy callback functions of the peripheral (so you do not need to destroy
|
|
* the peripheral object manually). It will also remove all memory allocated to
|
|
* the peripherals list, so you need to call the `esp_periph_set_init` function
|
|
* again if you want to use it.
|
|
*
|
|
* @param periph_set_handle The esp_periph_set_handle_t instance
|
|
*
|
|
* @return
|
|
* - ESP_OK
|
|
* - ESP_FAIL
|
|
*/
|
|
esp_err_t esp_periph_set_destroy(esp_periph_set_handle_t periph_set_handle);
|
|
|
|
/**
|
|
* @brief Stop monitoring all peripherals, the peripheral state is still
|
|
* kept. This funciton only temporary disables the peripheral.
|
|
*
|
|
* @param periph_set_handle The esp_periph_set_handle_t instance
|
|
*
|
|
* @return
|
|
* - ESP_OK
|
|
* - ESP_FAIL
|
|
*/
|
|
esp_err_t esp_periph_set_stop_all(esp_periph_set_handle_t periph_set_handle);
|
|
|
|
/**
|
|
* @brief Get the peripheral handle by Peripheral ID
|
|
*
|
|
* @param periph_set_handle The esp_periph_set_handle_t instance
|
|
*
|
|
* @param[in] periph_id as esp_periph_id_t, or any ID you use when calling
|
|
* `esp_periph_create`
|
|
*
|
|
*
|
|
* @return The esp_periph_handle_t
|
|
*/
|
|
esp_periph_handle_t esp_periph_set_get_by_id(
|
|
esp_periph_set_handle_t periph_set_handle, int periph_id);
|
|
|
|
/**
|
|
* @brief Return the event_iface used by this esp_peripherals
|
|
*
|
|
* @param periph_set_handle The esp_periph_set_handle_t instance
|
|
*
|
|
* @return The audio event iface handle
|
|
*/
|
|
audio_event_iface_handle_t esp_periph_set_get_event_iface(
|
|
esp_periph_set_handle_t periph_set_handle);
|
|
|
|
/**
|
|
* @brief Register peripheral sets event callback function.
|
|
*
|
|
* @param periph_set_handle The esp_periph_set_handle_t instance
|
|
* @param cb The event handle callback function
|
|
* @param user_context The user context pointer
|
|
*
|
|
* @return
|
|
* - ESP_OK
|
|
* - ESP_FAIL
|
|
*/
|
|
esp_err_t esp_periph_set_register_callback(
|
|
esp_periph_set_handle_t periph_set_handle, esp_periph_event_handle_t cb,
|
|
void *user_context);
|
|
|
|
/**
|
|
* @brief Peripheral is using event_iface to control the event, all events
|
|
* are send out to event_iface queue. This function will be useful in case we
|
|
* want to read events directly from the event_iface queue.
|
|
*
|
|
* @param periph_set_handle The esp_periph_set_handle_t instance
|
|
*
|
|
* @return The queue handle
|
|
*/
|
|
QueueHandle_t esp_periph_set_get_queue(
|
|
esp_periph_set_handle_t periph_set_handle);
|
|
|
|
/**
|
|
* @brief Call this function to initialize all the listed peripherals.
|
|
* @note Work with no task peripheral set only
|
|
*
|
|
* @param periph_set_handle The esp_periph_set_handle_t instance
|
|
*
|
|
* @return
|
|
* - ESP_OK
|
|
* - ESP_FAIL
|
|
*/
|
|
esp_err_t esp_periph_set_list_init(esp_periph_set_handle_t periph_set_handle);
|
|
|
|
/**
|
|
* @brief Call this function to run all the listed peripherals.
|
|
* @note Work with no task peripheral set only
|
|
*
|
|
* @param periph_set_handle The esp_periph_set_handle_t instance
|
|
* @param msg The audio_event_iface_msg_t handle message
|
|
*
|
|
* @return
|
|
* - ESP_OK
|
|
* - ESP_FAIL
|
|
*/
|
|
esp_err_t esp_periph_set_list_run(esp_periph_set_handle_t periph_set_handle,
|
|
audio_event_iface_msg_t msg);
|
|
|
|
/**
|
|
* @brief Call this function to destroy all the listed peripherals.
|
|
* @note Work with no task peripheral set only
|
|
*
|
|
* @param periph_set_handle The esp_periph_set_handle_t instance
|
|
*
|
|
* @return
|
|
* - ESP_OK
|
|
* - ESP_FAIL
|
|
*/
|
|
esp_err_t esp_periph_set_list_destroy(
|
|
esp_periph_set_handle_t periph_set_handle);
|
|
|
|
/**
|
|
* @brief Call this function to remove periph from periph_set.
|
|
*
|
|
* @param periph_set_handle The esp_periph_set_handle_t instance
|
|
* @param periph The esp_periph_handle_t instance
|
|
*
|
|
* @return
|
|
* - ESP_OK
|
|
* - ESP_FAIL
|
|
*/
|
|
esp_err_t esp_periph_remove_from_set(esp_periph_set_handle_t periph_set_handle,
|
|
esp_periph_handle_t periph);
|
|
|
|
/**
|
|
* @brief Call this function to change periph_set waiting time.
|
|
*
|
|
* @param periph_set_handle The esp_periph_set_handle_t instance
|
|
* @param time_ms The waiting time
|
|
*
|
|
* @return
|
|
* - ESP_OK
|
|
* - ESP_FAIL
|
|
*/
|
|
esp_err_t esp_periph_set_change_waiting_time(
|
|
esp_periph_set_handle_t periph_set_handle, int time_ms);
|
|
|
|
/**
|
|
* @brief Call this function to initialize a new peripheral
|
|
*
|
|
* @param[in] periph_id The periph identifier
|
|
* @param[in] tag The tag name, we named it easy to get in debug logs
|
|
*
|
|
* @return The peripheral handle
|
|
*/
|
|
esp_periph_handle_t esp_periph_create(int periph_id, const char *tag);
|
|
|
|
/**
|
|
* @brief Each peripheral has a cycle of sequential operations from
|
|
* initialization, execution of commands to destroying the peripheral. These
|
|
* operations are represented by functions passed as call parameters to this
|
|
* function.
|
|
*
|
|
* @param[in] periph The periph
|
|
* @param[in] init The initialize
|
|
* @param[in] run The run
|
|
* @param[in] destroy The destroy
|
|
*
|
|
* @return
|
|
* - ESP_OK
|
|
* - ESP_FAIL
|
|
*/
|
|
esp_err_t esp_periph_set_function(esp_periph_handle_t periph,
|
|
esp_periph_func init, esp_periph_run_func run,
|
|
esp_periph_func destroy);
|
|
|
|
/**
|
|
* @brief Add the peripheral to peripherals list, enable and start monitor
|
|
* task (if task stack size > 0)
|
|
*
|
|
* @param[in] periph_set_handle The esp_periph_set_handle_t instance
|
|
* @param[in] periph The peripheral instance
|
|
*
|
|
* @note
|
|
* This peripheral must be first created by calling `esp_periph_create`
|
|
*
|
|
* @return
|
|
* - ESP_OK on success
|
|
* - ESP_FAIL when any errors
|
|
*/
|
|
esp_err_t esp_periph_start(esp_periph_set_handle_t periph_set_handle,
|
|
esp_periph_handle_t periph);
|
|
|
|
/**
|
|
* @brief Stop monitoring the peripheral, the peripheral state is still
|
|
* kept. This funciton only temporary disables the peripheral.
|
|
*
|
|
* @param[in] periph The periph
|
|
*
|
|
* @return
|
|
* - ESP_OK
|
|
* - ESP_FAIL
|
|
*/
|
|
esp_err_t esp_periph_stop(esp_periph_handle_t periph);
|
|
|
|
/**
|
|
* @brief When this function is called, the command is passed to the
|
|
* event_iface command queue, and the `esp_periph_run_func` of this peripheral
|
|
* will be executed in the main peripheral task. This function can be called
|
|
* from any task, basically it only sends a queue to the main peripheral task
|
|
*
|
|
* @param[in] periph The periph
|
|
* @param[in] cmd The command
|
|
* @param data The data
|
|
* @param[in] data_len The data length
|
|
*
|
|
* @return
|
|
* - ESP_OK
|
|
* - ESP_FAIL
|
|
*/
|
|
esp_err_t esp_periph_send_cmd(esp_periph_handle_t periph, int cmd, void *data,
|
|
int data_len);
|
|
|
|
/**
|
|
* @brief Similar to `esp_periph_send_cmd`, but it can be called in the
|
|
* hardware interrupt handle
|
|
*
|
|
* @param[in] periph The periph
|
|
* @param[in] cmd The command
|
|
* @param data The data
|
|
* @param[in] data_len The data length
|
|
*
|
|
* @return
|
|
* - ESP_OK
|
|
* - ESP_FAIL
|
|
*/
|
|
esp_err_t esp_periph_send_cmd_from_isr(esp_periph_handle_t periph, int cmd,
|
|
void *data, int data_len);
|
|
|
|
/**
|
|
* @brief In addition to sending an event via event_iface, this function
|
|
* will dispatch the `event_handle` callback if the event_handle callback is
|
|
* provided at `esp_periph_init`
|
|
*
|
|
* @param[in] periph The peripheral
|
|
* @param[in] event_id The event identifier
|
|
* @param data The data
|
|
* @param[in] data_len The data length
|
|
*
|
|
* @return
|
|
* - ESP_OK
|
|
* - ESP_FAIL
|
|
*/
|
|
esp_err_t esp_periph_send_event(esp_periph_handle_t periph, int event_id,
|
|
void *data, int data_len);
|
|
|
|
/**
|
|
* @brief Each peripheral can initialize a timer, which is by default NULL.
|
|
* When this function is called, the timer for the peripheral is
|
|
* created and it invokes the callback function every interval tick.
|
|
*
|
|
* @note
|
|
* - You do not need to stop or destroy the timer, when the
|
|
* `esp_periph_destroy` function is called, it will stop and destroy all
|
|
* - This timer using FreeRTOS Timer, with autoreload = true
|
|
*
|
|
* @param[in] periph The peripheral
|
|
* @param[in] interval_tick The interval tick
|
|
* @param[in] callback The callback
|
|
*
|
|
* @return
|
|
* - ESP_OK
|
|
* - ESP_FAIL
|
|
*/
|
|
esp_err_t esp_periph_start_timer(esp_periph_handle_t periph,
|
|
TickType_t interval_tick,
|
|
timer_callback callback);
|
|
|
|
/**
|
|
* @brief Stop peripheral timer
|
|
*
|
|
* @param[in] periph The peripheral
|
|
*
|
|
* @return
|
|
* - ESP_OK
|
|
* - ESP_FAIL
|
|
*/
|
|
esp_err_t esp_periph_stop_timer(esp_periph_handle_t periph);
|
|
|
|
/**
|
|
* @brief Set the user data
|
|
*
|
|
* @note Make sure the `data` lifetime is sufficient, this function does
|
|
* not copy all data, it only stores the data pointer
|
|
*
|
|
* @param[in] periph The peripheral
|
|
* @param data The data
|
|
*
|
|
* @return
|
|
* - ESP_OK
|
|
* - ESP_FAIL
|
|
*/
|
|
esp_err_t esp_periph_set_data(esp_periph_handle_t periph, void *data);
|
|
|
|
/**
|
|
* @brief Get the user data stored in the peripheral
|
|
*
|
|
* @param[in] periph The peripheral
|
|
*
|
|
* @return Peripheral data pointer
|
|
*/
|
|
void *esp_periph_get_data(esp_periph_handle_t periph);
|
|
|
|
/**
|
|
* @brief Get the current state of peripheral.
|
|
*
|
|
* @param[in] periph The handle of peripheral
|
|
*
|
|
* @return The peripharal working state
|
|
*/
|
|
esp_periph_state_t esp_periph_get_state(esp_periph_handle_t periph);
|
|
|
|
/**
|
|
* @brief Get Peripheral identifier
|
|
*
|
|
* @param[in] periph The peripheral
|
|
*
|
|
* @return The peripheral identifier
|
|
*/
|
|
esp_periph_id_t esp_periph_get_id(esp_periph_handle_t periph);
|
|
|
|
/**
|
|
* @brief Set Peripheral identifier
|
|
*
|
|
* @param[in] periph The peripheral
|
|
* @param[in] periph_id The peripheral identifier
|
|
*
|
|
* @return
|
|
* - ESP_OK
|
|
* - ESP_FAIL
|
|
*/
|
|
esp_err_t esp_periph_set_id(esp_periph_handle_t periph,
|
|
esp_periph_id_t periph_id);
|
|
|
|
/**
|
|
* @brief Call this to execute `init` function of peripheral instance
|
|
*
|
|
* @param periph The peripheral handle
|
|
*
|
|
* @return
|
|
* - ESP_OK
|
|
* - ESP_FAIL
|
|
*/
|
|
esp_err_t esp_periph_init(esp_periph_handle_t periph);
|
|
|
|
/**
|
|
* @brief Call this to execute `run` function of peripheral instance
|
|
*
|
|
* @param periph The peripheral handle
|
|
*
|
|
* @return
|
|
* - ESP_OK
|
|
* - ESP_FAIL
|
|
*/
|
|
esp_err_t esp_periph_run(esp_periph_handle_t periph);
|
|
|
|
/**
|
|
* @brief Call this to execute `destroy` function of peripheral instance
|
|
*
|
|
* @param periph The peripheral handle
|
|
*
|
|
* @return
|
|
* - ESP_OK
|
|
* - ESP_FAIL
|
|
*/
|
|
esp_err_t esp_periph_destroy(esp_periph_handle_t periph);
|
|
|
|
/**
|
|
* @brief Rigster peripheral on event handle
|
|
*
|
|
* @param periph The peripheral handle
|
|
* @param evts The esp_periph_event_t handle
|
|
*
|
|
* @return
|
|
* - ESP_OK
|
|
* - ESP_FAIL
|
|
*/
|
|
esp_err_t esp_periph_register_on_events(esp_periph_handle_t periph,
|
|
esp_periph_event_t *evts);
|
|
|
|
#define periph_tick_get esp_periph_tick_get
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif
|