Comunicaciones puerto serie (UART)

Vamos a dedicar un par de entradas a examinar con cierto detalle el funcionamiento de las comunicaciones asíncronas (UART, o lo que habitualmente se conoce como el puerto serie) de la familia PIC18.

Nos centraremos en el software, dejando de lado el aspecto hardware, sobre todo la conversión de niveles si la comunicación es entre un PIC y el PC o entre dos microcontroladores con diferentes voltajes (p.e. 3.3V y 5V). En mis pruebas he usado el conversor de niveles integrado en la placa EasyPIC6. En general habrá que usar un conversor de niveles basado en el Max232 o similar. Una búsqueda de RS232 MAX232 TTL en ebay nos mostrará varias posibilidades a partir de unos $5.

En primer lugar presentaremos las funciones básicas que la mayoría de los compiladores tienen para abrir el puerto serie, enviar/recibir, etc. Luego escribiremos nuestras propias rutinas. El objetivo no es prescindir de las rutinas del compilador, sino entender los fundamentos para ser capaces (cuando sea necesario) de saltarnos las limitaciones de un compilador en particular.

También escribiremos una función que nos permita configurar el puerto serie a partir de la velocidad en baudios, sin tener que calcular y programar los registros asociados.

Código asociado a esta entrada:  uart0.c  uart1.c 

------------------------------------------------------------------------------------------------------------

Funciones básicas de manejo de puerto serie:  (uart0.c)

En primer lugar vamos a ver un sencillo código en C que establece una comunicación serie entre el PIC y p.e. un PC usando las rutinas del compilador. Dos compiladores que uso habitualmente son el C18 de Microchip y el MikroC Pro de Mikroelectronica. No importa que estéis usando algún otro compilador porque la idea es profundizar un poco más sobre que hace un compilador al manejar el puerto serie de un PIC.

Las funciones básicas de ambos compiladores  en relación al puerto serie son:

FUNCION	MikroC Pro	C18
Inicialización	UART1_init	Open_USART
Data ?	UART1_Data_ready	DataRdyUSART
Leer	UART1_read	ReadUSART  / getcUSART
Escribir	UART1_write	WriteUSART / putcUSART

Usando las funciones anteriores, un sencillo programa en C18 que abre el puerto serie a 9600 bauds, lo monitoriza el puerto serie y rebota lo que recibe sería el siguiente (notad que es necesario incluir usart.h):

#include <usart.h>

void main()

{

 char ch;

  

 TRISB=0; PORTB=0;

 OpenUSART(USART_ASYNCH_MODE & USART_EIGHT_BIT & USART_BRGH_HIGH,129);

 while(1)

   {

    if (DataRdyUSART())

     {

      ch = get_byte(); send_byte(ch+1); send_byte(0x0D); send_byte(0x0A);

      PORTB++;

     }

    Delay10KTCYx(5);

   } 

}

El mismo programa en MikroC Pro:

void main() {

char ch;

TRISB=0; PORTB=0;

  

UART1_Init(9600);

while(1)

  {

   if (UART1_Data_Ready())

    {

     ch = UART1_Read(); UART1_Write(ch+1); UART1_Write(0x0D); UART1_Write(0x0A);

     PORTB++;

    }

   delay_ms(10);

  }   

}

Si conectamos PIC y PC, cualquier cosa que tecleemos en un terminal nos es devuelta como el carácter siguiente en la tabla ASCII, debido a que enviamos (ch+1) donde ch es el carácter recibido. Además se manda un retorno de carro y salto de línea. Según la configuración de nuestro terminal es posible que veamos tanto el carácter que hemos tecleado como el que envía el PIC. Además PORTB se incrementa con cada carácter recibido de forma que podemos ver un feedback visual de los bytes recibidos.

Lo que vamos a hacer ahora es volver a escribir las funciones anteriores pero usando nuestro propio código, lo que implicará manejar los SFR (Special Function Register) del PIC asociados a la UART. El efecto  colateral será que entenderemos como funcionan a "bajo nivel" dichas comunicaciones.

Hay 5 registros que tendremos que conocer y manejar:

TXSTA  -> Status de TX, con el indicamos las opciones de transmisión

RXSTA  -> Status de RX, opciones de recepción.

SPBRG  -> determina la velocidad de las comunicaciones (bauds) junto con el bit BRGH de TXSTA

RCREG  y TXREG -> registros donde se guarda el byte recibido y donde ponemos el byte a transmitir.

La más complicada es la inicialización de la UART. Afecta a los distintos bits de TXTSTA, RXSTA y SPBRG.

void setup_UART(uint8 brgh,uint8 spbrg)

 {

  TRISCbits.TRISC6=0; TRISCbits.TRISC7=1;  // RC6 out (tx), RC7 in (rx)

 

  TXSTA =  0b00100110;

/*TXSTA = 0x00;  // Clear TX status

  TXSTA.SYNC=0;  // Async mode

  TXSTA.TXEN=1;  // Enable TX

  TXSTA.TRMT=1;  // TRS empty  (we start with an empty TX register)*/

  RCSTA = 0b10010000;

/*RCSTA =0x00;  // Clear RC status

  RCSTA.SPEN=1; // Enable Serial Port

  RCSTA.CREN=1; // Enable Receiver*/

 // BRGH=0 -> Baud Rate = Fosc / (64 * (SPBRG+1))

 // BRGH=1 -> Baud Rate = Fosc / (16 * (SPBRG+1))

  TXSTAbits.BRGH=brgh; SPBRG = spbrg; 

 }

La rutina setup_UART inicializa la UART para una comunicación asíncrona con 8 bits. La velocidad (bauds) se calcula en función de los parámetros BRGH y SPBRG, junto con la frecuencia del oscilador Fosc:

BRGH=0  ->  baud = F_osc / (64 x(SPBRG+1))  

BRGH=1  ->  baud = F_osc / (16x(SPBRG+1))

Con un oscilador de 20 MHz, para una velocidad de 9600 baudios usaríamos BRGH=1 y SPBRG=129, obteniendo

  baud = 20000000/(16 x 130) = 9615

suficientemente próxima al valor correcto.

En la rutina también se determina la dirección (out) del pin TX y la del pin RX (in). En este ejemplo (familia PIC18F2520/4520) son RC6 y RC7 respectivamente. No estoy seguro de que esto sea necesario (tal vez la dirección de RC6/RC7 se establezca automáticamente al habilitar el receptor y el emisor) pero por si acaso...

Enviar un byte es una simple cuestión de esperar a que el buffer de salida esté vacío (consultando flag TXSTA.TRMT) y cuando lo esté, poner el carácter a transmitir en el buffer de TX. Automáticamente el bit TRMT se pondrá a 0 (buffer lleno), por lo que una siguiente llamada a la  función tendría que esperar a terminar de mandar el carácter.

void send_byte(unsigned char ch)

{

 while (TXSTAbits.TRMT==0);   // wait until TX buffer is empty

 TXREG=ch;

}

Para ver si se ha recibido algo se consulta la bandera de la interrupción de recepción del puerto serie (definida como RX_flag como ya vimos):

char rx_ready(void) {  return RX_flag; }

Finalmente, si se ha detectado (rx_ready) una recepción, una llamada a get_byte recupera el byte recibido (que está esperándonos en RCREG). También se quita la bandera RX_flag para indicar que estamos de nuevo a la espera.

char get_byte(void)

{

 RX_flag=0; // Clear RX flag

 return RCREG;  // Devuelve byte recibido

}

El siguiente código usa estas funciones para hacer exactamente lo mismo que antes:

void main()

{

 char ch;

  

  TRISB=0; PORTB=0;

  setup_UART(1,129);

  while(1)

    {

     if (rx_ready())

      {

       ch = get_byte(); send_byte(ch+1); send_byte(0x0D); send_byte(0x0A);

       PORTB++;

      }

     Delay10KTCYx(5);

    }

}

¿Hemos ganado algo?  Obviamente nada si sólo queríamos hacer lo que hacíamos en el programa inicial. Para ello nos bastaban las rutinas que ya existían en nuestro compilador. Las ventajas aparecen cuando necesitamos apurar un poco más: 

1. Las rutinas standard en muchos compiladores solo soportan el modo de comunicación más usual (8 bits sin paridad). Si por ejemplo queremos usar paridad no nos sirven. Sin embargo ahora que sabemos lo fácil que es enviar o recibir bytes será muy sencillo cambiar algunos bits en TXSTA y/o RXSTA para establecer una comunicación usando p.e. paridad o 9 bits.
2. Las rutinas standard (y las que hemos escrito, ya que eran intercambiables) son bloqueantes. Antes de escribir debemos esperar a que el buffer de transmision (1 byte) se libere. Antes de recibir debemos estar continuamente preguntando (rx_ready) si se ha recibido algo.

Imaginad que el PIC está conectado a un sensor que genera unos 1000 bytes/segundo que deben ser enviados al PC). Cada byte supone como mínimo 10 bits (start + 8 bits + stop) , por lo que para poder enviar 1000 bytes/sec precisaremos un enlace de aproximadamentelo unos 1000 x 10 (podría valernos 9600). Si en estas circunstancias usamos las rutinas originales, todos los recursos del PIC estarían prácticamente dedicados a la transmisión de los datos.

Esta situación puede implementarse mucho más eficientemente usando interrupciones y esperando que la UART nos avise de que ha recibido un dato o que está libre para enviar otro. El resto del tiempo el PIC puede estar haciendo otras cosas. La diferencia puede ser grande. Si esperamos a que se complete la TX, enviar un byte puede costarnos del orden de 1 ms ( @ 9600 bauds). Usando interrupciones el único trabajo del microcontrolador será poner un byte en TXREG, lo que esencialmente nos llevará una instrucción. Transmitir dicho byte seguirá llevando 1 ms, pero el que estará ocupado durante ese tiempo será el periférico (UART).

Habiendo aprendido como funciona por debajo la UART será muy sencillo implementar tanto la recepción como la transmisión usando interrupciones.

Determinación de SPBRG y BRGH en función de la velocidad en baudios

Vimos que aunque la función de MikroC Pro era menos versátil en la configuración del puerto serie tiene la ventaja de que bastaba con darle la velocidad y ella se encargaba de determinar los parámetros SPBRG y el bit BRGH. Esto es posible porque en un proyecto de MikroC Pro se especifica la velocidad del oscilador. Por la misma razón en MikroC Pro podemos especificar delays en unidades  absolutas (msec o usec) en vez de limitarnos a ciclos como en C18.

Es muy sencillo escribir una función que calcule los valores correctos de SPBRG y BRGH y nos lo devuelva para usarlos en una llamada a nuestra rutina setup_UART o a la OpenUSART de C18:

uint8 get_usart_speed(uint32 baud, uint32 Fosc, uint8* spbrg)

// baud rate 1200,2400,4800,9600,19200, ..., 115200

// Fosc = Frequency osc in KHz -> 20MHz = 20000 

// Returns 0 (USART_BRGH_LOW), 1 (USART_BRGH_HIGH), or 2 (cannot get speed requested)

// It places in spbrg the value to be used as argument spbrg in OpenUSART

 {

  uint16 FF;

  uint8 brgh;

  uint8 shift;

  Fosc=Fosc*1000; 

  baud>>=1; Fosc=Fosc/baud+1; Fosc>>=1;  // computes round(Fosc/baud)

  FF=(uint16)Fosc;

 

  if ((FF>16320)||(FF<16)) return 2;   // Baud rate too low or too high

 

  brgh = (FF>4096)? 0:1;  // Decides between BRGH=0 o BRGH=1

  shift= (brgh==1)? 3:5; 

  FF>>=shift; FF--; FF>>=1; // Computes round(FF/64 -1) or round(FF/16-1)

  *spbrg = (uint8)FF;

  return brgh;

 }

La forma de usar esta rutina para inicializar la UART en conjunción con setup_UART() sería:

void main()

{

 uint8 brgh,sp; 

 brgh=get_usart_speed(38400,20000,&sp);

 setup_UART(brgh,sp); 

}

Si preferimos seguir usando la rutina de C18 (OpenUSART) para inicializar la USART:

void main()

{

 uint8 brgh,brgh_config,sp; 

 brgh=get_usart_speed(38400,20000,&sp);

 brgh_config=(brgh)? USART_BRGH_HIGH:USART_BRGH_LOW;

 OpenUSART(USART_ASYNCH_MODE & USART_EIGHT_BIT & brgh_config, sp); 

}

Si solo vamos a inicializar el puerto es obviamente más eficiente calcular nosotros los valores a usar y programarlos directamente. De esta forma nos ahorraríamos los 30-40 palabras de memoria de programa que ocupa la rutina anterior. Este enfoque es más útil si queremos dinámicamente cambiar la velocidad del puerto serie durante el programa.