Acercamiento al uso del USB

Hablar sobre USB es algo complejo, pues no es tan sencillo como pareciera. A diferencia de la transmisión serie o la transmisión por USB es mas elaborada, desde la construcción de las tramas hasta los descriptores que le componen; además de los métodos de transferencia que existen dentro del mismo USB.

La comunicación USB esta basada de manera céntrica, donde el HOST en este caso nuestra computadora es quien controla y enumera los dispositivos USB que se conectan a ella. Para entender mas a fondo el protocolo USB recomiendo los libros de Jan Axelson que son excelentes en la descripcion de todos los elementos que se deben considerar al diseñar un sistema que maneje el USB. Existen términos como Enumeracion, EndPoint, Descriptor entre otros que no serán detallados a fondo pues su complejidad requieren mayor estudio y esto solo es un acercamiento.

Existen varios tipos de transferencias usadas con el USB siendo 3 las mas conocidas: Bulk, Interrupción y Asíncrona. En el mundo de los PICs las mas usadas son la BULK y la de Interrupción, mejor conocidas como CDC o HID respectivamente, básicamente se diferencian en la forma en que transmiten los datos hacia el host y en la forma en que los descriptores están construidos.

Para usar la comunicación USB con los PICs Microchip ha liberado una serie de microcontroladores que incluyen un modulo interno para trabajar con dicha protocolo, los PICs que cuentan con este modulo los podemos ver en este enlace. Hay que decir que microchip ha liberado de hace ya algún tiempo la nueva familia OTG la cual puede actuar como HOST embebido, pero esta clase no sera tratada en el blog.

En C18, tenemos un framework liberado por Microchip para poder trabajar con estos PICs, actualmente están en la Versión 2.3, pero nosotros usaremos para estos simples ejemplos la versión 1.3 ya que es mas facil de trabajar y editar. Lo primero que debemos hacer es entender como trabaja este framework -o STACK- de la Versión 1.3 y los archivos que contiene. Para una visión general del funcionamiento esta pagina es excelente. Ahí encontraran la descripción del sistema y los archivos que están en este stack. Es necesario que den una revisada para poder entender mejor lo que viene. Como la mayoría de los Stacks de Microchip son usados para sus placas de desarrollo es necesario editar y añadir códigos para que el firmware trabaje con nuestro PIC, en mi caso me basare en el hardware de la TP-2550, creada por mi amigo Giovanni Lafebre.

Manos a la Obra
Lo primero que vamos a hacer es descargar el Stack USB v1.3 de este enlace. Una vez instalado por default en C:\MCHPFSUSB. Abriremos el compilador y en menú project cargaremos el ejemplo de la carpeta FW\CDC\.

Usando CDC con el 18F2550
Como el hardware de la TP-2550 esta basado en el 18F2550, tendremos que editar algunas cosas -he decidido usar el CDC antes que el HID solo por gusto no por otra cosa-. Al abrir el archivo MCHPUSB.mcp podemos ver como esta construida la estructura de directorios:

Para este pequeño ejemplo nosotros vamos a trabajar solamente con los siguientes archivos: main.c, user.c, io_cfg.h y usbcfg.h. Hay que tener cuidado con el archivo del linker, en este caso rm18f4550.lkr; este archivo viene default para el 18F4550 es usado para poder cargar el bootloader que por default trae el C18, el bootloader facilita la programación del PIC si se desea prescindir de un programador y se puede hacer con la misma conexión USB del hardware. Si se desea usar el bootloader con el 18F2550 basta con editar el archivo lkr y sustituir la linea FILES p18f4550.lib por FILES p18f2550.lib. Si no se desea usar el bootloader se deberá quitar el archivo rm18F4550 y sustituirlo por 18F2550.lkr que se encuentra en la carpeta lkr del directorio de instalación de C18; además de que en el archivo main.c se deberá comentar la siguiente porción de código:

/** V E C T O R R E M A P P I N G *******************************************/
/*extern void _startup (void); // See c018i.c in your C18 compiler dir
#pragma code _RESET_INTERRUPT_VECTOR = 0x000800
void _reset (void)
{
_asm goto _startup _endasm
}
#pragma code*/


Añadiendo nuestro Hardware

Ahora para usar la TP2550 tendremos que agregar algunas lineas y empezaremos en el archivo io_cfg.h. Tendremos que localizar la linea donde nos indica descomentar y agregar nuestro Hardware por ahora solo agregue 8 Leds y 4 Switches.




Abriremos el archivo main.c y de igual forma localizamos la linea donde nos pide descomentar para añadir nuestros fuses yo añadi algunos:



Unas lineas mas abajo dentro de la funcion InitializeSystem vamos a añadir el siguiente código, pues de lo contrario nos dara un error al compilar. Solo nos sirve para inicializar en modo digital el PIC.



Ahora abrimos el archivo usbcfg.h y vamos a añadir lo siguiente:



Esto sirve para que identifique los pines de sensado para el USB aunque estan comentados porque usamos el mismo voltaje del USB es necesario definirlos, en caso de que se requiera una fuente externa se necesitara definir que pin sensara cuando el USB se conecte al PIC.

Por último y mas importante editaremos el archivo user.c, que es el archivo donde se ejecutaran las rutinas pertinentes a nuestro programa nosotros solo añadiremos que encienda un led al recibir del puerto serie el ascii 1 y cuando se presione un switch nos mande el estatus al terminal. Vamos añadir una variable llamada old_sw1 y el prototipo de función para cuando se presione el switch 1 de tal forma que una parte del código debe verse asi:



La funcion de ProcessIO la dejaremos así:



El código donde se realizan nuestra función sera el siguiente:



Y por último añadimos la función del boton apretado:



En la carpeta de user del directorio c:\MCHPFSUSB\fw\Cdc\ existen varios ejemplos para poder utilizar el USB en modo CDC con el 18F4550 pero son utiles si desean usar el 18F2550.

Finalmente dejo el video de la simulación del programa anterior.

Y como no debe faltar el video en fisico de ese programa, pero sin botones.

Interacción del Usuario via Terminal Parte II

Hola, después de una larga ausencia continuamos con la segunda parte de la interacción del usuario y el PIC vía terminal. Esta vez vamos a configurar la hora y fecha, recibeindo los datos via el puerto serie.

Seguiremos usando como base el código anterior, solo añadiremos unas funciones necesarias; la primera es la siguiente:

void flush_buffer(void)
{
if ( RCSTAbits.OERR ) // Si se activa el bit de overflow
{
RCSTAbits.CREN=0; // toggleo de CREN para limpiar le buffer
W= RCREG; // flush del registro
W= RCREG;
W= RCREG;
RCSTAbits.CREN=1; // toggleo de CREN
}

}

Esta función es necesaria ya que el buffer de recepcion de los PICs fácilmente se llega a llenar y ocurre desbordamiento ocasionando un mal funcionamiento en la recepcion de datos. El bit 4 del registro RCSTA -registro encargado de la configuracion RX serial- es el OERR, este bit indica si existe un desbordamiento en el buffer cuando esta en estado alto.  Cuando dicho bit esta en estado alto es necesario vaciar el buffer de recepción y esto se logra haciendo un toggle en el bit CREN que es el que recibe. Es por esto que esa función es llamada antes de recibir algo para asegurar la integridad de los datos.

La segunda función añadida es:

unsigned char user_data(void)
{ unsigned char link[2]; // array para datos de usuario 

  while(!DataRdyUSART()); // esperamos caracter de usuario  
  getsUSART(link,2); // Obtenemos el dato del usuario
  return atoi(link); // convertimos los caracteres en byte
}

La cual nos sirve para obtener los datos del usuario a través del puerto serie. Para ello usamos una funcíon de la librería usart.h: getsUSART(cadena, longitud); Esta funcion lleva como parametros la cadena donde sera guardados los datos y la longitud de estos datos. Es decir, esta funcion es útil para recibir una cadena de caractéres cuando conocemos su longitud y como nosotros recibimos solamente 2 caracteres que equivalen a los dato de fecha y hora nos viene como anillo al dedo.

Asi pues recibimos 2 caractéres que son guardados en la variable LINK que es un array de 2 posiciones, posteriormente convertimos la cadena en un byte para poder trabajar con él. Recordemos que lo que viene del puerto serie son asciis y no bytes. Una vez que se realiza la conversion se retorna el valor convertido para su uso posterior.

Otra función agregada es:

unsigned char DEC2BCD(unsigned char aux)  
{ 
aux += (aux/0x0A)*0x06; // Procedimiento para convertir a BCD
return aux; 
}

Esta función es la que nos ayuda a pasar los datos recibidos desde el puerto serie a codigo BCD o HEX para poder escribir correctamente el RTC, si no usamos esta función los datos escritos en el RTC serían incorrectos pues recordemos que se escribe en HEX los registros del RTC. Esta función es un regalito de ANDRE LUIZ del foro de C18 de Microchip. Nunca dejen de buscar ahí, generalmente lo que deseamos alguien más ya lo ha hecho.

Y aquí esta el código que se utilizo para este fin, queda como tarea pendiente asegurar los máximos números de la hora y fecha; ademas de programar la eeprom del PIC para que una vez que ha sido grabado el RTC no nos ida de nuevo la configuración y esto puede servir para un mini-datalogger añadiendo una EEPROM al bus I2C.

Interacción del Usuario via Terminal

El programa anterior, envía la temperatura al Terminal y al LCD mientras este presionado el botón conectado en RA0; esto puede ser un tanto molesto si el dispositivo esta un poco alejado de donde se encuentra la PC, así que sería bueno añadir un acceso desde el terminal cuando el botón no este presionado.

Para eso podremos usar la función getcUSART();  la cual nos permite leer un byte proveniente del buffer de recepción. También vamos a usar la función DataRdyUSART(); la cual nos permite saber cuando hay un dato en el buffer de recepción, resulta útil usarla ya que esperara hasta que llegue un dato, lo cual servirá para esperar la orden del usuario.

La idea general del programa es: Si no esta presionado el botón que nos llegue un mensaje al terminal via serie para indicarnos como tomar la lectura, si se preiona el boton tener una lectura continua o salir del modo pasivo.

Para ello podemos basarnos en el siguiente código

Con esto obtenemos el resultado deseado y pueden descargar de aquí el vídeo de la simulación.

Sensando Temperatura con LM35DZ

Ahora que podemos mostrar datos analógicos en un LCD y enviarlos vía serie, podemos usar un sensor y cual otro podría ser si no el famosísimo LM35DZ. Este sensor se encuentra por todas partes, debido a su bajo costo y su funcionalidad.

Este es el circuito básico de conexión de LM35:

Como podemos apreciar en el circuito la salida analógica del sensor es de 10mV por cada grado centígrado que registra; por otra parte la resolución de nuestro ADC es de 10 bits y como nuestras fuentes de referencia son las misma que alimentan al PIC,  tenemos que:

  5V / 1024 = .0048 V 

De este modo nosotros tenemos una resolución de @5mV en cada paso de nuestro canal analógico. Esta resolución es más que perfecta para usar ese sensor, de tal modo que usando la lógica cada grado centígrado equivaldrá a 2 pasos de nuestro ADC.

Con los datos anteriores podemos realizar el siguiente programa:

Como podemos apreciar el programa es muy sencillo, aunque C18 soporta el uso de flotantes, la conversión a cadena de texto no se puede, y en la parte serial no soporta %f  por esta razón se trabaja directamente con enteros y se logra una conversión similar. No es exacta falla por unas decimas pero para este programa no viene ningún problema en ello.

El circuito es el mismo del programa anterior solo habrá que sustituir el potenciómetro por el sensor.

Y por último la simulación:

Usando un LCD

Al programa anterior le vendría bien mostrar el valor del ADC sin usar un PC, para ello podemos usar un LCD de 16x2.

Para este fin será necesario usar la libreria xlcd.h,  esta se encarga de mostrar los textos por nosotros. Esta librería posee varias funciones, pero nosotros nos enfocaremos especifcamente en 3 de ellas: openXLCD(); putrsXLCD(); y putsXLCD;

Antes de empezar a usar esta función es necesario hacer unos cambios a la librería, pero antes debemos pasarla a nuestra carpeta de proyecto.

Lo primero sera copiar la librería que se encuentra en Directorio_de_instalación\MCC18\h\xlcd.h a nuestra carpeta en mi caso será E:\Microchip Solutions\Proyectoblog\h\xlcd.h.

Después de eso copiaremos los archivos fuente de la libreria que se encuentran en Directorio_de_instalación\MCC18\src\extended\pmc\XLCD\*.c  a la carpeta de nuestro proyecto en nuestro caso será E:\Microchip Solutions\Proyectoblog\src\XLCD\ Nos aseguramos de copiar todos los archivos *.c a nuestra carpeta de proyecto.

Esto se hace para respaldar la libreria original y realizar modificaciones sin moderación alguna en nuestro proyecto, así evitamos daños a la librería original.

Posteriormente debemos configurar nuestro proyecto para que compile desde nuestra ruta la librería recien copiada. Para ello accedemos a Menú Project--->Build Option-->Project y se abrira la siguiente ventana:

Daremos click en la opción Show directories for  y posteriormente en Include search path:

Eliminaremos el path default y añadimos uno nuevo con nuestra ruta.

Posteriormente vamos añadir las fuentes de la librería, esto lo hacemos dando click derecho sobre la carpeta de y click en add:

Y seleccionaremos todos los archivos en ..\src\XLCD\  Por último añadimos el Header xlcd.h con el mismo procedimiento.

Ahora que ya tenemos preparado el entorno de trabajo lo primero que vamos a hacer es modificar la libreria para poder usar el LCD en el PORTD a 4 bits para eso abrimos el archivo xlcd.h  dando doble click. Una vez abierto es muy sencillo ya que esta completamente comentado los modos de trabajo asi que para nuestro ejemplo el archivo queda de la siguiente forma. Ubicamos esta porcion de codigo en la librería:

En este caso la librería ya fue editada para que trabaje como deseamos, pero es tan transparente que es bastante sencillo poder modificarla para llevarla a otro puerto del PIC.

Una vez que hemos modificado nuestra librería a nuestro gusto podemos empezar a programar. La idea es mostrar un mensaje incial, despues presionar el boton y mostrar el valor del ADC tanto serialmente como en el lcd, podemos basarnos en el siguiente codigo:

Como podemos apreciar en el código las funciones de la librería xlcd.h  que mas usamos fueron: openXLCD(); putrsXLCD(); y putsXLCD;

openXLCD(); Sirve para incializar el LCD con los argumentos de 4bits y el tamaño de cada caracter. Una vez que se llama esta función es necesario añadir 3 pausas para inicializar el LCD, estas pausas estan debajo del alias de nuestro botón.

putrsXLCD(); Sirve para poner una cadena de texto desde la memoria de nuestro programa.

putsXLCD; Sirve para poner una cadena de texto desde la memoria de datos, estas dos funciones se implementaron en una funciçon que cree para poder usar el mismo comando sin atascar la memoria del PIC con la función writeLCD.

El circuito propuesto para este programa es el siguiente:

Y el video de la simulación:

Leyendo un Canal AD y enviando el valor vía Serie

Es momento de hacer algo un poco mas elaborado que prender simples LEDS, así que vamos a leer una entrada analógica y el valor lo mandaremos vía serie al terminal.

Hay 3 librerías nuevas que vamos a utilizar: stdio.h, adc.h y usart.h. La librería stdio.h  nos va a servir para enviar los datos al terminal de la PC haciendo uso del comando printf

printf:

Este comando es util para enviar texto y/o numero formateados vía el hardware serial, la sintaxis es:

printf(sentencias/formato,valor de formato)

Las sentencias son las palabras o cadenas que enviaremos vía serie, el formato es opcional, pero a la ves muy útil, para utilizar el formato es necesario usar el símbolo %  para poder anexar un valor numérico después.

Por ejemplo podemos enviar la palabra hola usando el comando printf:

 

printf("hola");  

Como podrán ver el texto debe ir entrecomillado para poder enviarse, en este ejemplo solo enviamos la palabra hola, no usamos ningún formato ni nada. Para enviar un texto con un formato podemos usar el siguiente ejemplo:

  i=10;

  printf("el valor de i es: %d",i);

Como se puede apreciar, esta vez usamos un formato el cual fue %d  con esto estamos diciendo que ira un numero decimal en el lugar que corresponde a %d. Este numero decimal pertenece a i  y es declarado seguido y dentro de la instrucción printf. Tenemos que notar que a diferencia del ansi C no se usa el operado &i, ya que seria un puntero solamente se pone la variable deseada y también es necesario decir que printf no soporta el formateo de flotantes con %f como el ansi C.

La librería adc.h

Esta librería nos permitira configurar los registros del ADC sin acceder a ellos directamente, es decir, en lugar de asiganr valores individuales a los tres registros que componen la función de ADC del PIC usaremos una sola instrucción para ello.

OpenADC ();

Será quién nos permita configurar los 3 registros de nuestro de nuestro PIC, tenemos que tomar en cuenta que los argumentos de la función openadc(); cambien con respecto al PIC que usamos, es por ello que debemos revisar con calma la ayuda de esta libreria.

Para nuestro caso usamos un PIC18F4520, por lo que la función openadc(); llevará 8 argumentos. de este forma podemos construir la función de la siguiente manera:

 OpenADC ( ADC_FOSC_8 &             // Configuramos el FOSC a 8 
                      ADC_RIGHT_JUST &  // Sera 10 bits de 0-1024
                      ADC_4_TAD,                 // TAD en 4
                      ADC_CH0 &                   // Solo Canal0, RA0
                      ADC_INT_OFF &         // Sin interrupciones AD
                      ADC_VREFPLUS_VDD &   // Sin VREF+
                      ADC_VREFMINUS_VSS,   // Sin Vref- 
                      14 );                                        // Bits digitales de ADCON1

Como se puede apreciar en el codigo anterior, con los 8 argumento configuramos los 3 registros y los argumentos los podemos cambiar conforme nos convenga. Cabe destacar que el ultimo numero el 14  corresponde a los bits0-3 del registro ADCON1 donde seleccionamos el tipo de I/O de los pines para este caso solo RA0 es analógico los demás son digitales.

La Librería usart.h

Con esta librería vamos a configurar el modo de transmision serie de nuestro PIC, usaremos la función OpenUSART (); esta función esta dada por 7 argumentos, que corresponden a la configuración de nuestra transmisión, para este ejemplo buscamos una transmisión asyncrona de 8 bits sin paridad y con una velocidad de 9600KBps. De esta forma tenemos que:

OpenUSART ( USART_TX_INT_OFF &   // Sin interrupcion de TX  
                          USART_RX_INT_OFF &   // Sin interrupcion de RX  
                          USART_ASYNCH_MODE & // Modo Asincrono
                          USART_EIGHT_BIT &      // Solo 8 bits de transmision
                          USART_CONT_RX &         // Recepcion continua
                          USART_BRGH_HIGH,      // BRG HIGH
                          129 );                                     // 9600Kbps @ 20MHZ

Dependiendo de la frecuencia de nuestro crystal es como asiganaremos el ultimo valor decimal, que en este caso es 129 ya que segun la hoja del PIC como esta activado BRGH, solo es cuestion de buscar en la tabla correspondiente el valor de FOSC.

Una vez que tenemos el resumen de esas librerias podemos crear el programa. el cual cada que presionemos un boton conectado a RB0 enviara la lectura del ADC con una pausa de medio segundo. Para ello podemos basarnos en el siguiente programa:

El diagrama de conexion que vamos a usar:

La salida serie pueden usar un max232 o algunos componentes discretos lo que les convenga y funcione.

Y por útimo la simulacion del programa:

Una secuencia para LED's

Ahora que ya sabemos hacer blink en las salidas del PIC, podemos jugar con el puerto para hacer una secuencia de luces. La idea es correr el encendido de los LED's desde RB0 a RB7 y de RB7 a RB0.

Asi que vamos a usar los operadores corriemiento a la derecha(>>) y corrimiento a la izquierda(<<), para cambiar el sentido del corrimiento vamos a utilizar un botón, por lo que necesitaremos que un PIN actúe como entrada. Cuando este activado nos entregara un 1 lógico y la secuencia recorrerá de Rb0 a RB7 y cuando este desactivado nos entregara un 0  lógico y la secuencia recorrerá de RB7 a RB0. 

Para este fin usaremos el siguiente programa:

Como podemos ver el if..else es el que hace toda la tarea dependiendo del estado del botón, dentro del if..else hay un for que nos ayuda a recorrer el BIT 8 veces que son los pines del PORTB y la pausa que nos ayuda a visualizar el corrimiento.

Tenemos que notar que para cambiar el sentido del corrimiento tendremos que esperar a que se termine la secuencia de cada for, ya que no para de forma inmediata, para que se salga de forma inmediata se tendrá que hacer con una condición y la sentencia break, pero ojala eso lo puedan implementar ustedes.

Adjunto el video de la simulación:

Accediendo a los Bits Individuales de los Registros

Hasta ahora hemos trabajado con los registros del PIC de manera directa, asignando un valor que determina el estado de todos los bits que están dentro del él, pero también podemos asignar valores individuales a todos los registros del PIC, por ejemplo, si en vez de hacer blink en todo el PORTB solo queremos hacerlo en uno de sus bits como por ejemplo en RB3, podríamos asignar el siguiente valor:

 

 PORTB=8;

 Delay10KTCYx(250);

 PORTB=0;

 Delay10KTCYx(250);

 

Seria valido, ya que solo asignamos un 1 a RB3 y posteriormente  asignamos 0 a todo el PORTB, pero sería mas sencillo si accediéramos al bit del registro directamente, lo cual es posible. Para acceder a los bits individuales de los registros tenemos que usar la siguiente sentencia:

 

 nombre_del_registrobits.nombre_del_bit 

De tal forma que para encender el bit RB3 de PORTB tendremos que asignar la siguiente sentencia: PORTBbits.RB3, recordemos que C18 es sensible a las mayúsculas, así que escribir portbbits.rb3 nos generará un error en la sintaxis. Esta forma de acceder a los bits es valida para todos los registros del PIC. pero siempre hay que especificar el nombre correcto del bit del registro, para ello podemos acceder a la librería del PIC por ejemplo a la librería p18f4520.h. 

Ahora hagamos un blink en el bit RB3 del PORTB con el siguiente programa

:

Y aqui la simulación del programa anterior:

El acceder a los bits individuales es práctico, ya que nos perrmite leer el estado de un solo bit, o cambiar el estado de un solo bit sin modificar el estado del registro.

Introduccion al compilador C18

Al ser un compilador C, C18 conserva muchas de las características del ansi C, aunque como es para un PIC se deben considerar los aspectos de que no es una PC si no un chip al que se le requiere programar y este chip tiene mas limitaciones que las que se podrían encontrar en una PC.

Estructura de programa:

A continuación se muestra la estructura básica de un Programa en C18:

Sección de descripción:

Esta sección es opcional o a gusto del programador, es en esta sección donde se comenta de manera breve lo que realiza el programa o lo que realiza la librería; además de que es ahí donde se deben colocar los cambios a las subversiones o a los códigos generados.

Sección de Librerías:

Esta sección es la parte donde definimos las librerías que vamos a usar en nuestro programa, por ejemplo la librería del PIC  a usar para que las direcciones de los registros puedan ser tomadas automáticamente, su sintaxis es: #include <> . Por ejemplo: #include <>

Podemos añadir todas las librerías disponibles o las que vayamos a utilizar, generalmente es útil hacer un respaldo de la librería en la carpeta de nuestro proyecto por si se les desea cambios futuros, para así no modificar las originales.

Sección de Configuración de Fuses:

Esta sección es donde vamos a definir los valores de configl y configh, que es donde se encuentra la configuración de oscilador, uso de watchdogtimer, funciones de Poweron reset, brown out detect etc. La configuración depende de cada PIC a usar. Su sintaxis es: #pragma config nombre de fuse = estado. Por ejemplo #pragma config OSC = HS

Sección de Funciones/Prototipos de función: 

En esta sección es donde definimos los prototipos de las funciones o las funciones en sí. Un prototipo de funcion es la manera en que se construyen la funciona a usar por ejemplo: void myfuncion(void) la cual posteriormente sera llamada por la función principal main y deberá ser construida de manera correcta bajo la seccion de main.

Si un prototipo no es usado, se puede definir y configurar en esta seccion para ser llamada por main  posteriormente.

Sección de Variables Globales:

En esta seccion es donde se crean las variables globales, una variable global es usada por todo nuestro programa y funciones en todo momento.

Sección main:

Aqui es donde se contruira nuestro programa dentro de esta función, se podran definir variables locales, llamdas a funciones externas, procedimento y todo lo necesario para implementar un programa de un PIC.