MZ_spi_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 SPI using MonoZ_Lib.
 * 4. Demonstrate how to create a semaphore using MonoZ_Lib.
 *
 * NOTE : This is an empty example.
 *
 * Sources for this example :
 * MZ_spi_example.c                 - Main Application file
 * MZ_spi_example.h
 * MZ_spi1_instance.c               - SPI driver file
 * MZ_spi1_instance.h
 */
 
/* Include Header Files - START */
#include "MZ_sys_cmsis_os2.h"
#include "MZ_spi_example.h"
#include "MZ_timer.h"
#include "MZ_print.h"
#include "MZ_spi2_instance.h"
#include "MZ_error_handler.h"
#include "MZ_spi.h"
#include <stdio.h>
#include <math.h>
#include<stdlib.h>
#include "stm32l4xx_hal_spi.h"
/* Include Header Files - END */
 
/* Application related MACRO - START */
#define SPI_APP_STACK_SIZE          (1024)
#define SPI_TX_TIME             (pdMS_TO_TICKS(60000))
#define SPI_TX_SIZE             (10)
 
static mz_thread_t      spi_thread_id = NULL;
static StaticTask_t     spi_cb_mem;
static StackType_t      spi_stack[SPI_APP_STACK_SIZE];
static mz_semaphore_t   spi_sema_id = NULL;
static mzUint8 send_data[SPI_TX_SIZE];
/* Application related variables - END */
 
static void timer_cb(TimerHandle_t xTimer)
{
    mz_puts("Timer expires\r\n");
    MZ_SPI_Transmit_IT(MZ_SPI_INSTANCE,(uint8_t *)&send_data, sizeof(send_data));
}
 
static void spi_app(void * arg)
{
    (void)arg;
 
    /*
         * create the SPI 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 SPI_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("SPI Read timer",SPI_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.
 
}
/* SPI Application thread API. - END */
 
/*
 * @fn mz_error_t spi_app_init(void)
 * @brief creates the App thread and semaphore
 * @return MZ_OK/MZ_FAIL
 */
/* SPI Application initialization API. - START
 *
 * 1. It Initialize SPI interface
 * 2. It create the main SPI application
 * 3. It create a semaphore, that can be used in application
 */
mz_error_t spi_app_init(void)
{
    mz_error_t _ret = MZ_OK;
 
    // Initialize SPI 1
    if(MZ_OK != SPI1_init())
        return MZ_FAIL;
 
    // Create the SPI application threads
    if(!mz_thread_create(   &spi_thread_id,
                            "SPI Scheduler",
                            spi_app,
                            NULL,
                            osPriorityNormal,
                            spi_stack,
                            SPI_APP_STACK_SIZE,
                            &spi_cb_mem,
                            sizeof(spi_cb_mem)))
    {
        _ret = MZ_THREAD_CREATE_FAIL;
    }
 
    // Create lock with already locked
    if(!mz_sem_create(&spi_sema_id,1U,1U))
    {
        _ret = MZ_SEMA_CREATE_FAIL;
    }
 
    return _ret;
}
/* SPI Application initialization API. - END */