MSP430FR5994: SPI Configuration with MSP430 TI-RTOS

var halHwi0Params = new halHwi.Params();
halHwi0Params.arg = 0;
halHwi0Params.instance.name = "halHwi0";
halHwi0Params.priority = 1;
Program.global.halHwi0 = halHwi.create(48, "&UARTEUSCIA_hwiIntFxn", halHwi0Params);

var halHwi1Params = new halHwi.Params();
halHwi1Params.instance.name = "halHwi1";
halHwi1Params.arg = 3;
halHwi1Params.priority = 3;
Program.global.halHwi1 = halHwi.create(24, "&MSP_EXP430FR5994_isrDMA", halHwi1Params);

var halHwi2Params = new halHwi.Params();
halHwi2Params.arg = 4;
halHwi2Params.priority = 5;
Program.global.halHwi2 = halHwi.create(32, "&GPIO_hwiIntFxn", halHwi2Params);

/*
 *  =============================== DMA ===============================
 */
/*
 *  ======== MSP_EXP430FR5994_isrDMA ========
 *  This is a application defined DMA ISR. This ISR must map and call the
 *  appropriate Driver_event(handle) API to indicate completed DMA transfers.
 */
Void MSP_EXP430FR5994_isrDMA(UArg arg)
{
    /* Call the SPI DMA function, passing the SPI handle used for WiFi */
    SPI_serviceISR((SPI_Handle) &(SPI_config[0]));
}

void spiMasterFxn(UArg arg0, UArg arg1) {
    uint32_t        i;
    bool            transferOK;
    char uartStr[10];

    /* Configure spi master and slave ready gpio pins */
    GPIO_setConfig(CONFIG_SPI_MASTER_READY, GPIO_CFG_OUTPUT | GPIO_CFG_OUT_LOW);
    GPIO_setConfig(CONFIG_SPI_SLAVE_READY, GPIO_CFG_INPUT);

    /* Set master ready pin */
    GPIO_write(CONFIG_SPI_MASTER_READY, 1);
    UART_write(uart, "CONFIG_SPI_MASTER_READY\n", sizeof("CONFIG_SPI_MASTER_READY\n"));

    /* Wait for slave to be ready */
    while (GPIO_read(CONFIG_SPI_SLAVE_READY) == 0) {}
    UART_write(uart, "handshake complete! \n", sizeof("handshake complete! \n"));

    /* Handshake complete; now configure interrupt on CONFIG_SPI_SLAVE_READY */
    GPIO_setConfig(CONFIG_SPI_SLAVE_READY, GPIO_CFG_IN_PU | GPIO_CFG_IN_INT_FALLING);
    GPIO_setCallback(CONFIG_SPI_SLAVE_READY, slaveReadyFxn);
    GPIO_enableInt(CONFIG_SPI_SLAVE_READY);
    UART_write(uart, "configure interrupt on slave\n", sizeof("configure interrupt on slave\n"));

    /* Create a semaphore; the master will wait on this semaphore
     * until the slave is ready. */
    Semaphore_Params params;
    Error_Block eb;
    /* Init params */
    Semaphore_Params_init(&params);
    Error_init(&eb);
    /* Create semaphore instance */
    masterSem = Semaphore_create(0, &params, &eb);
    if(masterSem == NULL)
    {
        System_printf("Semaphore creation failed");
        System_flush();
    }

    /* Open SPI as master */
    SPI_Params_init(&spiParams);
    spiParams.frameFormat = SPI_POL0_PHA1;
    spiParams.mode = SPI_MASTER;
    spiParams.bitRate = 1000000;
    masterSpi = SPI_open(Board_SPI0, &spiParams);

    if (masterSpi == NULL) {
        UART_write(uart, "Error initializing master SPI\n", sizeof("Error initializing master SPI\n"));
         while (1);
     }
     else {
         UART_write(uart, "Master SPI initialized\n", sizeof("Master SPI initialized\n"));
     }

    /*
     * Master has opened CONFIG_SPI_MASTER; set CONFIG_SPI_MASTER_READY low to
     * inform the slave.
     */
    GPIO_write(CONFIG_SPI_MASTER_READY, 0);

    /* Copy message to transmit buffer */
    strncpy((char *) masterTxBuffer, MASTER_MSG, SPI_MSG_LENGTH);

    for (i = 0; i < MAX_LOOP; i++) {
        /*
         * Wait until slave is ready for transfer; slave will pull
         * CONFIG_SPI_SLAVE_READY low.
         */
        UART_write(uart, "Waiting for master_sem\n", sizeof("Waiting for master_sem\n"));
        Semaphore_pend(masterSem, BIOS_WAIT_FOREVER);

        UART_write(uart, "Create transaction\n", sizeof("Create transaction\n"));

        /* Initialize master SPI transaction structure */
        masterTxBuffer[sizeof(MASTER_MSG) - 1] = (i % 10) + '0';
        memset((void *) masterRxBuffer, 0, SPI_MSG_LENGTH);
        transaction.count = SPI_MSG_LENGTH;
        transaction.txBuf = (void *) masterTxBuffer;
        transaction.rxBuf = (void *) masterRxBuffer;

        /* Toggle user LED, indicating a SPI transfer is in progress */
        UART_write(uart, "Transfer in progress\n", sizeof("Transfer in progress\n"));
        GPIO_toggle(Board_LED1);

        /* Perform SPI transfer */
        transferOK = SPI_transfer(masterSpi, &transaction);

        sprintf(uartStr, "%d", transferOK );
        UART_write(uart, "transfer ok = ", sizeof("transfer ok = "));
        UART_write(uart, uartStr, sizeof(uartStr));

        if (transferOK) {
            UART_write(uart, "\nMaster received\n", sizeof("Master received\n"));
        }
        else {
            UART_write(uart, "\nUnsuccessful Master received\n", sizeof("Unsuccessful Master received\n"));
        }

        /* Sleep for a bit before starting the next SPI transfer  */
        Task_sleep(100);
    }

    SPI_close(masterSpi);

    /* Example complete - set pins to a known state */
    GPIO_disableInt(CONFIG_SPI_SLAVE_READY);
    GPIO_setConfig(CONFIG_SPI_SLAVE_READY, GPIO_CFG_OUTPUT | GPIO_CFG_OUT_LOW);
    GPIO_write(CONFIG_SPI_MASTER_READY, 0);

    UART_write(uart, "Done!\n", sizeof("Done!\n"));
}