Encaminado C Termina su ciclo...

Hola a aquellos que leyeron o lean este blog. El cual el día de hoy cierra sus puertas.

Existen cosas que realmente desagradan y enferman a su servidor entre ellas es la pirateria o la copia de ideas, desgraciadamennte este blog ha sido victima de ello. Y para no seguir con lo mismo evitare que se siga copiando el estilo de este blog que comenzo en diciembre del 2008. Nos han copiado al estructura, el diseño las explicaciones y hasta el estilo de marcas de agua en sus imagenes.

Me da pena saber que hay sujetos que no tienen iniciativa propia y copian el trabaja de algunos que lo hacemos con fines de ayudar y sin lucrar, la comunidad me conoce asi que no necesito rebajrme al nivel de estos tipos. Que solo carroñan el trabajo de uno, lo publican en PDFs y hasta se crean sus blogs que llenan de trabajas ajenos haciendolos pasar por suyos. Afortunadamente esto es un hobby y como tal se puede dejar de lado y es lo que me toca hacer. 

Lamento no haber llegado a la aparte ethernet que a muchos les hubiera encantado,  en www.micros.mforos.com encontraran un boceto del trabajo de PICS con Ethernet y el ENC28J60.

Asi pues me despido... Suerte en los proyectos y dejar claro NO NOS GANAN LOS OLGAZANES, SIMPLEMENTE NO LES DAREMOS NADA MAS GRATIS!!!

El LM35 via USB, temperatura via USB

Ahora que ya tenemos un programa base para trabajar el USB en modo CDC con C18 podemos hacer prcticamente lo que deseemos, en este caso vamos a añadir -tal como lo hicimos en la comunicación serial- un sensor de temperatura: El LM35DZ. Básicamente se trata de adaptar el programa que usamos para la comuncación serial a nuestro ejemplo del USB.

Lo primero que vamos a hacer es editar el archivo io_cfg.h, esto con el fin de añadir un PIN que funcione como ADC, en mi caso RA0 así que recorreremos los botones una posición:

Posteriormente en el archivo main.c, vamos a definir la inicialización del PIC, es decir, un canal AD y todos los demás pines digitales. Para ello debemos añadir la sentencia:

#include adc.h

en la sección de includes y en la función initializesystem añadiremos el siguiente código:

Ahora lo que nos resta es añadir la función para sensar temperatura y la rutina que la llame en el archivo user.c así que lo primero sera añadir en la sección de includes las siguientes cabeceras:

#include delay.h
#include adc.h
#include stdlib.h
#include string.h

Esto lo hacemos porque vamos a usar funciones de tiempo, de conversión AD y manejo de cadenas, sin estas librerías al compilar tendríamos muchos errores, posteriormente añadiremos 2 prototipos de función y las funciones para por fin leer la temperatura del LM35DZ:

La función de Temperatura es muy similar a la que usamos en la comunicación serie, salvo que hemos añadido funciones de concatenamiento para formar una cadena y poder enviar a través del USB la señal medida junto con la frase TEMP.

Al usar la función putsUSBUSART(); lo que hacemos es enviar cadenas a través del USB es por esto que no podemos enviar el dato en modo de byte y es necesario convertirlo a cadena.

Ahora lo que nos resta es la llamada de la función en este caso la llamada se da si el byte 0 del buffer de USB es la letra minúscula "t":

Y el vídeo del resultado obtenido:



En este caso enviamos la temperatura después de la entrada de un usuario pero podríamos enviarla automtáicamente solo llamando la función dentro del loop principal del programa.

El USB desde LINUX con la Consola

Escogí usar el modo CDC, por una sencilla razón: Es más fácil de usar y el programa para la PC se basa en la comunicación via puerto serie, lo cual hace aún más sencillo el proceso. También porque bajo LINUX es un modo "nativo".

El programa para la PC puede ir desde Visual Basic, DELPHI, C++ o C, incluso existen un sin fin de ejemplos en la WEB para realizar una comunicación a traves del puerto serie. Pero en mi caso voy hablar de la interfaz con LINUX y no con Windows.

En el caso del modo CDC LINUX facilita las cosas ampliamente, basta con tener instalado LIBUSB y CDC_ACM dentro del KERNEL, esto viene por default en la mayoria de las distros de LINUX. Entonces con esto sabemos que el modo CDC en LINUX es nativo, es decir, no necesitamos instalar ningún driver ni compilar nada para que la PC reconozca el dispositivo.

Entonces vamos a ver como interactuar desde la linea de comandos con el PIC. Priemro abriremos el terminal de LINUX -yo uso FEDORA KDE- y veremos en el log de mensajes del sistema como se registra nuestro PIC.

# tail -f /var/log/messages

Y nuestra salida será:

Apr 26 12:49:38 AiroTux kernel: usb 1-2: new full speed USB device using uhci_hcd and address 6
Apr 26 12:49:39 AiroTux kernel: usb 1-2: configuration #1 chosen from 1 choice
Apr 26 12:49:39 AiroTux kernel: drivers/usb/class/cdc-acm.c: This device cannot do calls on its own. It is no modem.
Apr 26 12:49:39 AiroTux kernel: cdc_acm 1-2:1.0: ttyACM0: USB ACM device

La última línea nos muestra el dispositivo que tomo el USB al conectarse en mi caso fue ttyACM0.

He modificado el programa para que reciba 2 bytes a traves del USB y el 1er byte elige el bit del puerto B a encender y el segundo bit la duracion de este encendido antes de apagarse. Entonces si quisiera enceder el PORTB2 durante 3 segundos enviare "03" y este se encendera, recordemos que tenemos 2 LEDs de estatus por lo que RB0 y RB1 no seranutilizados como GPIO.

Daremos CTRL+C para cerrar el log de mensajes del sistema y a continuación vamos a hacer que encienda nuestro RB3 durenate 3 y 5 segundos sin necesidad de configurar un puerto serie.


# echo 03 > /dev/ttyACM0

Nos encenderá RB· durante 3 segundos y


# echo 05 > /dev/ttyACM0

Ecenderá durante 5 Segundos el RB3.

Si quisieramos usar un teminal podría usarse el minicom, o bien generar un programa grafico bastaria con QT o GLADE.

Veamos el video de esto:

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.

Añadiendo un RTC DS1307

Un reloj de tiempo real (RTC por sus siglas en ingles), es un dispositivo que nos ayuda a llevar la cuenta de la fecha y la hora, además que gracias a su tecnología aun sin la prescencia de la energía principal del circuito puede guardar la fecha y hora con exactitud, además de seguir tomándola, para ello se ayuda de una bateráa de 3V.

El RTC que vamos a usar es el de la casa maxim-ic el DS1307, aquí tenemos el diagrama básico de conexión:

Este dispositivo se comunica mediante el protocolo I2C, por lo que solo necesitamos 2 lineas del PIC, además de que el PIC18f4520 posee le modulo I2C por Hardware. Como se aprecia en la imagen los pines que se conectan al PIC son SDA y SCL y estos deberán llevar cada uno una resistencia de pullup para que el bus I2C  funcione correctamente.

El DS1307 funciona en modo esclavo solamente, es decir, solo responde a peticiones externas y este no manda ninguna petición. La forma de pedir los datos al DS1307 es generando una condición de inicio al bus I2C, posteriormente enviando la dirección del esclavo que corresponde al DS1307 y de manera secuencial los registros internos a escribir. Esto se ve mejor en la siguiente imagen:

Y del mismo modo para la lectura solo que cambiando el bit de RW:

Así que podemos notar que la dirección de un DS1307 es 0b11010000 que equivale a 208 decimal o 0xD0 hexadecimal, este valor es de suma importancia pues es el identificador del dispositivo en el bus I2C.

Es importante notar que la información que va a ser leída o escrita en los registros del DS1307 debe ser BCD o hexadecimal, los registros y sus direcciones del RTC son los siguientes:

Como se aprecia en la imagen la primer columna es la dirección del registro a escribir y los bits que mas importan son los bit0:bit3 que es el valor del registro a grabar, y la ultima columna nos habla del rango máximo de cada registro.

Con esta información podemos empezar a programar. Lo único que se desea es añadir la fecha y hora en que se hizo la lectura de la temperatura, para esto usaremos la librería i2c.h.

Esta librería posee un 2 instrucciones que nos van a servir para evitar un largo procedimiento de inicio, las instrucciones que vamos a usar son EEByteWrite(); y  EERandomRead();

Antes de utilizar estas instrucciones es necesario inicializar el BUS y esto se hace con la función OpenI2C(); Esta función lleva como argumento el tipo de esclavo o maestro a usar y se define si el slew rate se habilita o no, para nuestro caso sera en maestro y con slew off ya que pretendemos usar un bus a 100Khz.

EEByteWrite();

Esta instrucción envía a una dirección especifica, un valor. Mediante el protocolo I2C. y sus argumentos son: dirección de dispositivo, dirección de registro, datos. Por ejemplo:

   EEByteWrite(0xd0, 0x00, 128);       // dummy byte

EERandomRead();

Esta función lee los datos del dispositivo especificado, en  la posición de memoria indicada. Sus argumentos son: dirección de dispositivo, dirección de registro. Un ejemplo es:

  Sec = EERandomRead(0xd0,0x00);  // Leemos Los Segundos

Así pues podemos basarnos en el siguiente código para nuestros programas:
 

Hay que notar que cuando enviamos el valor al terminal se envía en modo HEX para poder leer correctamente la fecha y la hora, es decir que concuerde con formato humano.

El circuito propuesto es el siguiente:

Y el vídeo de la simulación descargar de aquí.

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: