【ZynqMP】2.Cortex-R5でRTOS+GPIO

/* FreeRTOS */
#include "FreeRTOS.h"
#include "task.h"
#include "queue.h"

/* Xilinx */
#include "xparameters.h"
#include "xgpio.h"
#include "xil_exception.h"
#include "xscugic.h"
#include "xinterrupt_wrap.h"
#include "xil_printf.h"

/* others */
#include "stdint.h"
#include <FreeRTOSConfig.h>
#include <portmacro.h>

static TaskHandle_t hb_led_task = NULL;
static TaskHandle_t led_task = NULL;
static TaskHandle_t switch_task =NULL;
static QueueHandle_t sw_event_queue = NULL;

/* main ---------------------------------------------------------*/
int main(void)
{
    BaseType_t ret;

    ret = xTaskCreate(  HeartBeatLedTask,
                        (const char *)"HBLedTask",
                        configMINIMAL_STACK_SIZE,
                        NULL,
                        tskIDLE_PRIORITY,
                        &hb_led_task);
    if(ret != pdPASS){
        xil_printf("xTaskCreate Error.");
        return 0;
    }

    ret = xTaskCreate(  LedTask,
                        (const char *)"LedTask",
                        configMINIMAL_STACK_SIZE,
                        NULL,
                        tskIDLE_PRIORITY + 1,
                        &led_task);
    if(ret != pdPASS){
        xil_printf("xTaskCreate Error.");
        return 0;
    }
    
    ret = xTaskCreate(  SwitchTask,
                        (const char *)"SwitchTask",
                        configMINIMAL_STACK_SIZE,
                        NULL,
                        tskIDLE_PRIORITY + 2,
                        &switch_task);
    if(ret != pdPASS){
        xil_printf("xTaskCreate Error.");
        return 0;
    }
    
    sw_event_queue = xQueueCreate(QUEUE_LENGTH, sizeof(SwitchEvents_t));
    configASSERT(sw_event_queue);

    vTaskStartScheduler();

    while(1);
}

/* Switch Control -----------------------------------------------*/
static void SwitchTask(void *pvParameters);
static void GpioIntHandler(void *CallbackRef);

static XGpio user_sw_gpio;
#define USER_SW_MASK   (0x00000001U)
#define SW_GPIO_CH     (1U)
#define SW_GPIO_ACTIVE (0U)
#define QUEUE_LENGTH   (4U)

typedef enum {
    kSwErr = 0,
    kSw1Pushed,
} SwitchEvents_t;

static void SwitchTask(void *pvParameters)
{
    int gpio_ret;
    XGpio_Config *ConfigPtr;
    uint32_t gpio_io_reg = 0U;
    const SwitchEvents_t sw_event_push = kSw1Pushed;

    /* AXI-GPIO初期化 */
    ConfigPtr = XGpio_LookupConfig(XPAR_XGPIO_2_BASEADDR);
    gpio_ret = XGpio_Initialize(&user_sw_gpio, XPAR_XGPIO_2_BASEADDR);
    if (gpio_ret != XST_SUCCESS) {
        xil_printf("led gpio driver init error.");
        configASSERT(FALSE);
    }
    XGpio_SetDataDirection(&user_sw_gpio, SW_GPIO_CH, USER_SW_MASK);

    /* GICv1のAXI-GPIO関連設定 */
    gpio_ret = XSetupInterruptSystem(   &user_sw_gpio,
                                        &GpioIntHandler,
                                        ConfigPtr->IntrId,
                                        ConfigPtr->IntrParent,
                                        XINTERRUPT_DEFAULT_PRIORITY);
    if (gpio_ret != XST_SUCCESS) {
        xil_printf("switch gpio driver init error.");
        configASSERT(FALSE);
    }

    /* AXI-GPIOのピン入力割込有効 */
    XGpio_InterruptEnable(&user_sw_gpio, USER_SW_MASK);
    XGpio_InterruptGlobalEnable(&user_sw_gpio);    

    while(1){
        (void)ulTaskNotifyTake(pdTRUE, portMAX_DELAY);

        gpio_io_reg = XGpio_DiscreteRead(&user_sw_gpio, SW_GPIO_CH);

        if((gpio_io_reg & USER_SW_MASK) == SW_GPIO_ACTIVE){
            xQueueSend(sw_event_queue,
                        &sw_event_push,
                        0UL);
        }
    }
}

/* GPIO割込みハンドラ */
static void GpioIntHandler(void *CallbackRef)
{
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    XGpio *GpioPtr = (XGpio *)CallbackRef;

    /* AXI-GPIOの割込み要因クリア */
    XGpio_InterruptClear(GpioPtr, SW_GPIO_CH);

    /* スイッチタスクに通知 */
    vTaskNotifyGiveFromISR(switch_task, &xHigherPriorityTaskWoken);

    /* スケジューラ制御 */
    portYIELD_FROM_ISR( xHigherPriorityTaskWoken );
}

/* User LED Control ----------------------------------------------*/
static void LedTask(void *pvParameters);

static XGpio user_led_gpio;
#define USER_LED_MASK (0x00000001U)
#define LED_GPIO_CH   (1U)

static void LedTask(void *pvParameters)
{
    SwitchEvents_t sw_ev = kSwErr;
    BaseType_t ret;
    int gpio_ret;
    LedStatus_t led_status = kLedOff;

    /* AXI-GPIO初期化 */
    gpio_ret = XGpio_Initialize(&user_led_gpio, XPAR_XGPIO_1_BASEADDR);
    if (gpio_ret != XST_SUCCESS) {
        xil_printf("gpio driver init error.");
        configASSERT(FALSE);
    }
    XGpio_SetDataDirection(&user_led_gpio, LED_GPIO_CH, ~USER_LED_MASK);
    XGpio_DiscreteClear(&user_led_gpio, LED_GPIO_CH, USER_LED_MASK);

    while(1){
        /* Switchタスクからの押下イベント待ち */
        ret = xQueueReceive(sw_event_queue,
                            (SwitchEvents_t*) &sw_ev,
                            portMAX_DELAY);
        if(ret != pdPASS){
            xil_printf("xTaskReceive Error.");
            configASSERT(FALSE);
        }else {
            switch(sw_ev){
                case kSwErr:
                    xil_printf("Switch events Error.");
                    configASSERT(FALSE);
                    break;
                case kSw1Pushed:
                    /* スイッチが押下されたのでLEDをトグル */
                    if(led_status == kLedOn){
                        led_status = kLedOff;
                        XGpio_DiscreteClear(&user_led_gpio,
                                            LED_GPIO_CH,
                                            USER_LED_MASK);
                    }else{
                        led_status = kLedOn;
                        XGpio_DiscreteWrite(&user_led_gpio,
                                            LED_GPIO_CH,
                                            USER_LED_MASK);
                    }
                    break;
                default:
                    xil_printf("Switch events Error.");
                    configASSERT(FALSE);
                    break;
            }
        }
    }
}

/* Heart Beat LED ----------------------------------------------- */
static void HeartBeatLedTask(void *pvParameters);

static XGpio beat_led_gpio;

#define BEAT_LED_MASK    (0x00000001U)
#define BEAT_LED_GPIO_CH (1U)

typedef enum {
    kLedOff = 0,
    kLedOn
} LedStatus_t;

static void HeartBeatLedTask(void *pvParameters)
{
    int gpio_ret;
    LedStatus_t led_status = kLedOff;

    /* AXI-GPIO初期化 */
    gpio_ret = XGpio_Initialize(&beat_led_gpio, XPAR_XGPIO_0_BASEADDR);
    if (gpio_ret != XST_SUCCESS) {
        xil_printf("gpio driver init error.");
        configASSERT(FALSE);
    }
    XGpio_SetDataDirection(&user_led_gpio, BEAT_LED_GPIO_CH, ~BEAT_LED_MASK);
    XGpio_DiscreteClear(&user_led_gpio, BEAT_LED_GPIO_CH, BEAT_LED_MASK);

    while(1)
    {
        /* LED点滅 */
        vTaskDelay(500/portTICK_PERIOD_MS);
        if(led_status == kLedOff){
            led_status = kLedOn;
            XGpio_DiscreteWrite(&beat_led_gpio,
                                BEAT_LED_GPIO_CH,
                                BEAT_LED_MASK);
        }else{
            led_status = kLedOff;
            XGpio_DiscreteClear(&beat_led_gpio,
                                BEAT_LED_GPIO_CH,
                                BEAT_LED_MASK);
        }
    }
}