394 lines
14 KiB
C
394 lines
14 KiB
C
/*
|
|
* Copyright 2018-2020 NXP
|
|
* All rights reserved.
|
|
*
|
|
*
|
|
* SPDX-License-Identifier: BSD-3-Clause
|
|
*/
|
|
|
|
#ifndef __LED_H__
|
|
#define __LED_H__
|
|
|
|
#include "fsl_common.h"
|
|
#include "fsl_adapter_gpio.h"
|
|
/*!
|
|
* @addtogroup LED
|
|
* @{
|
|
*/
|
|
|
|
/*******************************************************************************
|
|
* Definitions
|
|
******************************************************************************/
|
|
/*! @brief Definition to determine whether enable dimming. */
|
|
#ifndef LED_DIMMING_ENABLEMENT
|
|
#define LED_DIMMING_ENABLEMENT (0U) /*!< Enable or disable the dimming feature */
|
|
#endif
|
|
|
|
/*! @brief Definition to determine whether enable color wheel. */
|
|
#ifndef LED_COLOR_WHEEL_ENABLEMENT
|
|
#define LED_COLOR_WHEEL_ENABLEMENT (0U) /*!< Enable or disable the color wheel feature */
|
|
#endif
|
|
|
|
/*! @brief Definition to determine whether use confgure structure. */
|
|
#ifndef LED_USE_CONFIGURE_STRUCTURE
|
|
#define LED_USE_CONFIGURE_STRUCTURE (1U) /*!< Enable or disable the confgure structure pointer */
|
|
#endif
|
|
/*! @brief The handle of LED */
|
|
typedef void *led_handle_t;
|
|
|
|
/*! @brief Definition of LED handle size. */
|
|
#if (defined(LED_DIMMING_ENABLEMENT) && (LED_DIMMING_ENABLEMENT > 0U))
|
|
/* HAL_GPIO_HANDLE_SIZE * 3 + HAL_PWM_HANDLE_SIZE *3 + LED dedicated size */
|
|
#define LED_HANDLE_SIZE ((16U * 3U) + (8U * 3U) + 40U)
|
|
#else
|
|
#if (defined(LED_USE_CONFIGURE_STRUCTURE) && (LED_USE_CONFIGURE_STRUCTURE > 0U))
|
|
/* HAL_GPIO_HANDLE_SIZE * 3 + LED dedicated size */
|
|
#define LED_HANDLE_SIZE ((16U * 3U) + 32U)
|
|
#else
|
|
/* HAL_GPIO_HANDLE_SIZE * 3 + LED dedicated size */
|
|
#define LED_HANDLE_SIZE ((16U * 3U) + 36U)
|
|
#endif
|
|
#endif
|
|
|
|
/*!
|
|
* @brief Defines the led handle
|
|
*
|
|
* This macro is used to define a 4 byte aligned led handle.
|
|
* Then use "(led_handle_t)name" to get the led handle.
|
|
*
|
|
* The macro should be global and could be optional. You could also define led handle by yourself.
|
|
*
|
|
* This is an example,
|
|
* @code
|
|
* LED_HANDLE_DEFINE(ledHandle);
|
|
* @endcode
|
|
*
|
|
* @param name The name string of the led handle.
|
|
*/
|
|
#define LED_HANDLE_DEFINE(name) uint32_t name[((LED_HANDLE_SIZE + sizeof(uint32_t) - 1U) / sizeof(uint32_t))]
|
|
|
|
/*!
|
|
* @brief Defines the led handle array
|
|
*
|
|
* This macro is used to define a 4 byte aligned led handle array.
|
|
* Then use "(led_handle_t)name[0]" to get the first led handle.
|
|
*
|
|
* The macro should be global and could be optional. You could also define these led handle by yourself.
|
|
*
|
|
* This is an example,
|
|
* @code
|
|
* LED_HANDLE_ARRAY_DEFINE(ledHandleArray,1);
|
|
* @endcode
|
|
*
|
|
* @param name The name string of the led handle array.
|
|
* @param count The amount of led handle.
|
|
*/
|
|
#define LED_HANDLE_ARRAY_DEFINE(name, count) \
|
|
uint32_t name[count][((LED_HANDLE_SIZE + sizeof(uint32_t) - 1U) / sizeof(uint32_t))]
|
|
|
|
/*! @brief Definition of LED timer interval,unit is ms. */
|
|
#define LED_TIMER_INTERVAL (100U)
|
|
|
|
/*! @brief Definition of LED dimming update interval,unit is ms. */
|
|
#define LED_DIMMING_UPDATE_INTERVAL (100U)
|
|
|
|
/*! @brief Definition of LED flash cycle forever. */
|
|
#define LED_FLASH_CYCLE_FOREVER (0xFFFFFFFFU)
|
|
|
|
/*! @brief Definition of LED blip interval,unit is ms. */
|
|
#define LED_BLIP_INTERVAL (250U)
|
|
|
|
/*! @brief The status type of LED */
|
|
typedef enum _led_status
|
|
{
|
|
kStatus_LED_Success = kStatus_Success, /*!< Success */
|
|
kStatus_LED_Error = MAKE_STATUS(kStatusGroup_LED, 1), /*!< Failed */
|
|
kStatus_LED_InvalidParameter = MAKE_STATUS(kStatusGroup_LED, 2), /*!< Invalid parameter*/
|
|
} led_status_t;
|
|
|
|
/*! @brief The flash type of LED */
|
|
typedef enum _led_flash_type
|
|
{
|
|
kLED_FlashOneColor = 0x00U, /*!< Fast with one color */
|
|
#if (defined(LED_COLOR_WHEEL_ENABLEMENT) && (LED_COLOR_WHEEL_ENABLEMENT > 0U))
|
|
kLED_FlashColorWheel, /*!< Fast with color wheel */
|
|
#endif /* (defined(LED_COLOR_WHEEL_ENABLEMENT) && (LED_COLOR_WHEEL_ENABLEMENT > 0U)) */
|
|
} led_flash_type_t;
|
|
|
|
/*! @brief The color struct of LED */
|
|
typedef uint32_t led_color_t;
|
|
|
|
/*! @brief Definition to set LED color. */
|
|
#define LED_MAKE_COLOR(r, g, b) ((led_color_t)((((led_color_t)b) << 16) | (((led_color_t)g) << 8) | ((led_color_t)r)))
|
|
|
|
/*! @brief The color type of LED */
|
|
enum _led_color
|
|
{
|
|
kLED_Black = LED_MAKE_COLOR(0, 0, 0), /*!< Black */
|
|
kLED_Red = LED_MAKE_COLOR(255, 0, 0), /*!< Red */
|
|
kLED_Green = LED_MAKE_COLOR(0, 255, 0), /*!< Green */
|
|
kLED_Yellow = LED_MAKE_COLOR(255, 255, 0), /*!< Yellow */
|
|
kLED_Blue = LED_MAKE_COLOR(0, 0, 255), /*!< Blue */
|
|
kLED_Pink = LED_MAKE_COLOR(255, 0, 255), /*!< Pink */
|
|
kLED_Aquamarine = LED_MAKE_COLOR(0, 255, 255), /*!< Aquamarine */
|
|
kLED_White = LED_MAKE_COLOR(255, 255, 255), /*!< White */
|
|
};
|
|
|
|
#if defined(__CC_ARM)
|
|
#pragma anon_unions
|
|
#endif
|
|
/*! @brief The pin config struct of LED */
|
|
typedef struct _led_pin_config
|
|
{
|
|
uint8_t dimmingEnable; /*!< dimming enable, 0 - disable, 1 - enable */
|
|
union
|
|
{
|
|
#if (defined(LED_USE_CONFIGURE_STRUCTURE) && (LED_USE_CONFIGURE_STRUCTURE > 0U))
|
|
hal_gpio_pin_config_t gpio;
|
|
#else
|
|
struct
|
|
{
|
|
uint8_t port; /*!< GPIO Port */
|
|
uint8_t pin; /*!< GPIO Pin */
|
|
uint8_t pinStateDefault; /*!< GPIO Pin voltage when LED is off (0 - low level, 1 - high level)*/
|
|
} gpio;
|
|
#endif
|
|
struct
|
|
{
|
|
uint32_t sourceClock; /*!< The clock source of the PWM module */
|
|
uint8_t instance; /*!< PWM instance of the pin */
|
|
uint8_t channel; /*!< PWM channel of the pin */
|
|
uint8_t pinStateDefault; /*!< The Pin voltage when LED is off (0 - low level, 1 - high level)*/
|
|
} dimming;
|
|
};
|
|
} led_pin_config_t;
|
|
|
|
/*! @brief The pin config struct of rgb LED */
|
|
typedef struct _led_rgb_config
|
|
{
|
|
led_pin_config_t redPin; /*!< Red pin setting */
|
|
led_pin_config_t greenPin; /*!< Green pin setting */
|
|
led_pin_config_t bluePin; /*!< Blue pin setting */
|
|
} led_rgb_config_t;
|
|
|
|
/*! @brief The pin config struct of monochrome LED */
|
|
typedef struct _led_monochrome_config
|
|
{
|
|
led_pin_config_t monochromePin; /*!< Monochrome pin setting */
|
|
} led_monochrome_config_t;
|
|
|
|
/*! @brief The type of LED */
|
|
typedef enum _led_type
|
|
{
|
|
kLED_TypeRgb = 0x01U, /*!< RGB LED */
|
|
kLED_TypeMonochrome = 0x02U, /*!< Monochrome LED */
|
|
} led_type_t;
|
|
|
|
/*! @brief The config struct of LED */
|
|
typedef struct _led_config
|
|
{
|
|
led_type_t type;
|
|
union
|
|
{
|
|
led_rgb_config_t ledRgb; /*!< RGB setting */
|
|
led_monochrome_config_t ledMonochrome; /*!< Monochrome setting */
|
|
};
|
|
} led_config_t;
|
|
|
|
/*! @brief The flash config struct of LED */
|
|
typedef struct _led_flash_config
|
|
{
|
|
uint32_t times; /*!< Flash times, LED_FLASH_CYCLE_FOREVER for forever */
|
|
uint16_t period; /*!< Flash period, unit is ms */
|
|
led_flash_type_t flashType; /*!< Flash type, one color or color wheel. Refer to #led_flash_type_t */
|
|
uint8_t duty; /*!< Duty of the LED on for one period (duration = duty * period / 100). */
|
|
} led_flash_config_t;
|
|
|
|
/*******************************************************************************
|
|
* API
|
|
******************************************************************************/
|
|
|
|
#if defined(__cplusplus)
|
|
extern "C" {
|
|
#endif /* _cplusplus */
|
|
|
|
/*!
|
|
* @brief Initializes a LED with the LED handle and the user configuration structure.
|
|
*
|
|
* This function configures the LED with user-defined settings. The user can configure the configuration
|
|
* structure. The parameter ledHandle is a pointer to point to a memory space of size #LED_HANDLE_SIZE allocated by the
|
|
* caller. The LED supports two types LED, RGB and monochrome. Please refer to #led_type_t. These two types can be set
|
|
* by using #led_config_t. The LED also supports LED dimming mode.
|
|
*
|
|
* Example below shows how to use this API to configure the LED.
|
|
* For monochrome LED,
|
|
* @code
|
|
* static LED_HANDLE_DEFINE(s_ledMonochromeHandle);
|
|
* led_config_t ledMonochromeConfig;
|
|
* ledMonochromeConfig.type = kLED_TypeMonochrome;
|
|
* ledMonochromeConfig.ledMonochrome.monochromePin.dimmingEnable = 0;
|
|
* ledMonochromeConfig.ledMonochrome.monochromePin.gpio.port = 0;
|
|
* ledMonochromeConfig.ledMonochrome.monochromePin.gpio.pin = 1;
|
|
* ledMonochromeConfig.ledMonochrome.monochromePin.gpio.pinStateDefault = 0;
|
|
* LED_Init((led_handle_t)s_ledMonochromeHandle, &ledMonochromeConfig);
|
|
* @endcode
|
|
* For rgb LED,
|
|
* @code
|
|
* static LED_HANDLE_DEFINE(s_ledRgbHandle);
|
|
* led_config_t ledRgbConfig;
|
|
* ledRgbConfig.type = kLED_TypeRgb;
|
|
* ledRgbConfig.ledRgb.redPin.dimmingEnable = 0;
|
|
* ledRgbConfig.ledRgb.redPin.gpio.port = 0;
|
|
* ledRgbConfig.ledRgb.redPin.gpio.pin = 1;
|
|
* ledRgbConfig.ledRgb.redPin.gpio.pinStateDefault = 0;
|
|
* ledRgbConfig.ledRgb.greenPin.dimmingEnable = 0;
|
|
* ledRgbConfig.ledRgb.greenPin.gpio.port = 0;
|
|
* ledRgbConfig.ledRgb.greenPin.gpio.pin = 2;
|
|
* ledRgbConfig.ledRgb.greenPin.gpio.pinStateDefault = 0;
|
|
* ledRgbConfig.ledRgb.bluePin.dimmingEnable = 0;
|
|
* ledRgbConfig.ledRgb.bluePin.gpio.port = 0;
|
|
* ledRgbConfig.ledRgb.bluePin.gpio.pin = 3;
|
|
* ledRgbConfig.ledRgb.bluePin.gpio.pinStateDefault = 0;
|
|
* LED_Init((led_handle_t)s_ledRgbHandle, &ledRgbConfig);
|
|
* @endcode
|
|
* For dimming monochrome LED,
|
|
* @code
|
|
* static LED_HANDLE_DEFINE(s_ledMonochromeHandle);
|
|
* led_config_t ledMonochromeConfig;
|
|
* ledMonochromeConfig.type = kLED_TypeMonochrome;
|
|
* ledMonochromeConfig.ledMonochrome.monochromePin.dimmingEnable = 1;
|
|
* ledMonochromeConfig.ledMonochrome.monochromePin.dimming.sourceClock = 48000000;
|
|
* ledMonochromeConfig.ledMonochrome.monochromePin.dimming.instance = 0;
|
|
* ledMonochromeConfig.ledMonochrome.monochromePin.dimming.channel = 1;
|
|
* ledMonochromeConfig.ledMonochrome.monochromePin.dimming.pinStateDefault = 0;
|
|
* LED_Init((led_handle_t)s_ledMonochromeHandle, &ledMonochromeConfig);
|
|
* @endcode
|
|
* For multiple LEDs,
|
|
* @code
|
|
* static LED_HANDLE_ARRAY_DEFINE(s_ledArrayHandle, count);
|
|
* led_config_t ledArrayConfig[count];
|
|
* for(uint8_t i = 0; i < count; i++ )
|
|
* {
|
|
* ledArrayConfig[i].type = kLED_TypeMonochrome;
|
|
* ledArrayConfig[i].ledMonochrome.monochromePin.dimmingEnable = 1;
|
|
* ledArrayConfig[i].ledMonochrome.monochromePin.dimming.sourceClock = 48000000;
|
|
* ledArrayConfig[i].ledMonochrome.monochromePin.dimming.instance = 0;
|
|
* ledArrayConfig[i].ledMonochrome.monochromePin.dimming.channel = 1;
|
|
* ledArrayConfig[i].ledMonochrome.monochromePin.dimming.pinStateDefault = 0;
|
|
* LED_Init((led_handle_t)s_ledArrayHandle[i], &ledArrayConfig[i]);
|
|
* }
|
|
* @endcode
|
|
*
|
|
* @param ledHandle Pointer to point to a memory space of size #LED_HANDLE_SIZE allocated by the caller.
|
|
* The handle should be 4 byte aligned, because unaligned access doesn't be supported on some devices.
|
|
* You can define one handle in the following two ways:
|
|
* #LED_HANDLE_DEFINE(ledHandle);
|
|
* or
|
|
* uint32_t ledHandle[((LED_HANDLE_SIZE + sizeof(uint32_t) - 1U) / sizeof(uint32_t))];
|
|
* You can define multiple handles in the following way:
|
|
* #LED_HANDLE_ARRAY_DEFINE(ledHandleArray, count);
|
|
* @param ledConfig Pointer to user-defined configuration structure.
|
|
* please note, if the LED_USE_CONFIGURE_STRUCTURE is set to 1, then user must use const buffer
|
|
* forledConfig, LED module will directly use the const buffer.
|
|
* @retval kStatus_LED_Error An error occurred.
|
|
* @retval kStatus_LED_Success LED initialization succeed.
|
|
*/
|
|
led_status_t LED_Init(led_handle_t ledHandle, led_config_t *ledConfig);
|
|
|
|
/*!
|
|
* @brief Deinitializes a LED instance.
|
|
*
|
|
* This function deinitializes the LED instance.
|
|
*
|
|
* @param ledHandle LED handle pointer.
|
|
* @retval kStatus_LED_Success LED de-initialization succeed.
|
|
*/
|
|
led_status_t LED_Deinit(led_handle_t ledHandle);
|
|
|
|
/*!
|
|
* @brief Sets the LED color.
|
|
*
|
|
* This function sets the LED color. The function only supports the RGB LED.
|
|
* The default color is #kLED_White. Please refer to #LED_MAKE_COLOR(r,g,b).
|
|
*
|
|
* @param ledHandle LED handle pointer.
|
|
* @param ledRgbColor LED color.
|
|
* @retval kStatus_LED_Error An error occurred.
|
|
* @retval kStatus_LED_Success Color setting succeed.
|
|
*/
|
|
led_status_t LED_SetColor(led_handle_t ledHandle, led_color_t ledRgbColor);
|
|
|
|
/*!
|
|
* @brief Turns on or off the LED.
|
|
*
|
|
* This function turns on or off the led.
|
|
*
|
|
* @param ledHandle LED handle pointer.
|
|
* @param turnOnOff Setting value, 1 - turns on, 0 - turns off.
|
|
* @retval kStatus_LED_Error An error occurred.
|
|
* @retval kStatus_LED_Success Successfully turn on or off the LED.
|
|
*/
|
|
led_status_t LED_TurnOnOff(led_handle_t ledHandle, uint8_t turnOnOff);
|
|
|
|
/*!
|
|
* @brief Blips the LED.
|
|
*
|
|
* This function blips the led.
|
|
*
|
|
* @param ledHandle LED handle pointer.
|
|
* @retval kStatus_LED_Error An error occurred.
|
|
* @retval kStatus_LED_Success Successfully blip the LED.
|
|
*/
|
|
led_status_t LED_Blip(led_handle_t ledHandle);
|
|
|
|
/*!
|
|
* @brief Flashes the LED.
|
|
*
|
|
* This function flashes the led. The flash configuration is passed by using #led_flash_config_t.
|
|
*
|
|
* @param ledHandle LED handle pointer.
|
|
* @param ledFlash LED flash configuration.
|
|
* @retval kStatus_LED_Error An error occurred.
|
|
* @retval kStatus_LED_Success Successfully flash the LED.
|
|
*/
|
|
led_status_t LED_Flash(led_handle_t ledHandle, led_flash_config_t *ledFlash);
|
|
|
|
/*!
|
|
* @brief Adjusts the brightness of the LED.
|
|
*
|
|
* This function adjust the brightness of the LED.
|
|
*
|
|
* @param ledHandle LED handle pointer.
|
|
* @param dimmingPeriod The duration of the dimming (unit is ms).
|
|
* @param increasement Brighten or dim (1 - brighten, 0 - dim).
|
|
* @retval kStatus_LED_Error An error occurred.
|
|
* @retval kStatus_LED_Success Successfully adjust the brightness of the LED.
|
|
*/
|
|
led_status_t LED_Dimming(led_handle_t ledHandle, uint16_t dimmingPeriod, uint8_t increasement);
|
|
|
|
/*!
|
|
* @brief Prepares to enter low power consumption.
|
|
*
|
|
* This function is used to prepare to enter low power consumption.
|
|
*
|
|
* @param ledHandle LED handle pointer.
|
|
* @retval kStatus_LED_Success Successful operation.
|
|
*/
|
|
led_status_t LED_EnterLowpower(led_handle_t ledHandle);
|
|
|
|
/*!
|
|
* @brief Restores from low power consumption.
|
|
*
|
|
* This function is used to restore from low power consumption.
|
|
*
|
|
* @param ledHandle LED handle pointer.
|
|
* @retval kStatus_LED_Success Successful operation.
|
|
*/
|
|
led_status_t LED_ExitLowpower(led_handle_t ledHandle);
|
|
|
|
#if defined(__cplusplus)
|
|
}
|
|
#endif
|
|
/*! @}*/
|
|
#endif /* __LED_H__ */
|