Android Guided Vehicle

#include "board.h"
#include "fsl_flexio_uart_driver.h"
#include "fsl_clock_manager.h"
#include "fsl_lpuart_driver.h"
#include "fsl_debug_console.h"
// Standard C Included Files
#include <stdio.h>
// SDK Included Files
#include "board.h"
#include "gpio_pins.h"
#include "fsl_debug_console.h"


//GPIO

// Variables


volatile bool isButtonPress = false;

// Code

/*
 * Uses a switch to run a motor
 *
 * This function toogles motor when press the switch.
 */
int main(void)
{
    // Define gpio input pin config structure SW.
    gpio_input_pin_user_config_t inputPin[] = {
        {
            .pinName                       = BOARD_SW_GPIO,
            .config.isPullEnable           = true,
#if FSL_FEATURE_PORT_HAS_PULL_SELECTION
            .config.pullSelect             = kPortPullUp,
#endif
#if FSL_FEATURE_PORT_HAS_PASSIVE_FILTER
            .config.isPassiveFilterEnabled = false,
#endif
#if FSL_FEATURE_PORT_HAS_DIGITAL_FILTER
            .config.isDigitalFilterEnabled = false,
#endif
            .config.interrupt              = kPortIntFallingEdge,
        },
        {
            .pinName = GPIO_PINS_OUT_OF_RANGE,
        }
    };

    // Define gpio output pin config structure LED1.
    gpio_output_pin_user_config_t outputPin[] = {
        {
            .pinName              = kGpioM1,
            .config.outputLogic   = 0,
#if FSL_FEATURE_PORT_HAS_SLEW_RATE
            .config.slewRate      = kPortFastSlewRate,
#endif
#if FSL_FEATURE_PORT_HAS_DRIVE_STRENGTH
            .config.driveStrength = kPortHighDriveStrength,
#endif
        },
        {
            .pinName = GPIO_PINS_OUT_OF_RANGE,
        }
    };

    // Init hardware
    hardware_init();

    // Print a note to terminal.
    PRINTF("\r\n Press %s to turn on/off a motor\r\n",BOARD_SW_NAME);

    // Init motor, Switch.
    GPIO_DRV_Init(inputPin, outputPin);
    // Turn motor on.
    GPIO_DRV_ClearPinOutput(kGpioM1);

    while(1)
    {
        if(isButtonPress)
        {
            PRINTF(" %s is pressed \r\n",BOARD_SW_NAME);
            // Reset state of button.
            isButtonPress=false;
        }
    }
}

/*!
 * @brief Interrupt service fuction of switch.
 *
 * This function toogles motor
 */
void BOARD_SW_IRQ_HANDLER(void)
{
    // Clear external interrupt flag.
    GPIO_DRV_ClearPinIntFlag(BOARD_SW_GPIO);
    // Change state of button.
    isButtonPress = true;
    // Toggle motor
    GPIO_DRV_TogglePinOutput(kGpioM1);
}


//  Variables

static uint32_t s_flexioInstance;
flexio_uart_state_t uartState;
#define DATA_LENGTH         65
const uint8_t txBuff[] = "This data to transfer between FlexIO simulated UART and LPUART";
uint8_t rxBuff[DATA_LENGTH] = {0};
#if defined TWR_K80F150M || defined TWR_K81F150M || defined FRDM_K82F
#define COMM_UART_INSTANCE    0
#else
#define COMM_UART_INSTANCE    1
#endif

//  Codes


bool flexio_uart_compare(uint8_t *txBuff, uint8_t *rxBuff, uint32_t count)
{
    uint32_t i;
    /* Comapre source and sink data*/
    for (i = 0; i < count ; i++)
    {
        if (txBuff[i] != rxBuff[i])
        {
            return false;
        }
    }
    return true;
}
/*!
 * @brief reset a buffer.
 * @param source The pointer to the buffer
 * @param size of the buffer
 */
void flexio_uart_reset_buffer(uint8_t *txBuff, uint32_t count)
{
    uint32_t i;
    /* Comapre source and sink data*/
    for (i = 0; i < count ; i++)
    {
        txBuff[i] = 0;
    }
}
/*!
 * @brief Check send/receive blocking functionality
 *
 */
int main(void)
{
    lpuart_state_t lpuartStatePtr;
    s_flexioInstance = 0;
    /* Fill in FlexIO config data */
    flexio_user_config_t userConfig =
    {
        .useInt = true,
        .onDozeEnable = false,
        .onDebugEnable = true,
        .fastAccessEnable = false
    };

    // Enable clock for PORTs, setup board clock source, config pin
    hardware_init();

    // Call OSA_Init to setup LP Timer for timeout
    OSA_Init();

    FLEXIO_DRV_Init(s_flexioInstance,&userConfig);
    FLEXIO_DRV_Start(s_flexioInstance);

    /* Fill in FlexIO UART config data */
    flexio_uart_userconfig_t uartConfig;
    uartConfig.bitCounter = kFlexIOUart8BitsPerChar;
    uartConfig.baudRate = 115200;
    uartConfig.uartMode = flexioUART_TxRx;
    uartConfig.txConfig.pinIdx = 5;
    uartConfig.txConfig.shifterIdx = 0;
    uartConfig.txConfig.timerIdx = 0;
    uartConfig.rxConfig.pinIdx = 4;
    uartConfig.rxConfig.shifterIdx = 1;
    uartConfig.rxConfig.timerIdx = 1;

    // Fill in lpuart config data
    lpuart_user_config_t lpuartConfig = {
        .clockSource     = BOARD_LPUART_CLOCK_SOURCE,
        .bitCountPerChar = kLpuart8BitsPerChar,
        .parityMode      = kLpuartParityDisabled,
        .stopBitCount    = kLpuartOneStopBit,
        .baudRate        = 115200
    };

    /* init the FlexIO simulated UART module with base address and config structure*/
    FLEXIO_UART_DRV_Init(s_flexioInstance, &uartState, &uartConfig);
    // Initialize the lpuart module with instance number and config structure
    LPUART_DRV_Init(COMM_UART_INSTANCE, &lpuartStatePtr, &lpuartConfig);
    // Inform to start blocking example
    PRINTF("\r\n++++++++++++++++ FLEXIO UART Send/Receive Example Start +++++++++++++++++\r\n");
    PRINTF("\r\n1. FlexIO simulated UART send a buffer \
            \r\n2. LPUART receives data from FlexIO simulated UART.\
            \r\n3. Compare rxBuff and txBuff to see result.\
            \r\n4. LPUART send a buffer\
            \r\n5. FlexIO simulated UART receives data from LPUART.\
            \r\n6. Compare rxBuff and txBuff to see result.\r\n");
    PRINTF("\r\n============================================================\r\n");
    PRINTF("\r\nPress any key to start transfer:\r\n\r\n");
    while(true)
    {
        GETCHAR();
       // FlexIO UART sends data to LPUART

        FLEXIO_UART_DRV_SendData(&uartState, txBuff, DATA_LENGTH);
        LPUART_DRV_ReceiveDataBlocking(COMM_UART_INSTANCE, rxBuff, DATA_LENGTH, 1000U);
        if(flexio_uart_compare((uint8_t*)txBuff, rxBuff, DATA_LENGTH) != true)
        {
            PRINTF("\r\nFailure transfer from FlexIO simualted UART to LPUART");
            break;
        }
        PRINTF("Transfer from FlexIO simulated UART to LPUART successfully\r\n");

        flexio_uart_reset_buffer(rxBuff,DATA_LENGTH);
        // FlexIO UART receives data from LPUART
        LPUART_DRV_SendData(COMM_UART_INSTANCE, txBuff, DATA_LENGTH);
        FLEXIO_UART_DRV_ReceiveDataBlocking(&uartState, rxBuff, DATA_LENGTH,1000U);
        if(flexio_uart_compare((uint8_t*)txBuff, rxBuff, DATA_LENGTH) != true)
        {
            PRINTF("\r\nFailure FlexIO simulated UART receive from FlexIO LPUART");
            break;
        }
        PRINTF("FlexIO simulated UART receive from FlexIO LPUART successfully\r\n");
    }

    return 0;
}