led_effect.h

Go to the documentation of this file.

/*
 * Copyright (c) 2019-2021 Nordic Semiconductor ASA
 *
 * SPDX-License-Identifier: LicenseRef-Nordic-5-Clause
 */
 
#ifndef _LED_EFFECT_H_
#define _LED_EFFECT_H_
 
#include <zephyr/types.h>
#include <zephyr/sys/util.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define _CAF_LED_COLOR_CHANNEL_COUNT 3
 
struct led_color {
        uint8_t c[_CAF_LED_COLOR_CHANNEL_COUNT];
};
 
struct led_effect_step {
        struct led_color color;
 
        uint16_t substep_count;
 
        uint16_t substep_time;
};
 
struct led_effect {
        const struct led_effect_step *steps;
 
        uint16_t step_count;
 
        bool loop_forever;
};
 
#define COLOR_BRIGHTNESS_TO_PCT(_val) ((_val * 100) / UINT8_MAX)
 
#define LED_COLOR_ARG_PASS(...) __VA_ARGS__
 
#define LED_COLOR(_r, _g, _b) {                         \
                .c = {                                  \
                        COLOR_BRIGHTNESS_TO_PCT(_r),    \
                        COLOR_BRIGHTNESS_TO_PCT(_g),    \
                        COLOR_BRIGHTNESS_TO_PCT(_b)     \
                }                                       \
}
 
#define LED_NOCOLOR() {                 \
                .c = {0, 0, 0}          \
}
 
#define LED_EFFECT_LED_ON(_color)                                               \
        {                                                                       \
                .steps = ((const struct led_effect_step[]) {                    \
                        {                                                       \
                                .color = _color,                                \
                                .substep_count = 1,                             \
                                .substep_time = 0,                              \
                        },                                                      \
                }),                                                             \
                .step_count = 1,                                                \
                .loop_forever = false,                                          \
        }
 
 
#define LED_EFFECT_LED_OFF() LED_EFFECT_LED_ON(LED_NOCOLOR())
 
#define LED_EFFECT_LED_ON_GO_OFF(_color, _on_time, _off_delay)                  \
        {                                                                       \
                .steps = ((const struct led_effect_step[]) {                    \
                        {                                                       \
                                .color = _color,                                \
                                .substep_count = 1,                             \
                                .substep_time = 0,                              \
                        },                                                      \
                        {                                                       \
                                .color = _color,                                \
                                .substep_count = 1,                             \
                                .substep_time = (_on_time),                     \
                        },                                                      \
                        {                                                       \
                                .color = LED_NOCOLOR(),                         \
                                .substep_count = (_off_delay)/10,               \
                                .substep_time = 10,                             \
                        },                                                      \
                }),                                                             \
                .step_count = 3,                                                \
                .loop_forever = false,                                          \
        }
 
#define LED_EFFECT_LED_BLINK2(_period_on, _period_off, _color)                  \
        {                                                                       \
                .steps = ((const struct led_effect_step[]) {                    \
                        {                                                       \
                                .color = _color,                                \
                                .substep_count = 1,                             \
                                .substep_time = (_period_off),                  \
                        },                                                      \
                        {                                                       \
                                .color = LED_NOCOLOR(),                         \
                                .substep_count = 1,                             \
                                .substep_time = (_period_on),                   \
                        },                                                      \
                }),                                                             \
                .step_count = 2,                                                \
                .loop_forever = true,                                           \
        }
 
#define LED_EFFECT_LED_BLINK(_period, _color) \
        LED_EFFECT_LED_BLINK2(_period, _period, LED_COLOR_ARG_PASS(_color))
 
#define _BREATH_SUBSTEPS 15
 
#define LED_EFFECT_LED_BREATH(_period, _color)                                          \
        {                                                                               \
                .steps = ((const struct led_effect_step[]) {                            \
                        {                                                               \
                                .color = _color,                                        \
                                .substep_count = _BREATH_SUBSTEPS,                      \
                                .substep_time = ((_period + (_BREATH_SUBSTEPS - 1))     \
                                                / _BREATH_SUBSTEPS),                    \
                        },                                                              \
                        {                                                               \
                                .color = _color,                                        \
                                .substep_count = 1,                                     \
                                .substep_time = _period,                                \
                        },                                                              \
                        {                                                               \
                                .color = LED_NOCOLOR(),                                 \
                                .substep_count = _BREATH_SUBSTEPS,                      \
                                .substep_time = ((_period + (_BREATH_SUBSTEPS - 1))     \
                                                / _BREATH_SUBSTEPS),                    \
                        },                                                              \
                        {                                                               \
                                .color = LED_NOCOLOR(),                                 \
                                .substep_count = 1,                                     \
                                .substep_time = _period,                                \
                        },                                                              \
                }),                                                                     \
                .step_count = 4,                                                        \
                .loop_forever = true,                                                   \
        }
 
#define LED_CLOCK_BLINK_PERIOD 200
 
#define LED_CLOCK_SLEEP_PERIOD 1000
 
#define _LED_CLOCK_TIK(i, ...)                                          \
                {                                                       \
                        .color = __VA_ARGS__,                           \
                        .substep_count = 1,                             \
                        .substep_time = LED_CLOCK_BLINK_PERIOD,         \
                },                                                      \
                {                                                       \
                        .color = LED_NOCOLOR(),                         \
                        .substep_count = 1,                             \
                        .substep_time = LED_CLOCK_BLINK_PERIOD,         \
                }
 
#define LED_EFFECT_LED_CLOCK(_ticks, _color)                                    \
        {                                                                       \
                .steps = ((const struct led_effect_step[]) {                    \
                        {                                                       \
                                .color = LED_NOCOLOR(),                         \
                                .substep_count = 1,                             \
                                .substep_time = LED_CLOCK_SLEEP_PERIOD,         \
                        },                                                      \
                        LISTIFY(_ticks, _LED_CLOCK_TIK, (,), _color)            \
                }),                                                             \
                .step_count = (2 * _ticks + 1),                                 \
                .loop_forever = true,                                           \
        }
 
#ifdef __cplusplus
}
#endif
 
#endif /* _LED_EFFECT_H_ */