MZ_uart_example.c

Go to the documentation of this file.

/*
 * Objectives covered in this Example :
 * 1. Demonstrate how to create a simple recursive Timer using MonoZ_Lib
 * 2. Demonstrate how to create a Application Thread using MonoZ_Lib
 * 3. Demonstrate how to send data in UART using MonoZ_Lib.
 * 4. Demonstrate how to create a semaphore using MonoZ_Lib.
 *
 * NOTE : This is an empty example.
 *
 * Sources for this example :
 * MZ_uart_example.c                - Main Application file
 * MZ_uart_example.h
 * MZ_uart3_instance.c              - UART driver file
 * MZ_uart3_instance.h
 */
 
 
#include "MZ_sys_cmsis_os2.h"
#include "MZ_uart_example.h"
#include "MZ_timer.h"
#include "MZ_print.h"
#include "MZ_uart3_instance.h"
#include "MZ_error_handler.h"
#include "MZ_uart.h"
 
/* Application related MACRO - START */
#define UART_APP_STACK_SIZE         (128)                                       
#define UART_TX_TIME                (pdMS_TO_TICKS(60000))                      
#define UART_TX_SIZE                (10)                                        
/* Application related MACRO - END */
 
/* Application related variables - START */
static mz_thread_t      uart_thread_id = NULL;                                  
static StaticTask_t     uart_cb_mem;                                            
static StackType_t      uart_stack[UART_APP_STACK_SIZE];                        
static mz_semaphore_t   uart_sema_id = NULL;                                    
static uint8_t send_data[UART_TX_SIZE];                                         
/* Application related variables - END */
 
/*
 * UART transmission timer callback - START
 *
 * This Timer callback will be called after the UART transmission timer is
 * expired.
 * The timer value is set as UART_TX_TIME
 */
static void timer_cb(TimerHandle_t xTimer)
{
    mz_puts("Timer expires\r\n");
    MZ_UART_Transmit_IT(MZ_UART_INSTANCE,
                        (uint8_t *)&send_data,
                        sizeof(send_data));
}
/* UART transmission timer callback - END */
 
 
/*
 * UART Application thread API. - START
 *
 * 1. It Create and start UART transmission timer
 * 2. Process other actions on the thread loop
 */
static void uart_app(void * arg)
{
    (void)arg;
 
    /*
     * create the UART transmission timer.
     * As per requirement, We are creating a recursive timer using
     * mz_tm_create_start_recursive() API.
     * In-case of other type of timer, please refer MZ_timer.h
     * The expire time for this timer set to UART_TX_TIME.
     * "timer_cb" is passed as an argument.
     * When the timer expires, the "timer_cb" API will be processed.
     */
    if(MZ_OK != mz_tm_create_start_recursive("UART transmission timer",
                                            UART_TX_TIME,
                                            timer_cb))
    {
        /* Timer create and start failed. */
        __NOP(); /* Dummy No operation statement */
    }
 
    /*
     * This is the infinite loop for this thread - the thread will execute this
     * loop forever and not come outside of this loop
     */
    while(1)
    {
        /* Need to write the periodic executing logic in this loop block */
        __NOP(); /* Dummy No operation statement */
 
        /* Add a delay for Non-blocking */
        HAL_Delay(1);
 
    }//End of while(1) - Do not place any code after this.
 
}
/* UART Application thread API. - END */
 
/*
 * UART Application initialization API. - START
 *
 * 1. It Initialize UART interface
 * 2. It create the main UART application
 * 3. It create a semaphore, that can be used in application
 */
mz_error_t uart_app_init(void)
{
    mz_error_t _ret = MZ_OK;
 
    /* Initialize UART 3 */
    mz_error_t UART3_init(void);
 
    /* Create the UART application threads */
    if(!mz_thread_create(   &uart_thread_id,
                            "UART Scheduler",
                            uart_app,
                            NULL,
                            osPriorityNormal,
                            uart_stack,
                            UART_APP_STACK_SIZE,
                            &uart_cb_mem,
                            sizeof(uart_cb_mem)))
    {
        _ret = MZ_THREAD_CREATE_FAIL;
    }
 
    /* Create lock with already locked */
    if(!mz_sem_create(&uart_sema_id,1U,1U))
    {
        _ret = MZ_SEMA_CREATE_FAIL;
    }
 
    return _ret;
}
/* UART Application initialization API. - END */