Button-Triggered Distance Measurement Solution

/*
 * Solution Name: Button-Triggered Distance Measurement Solution
 *
 * Description:
 * This embedded application uses Button Play Click and LightRanger 3
 * Click to measure the distance to an object when a button is pressed.
 * The button's backlight gradually fades in on press and fades out on release,
 * providing visual feedback. Distance measurements are averaged over multiple
 * readings to mitigate sensor noise and improve accuracy.
 *
 * The system utilizes the following Click boards:
 *   - Button Play Click: Captures button press/release events and controls
 *     LED backlight.
 *   - LightRanger 3 Click: Measures the distance to a nearby object using
 *     a laser sensor.
 *
 * The `application_init` function initializes the logger and both Click boards,
 * ensuring proper startup conditions. Any initialization failure is logged,
 * and the system halts.
 *
 * The `application_task` function monitors the button state and triggers
 * distance measurements when the button is pressed. It takes multiple readings,
 * calculates the average distance, and logs the result via UART.
 *
 * Hardware Setup:
 *   - MIKROBUS_1: Button Play Click
 *   - MIKROBUS_2: LightRanger 3 Click
 *
 * Key Features:
 *   - Button-controlled distance measurement with backlight feedback.
 *   - Multi-sample averaging to reduce sensor reading noise.
 *   - Smooth LED fade-in/out on button press/release.
 *   - UART logging for measurement data and system events.
 *
 * Development Environment:
 *   - [NECTO Studio](https://www.mikroe.com/necto)
 *   - [mikroSDK v2.0](https://www.mikroe.com/mikrosdk) framework
 *   - MIKROE [Click boards](https://www.mikroe.com/click-boards) Add-ons
 *
 * Author: Branko Jaksic
 * Date: 2025
 */

// ------------------------------------------------------------------- INCLUDES
#include "log.h"
#include "board.h"
#include "buttonplay.h"
#include "lightranger3.h"

// ------------------------------------------------------------------ VARIABLES
static buttonplay_t buttonplay;
static lightranger3_t lightranger3;
static log_t logger;

// ----------------------------------------------- PUBLIC FUNCTION DECLARATIONS

/**
 * @brief Initializes the Button Play Click board.
 *
 * Configures the Button Play Click board, sets up the PWM for LED
 * backlight control, and starts the PWM signal. If initialization fails,
 * the function logs an error and halts execution.
 *
 * @note The Button Play Click is connected to MIKROBUS_1.
 */
void initialize_button_play( void );

/**
 * @brief Initializes the LightRanger 3 Click board.
 *
 * Configures the LightRanger 3 Click board and performs device initialization. 
 * If the sensor fails to initialize, the function logs an error and halts
 * execution.
 *
 * @note The LightRanger 3 Click is connected to MIKROBUS_2.
 */
void initialize_light_ranger( void );

/**
 * @brief Updates the button backlight brightness.
 *
 * Smoothly fades the button's backlight LED in or out, depending on the
 * button state. When the button is pressed, the backlight gradually brightens.
 * When released, the backlight gradually dims.
 *
 * @param[in] is_pressed  Boolean indicating the button state:
 *                        - `true`: Fade in the backlight.
 *                        - `false`: Fade out the backlight.
 */
void update_button_backlight( bool is_pressed );

/**
 * @brief Measures and logs the distance using the LightRanger 3 Click.
 *
 * Takes a single distance measurement, retrieves the distance value,
 * and logs it via UART. This function is useful for quick,
 * real-time distance readings.
 */
void measure_and_log_distance( void );

// ------------------------------------------------------ APPLICATION FUNCTIONS
void application_init( void ) 
{
    log_cfg_t log_cfg;

    // Logger initialization
    LOG_MAP_USB_UART( log_cfg );
    log_init( &logger, &log_cfg );
    log_info( &logger, "Application Init" );

    initialize_button_play();
    initialize_light_ranger();

    log_info( &logger, "Initialization Complete, Starting Application Task" );
}

void initialize_button_play( void )
{
    buttonplay_cfg_t buttonplay_cfg;

    buttonplay_cfg_setup( &buttonplay_cfg );
    BUTTONPLAY_MAP_MIKROBUS( buttonplay_cfg, MIKROBUS_1 );

    if ( buttonplay_init( &buttonplay, &buttonplay_cfg ) == PWM_ERROR ) 
    {
        log_error( &logger, "Button Play Click initialization failed!" );
        for ( ; ; );  // Halt execution
    }

    buttonplay_set_duty_cycle( &buttonplay, 0.0 );
    buttonplay_pwm_start( &buttonplay );
    log_info( &logger, "Button Play Click initialized successfully." );
}

void initialize_light_ranger( void )
{
    lightranger3_cfg_t lightranger3_cfg;

    lightranger3_cfg_setup( &lightranger3_cfg );
    LIGHTRANGER3_MAP_MIKROBUS( lightranger3_cfg, MIKROBUS_2 );
    lightranger3_init( &lightranger3, &lightranger3_cfg );

    if ( lightranger3_device_init( &lightranger3 ) != 0 ) 
    {
        log_error( &logger, "LightRanger Click initialization failed!" );
        for ( ; ; );  // Halt execution
    }

    log_info( &logger, "LightRanger Click initialized successfully." );
}

void application_task( void ) 
{
    static uint8_t button_state_old = 0;
    uint8_t button_state = buttonplay_get_button_state( &buttonplay );

    if ( button_state != button_state_old ) 
    {
        if ( button_state ) 
        {
            log_printf( &logger, " <-- Button Pressed --> \r\n" );
            update_button_backlight( true );

            // Measure distance multiple times and calculate the mean value
            uint32_t distance_sum = 0;
            uint8_t num_measurements = 5;

            for ( uint8_t i = 0; i < num_measurements; i++ ) 
            {
                lightranger3_take_single_measurement( &lightranger3 );
                distance_sum += lightranger3_get_distance( &lightranger3 );
                Delay_ms( 100 ); // Small delay between measurements
            }

            uint16_t average_distance = ( uint16_t )( distance_sum / num_measurements );
            log_printf( &logger, "Average Distance: %u mm\r\n", average_distance );
        } 
        else 
        {
            log_printf( &logger, " <-- Button Released --> \r\n" );
            update_button_backlight( false );
        }

        button_state_old = button_state;
    }
}

void update_button_backlight( bool is_pressed )
{
    float duty_cycle;

    if ( is_pressed ) 
    {
        for ( uint8_t n = 1; n <= 100; n++ ) 
        {
            buttonplay_set_duty_cycle( &buttonplay, (float)n / 100 );
            Delay_ms( 10 );
        }
    } 
    else 
    {
        for ( uint8_t n = 100; n > 0; n-- ) 
        {
            buttonplay_set_duty_cycle( &buttonplay, (float)n / 100 );
            Delay_ms( 10 );
        }
    }
}

void measure_and_log_distance( void )
{
    lightranger3_take_single_measurement( &lightranger3 );
    uint16_t distance = lightranger3_get_distance( &lightranger3 );

    log_printf( &logger, "Distance: %u mm\r\n", distance );
}

int main( void ) 
{
    #ifdef PREINIT_SUPPORTED
    preinit();
    #endif

    application_init();

    while ( 1 ) 
    {
        application_task();
    }

    return 0;
}