[参考译文] TM4C1294NCPDT：基于 trame RS485中断端的 TI RTOS UART

 *  ======== mutex.c ========
 */

#include <stdbool.h>

/* XDC module Headers */
#include <xdc/std.h>
#include <xdc/runtime/System.h>

/* BIOS module Headers */
#include <ti/sysbios/BIOS.h>
#include <ti/sysbios/knl/Clock.h>
#include <ti/sysbios/knl/Task.h>
#include <ti/sysbios/knl/Semaphore.h>

/* TI-RTOS Header files */
#include <ti/drivers/GPIO.h>
#include <ti/drivers/UART.h>
#include <ti/drivers/uart/UARTtiva.c>

#include "inc/hw_uart.h"
#include "driverlib/uart.h"
#include "utils/ringbuf.h"
#include "utils/uartstdio.h"

#include "inc/hw_uart.h"
#include "inc/hw_types.h"
#include "inc/hw_memmap.h"

#include "driverlib/gpio.h"
#include "driverlib/pin_map.h"
#include "driverlib/interrupt.h"

/* Example/Board Header files */
#include "Board.h"

#define TASKSTACKSIZE   512

Void task1Fxn(UArg arg0, UArg arg1);
Void task2Fxn(UArg arg0, UArg arg1);

Int resource = 0;
Int finishCount = 0;
UInt32 sleepTickCount;

Task_Struct task1Struct, task2Struct;
Char task1Stack[TASKSTACKSIZE], task2Stack[TASKSTACKSIZE];
Semaphore_Struct semStruct;
Semaphore_Handle semHandle;

char input = 0x9;
UART_Handle uart;

void UART00_IRQHandlerWrite(UART_Handle handle, void *buffer, size_t num);
/*
 *  ======== main ========
 */
Int main()
{
    /* Construct BIOS objects */
    Task_Params taskParams;
    Semaphore_Params semParams;


    UART_Params uartParams;
 //   const char echoPrompt[] = "\fEchoing characters:\r\n";

    /* Call board init functions */
    Board_initGeneral();
    Board_initGPIO();
    Board_initUART();



    /* Construct writer/reader Task threads */
    Task_Params_init(&taskParams);
    taskParams.stackSize = TASKSTACKSIZE;
    taskParams.stack = &task1Stack;
    taskParams.priority = 1;
    Task_construct(&task1Struct, (Task_FuncPtr)task1Fxn, &taskParams, NULL);

    taskParams.stack = &task2Stack;
    taskParams.priority = 2;
    Task_construct(&task2Struct, (Task_FuncPtr)task2Fxn, &taskParams, NULL);

    /* Construct a Semaphore object to be use as a resource lock, inital count 1 */
    Semaphore_Params_init(&semParams);
    Semaphore_construct(&semStruct, 1, &semParams);

    /* Obtain instance handle */
    semHandle = Semaphore_handle(&semStruct);

    /* Create a UART with data processing off. */
    UART_Params_init(&uartParams);
    uartParams.writeDataMode = UART_DATA_BINARY;
    uartParams.baudRate = 115200;
    uartParams.dataLength = UART_LEN_8;
    uartParams.stopBits = UART_STOP_ONE;
    uartParams.parityType = UART_PAR_NONE;
//    uartParams.writeTimeout = UART_WAIT_FOREVER;
    uartParams.writeMode = UART_MODE_CALLBACK;//UART_MODE_BLOCKING;//UART_MODE_CALLBACK; // the uart uses a read interrupt
    uartParams.writeCallback = &UART00_IRQHandlerWrite; // function called when the uart interrupt fires
    HWREG(UART0_BASE + UART_O_CTL) |= UART_TXINT_MODE_EOT;

    //uart = UART_open(Board_UART0, &uartParams);

     UARTTiva_open(uart, &uartParams);


    if (uart == NULL) {
        System_abort("Error opening the UART");
    }

   // UART_write(uart, echoPrompt, sizeof(echoPrompt));

    /* We want to sleep for 10000 microseconds */
    sleepTickCount = 10000 / Clock_tickPeriod;

    BIOS_start();    /* Does not return */
    return(0);
}

/*
 *  ======== task1Fxn ========
 */
Void task1Fxn(UArg arg0, UArg arg1)
{
    UInt32 time;

   while(1) {
        System_printf("Running task1 function\n");

        if (Semaphore_getCount(semHandle) == 0) {
            System_printf("Sem blocked in task1\n");
        }

        GPIOPinWrite(GPIO_PORTB_BASE, GPIO_PIN_0, 1);
        UART_write(uart, &input, 1);


        /* Get access to resource */
        Semaphore_pend(semHandle, BIOS_WAIT_FOREVER);
        //while((UARTBusy(Board_UART0)));
        //GPIOPinWrite(GPIO_PORTB_BASE,GPIO_PIN_0,0);


        /* Do work by waiting for 2 system ticks to pass */
        time = Clock_getTicks();
        while (Clock_getTicks() <= (time + 1)) {
            ;
        }

        /* Do work on locked resource */
        resource += 1;
        /* Unlock resource */

        Semaphore_post(semHandle);

        Task_sleep(sleepTickCount);
    }
}

/*
 *  ======== task2Fxn ========
 */
Void task2Fxn(UArg arg0, UArg arg1)
{
    while(1) {
        System_printf("Running task2 function\n");

        if (Semaphore_getCount(semHandle) == 0) {
            System_printf("Sem blocked in task2\n");
        }

//        GPIOPinWrite(GPIO_PORTB_BASE, GPIO_PIN_0, 0);

        /* Get access to resource */
        Semaphore_pend(semHandle, BIOS_WAIT_FOREVER);

        /* Do work on locked resource */
        resource += 1;
        /* Unlock resource */

        Semaphore_post(semHandle);

        Task_sleep(sleepTickCount);

        finishCount++;
        if (finishCount == 5) {
            System_printf("Calling BIOS_exit from task2\n");
            BIOS_exit(0);
        }
    }
}

void UART00_IRQHandlerWrite(UART_Handle handle, void *buffer, size_t num)
{

   // GPIOPinWrite(GPIO_PORTB_BASE, GPIO_PIN_0, 0);



    {
     //  ++ucEndOfFrame;
     //
     //  Write the next character into the transmit FIFO.
     //
     //  UART_write(uart, &input, 1);
     //  UARTCharPut(MODBUS_UART_BASE, RingBufReadOne(&g_sTxBuf));

    }

   //while(UARTBusy(Board_UART0))


    //while(  (UARTIntStatus(UART0_BASE,UART_RIS_TXRIS)) == 1)
    {
       //      GPIOPinWrite(GPIO_PORTB_BASE,GPIO_PIN_0,0);
        //while((UARTBusy(Board_UART0)));
        //GPIOPinWrite(GPIO_PORTB_BASE,GPIO_PIN_0,0);

        Semaphore_post(semHandle);
    }
}