Dual Joystick Position Tracking Solution

/*
 * Solution Name: Dual Joystick Real-Time Position Tracking Solution
 *
 * Description:
 * This embedded application continuously tracks joystick positions 
 * using two Joystick 3 Click boards and logs the detected positions 
 * to Flash memory via the Flash 12 Click.
 *
 * The system utilizes the following Click boards:
 *   - Joystick 3 Click (x2): Captures joystick positions in raw ADC values and detects 
 *     movement directions for both joysticks.
 *   - Flash 12 Click: Stores detected joystick positions in non-volatile memory.
 *
 * The `application_init` function initializes both Joystick 3 Click boards and the Flash 12 Click,
 * ensuring proper configuration and communication, and sets up the UART logger for debugging.
 *
 * The `application_task` function monitors position changes for both joysticks 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 #1 (Joystick position tracking)
 *   - MIKROBUS_2: Flash 12 Click (Persistent storage for joystick positions)
 *   - MIKROBUS_4: Joystick 3 Click #2 (Second joystick position tracking)
 *
 * Key Features:
 *   - Real-time detection of joystick position changes for both joysticks.
 *   - 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: March, 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_1;  // First Joystick (mikroBUS_1)
static joystick3_t joystick3_2;  // Second Joystick (mikroBUS_4)

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_1;  /**< Click config object. */
    joystick3_cfg_t joystick3_cfg_2;  /**< 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 (1st) Click initialization.
    joystick3_cfg_setup( &joystick3_cfg_1 );
    JOYSTICK3_MAP_MIKROBUS( joystick3_cfg_1, MIKROBUS_1 );
    if ( SPI_MASTER_ERROR == joystick3_init( &joystick3_1, &joystick3_cfg_1 ) )
    {
        log_error( &logger, " Communication init." );
        for ( ; ; );
    }

    // Joystick 3 (2nd) Click initialization.
    joystick3_cfg_setup( &joystick3_cfg_2 );
    JOYSTICK3_MAP_MIKROBUS( joystick3_cfg_2, MIKROBUS_4 );
    if ( SPI_MASTER_ERROR == joystick3_init( &joystick3_2, &joystick3_cfg_2 ) )
    {
        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_1 = STARTING_ADDRESS;
    uint32_t mem_address_2 = STARTING_ADDRESS + 0x100;
    uint8_t data_buf[32] = { 0 };

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

    // Read Joystick 1 logged positions
    log_printf( &logger, "Joystick 1 Positions:\r\n" );
    while ( 1 ) 
    {
        memset( data_buf, 0, sizeof( data_buf ) );

        if ( FLASH12_OK != flash12_memory_read( &flash12, mem_address_1, data_buf, sizeof( data_buf ) ) )
        {
            log_printf( &logger, "Error reading memory at 0x%.6lX\r\n", mem_address_1 );
            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 Joystick 1 logged data.\r\n" );
            break;
        }

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

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

    // Read Joystick 2 logged positions
    log_printf( &logger, "Joystick 2 Positions:\r\n" );
    while ( 1 ) 
    {
        memset( data_buf, 0, sizeof( data_buf ) );

        if ( FLASH12_OK != flash12_memory_read( &flash12, mem_address_2, data_buf, sizeof( data_buf ) ) )
        {
            log_printf( &logger, "Error reading memory at 0x%.6lX\r\n", mem_address_2 );
            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 Joystick 2 logged data.\r\n" );
            break;
        }

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

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

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

const char* joystick_position_to_string( joystick3_position_t position ) 
{
    switch ( position ) 
    {
        case JOYSTICK3_POSITION_NEUTRAL:      return "NEUTRAL";
        case JOYSTICK3_POSITION_UP:           return "UP";
        case JOYSTICK3_POSITION_DOWN:         return "DOWN";
        case JOYSTICK3_POSITION_LEFT:         return "LEFT";
        case JOYSTICK3_POSITION_RIGHT:        return "RIGHT";
        case JOYSTICK3_POSITION_UPPER_LEFT:   return "UPPER-LEFT";
        case JOYSTICK3_POSITION_UPPER_RIGHT:  return "UPPER-RIGHT";
        case JOYSTICK3_POSITION_LOWER_LEFT:   return "LOWER-LEFT";
        case JOYSTICK3_POSITION_LOWER_RIGHT:  return "LOWER-RIGHT";
        default:                              return "UNKNOWN";
    }
}

void application_task ( void ) 
{
    static uint32_t mem_address_1 = STARTING_ADDRESS; // Rolling memory address
    static uint32_t mem_address_2 = STARTING_ADDRESS + 0x100;  // Offset for second joystick
    static joystick3_position_t last_position_1 = JOYSTICK3_POSITION_NEUTRAL;
    static joystick3_position_t last_position_2 = JOYSTICK3_POSITION_NEUTRAL;
    
    uint16_t raw_x1, raw_y1, raw_x2, raw_y2;
    uint8_t data_buf[32] = { 0 };  // Buffer for logging position
    
    // Read Joystick 1 raw ADC values
    if ( JOYSTICK3_OK == joystick3_read_raw_adc ( &joystick3_1, &raw_x1, &raw_y1 ) ) 
    {
        joystick3_position_t current_position_1 = joystick3_get_position( raw_x1, raw_y1 );

        // Log position if it changes
        if ( current_position_1 != last_position_1 ) 
        {
            const char* position_str_1 = joystick_position_to_string( current_position_1 );
            log_printf( &logger, "Joystick 1 position: %s\r\n", position_str_1 );

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

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

            last_position_1 = current_position_1;  // Update last position
        }
        read_logged_positions();  // Call to read and verify stored positions
    }

    // Read Joystick 2 raw ADC values
    if ( JOYSTICK3_OK == joystick3_read_raw_adc ( &joystick3_2, &raw_x1, &raw_y2 ) ) 
    {
        joystick3_position_t current_position_2 = joystick3_get_position( raw_x2, raw_y2 );

        // Log position if it changes
        if ( current_position_2 != last_position_2 ) 
        {
            const char* position_str_2 = joystick_position_to_string( current_position_2 );
            log_printf( &logger, "Joystick 2 position: %s\r\n", position_str_2 );

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

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

            last_position_2 = current_position_2;  // Update last position
        }
        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