[参考译文] TM4C1292NCPDT：UART 传输问题

Mayra、您好！

您是否检查了 UART 配置是否与终端窗口的配置相匹配？

您还可以尝试其他终端软件、如 TeraTerm 吗？ 虽然我认为在这种情况下、它并不是很相关、但我以前曾遇到过术语显示的一些问题。

此致、

Ralph Jacobi

您好！

我已经检查了术语配置、它们看起来很好、 
我还尝试了 TeraTerm、数据看起来也很混乱。 

梅拉 

您好、Mayra、

您能否发送您正在使用的代码以便我可以在我的板上运行它？ 如果我可以这样调试它、这对我来说将是最简单的。

https://e2e.ti.com/support/site-support-group/site-support/f/site-support-forum/812271/faq-how-do-i-add-a-code-snippet-to-my-post

此致、

Ralph Jacobi

#include <stdint.h>
#include <stdbool.h>
#include <string.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include "inc/hw_types.h"
#include "inc/hw_memmap.h"
#include "inc/hw_gpio.h"
#include "driverlib/sysctl.h"
#include "driverlib/pin_map.h"
#include "driverlib/gpio.h"
#include "driverlib/adc.h"
#include "driverlib/debug.h"
#include <driverlib/uart.h>
#include <driverlib/interrupt.h>
#include "inc/hw_ints.h"          //librería para interrupciones
#include <stdbool.h>

#define NORM_MSG_LEN    26
#define ERR_MSG_LEN     8

uint32_t g_ui32SysClock; //variable para configurar el reloj del microcontrolador
uint32_t ui32Status;

uint32_t buffer_ADC[24]; // arreglo para guardar datos entrantes del ADC
//uint32_t pui32ADC0Value[20];



volatile int i_rx=0;
volatile bool flag_rx=false;
char BUFFER_UART[27];
char BUFFER[27];
int i_Rx=0,lim=0;
int i_y=0;
int flagUART_P=0;

int coincidencia=0;
int impedimenta=0;
int lumos=0, t=0;
char S_P1 [] = "?V913\r\n";//solicitud de respuesta al Edwards para el sensor de presion 1
char S_P2 [] = "?V914\r\n";//solicitud de respuesta al Edwards para el sensor de presion 2
char S_P4 [] = "!S925 5\r\n";//Instrucción para subir o bajar el contraste a la pantalla del edwards
int recepcion=0;
int contadordeborrado=0;
int flag_UART=0; //bandera para detectar coincidencia entre las posiciones del arreglo
float a,b,c,d,e,E,F,G,H,p1,p=0;
int bandera=0,banderanum;
float arregloP[2]; //arreglo para guardar los datos de presion


 float arreglo[12]; //arreglo para guardar los datos de los termistores
 float vol_T=0.0; //guarda el dato de voltaje
 float RT=0.0;//guarda el dato de resistencia del termistor
 float mu_T; //guarda el promedio de muestreo del adc
 float T=0.0;//guarda el dato de temperatura


//-----------------------------------------------------------------------------------------------------------------
//                                               ADC
//------------------------------------------------------------------------------------------------------------------

 //función de autoria propia
 void INIT_ADC() //inicializa el ADC
 {
     SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0); //habilita el periferico para ADC0
     SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);
     while(!SysCtlPeripheralReady(SYSCTL_PERIPH_ADC0));

     GPIOPinTypeADC(GPIO_PORTE_BASE,GPIO_PIN_3); //PINES PARA ENTRADA ADC0
   //ADCSequenceConfigure(ADC0_BASE, 0, ADC_TRIGGER_PROCESSOR,0);
 }

 //Función copiada
 void TEMP_TERMISTOR() //configura la secuencia de muestreo del adc y procesa los datos entrantes del adc
 {
    int i_adc;

    for(i_adc=0; i_adc<12; i_adc++)
     {
        ADCSequenceConfigure(ADC0_BASE, 0, ADC_TRIGGER_PROCESSOR,0);
        ADCSequenceStepConfigure(ADC0_BASE, 0,0, i_adc);//(paso 1)
        ADCSequenceStepConfigure(ADC0_BASE, 0,1, i_adc);//(paso 2)
        ADCSequenceStepConfigure(ADC0_BASE, 0,2, i_adc);//(paso 3)
        ADCSequenceStepConfigure(ADC0_BASE, 0,3, i_adc);//(paso 4)
        ADCSequenceStepConfigure(ADC0_BASE, 0,4, i_adc);//(paso 5)
        ADCSequenceStepConfigure(ADC0_BASE, 0,5, i_adc);//(paso 6)
        ADCSequenceStepConfigure(ADC0_BASE, 0,6, i_adc);//(paso 7)
        ADCSequenceStepConfigure(ADC0_BASE, 0,7, i_adc|ADC_CTL_IE|ADC_CTL_END);//(paso 8)

        ADCSequenceEnable(ADC0_BASE,0);
        ADCIntClear(ADC0_BASE,0); //limpia las banderas de interrupción del ADC
        ADCProcessorTrigger(ADC0_BASE,0); //Causa un trigger para una secuencia de muestreo
        while(!ADCIntStatus(ADC0_BASE,0,false)) //indica el estado de las interrupciones
          {

          }
        ADCSequenceDataGet(ADC0_BASE,0,buffer_ADC);//obtiene los datos capturados por el adc

         mu_T=(buffer_ADC[0]+buffer_ADC[1]+buffer_ADC[2]+buffer_ADC[3]+buffer_ADC[4]+buffer_ADC[5]+buffer_ADC[6]+buffer_ADC[7])/8;
         vol_T=mu_T*3.3/4096; //aqui hubo breakpoint
         RT=((3900*(3.3-vol_T))/vol_T);
         T=(1/(0.000634544+(0.000321866*log(RT))+(-0.000000306*pow(log(RT),3))))-273.15;//aqui hubo breakpoint

         arreglo[i_adc]=T; //aqui hubo breakpoint
      }
 }
//---------------------------------------------------------------------------------------------------------------
//                                                  UART
//----------------------------------------------------------------------------------------------------------------

 void INIT_UART() //HABILITA LOS MÓDULOS UART0 Y UART1
 {
     SysCtlPeripheralEnable(SYSCTL_PERIPH_UART2);//Habilitación del módulo UART2
     SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
     SysCtlPeripheralEnable(SYSCTL_PERIPH_UART1);//Habilitación del módulo UART1 (Recepción y transmisión de datos de presión)
     SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
     SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);//Habilitación del módulo UART0 (conexión USB)
     SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
     while(!SysCtlPeripheralReady(SYSCTL_PERIPH_UART1));
     GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_6 | GPIO_PIN_7); //Configurar los pines a usar en UART0
     GPIOPinTypeUART(GPIO_PORTB_BASE, GPIO_PIN_0 | GPIO_PIN_1); //Configurar los pines a usar en UART1
     GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1); //Configurar los pines a usar en UART0
 }

 void CONFIG_UART()
 {
     //ASIGNACIÓN DE PINES? RX y TX
     GPIOPinConfigure(GPIO_PA6_U2RX); //Configurar terminal de RX UART2
     GPIOPinConfigure(GPIO_PA7_U2TX); //Configurar terminal de TX UART2
     GPIOPinConfigure(GPIO_PB0_U1RX); //Configurar terminal de RX UART1
     GPIOPinConfigure(GPIO_PB1_U1TX); //Configurar terminal de TX UART1
     GPIOPinConfigure(GPIO_PA0_U0RX); //Configurar terminal de RX UART0
     GPIOPinConfigure(GPIO_PA1_U0TX); //Configurar terminal de TX UART0


     //configuración de dirección del puerto UART, reloj del modulo, baudrate, tamaño de bit y bit de paridad
     UARTConfigSetExpClk(UART2_BASE,g_ui32SysClock,9600,(UART_CONFIG_WLEN_8|UART_CONFIG_STOP_ONE|UART_CONFIG_PAR_NONE)); //configuración de dirección del puerto UART1
     UARTConfigSetExpClk(UART1_BASE,g_ui32SysClock,9600,(UART_CONFIG_WLEN_8|UART_CONFIG_STOP_ONE|UART_CONFIG_PAR_NONE)); //configuración de dirección del puerto UART1
     UARTConfigSetExpClk(UART0_BASE,g_ui32SysClock,9600,(UART_CONFIG_WLEN_8|UART_CONFIG_STOP_ONE|UART_CONFIG_PAR_NONE)); //configuración de dirección del puerto UART0


     IntEnable(INT_UART2);     //habilitación de interrupción por UART1
     UARTIntEnable(UART2_BASE,UART_INT_RX);  //habilitar interrupción por recepción y transmision UART1
     IntEnable(INT_UART1);     //habilitación de interrupción por UART1
     UARTIntEnable(UART1_BASE,UART_INT_RX);  //habilitar interrupción por recepción y transmision UART1
     IntEnable(INT_UART0);     //habilitación de interrupción por UART0
     UARTIntEnable(UART0_BASE,UART_INT_RX|UART_INT_RT);  //habilitar interrupción por recepción y transmision  UART0
     IntMasterEnable(); //Habilita las interrupciones globales
 }

void sendDataUART1(uint32_t c) //envia la petición de respuesta al sensor de presión por UART1 al Edwards dato por dato
{
    UARTCharPut(UART1_BASE, c);
}

void sendStringUART1(char* txt) //envia la petición de respuesta al sensor de presión por UART1 al Edwards dato en arreglo
{
  while(*txt!=0x00)
    {
        sendDataUART1(*txt);
        txt++;
    }
}

void sendDataUART0(uint32_t c) //envia la petición de respuesta al sensor de presión por UART0 al Edwards dato por dato
{
    UARTCharPut(UART0_BASE, c);
}

void sendStringUART0(char* txt) //envia la petición de respuesta al sensor de presión por UART0 al Edwards en arreglo
{
   while(*txt!=NULL)
    {
        sendDataUART0(*txt);
        txt++;
    }
}


//función de autoria propia
void convertir_hexadecimal(uint32_t ui32Base, float number)
{
      int32_t entero;
   // uint32_t entero;
      float auxiliar;
      uint32_t decimal;
    //char digito;
      char ad;
      char ad2;


     if(number>0) //coloca el signo (si es mayor o menor a cero) a la temperatura
        {
          UARTCharPut(ui32Base,0x2B);//+
        }
   else
       {
         UARTCharPut(ui32Base,0x2D);//-
         number=number*-1;
       }

      auxiliar=number;
      entero=number;
      decimal=(auxiliar-entero)*100;


    //AQUI VA LA CONVERSIÓN DE LA PARTE ENTERA A HEXADECIMAL
       UARTCharPut(ui32Base,(char)(entero));
       ad=(char)(entero);
       UARTCharPut(ui32Base,0x2E);//.
    //AQUI VA LA CONVERSIÓN DE LA PARTE DECIMAL A HEXADECIMAL
       UARTCharPut(ui32Base,(char)(decimal));
       ad2=(char)(decimal);
}

//funcion de autoria propia
void cabecera(uint32_t ui32Base, char letra)  //envía los datos en formato hexadecimal T+0x32.0x87
{
    int y=0, z=0;
    switch(letra)
       {
        case 'I':
           UARTCharPut(ui32Base,0x49);//cabecera para corriente (I)

        break;

        case 'P':

          if(arregloP[0]!=0x00 && arregloP[1]!=0x00)
            {
               UARTCharPut(ui32Base,0x50);//cabecera para presion (P)

                  for(z=0;z<2;z++)//envia los datos de temperatura
                   {
                     convertir_hexadecimal(UART0_BASE,arregloP[z]);//manda a llamar a la funcion convertir_hexadecimal2
                   }
                  UARTCharPut(UART0_BASE,0x0A);//salto de linea
           }

        break;

        case 'R':
           UARTCharPut(ui32Base,0x52);//cabecera para el RTD (R)
        break;

        case 'T':
           UARTCharPut(UART0_BASE,0x0A);//salto de linea
           UARTCharPut(ui32Base,0x54);//cabecera para el termistor(T)
           for(y=0;y<12;y++)//envia los datos de temperatura
              {
                 convertir_hexadecimal(UART0_BASE,arreglo[y]);//manda a llamar a la funcion convertir_hexadecimal
              }
           UARTCharPut(UART0_BASE,0x0D);//retorno de carro
        break;

        case'V':
           UARTCharPut(ui32Base,0x56);//V para el volaje
        break;

        default:

            break;

        //default, que no haga algo
      }
}

//-----------------------------------------------------------------------------------------------------------------
//                                                  TERMISTOR
//-----------------------------------------------------------------------------------------------------------------


//------------------------------------------------------------------------------------------------------------------
//                                                   RTD
//------------------------------------------------------------------------------------------------------------------




//-----------------------------------------------------------------------------------------------------------------
//                                                  PRESION
//-----------------------------------------------------------------------------------------------------------------


//función para limpiar los buffer y el contador de UART
void clear_variables()
{
  i_rx=0; //pone en cero el contador
  lumos=0;
  impedimenta=0;
    for(i_Rx=0;i_Rx<=25;i_Rx++)
      {
        BUFFER_UART[i_Rx]=0;    //Limpia el buffer de UART     breakpoint
        BUFFER[i_Rx]=0;         //Limpia el buffer de proceso
      }
}


//Procesa los datos de presión
void calculo()
{

    if ( BUFFER[6]>=0x30 && BUFFER[6] <= 0x39 ) banderanum=1; //verifica que el dato en la posición [6] sea un numero

      t=8;
     do
      {
        if(BUFFER[t]>=0x30 && BUFFER[t] <= 0x39)////verifica que los datos desde la posición [8] a [11] sean numeros
         {
           banderanum=1;// bandera se pone en 1
         }
         else
          {
            banderanum=0; // bandera se pone en 0
          }
         t++;
      }while(t<=11);

     if(banderanum==1) //si los datos son mumeros
     {
       if(BUFFER[15] >=0x30 && BUFFER[15] <= 0x39 ) bandera=1;// verifica que el dato en la posición [15] sea un numero
     }


     if(banderanum==1)
     {

            if(bandera==1)
             {                   //resta 48 a los datos del arreglo para convertir los caracteres en numeros
               a=1*(BUFFER[6]-48);// numero*1=numero
               b=0.1*(BUFFER[8]-48); //numero*0.1=0.numero
               c=0.01*(BUFFER[9]-48);//numero*0.01=0.0numero
               d=0.001*(BUFFER[10]-48);//numero*0.001=0.00numero
               e=0.0001*(BUFFER[11]-48);//numero*0.0001=0.000numero
               G=BUFFER[15]-48; // exponente de la presion
               E=a+b+c+d+e; //suma los numeros
               //G=ver[15]-48;
               F=pow(10,G);//eleva el 10 al exponente de la presion

              if(BUFFER[13]==0x2D) //breakpoint (posición [13] del arreglo) si el signo de la presión es negativo
               {
                  p1=E/F; //breakpoint presion en el sensor 1 = suma de los numeros dividido entre el exponente de la presion
                  p=p1/1000;//breakpoint
                 // convertir_hexadecimal(UART0_BASE, p1);

               }
               else if (BUFFER[13]==0x2B)  //(posición [13] del arreglo) si el signo de la presión es positivo
               {
                  p1=E*F; //presion en el sensor 2 = suma de los numeros multiplicado por el exponente de la presion
                  p=p1/1000;//breakpoint

               }

            }
          if(contadordeborrado==0)
          {
              arregloP[0]=p;
          }
          else if(contadordeborrado==1)
          {
              arregloP[1]=p;
          }
       }
}


//Guarda los datos procedentes del UART en un nuevo arreglo y vacía los buffer
void GUARDA_ARREGLO()
{
    if(lumos==1)
     {
       if(BUFFER_UART[0]==0x3D && BUFFER_UART[18]==0x39)//compara si la posicion 0 del arreglo es = y la posición 19 es ;
          {
            coincidencia=1; //breakpoint pone en uno la bandera de coincidencia
            flag_UART=1;   //pone en uno la bandera de flag_UART
            i_rx=0;   //reinicia el contador
          }
       else
          {

            clear_variables(); //limpia los buffer y reinicia el contador i_rx
          }
     }

    if(flag_UART==1)
      {
          flag_UART=0; //breakpoint
         if(coincidencia==1)//si la posición 0 y 25 del arreglo entrante son iguales
          {
             coincidencia=0;
             i_rx=0; //reinicia el contador
             for(i_y=0;i_y<=25;i_y++)//Guarda el contenido del buffer de uart en un buffer para procesar los datos
                 {
                   BUFFER[i_y]=BUFFER_UART[i_y];
                 }
                  calculo();
           }
         else
          {
             clear_variables(); //limpia los buffer y reinicia el contador i_rx
          }

         contadordeborrado++;
         if(contadordeborrado==2) contadordeborrado=0;//lleva el conteo de las posiciones del arreglo de presion
     }

     clear_variables();

//Limpia los buffer y el contador cuando la trama es erronea o está cortada.

        if(BUFFER_UART[0]==0x2A) //compara si la posicion 0 del arreglo es igual a "*"
        {
            clear_variables(); //limpia los buffer y reinicia el contador i_rx
        }
}



//----------------------------------------------------------------------------------------------------------------------------
//                                             MAIN
//----------------------------------------------------------------------------------------------------------------------------
int main(void)
{
   //configurar el reloj del microcontrolador
     g_ui32SysClock = SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ | SYSCTL_OSC_MAIN |SYSCTL_USE_PLL |SYSCTL_CFG_VCO_240), 120000000);//120 MHz

    INIT_ADC(); //inicializa el ADC
    INIT_UART();
    CONFIG_UART();
  //sendStringUART1(S_P4);

    while(1)
   {
      TEMP_TERMISTOR();//configura las caracteristicas de las funciones de ADC del micro y procesa los datos entrantes a temperatura
      SysCtlDelay(10000);
      sendStringUART1(S_P1);
      SysCtlDelay(21000000);//514ms
      GUARDA_ARREGLO();
      SysCtlDelay(10000000);//514ms
      sendStringUART1(S_P2);
      SysCtlDelay(21000000);//514ms
      GUARDA_ARREGLO();
      SysCtlDelay(17000000);//514ms
      cabecera(UART0_BASE,0x54);// Manda a llamar a la funcion "cabecera"
      cabecera(UART0_BASE,0x50);
   }
}

//------------------------------------------------------------------------------------------------------------------------------
//                                              ISR
//------------------------------------------------------------------------------------------------------------------------------

//i_rx=0;
//int variable=0;
void ISR_UART0(void)
{


}

void ISR_UART1(void)
{
    ui32Status = UARTIntStatus(UART1_BASE,true);
       UARTIntClear(UART1_BASE, ui32Status);        //limpia las banderas de interrupción?

       if (UARTCharsAvail(UART1_BASE))
       {
           char rxData = UARTCharGetNonBlocking(UART1_BASE); //recibe el dato UART entrante

           if (flag_rx)
           {
               if (rxData == 0x0D)
               {
                   flag_rx = false;
               }
               BUFFER_UART[i_rx++]=rxData;// Guarda el dato recibido en un arreglo
           }
           else
           {
               if (rxData == '=')
                    {
                      flag_rx = true;
                      i_rx = 0;
                      BUFFER_UART[i_rx++]=rxData;// Guarda el dato recibido en un arreglo
                     }
           }
           impedimenta=1; //breakpoint
       }//cierra if(charsAvail)
       lumos=1; //breakpoint
}

void ISR_UART2(void)
{

}
//

你好！

这是我的代码！

梅拉

Mayra、您好！

谢谢、我希望能够轻松地运行代码并进行复制、但我不确定这在这里会很简单。 如果我正在正确读取代码、您有时会收到指示 UART 输出的 UART 消息？

如果是、我将无法完全复制您的系统设置。

尽管知道这一点之后会带来一个不同的问题、即您看到的错误输出区域是否与通过 UART 接收的内容、与热敏电阻读数相关的内容或与器件中存储的静态消息相关的内容？  

此致、

Ralph Jacobi

Mayra、您好！

实际上、我认为发生的情况是、您收到的数据值有时为0x20。

当您将0x20发送到带有 UARTCharPut 的 Termite 时、它只打印一个空格、而不显示数据值。

因此、我建议检查您是否以数据的形式发送0x20、例如在发送数据之前查看数据、并使计数器递增、即数据值等于0x20。 如果是、这将解释问题。

然后、您可以使用  UARTprintf 解决该问题。

此致、

Ralph Jacobi

你好！

我尝试使用 UARTprintf()，但它不会向终端发送任何内容， 
程序和函数中都可以识别这些库、但测试短语不会出现在终端中。 

梅拉 

很抱歉，如果我有很多疑问，我没有太多编程经验:( 

您好、Mayra、

您需要以不同的方式初始化 UART、然后才能使用该调用。  需要调用 UARTStdioConfig 以使 UART stdio 函数知道要使用哪个 UART。 请参阅以下代码片段。

void prvConfigureUART(void)
{
    /* Enable GPIO port A which is used for UART0 pins.
     * TODO: change this to whichever GPIO port you are using. */
    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);

    /* Configure the pin muxing for UART0 functions on port A0 and A1.
     * This step is not necessary if your part does not support pin muxing.
     * TODO: change this to select the port/pin you are using. */
    GPIOPinConfigure(GPIO_PA0_U0RX);
    GPIOPinConfigure(GPIO_PA1_U0TX);

    /* Enable UART0 so that we can configure the clock. */
    SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);

    /* Use the internal 16MHz oscillator as the UART clock source. */
    UARTClockSourceSet(UART0_BASE, UART_CLOCK_PIOSC);

    /* Select the alternate (UART) function for these pins.
     * TODO: change this to select the port/pin you are using. */
    GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);

    /* Initialize the UART for console I/O. */
    UARTStdioConfig(0, 115200, 16000000);
}

此致、

Ralph Jacobi

Mayra、您好！

 您能否在应用中使用 UARTprintf 函数时发布该函数？  

此致、

Ralph Jacobi

您好、Mayra、

当然。  原始数据通常指未处理/分析的任何数据。 由于您提到过您正在读取热敏电阻、这意味着您尝试获取温度数据-但您显示的输出都是十六进制字符、问题似乎存在(现在已确认为) 源自非典型 ASCII 数字/字母的输出字符。 因此、在我看来 、数据似乎尚未经过处理、无法将传感器读数转换为"35摄氏度"等实际温度。 这方面我可能会错、但这正是我所期望的。

此致、

Ralph Jacobi