Real-Time Joystick Position Tracking

/*
 * Solution Name: Real-Time Joystick Position Tracking Solution
 *
 * Description:
 * This embedded application continuously tracks joystick positions 
 * using the Joystick 3 Click and logs the detected positions to Flash memory 
 * via the Flash 12 Click.
 *
 * The system utilizes the following Click boards:
 *   - Joystick 3 Click: Captures joystick position in raw ADC values and detects 
 *     movement directions.
 *   - Flash 12 Click: Stores detected joystick positions in non-volatile memory.
 *
 * The `application_init` function initializes both Joystick 3 and Flash 12 Clicks,
 * ensuring proper configuration and communication, and sets up the UART logger for debugging.
 *
 * The `application_task` function monitors joystick position changes and logs the detected 
 * positions to Flash memory when a new position is detected. It also verifies stored data 
 * by reading from memory.
 *
 * Hardware Setup:
 *   - MIKROBUS_1: Joystick 3 Click (Joystick position tracking)
 *   - MIKROBUS_2: Flash 12 Click (Persistent storage for joystick positions)
 *
 * Key Features:
 *   - Real-time detection of joystick position changes.
 *   - Logging of joystick positions to Flash memory.
 *   - Verification of stored data through memory read-back.
 *   - UART-based logging for displaying position updates.
 *
 * 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 "board.h"
#include "log.h"
#include "flash12.h"
#include "joystick3.h"

// ------------------------------------------------------------- PRIVATE MACROS
// Starting memory address
#define STARTING_ADDRESS 0x012345

// ------------------------------------------------------------------ VARIABLES
static log_t logger;
static flash12_t flash12;
static joystick3_t joystick3;
typedef uint8_t joystick3_position_t;

// ------------------------------------------------------ APPLICATION FUNCTIONS
void application_init ( void )
{
    log_cfg_t log_cfg;  /**< Logger config object. */
    joystick3_cfg_t joystick3_cfg;  /**< Click config object. */
    flash12_cfg_t flash12_cfg;  /**< Click config object. */

    /** 
     * Logger initialization.
     * Default baud rate: 115200
     * Default log level: LOG_LEVEL_DEBUG
     * @note If USB_UART_RX and USB_UART_TX 
     * are defined as HAL_PIN_NC, you will 
     * need to define them manually for log to work. 
     * See @b LOG_MAP_USB_UART macro definition for detailed explanation.
     */
    LOG_MAP_USB_UART( log_cfg );
    log_init( &logger, &log_cfg );
    log_info( &logger, " Application Init " );

    // Joystick 3 Click initialization.
    joystick3_cfg_setup( &joystick3_cfg );
    JOYSTICK3_MAP_MIKROBUS( joystick3_cfg, MIKROBUS_1 );
    if ( SPI_MASTER_ERROR == joystick3_init( &joystick3, &joystick3_cfg ) )
    {
        log_error( &logger, " Communication init." );
        for ( ; ; );
    }

    // Flash 12 Click initialization.
    flash12_cfg_setup( &flash12_cfg );
    FLASH12_MAP_MIKROBUS( flash12_cfg, MIKROBUS_2 );
    if ( SPI_MASTER_ERROR == flash12_init( &flash12, &flash12_cfg ) )
    {
        log_error( &logger, " Communication init." );
        for ( ; ; );
    }
    
    if ( FLASH12_ERROR == flash12_default_cfg ( &flash12 ) )
    {
        log_error( &logger, " Default configuration." );
        for ( ; ; );
    }

    log_info( &logger, " Application Task " );
}

void read_logged_positions ( void ) 
{
    uint32_t mem_address = STARTING_ADDRESS;
    uint8_t data_buf[32] = { 0 };

    log_printf( &logger, "\r\n--- Reading Stored Joystick Positions ---\r\n" );

    while ( 1 ) 
    {
        memset( data_buf, 0, sizeof( data_buf ) );

        if ( FLASH12_OK != flash12_memory_read( &flash12, mem_address, data_buf, sizeof( data_buf ) ) )
        {
            log_printf( &logger, "Error reading memory at 0x%.6lX\r\n", mem_address );
            break;
        }

        // Stop if we reach an empty space (default erased flash value is 0xFF)
        if ( data_buf[0] == 0xFF || data_buf[0] == '\0' ) 
        {
            log_printf( &logger, "End of logged data.\r\n" );
            break;
        }

        log_printf( &logger, "Memory 0x%.6lX: %s\r\n", mem_address, data_buf );

        mem_address += strlen( (char*)data_buf ) + 1;  // Move to the next stored entry
    }

    log_printf( &logger, "-----------------------------------------\r\n" );
}

void application_task ( void ) 
{
    static uint32_t mem_address = STARTING_ADDRESS;  // Rolling memory address
    static joystick3_position_t last_position = JOYSTICK3_POSITION_NEUTRAL;
    
    uint16_t raw_x, raw_y;
    uint8_t data_buf[32] = { 0 };  // Buffer for logging position
    
    // Read Joystick raw ADC values
    if ( JOYSTICK3_OK == joystick3_read_raw_adc ( &joystick3, &raw_x, &raw_y ) ) 
    {
        joystick3_position_t current_position = joystick3_get_position( raw_x, raw_y );

        // Log position if it changes
        if ( current_position != last_position ) 
        {
            const char* position_str = "UNKNOWN";

            switch ( current_position ) 
            {
                case JOYSTICK3_POSITION_NEUTRAL: position_str = "NEUTRAL"; break;
                case JOYSTICK3_POSITION_UP: position_str = "UP"; break;
                case JOYSTICK3_POSITION_UPPER_RIGHT: position_str = "UPPER-RIGHT"; break;
                case JOYSTICK3_POSITION_RIGHT: position_str = "RIGHT"; break;
                case JOYSTICK3_POSITION_LOWER_RIGHT: position_str = "LOWER-RIGHT"; break;
                case JOYSTICK3_POSITION_DOWN: position_str = "DOWN"; break;
                case JOYSTICK3_POSITION_LOWER_LEFT: position_str = "LOWER-LEFT"; break;
                case JOYSTICK3_POSITION_LEFT: position_str = "LEFT"; break;
                case JOYSTICK3_POSITION_UPPER_LEFT: position_str = "UPPER-LEFT"; break;
            }

            // Display position on UART
            log_printf( &logger, "Joystick position: %s\r\n", position_str );

            // Write position to Flash memory
            memset( data_buf, 0, sizeof( data_buf ) );
            strncpy( (char*)data_buf, position_str, sizeof( data_buf ) - 1 );

            if ( FLASH12_OK == flash12_memory_write( &flash12,
                                                     mem_address,
                                                     data_buf,
                                                     strlen( position_str ) + 1 ) )
            {
                log_printf( &logger, "Stored in Flash at 0x%.6lX: %s\r\n",
                            mem_address,
                            data_buf );
                mem_address += strlen( position_str ) + 1;  // Move address forward
            }

            last_position = current_position;  // Update last position
            Delay_ms( 2000 );
        }
        read_logged_positions();  // Call to read and verify stored positions
    }

    Delay_ms( 100 );
}


int main ( void ) 
{
    /* Do not remove this line or clock might not be set correctly. */
    #ifdef PREINIT_SUPPORTED
    preinit();
    #endif

    application_init( );

    for ( ; ; ) 
    {
        application_task( );
    }

    return 0;
}

// ------------------------------------------------------------------------ END