This thread has been locked.

If you have a related question, please click the "Ask a related question" button in the top right corner. The newly created question will be automatically linked to this question.

用TI-RTOS实现用两个线程分别控制一个串口一收一发,提示未初始化TASK

我想用TI-RTOS实现用两个线程分别控制一个串口一收一发,但查看ROV却未初始化TASK ,我看UART.h的文档里说可以同时进行一个读和一个写的啊。我屏蔽和UART相关的代码后就可以正常跑两个TASK。代码如下:

   /* TI-RTOS Header files */
  #include <xdc/std.h>
  #include <ti/sysbios/BIOS.h>
  #include <ti/sysbios/knl/Task.h>
  #include <ti/sysbios/knl/Clock.h>

  #include <ti/drivers/GPIO.h>
  #include <ti/drivers/UART.h>

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

  void myDelay(int count);

  /* Could be anything, like computing primes */
  #define FakeBlockingSlowWork()   myDelay(12000000)
  #define FakeBlockingFastWork()   myDelay(2000000)

  Task_Struct workTask;
  Task_Struct urgentWorkTask;
  /* Make sure we have nice 8-byte alignment on the stack to avoid wasting memory */
  #pragma DATA_ALIGN(workTaskStack, 8)
  #define STACKSIZE 2048
  static uint8_t workTaskStack[STACKSIZE];
  static uint8_t urgentWorkTaskStack[STACKSIZE];

  UART_Handle uart;

  void doUrgentWork(void)
  {
      GPIO_write(Board_GPIO_LED1, Board_GPIO_LED_OFF);
      FakeBlockingFastWork(); /* Pretend to do something useful but time-consuming */
      GPIO_write(Board_GPIO_LED1, Board_GPIO_LED_ON);
  }

  void doWork(void)
  {
      GPIO_write(Board_GPIO_LED0, Board_GPIO_LED_OFF);
      FakeBlockingSlowWork(); /* Pretend to do something useful but time-consuming */
      GPIO_write(Board_GPIO_LED0, Board_GPIO_LED_ON);
  }

  Void workTaskFunc(UArg arg0, UArg arg1)
  {
//      char input;

      while (1) {
//          UART_read(uart, &input, 1);

          /* Do work */
          doWork();

          /* Wait a while, because doWork should be a periodic thing, not continuous.*/
          //myDelay(24000000);
          Task_sleep(500 * (1000 / Clock_tickPeriod));
      }
  }

  Void urgentWorkTaskFunc(UArg arg0, UArg arg1)
  {
      char text[] = "urgentwork:\r\n";
      while (1) {

          /* Do work */
          doUrgentWork();

          /* Wait a while, because doWork should be a periodic thing, not continuous.*/
          //myDelay(24000000);
          Task_sleep(50 * (1000 / Clock_tickPeriod));

//          UART_write(uart, text, sizeof(text));
      }
  }

  /*
   *  ======== uart init ========
   */
  void uart_init(void)
  {

      UART_Params uartParams;

      const char  echoPrompt[] = "Echoing characters:\r\n";

//      Semaphore_Params semParams;
//
//      /* Construct a Semaphore object to be use as a resource lock, inital count 1 */
//      Semaphore_Params_init(&semParams);
//
//      Semaphore_construct(&semStruct, 0, &semParams);
//      /* Obtain instance handle */
//      semHandle = Semaphore_handle(&semStruct);
//
//      Semaphore_construct(&buf_semStruct, 1, &semParams);
//      /* Obtain instance handle */
//      buf_semHandle = Semaphore_handle(&buf_semStruct);


      /* Call driver init functions */
      UART_init();

      /* Turn on user LED */
      GPIO_write(Board_GPIO_LED0, Board_GPIO_LED_ON);

      /* Create a UART with data processing off. */
      UART_Params_init(&uartParams);
      uartParams.writeDataMode = UART_DATA_BINARY;
      uartParams.readDataMode = UART_DATA_BINARY;
      uartParams.readReturnMode = UART_RETURN_FULL;
      uartParams.readEcho = UART_ECHO_OFF;
      uartParams.baudRate = 115200;

      uart = UART_open(Board_UART0, &uartParams);

      if (uart == NULL) {
          /* UART_open() failed */
          while (1);
      }

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

  /*
   *  ======== main ========
   *
   */
  int main(void)
  {
      Board_initGeneral();
      GPIO_init();

//      uart_init();

      /* Set up the led task */
      Task_Params workTaskParams;
      Task_Params_init(&workTaskParams);
      workTaskParams.stackSize = STACKSIZE;
      workTaskParams.priority = 2;
      workTaskParams.stack = &workTaskStack;

      Task_construct(&workTask, workTaskFunc, &workTaskParams, NULL);

      workTaskParams.priority = 3;
      workTaskParams.stack = &urgentWorkTaskStack;

      Task_construct(&urgentWorkTask, urgentWorkTaskFunc, &workTaskParams, NULL);



      /* Start kernel. */
      BIOS_start();

      return (0);
  }

  /*
   *  ======== myDelay ========
   *  Assembly function to delay. Decrements the count until it is zero
   *  The exact duration depends on the processor speed.
   */
  __asm("    .sect \".text:myDelay\"\n"
        "    .clink\n"
        "    .thumbfunc myDelay\n"
        "    .thumb\n"
        "    .global myDelay\n"
        "myDelay:\n"
        "    subs r0, #1\n"
        "    bne.n myDelay\n"
        "    bx lr\n");

  • 你好,我写了一个你可以去试试。

    是基于uartecho那个例程的。

    code.c
    /*
     * Copyright (c) 2015-2019, Texas Instruments Incorporated
     * All rights reserved.
     *
     * Redistribution and use in source and binary forms, with or without
     * modification, are permitted provided that the following conditions
     * are met:
     *
     * *  Redistributions of source code must retain the above copyright
     *    notice, this list of conditions and the following disclaimer.
     *
     * *  Redistributions in binary form must reproduce the above copyright
     *    notice, this list of conditions and the following disclaimer in the
     *    documentation and/or other materials provided with the distribution.
     *
     * *  Neither the name of Texas Instruments Incorporated nor the names of
     *    its contributors may be used to endorse or promote products derived
     *    from this software without specific prior written permission.
     *
     * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
     * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
     * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
     * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
     * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
     * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
     * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
     * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
     * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
     * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     */
    
    /*
     *  ======== uartecho.c ========
     */
     
    /****************this code by alvin chen**********************/
    #include <stdint.h>
    #include <stddef.h>
    
    /* Driver Header files */
    #include <ti/drivers/GPIO.h>
    #include <ti/drivers/UART.h>
    #include <ti/sysbios/BIOS.h>
    #include <ti/sysbios/knl/Clock.h>
    #include <ti/sysbios/knl/Task.h>
    /* Example/Board Header files */
    #include "Board.h"
    void task1Fxn(UArg arg0, UArg arg1);
    void task2Fxn(UArg arg0, UArg arg1);
    #define TASKSTACKSIZE   512
    Task_Struct task1Struct, task2Struct;
    Char task1Stack[TASKSTACKSIZE], task2Stack[TASKSTACKSIZE];
    /*
     *  ======== mainThread ========
     */
    UART_Handle uart;
    void *mainThread(void *arg0)
    {
    
    
    
        UART_Params uartParams;
        Task_Params taskParams;
        /* Call driver init functions */
        GPIO_init();
        UART_init();
    
        /* Configure the LED pin */
        GPIO_setConfig(Board_GPIO_LED0, GPIO_CFG_OUT_STD | GPIO_CFG_OUT_LOW);
    
        /* Turn on user LED */
        GPIO_write(Board_GPIO_LED0, Board_GPIO_LED_ON);
    
        /* Create a UART with data processing off. */
        UART_Params_init(&uartParams);
        uartParams.writeDataMode = UART_DATA_BINARY;
        uartParams.readDataMode = UART_DATA_BINARY;
        uartParams.readReturnMode = UART_RETURN_FULL;
        uartParams.readEcho = UART_ECHO_OFF;
        uartParams.baudRate = 115200;
    
        uart = UART_open(Board_UART0, &uartParams);
    
        if (uart == NULL) {
            /* UART_open() failed */
            while (1);
        }
    
    
    
        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);
    }
    void task1Fxn(UArg arg0, UArg arg1)
    {
        const char  echoPrompt[] = "Echoing characters:\r\n";
        for(;;){
    
            UART_write(uart, echoPrompt, sizeof(echoPrompt));
            Task_sleep(500000);
        }
    
    
    }
    void task2Fxn(UArg arg0, UArg arg1){
    
        char input;
        for(;;)
        {
            UART_read(uart,&input,1);
            UART_write(uart,&input,1);
        }
    }