MZ_gpio_example.c

Go to the documentation of this file.

/*
 * MZ_gpio_example.c
 *
 *  Created on: 16-Mar-2022
 *      Author: Mahendra
 */
/*
 * 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 GPIO using MonoZ_Lib.
 * 4. Demonstrate how to create a semaphore using MonoZ_Lib.
 *
 * NOTE : This is an empty example.
 *
 * Sources for this example :
 * MZ_gpio_example.c                - Main Application file
 * MZ_gpio_example.h
 * MZ_gpio_instance.c               - GPIO driver file
 * MZ_gpio_instance.h
 */
 
 
#include "MZ_sys_cmsis_os2.h"
#include "MZ_gpio_example.h"
#include "MZ_timer.h"
#include "MZ_print.h"
#include "MZ_gpio_instance.h"
#include "MZ_error_handler.h"
#include "MZ_gpio.h"
#include "MZ_gpio_instance.h"
 
/* Application related MACRO - START */
#define GPIO_APP_STACK_SIZE         (128)                                       
#define GPIO_TX_TIME                (pdMS_TO_TICKS(5000))                       
#define GPIO_TX_SIZE                (10)                                        
/* Application related MACRO - END */
 
/* Application related variables - START */
static mz_thread_t      gpio_thread_id = NULL;                                  
static StaticTask_t     gpio_cb_mem;                                            
static StackType_t      gpio_stack[GPIO_APP_STACK_SIZE];                        
static mz_semaphore_t   gpio_sema_id = NULL;                                    
//static uint8_t send_data[GPIO_TX_SIZE];                                           /*!< GPIO transmission buffer */
/* Application related variables - END */
 
/*
 * GPIO transmission timer callback - START
 *
 * This Timer callback will be called after the GPIO transmission timer is
 * expired.
 * The timer value is set as GPIO_TX_TIME
 */
static void timer_cb(TimerHandle_t xTimer)
{
    mz_puts("Timer expires\r\n");
//  MZ_GPIO_Transmit_IT(MZ_GPIO_INSTANCE,
//                      (uint8_t *)&send_data,
//                      sizeof(send_data));
MZ_GPIO_TogglePin(MZ_PORT_GPIO1,MZ_GPIO_PIN1);
 
}
/* GPIO transmission timer callback - END */
 
 
/*
 * GPIO Application thread API. - START
 *
 * 1. It Create and start GPIO transmission timer
 * 2. Process other actions on the thread loop
 */
static void gpio_app(void * arg)
{
    (void)arg;
 
    /*
     * create the GPIO 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 GPIO_TX_TIME.
     * "timer_cb" is passed as an argument.
     * When the timer expires, the "timer_cb" API will be processed.
     */
 
    MZ_GPIO_WritePin(MZ_PORT_GPIO1, MZ_GPIO_PIN1, GPIO_PIN_SET);
    /* Initialize GPIO  */
//  if(MZ_OK != gpio_init()){
//      Error_Handler();
//  }
 
    if(MZ_OK != mz_tm_create_start_recursive("GPIO transmission timer",
                                            GPIO_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
     */
    /*
     * Use GPIO Configure API as output(GPIO_PIN_RESET) or input (GPIO_PIN_SET)
     */
//  MZ_GPIO_INIT_ST gpio_instance = {0};
 
//  MZ_GPIO_WritePin(MZ_PORT_GPIOF, MZ_GPIO_PIN_3, GPIO_PIN_SET);
//  /* Initialize GPIO  */
//  if(MZ_OK != gpio_init()){
//      Error_Handler();
//  }
 
    while(1)
    {
        /* Need to write the periodic executing logic in this loop block */
        __NOP(); /* Dummy No operation statement */
//
//      MZ_GPIO_TogglePin(MZ_PORT_GPIOF,MZ_GPIO_PIN_3);
//
//      /* Add a delay for Non-blocking */
//      HAL_Delay(5000);
 
    }//End of while(1) - Do not place any code after this.
 
}
/* GPIO Application thread API. - END */
 
/*
 * GPIO Application initialization API. - START
 *
 * 1. It Initialize GPIO interface
 * 2. It create the main GPIO application
 * 3. It create a semaphore, that can be used in application
 */
mz_error_t gpio_app_init(void)
{
    mz_error_t _ret = MZ_OK;
    /* Create the GPIO application threads */
    if(!mz_thread_create(   &gpio_thread_id,
                            "GPIO Scheduler",
                            gpio_app,
                            NULL,
                            osPriorityNormal,
                            gpio_stack,
                            GPIO_APP_STACK_SIZE,
                            &gpio_cb_mem,
                            sizeof(gpio_cb_mem)))
    {
        _ret = MZ_THREAD_CREATE_FAIL;
    }
 
    /* Create lock with already locked */
    if(!mz_sem_create(&gpio_sema_id,1U,1U))
    {
        _ret = MZ_SEMA_CREATE_FAIL;
    }
 
    return _ret;
}
/* GPIO Application initialization API. - END */