1. 首頁
  2. 問答
  3. 多任務下與UART FIFO有關的問題

多任務下與UART FIFO有關的問題

2017-10-13 45 views
-1

附加程序： 這些代碼是由我基於TI uart.c驅動程序庫編寫的。多任務下與UART FIFO有關的問題

 while(1){ 
     //check if message on Queue -> read or check UART input 
     if(uxQueueMessagesWaiting(UART_TASKQ) != 0){ //may have bugs 

     // deQueue 
     xQueueReceive(UART_TASKQ, &UARTTaskHandle, 0x0A); 
     //do the task's mission using the data in the stucture(put by control 
     task) 
     //Print out the input data. 

     //**********debugging data 
/* 
     testPointer = UARTTaskHandle->dataBuffer; 
     testAmount = UARTTaskHandle->dataSize; 

     while(testAmount){ 
      if(*testPointer != 1){ 
       error = error + 1; 
      } 
      if(*(testPointer + 1) != 2){ 
       error = error + 1; 
      } 
      if(*(testPointer + 2) != 3){ 
          error = error + 1; 
         } 
      if(*(testPointer + 3) != 4){ 
          error = error + 1; 
         } 
      if(*(testPointer + 4) != 5){ 
          error = error + 1; 
         } 
      if(*(testPointer + 5) != 6){ 
          error = error + 1; 
         } 
      if(*(testPointer + 6) != 7){ 
          error = error + 1; 
         } 
      if(*(testPointer + 7) != 8){ 
          error = error + 1; 
         } 

      testPointer = testPointer + 8; 
      testAmount = testAmount - 8; 
     } 
*/ 

     if(UART_write(UART_Handle, UARTTaskHandle->dataBuffer, UARTTaskHandle->dataSize, 0xff) >= 0){ 
     UARTwriteCount = UARTwriteCount + 1; 
     } 

     //let control task take new command 
     //free allocated memory 
     free(UARTTaskHandle->dataBuffer); 
     free(UARTTaskHandle); // free memory space 

//(above is code using UART) 


//here are UART driver code: 


    unsigned long UARTStatus(unsigned long ulBase){ 
    ASSERT(UARTBaseValid(ulBase)); 
    return(HWREG(ulBase + UART_O_FR)); 
} 
//***************************************** 
//UART_ISR 
//Interrupt service routine for 
//the UART read and write process 
//***************************************** 
void UART_ISR(){ 


    //read FIFO full or read time out 
    if(UARTIntStatus(UART_Handle->UART_PORT,false) & (UART_INT_RX | UART_INT_RT)){ 
     UARTIntClear(UART_Handle->UART_PORT, UART_INT_RX | UART_INT_RT); //clear INT flag 

     while (!(UARTStatus(UART_Handle->UART_PORT) & UART_FR_RXFE)){ 
      //data reading 
      *UART_Handle->pCurrentRead = UARTCharGet(UART_Handle->UART_PORT); //read autoly clear INT 
      UART_Handle->pCurrentRead++; 
      UART_Handle->ReadLength--; 

      //adjust code here: 
      if(UART_Handle->ReadLength == 0){ 
       break; 
      } 
     } 

     //check if read certain bytes finished 
     if(UART_Handle->ReadLength == 0){ 
      memcpy(UART_Handle->dataput, UART_Handle->pReadBuf,UART_Handle->ReadLengthcpy); // copy data back 
      xSemaphoreGiveFromISR(UART_Handle->UARTRead_Semaphore, &xHigherPriorityTaskWoken);// release semaphore 
      portYIELD_FROM_ISR(xHigherPriorityTaskWoken);//forcing context exchange 
     } 

    } 

    //send FIFO empty 
    if(UARTIntStatus(UART_Handle->UART_PORT,false) & UART_INT_TX){ 

     UARTIntClear(UART_Handle->UART_PORT, UART_INT_TX); //clear INT flag 

     if(UART_Handle->WriteLength == BUFFEMPTY){ 

      UART_Handle->UART_SendComplete = true; 

      xSemaphoreGiveFromISR(UART_Handle->UARTWrite_Semaphore, &xHigherPriorityTaskWoken);// release semaphore 
      portYIELD_FROM_ISR(xHigherPriorityTaskWoken);//forcing context exchange 
     } 

      //putting data into send FIFO 
       if(UART_Handle->WriteLength > FIFOMAX){ 
        for(Cindex = 0 ; Cindex < FIFOMAX ;){ 
         if(UARTCharPutNonBlocking(UART_Handle->UART_PORT, *(UART_Handle->pCurrentWrite))){//write autoly clear INT 
          (UART_Handle->pCurrentWrite) = (UART_Handle->pCurrentWrite) + 1; 
          (UART_Handle->WriteLength) = (UART_Handle->WriteLength) - 1; 
          Cindex = Cindex + 1; 
          UART_Handle->sentCount = UART_Handle->sentCount + 1; 
         } 
        } 
       }else{ 
        templength = UART_Handle->WriteLength; 
        for(Cindex = 0; Cindex < templength ;){ 
         if(UARTCharPutNonBlocking(UART_Handle->UART_PORT, *(UART_Handle->pCurrentWrite))){//write autoly clear INT 
          (UART_Handle->pCurrentWrite) = (UART_Handle->pCurrentWrite) + 1; 
          (UART_Handle->WriteLength) = (UART_Handle->WriteLength) - 1; 
          Cindex = Cindex + 1; 
          UART_Handle->sentCount = UART_Handle->sentCount + 1; 
         } 
        } 
       } 

    } 

} 

//***************************************** 
//UART_write 
//write certain length of data to UART port 
//***************************************** 
int32_t UART_write(UART_STATE *UART_Handle, uint8_t *pData, uint32_t length, uint32_t time_out){ 


    while(!UART_Handle->UART_SendComplete); //debugging purpose 
    UART_Handle->UART_SendComplete = false;//debugging purpose 

    UART_Handle->WriteLength = length; 

    if(UART_Handle->WriteLength <= UART_Handle->WriteBufSize){ 

     UARTIntClear(UART_Handle->UART_PORT, UART_INT_TX); //clear INT flag 

     memcpy(UART_Handle->pWriteBuf,pData,UART_Handle->WriteLength); //copy data into writebuff 
     UART_Handle->pCurrentWrite = UART_Handle->pWriteBuf; 
     //putting data into send FIFO 
     if(UART_Handle->WriteLength > FIFOMAX){ 
      // if 
      for(Cindex = 0 ; Cindex < FIFOMAX ;){ 
       if(UARTCharPutNonBlocking(UART_Handle->UART_PORT, *(UART_Handle->pCurrentWrite))){//write autoly clear INT 
        (UART_Handle->pCurrentWrite) = (UART_Handle->pCurrentWrite) + 1; 
        (UART_Handle->WriteLength) = (UART_Handle->WriteLength) - 1; 
        Cindex = Cindex + 1; 
        UART_Handle->sentCount = UART_Handle->sentCount + 1; 
       } 
      } 
     }else{ 
      for(Cindex = 0 ; Cindex < FIFOMAX ;){ 
       if(UARTCharPutNonBlocking(UART_Handle->UART_PORT, *(UART_Handle->pCurrentWrite))){//write autoly clear INT 
        (UART_Handle->pCurrentWrite) = (UART_Handle->pCurrentWrite) + 1; 
        (UART_Handle->WriteLength) = (UART_Handle->WriteLength) - 1; 
        Cindex = Cindex + 1; 
        UART_Handle->sentCount = UART_Handle->sentCount + 1; 
       } 
      } 
     } 

     //start sending 
     UARTEnable(UART_Handle->UART_PORT); 

     if(UART_Handle->UARTWrite_Semaphore != NULL) { 
      if(xSemaphoreTake(UART_Handle->UARTWrite_Semaphore, time_out/(portTICK_PERIOD_MS)) == pdTRUE){ 
       reValue = WRITESUCCESS; //wait return till write complete 

      }else{ 
       reValue = WRITETIMEOUT; // timeout (ms) 

       } 
     }else{ 
      while(1); //no Semaphore 
      } 

     return reValue; 

    }else{ 
     return FAILURE; //wrong length 
    } 

} 

//***************************************** 
//UART_read 
//read certain length of data from UART port 
//***************************************** 
int32_t UART_read(UART_STATE *UART_Handle, uint8_t *pData, uint32_t length, uint32_t time_out){ 



    //later added part 
    UARTDisable(UART_Handle->UART_PORT); //clearUART 
    UARTFIFOEnable(UART_Handle->UART_PORT); 
    // 

    UART_Handle->ReadLength = length; // set readlength 
    UART_Handle->ReadLengthcpy = length; 

    if(UART_Handle->ReadLength <= UART_Handle->ReadBufSize){ 

     UARTIntClear(UART_Handle->UART_PORT, UART_INT_RX | UART_INT_RT); //clear INT flag 
     UART_Handle->dataput = pData; //store the destination buffer address 
     UART_Handle->pCurrentRead = UART_Handle->pReadBuf; //set current read 

     UARTEnable(UART_Handle->UART_PORT); //start receiving 

     //suspend before read ISR finish whole process 
     if(UART_Handle->UARTRead_Semaphore != NULL) { 
        if(xSemaphoreTake(UART_Handle->UARTRead_Semaphore, time_out/(portTICK_PERIOD_MS)) == pdTRUE){ 
         reValue = READSUCCESS; //wait return till write complete 
        }else{ 
         reValue = READTIMEOUT; // timeout (ms) 
         } 
       }else{ 
        while(1); //no Semaphore 
        } 

       return reValue; 

    }else{ 
     return FAILURE; //wrong length 
    } 
} 

//***************************************** 
//UART_open 
//open UART for certain port and bandrate 
//***************************************** 
UART_HANDLE UART_open(uint32_t UART_port, uint32_t UART_portperiph, uint32_t UART_baudrate){ 

    //initialize structure 
    UART_Handle = (UART_HANDLE)malloc(sizeof(UART_STATE)); 

    UART_Handle->ReadBufSize = UARTBUFFERSIZE; 
    UART_Handle->WriteBufSize = UARTBUFFERSIZE; 
    UART_Handle->UART_PORT = UART_port; 
    UART_Handle->UART_PORTPERIPH = UART_portperiph; 
    UART_Handle->UART_BRATE = UART_baudrate; 
    UART_Handle->pWriteBuf = (uint8_t*)malloc(UART_Handle->WriteBufSize * sizeof(uint8_t)); 
    UART_Handle->pReadBuf = (uint8_t*)malloc(UART_Handle->ReadBufSize * sizeof(uint8_t)); 
    UART_Handle->pCurrentWrite = UART_Handle->pWriteBuf; 
    UART_Handle->pCurrentRead = UART_Handle->pReadBuf; 
    UART_Handle->UARTWrite_Semaphore = NULL; 
    UART_Handle->UARTRead_Semaphore = NULL; 
    UART_Handle->UARTprotect_Semaphore = NULL; 
    UART_Handle->UART_SendComplete = true; 

    UART_Handle->sentCount = 0;//debugging purpose 

    vSemaphoreCreateBinary(UART_Handle->UARTWrite_Semaphore); //semaphore create 
    vSemaphoreCreateBinary(UART_Handle->UARTRead_Semaphore); //semaphore create 
// vSemaphoreCreateBinary(UART_Handle->UARTprotect_Semaphore); //debugging purpose 
    xSemaphoreTake(UART_Handle->UARTRead_Semaphore, portMAX_DELAY); //semaphore take 
    xSemaphoreTake(UART_Handle->UARTWrite_Semaphore, portMAX_DELAY); //semaphore take 

    // Enable Peripheral Clocks 
    MAP_PRCMPeripheralClkEnable(UART_Handle->UART_PORTPERIPH, PRCM_RUN_MODE_CLK); 

    // Configure PIN_55 for UART0 UART0_TX 
    MAP_PinTypeUART(PIN_55, PIN_MODE_3); 

    // Configure PIN_57 for UART0 UART0_RX 
    MAP_PinTypeUART(PIN_57, PIN_MODE_3); 

    // configuration, 8 bits length data width, 1 stop bit, no parity check 
    UARTConfigSetExpClk(UART_Handle->UART_PORT,PRCMPeripheralClockGet( UART_Handle->UART_PORTPERIPH), 
      UART_Handle->UART_BRATE, (UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | 
      UART_CONFIG_PAR_NONE)); 

    // disable UART since function above contained UARTenable 
    UARTDisable(UART_Handle->UART_PORT); 

    UARTIntEnable(UART_Handle->UART_PORT, UART_INT_TX | UART_INT_RX | UART_INT_RT); // enable interrupt for send and receive and receive timeout 
    UARTIntRegister(UART_Handle->UART_PORT, UART_ISR); //hook ISR 
    UARTFIFOEnable(UART_Handle->UART_PORT); //enable FIFO for send and receive 
    UARTFIFOLevelSet(UART_Handle->UART_PORT, UART_FIFO_TX1_8, UART_FIFO_RX4_8); //Interrupt occur when 7 bytes send from FIFO or read in FIFO 


    return UART_Handle; 
}

我正在處理長時間的多線程錯誤。經過多次測試後，我意識到最可能與UART FIFO傳輸有關的錯誤。

這是我對我的程序的描述： 該程序基於Free-RTOS。它有兩個並行運行的線程。 一個線程正在通過I2C驅動程序從傳感器讀取。另一個是通過UART驅動程序將讀取任務的數據發送到計算機。我有一個多任務框架將數據從閱讀任務轉移到發送任務。我有一個計時器文件來控制實時測量。我的I2C驅動程序和UART驅動程序都是基於中斷的。

問題描述： 我的數據只有2分鐘。之後，我的數據發生了變化。在進行測試時，我封鎖了I2C驅動程序，只將常量數據「1 2 3 4 5 6 7 8」放入I2C讀緩衝區，並將它們傳送到發送任務以進行UART發送。在2分鐘後，我讀出的數據將變爲「8 1 2 3 4 5 6 7」，第一次更改後，後來的更改迅速發生，「7 8 1 2 3 4 5 6」並持續到定時結束。 this is plot of one channel of my data, begin with 8 and changing

我已經對我的程序設置了很多測試，我確信我的多任務框架（從讀任務到發送任務的轉換數據）不會改變數據。 重要意見： 1.當我把讀取和發送到一個線程時，數據非常好，沒有這個bug。 2.我在我的UART驅動程序中設置計數，發現發送的數量是正確的，這裏發送是將字節放入TX FIFO。但是，在Excel中，我通過JAVA UART程序讀取數據，錯過了。並且JAVA UART程序應該可以，因爲當我使用單線程測試時它運行良好。 3.調試時CCS不會產生內存泄漏錯誤。

所以我想，在多線程環境下，我將UART字節放入之後，某些東西停止了我的UART TX FIFO傳輸。但是我無法找到我的代碼中哪裏出錯，它們都似乎是正確的。

另一個合理的原因可能是改變我的指針在中斷，在鏈接的圖片「pCurrentWrite」指針。但該指針只能由UART驅動程序訪問，並且在中斷完成之前，下一個UART寫入無法進入。

我在鏈接中包含了部分代碼，我想表明數據已放入TX FIFO中，並且發送計數正確。

我不能包含所有代碼，我不認爲有人想檢查這些長代碼。沒有運行它，很難找出哪裏出錯。

所以，我只想描述我遇到的情況，看看有沒有人有過類似的bug。也許有人知道多線程環境下UART FIFO的問題。如果能夠幫助的人希望看到代碼，我們可以進一步聯繫。

謝謝（我的新帳戶不能包含圖片的是，圖片下面鏈接）

This code is part of my UART driver, in the sending interrupt. I use the PutCharNonBlocking to put byte, since it return 1 if success, return 0 if FIFO full, so in this way I make sure the program will send all my data into the FIFO, which turn out to be true, all data was put into the TX FIFO

來源

2017-10-13 DoubleFred

+1

提示：沒有人會在沒有看到任何代碼的情況下閱讀這段文字。 –

+1

沒有任何代碼，就不可能說出你的bug。但只是猜測;你需要在你的任務之間進行某種同步。你說你有一個FIFO。這必須受到一些同步原語的保護。據我所知，FreeRTOS擁有互斥量，用它來保護你的FIFO。 – user1048576

+0

感謝您的稱讚，我現在會發布一些代碼。但他們會以鏈接形式。 @ user1048576，我使用的是UART的硬件FIFO，我沒有創建FIFO，並且FIFO由來自uart.c驅動程序文件的API調用處理。而且，我還可以爲這種FIFO添加保護嗎？感謝您的建議。 – DoubleFred

回答

相關問題

 相關問題