Microcontroladores: mikroBasic para microcontroladores PIC 2da parte

_______________________________________________________________________________________
Contenido - Basic para Microcontroladores PIC – www.conexionelectronica.com – Christian Bodington Esteva
250
Capítulo IX. Comunicación Serial Asíncrona RS232.
9.1.- Comunicación Serial Asíncrona RS232.
La librería que a continuación vamos a estudiar nos permite hacer uso del hardware
encargado de las comunicaciones bajo el protocolo RS-232 (UART - Universal
Asynchronous Receiver/Transmitter) de una serie de microcontroladores que disponen de
éste. Para esto debemos siempre verificar que hemos elegido el microcontrolador correcto,
es decir, que tenga en su arquitectura el hardware correspondiente, y el cual se encuentra
comúnmente en microcontroladores de gama alta como por ejemplo, en el PIC16F877,
PIC18F442, PIC18F458 entre otra buena cantidad de microcontroladores disponibles en el
mercado.
La comunicación serial asíncrona resulta muy útil cuando necesitamos transmitir o recibir
datos entre circuitos gobernados por microcontroladores PIC, o inclusive cuando deseamos
establecer una comunicación entre nuestros circuitos y un PC.
Este protocolo define estándares como la velocidad de transmisión en baudios (110, 300,
1200, 2400, 4800, 9600, 14400, 19200, 38400, 56000, 57600, 115200, 128000 y 256000
bps), niveles de voltaje, distancia entre dispositivos, entre otros.
Cuando se trata de comunicación serial entre un microcontrolador y un PC, es importante
tomar en cuenta que los niveles de voltaje entre ambos dispositivos deben ser acoplados, ya
que en el puerto serial de un PC, los niveles de voltaje están comprendidos entre +12V y -
12V, y en un microcontrolador los niveles de voltaje están comprendidos entre 0V y 5V.
Las señales en el puerto del PC son digitales y la tensión con la cual trabaja, +12V y -12V,
poseen una lógica invertida, la cual es de suma importancia tomar en cuenta a la hora de
realizar el diseño de un circuito.
+12 V Lógica = “0”
-12 V Lógica = “1”
Acoplar el puerto serial de nuestro PC con estos niveles de voltaje y lógica invertida a
nuestros circuitos digitales de 5 voltios, resulta sencillo cuando utilizamos un circuito
integrado diseñado para solucionar este inconveniente y el cual es posible encontrar en casi
todos los diseños electrónicos actuales.
El circuito integrado MAX232 de MAXIM, es una interfaz que traduce estos niveles de voltaje
y la lógica binaria entre el PC y el microcontrolador.

_______________________________________________________________________________________
251
La siguiente figura muestra el diagrama de pines del MAX232 y la configuración para la
conexión de cinco condensadores de 1uF necesarios para su funcionamiento:
Figura 9.1
Es importante tomar en cuenta la polaridad de los condensadores de 1uF, ya que una
polaridad invertida afectará negativamente el funcionamiento del MAX232.
A través del uso de librerías de mikroBasic, podemos concentrarnos básicamente en el
desarrollo de las funciones que deseamos realizar en nuestros proyectos. Esto significa que
todo el trabajo que anteriormente se realizaba referente al manejo de registros específicos
de la UART en un microcontrolador, ha sido simplificado a través de rutinas de inicialización,
captura y envío de datos, entre otras, y las cuales estaremos estudiando a continuación.

_______________________________________________________________________________________
252
El microcontrolador elegido para las siguientes prácticas ha sido el PIC16F877, sin embargo
los programas que a continuación vamos a realizar funcionan con cualquier otro modelo de
gama alta de Microchip, siempre y cuando hagamos los ajustes pertinentes en la ficha de
configuración del proyecto que realicemos en mikroBasic.
Como periféricos emplearemos una pantalla LCD, un MAX232 para acoplar nuestro circuito
al puerto serial de PC, un modulo BlueTooth para comunicación serial inalámbrica y un
módulo GPS (OEM) cuyos modelos especificaremos mas adelante.
Veamos a continuación el diagrama esquemático sobre el cual estaremos desarrollando los
siguientes ejemplos prácticos:
Figura 9.2

_______________________________________________________________________________________
253
9.2.- Librería UART.
El primer paso en el estudio de la librería UART se refiere a la rutina de inicialización del
módulo:
9.2.1.- UART1_Init(“Velocidad de transmisión de datos”)
Esta rutina inicializa automáticamente algunos parámetros en los registros internos de la
UART. Esta inicialización comprende la habilitación de la transmisión y recepción de datos,
el tamaño de la cadena de bits a ser transmitidos (8 bits), configura 1 bit de parada, la
paridad y selecciona el modo de transmisión asíncrono.
La velocidad de transmisión de datos puede ser configurada entre 2400 bps y 115000 bps a
través del campo denominado “Velocidad de transmisión de datos” en la rutina de
inicialización.
Entonces, si deseáramos realizar una comunicación serial entre un microcontrolador y un
PC a una velocidad de 2400 bps, la rutina de inicialización en nuestros programas deberá
ser configurada de la siguiente forma:
UART1_Init(2400)
Es importante tomar en cuenta que el valor de la velocidad de transmisión deberá ser
siempre una constante y nunca un valor cargado en una variable.
Otro punto importante a considerar sobre la rutina de inicialización, será que ésta deberá
estar siempre antes del uso de cualquier otra rutina correspondiente a la librería UART.
La siguiente rutina que debemos tomar siempre en cuenta es la responsable de verificar si
hay datos en el Buffer de la UART listos para ser leídos y cargados en una variable
previamente definida:
9.2.2.- UART1_Data_Ready()
Esta función nos devuelve dos posibles estados:
1, si el Buffer de la UART contiene datos listos para ser leídos.
0, si no hay datos en el Buffer de la UART.
Una forma sencilla de verificar si hay datos listos en el Buffer en forma de código a través de
esta rutina sería empleando el condicional “If” de la siguiente manera:
If (UART1_Data_Ready() = 1) Then ' Si recibimos datos en el puerto entonces,
' Capturamos los datos en una variable previamente definida.
End If

_______________________________________________________________________________________
254
También podríamos hacerlo de la siguiente manera:
If (UART1_Data_Ready() <> 0) Then ' Si recibimos datos en el puerto entonces,
' Capturamos los datos en una variable previamente definida.
End If
Una vez verificado el Buffer de datos de la UART, procedemos a vaciar el mismo en una
variable previamente declarada en nuestro programa, y para verificar su contenido podemos
imprimir el resultado en la pantalla LCD o simplemente enviar el dato de vuelta por el puerto
serial del microcontrolador hacia la terminal de comunicaciones en el PC.
La rutina para leer los datos cargados en el Buffer de la UART es la siguiente:
9.2.3.- UART1_Read()
Esta rutina extrae del Buffer un Byte y lo carga en una variable definida:
' Area de declaración de variables:
Dim Datos_RX As Byte
.
.
main:
.
.
Datos_RX = UART1_Read() ' Descargamos el Buffer en la variable.
.
.
Los datos que enviamos desde una terminal de comunicaciones o desde cualquier otro
dispositivo vía RS232 hacia el microcontrolador PIC16F877, son cargados Byte a Byte a
través de un registro denominado RSR (Receive Shift Register), quien espera a que el Bit de
Stop de la transmisión llegue para pasar el Byte al Buffer o registro RCSTA, el cual tiene una
capacidad máxima de dos Bytes, por lo tanto podríamos decir que podemos contar con tres
Bytes de información disponible en la UART antes de que el Buffer se desborde y perdamos
información en la transmisión.
Nota: Los símbolos “<>” significan “diferente a…”

_______________________________________________________________________________________
255
De lo anterior podemos deducir que sólo hace falta un cuarto Byte en la transmisión antes
de descargar el Buffer, para que éste se desborde y deje de almacenar datos. Entonces, si
deseamos capturar una serie de datos continuos en la UART para ser procesados, debemos
descargar el buffer cada tres Bytes para no perder información en el proceso de transmisión
de datos.
9.2.4.- Ejemplo de programación #49:
Veamos a continuación un ejemplo de transmisión y recepción de datos, basado en el
diagrama esquemático de la figura 9.2. Este ejemplo muestra a través de la pantalla LCD los
datos enviados desde la terminal de comunicaciones de mikroBasic, a una velocidad de
transmisión de 2400 bps.
program RS232
'--- Area de declaración:
Dim LCD_RS As sbit At RB4_bit
LCD_EN As sbit At RB5_bit
LCD_D4 As sbit At RB0_bit
LCD_RS_Direction As sbit At TRISB4_bit
LCD_EN_Direction As sbit At TRISB5_bit
LCD_D4_Direction As sbit At TRISB0_bit
' Fin de la configuración de conexiones
main: ' Programa Principal
UART1_Init(2400) ' Inicializamos el módulo UART a 2400 bps.
Delay_ms(100) ' Pausa de 100 milisegundos para estabilización.
LCD_Init() ' Inicializa la pantalla LCD
LCD_Cmd(_LCD_CLEAR) ' Limpia la pantalla LCD
LCD_Cmd(_LCD_CURSOR_OFF) ' Apaga el cursor en la pantalla
Lcd_Out(1, 1, "Datos: ") ' Se imprime "Datos: " en la primera línea de la pantalla.
Recepcion:
If (UART1_Data_Ready() = 1) Then ' Si recibe datos en el puerto...
Datos_RX = UART1_Read() ' Almacena el dato en la variable "Datos_RX"
GoSub Imprime ' Salta a la subrutina de Impresión.
Else
Lcd_Out(2, 1, "Buffer Vacio...") ' Mensaje de estado del Buffer.
El registro RCSTA es FIFO (Firts In, Firts Out), Es decir, el primer dato en entrar es
el primer dato en salir).

_______________________________________________________________________________________
256
End If
GoTo Recepcion ' Repetimos el proceso.
Imprime:
Lcd_Out(2, 1, "Vaciando Buffer") ' Mensaje de estado del Buffer.
Lcd_Chr(1, 8, Datos_RX) ' Transmitimos de vuelta el valor cargado
' en la variable "Datos_RX"
Delay_ms(1000) ' Retardo de 1.5 segundos.
Return
End.
El primer paso en este ejemplo ha sido definir la variable en la cual almacenaremos los
datos enviados desde la terminal de comunicaciones, y los pines de control y datos de la
pantalla LCD. Seguidamente inicializamos la UART a 2400 bps e inicializamos la pantalla
LCD con el mensaje “Datos:“ impreso en la primera línea.
Analicemos ahora el contenido de la subrutina “Recepción”:
A través de la rutina UART1_Data_Ready(), preguntamos si tenemos datos
disponibles en el Buffer. Si se cumple la condición, cargamos el primer dato
almacenado en el Buffer en la variable “Dato_RX”. Si no se cumple la condición, se
imprime en la segunda línea de la pantalla un mensaje de estado del Buffer.
Al cumplirse la condición y almacenar el primer Byte en la variable “Datos_RX”,
hacemos un salto con retorno a la subrutina “Imprime”, la cual actualiza el mensaje de
estado en la segunda línea de la pantalla y muestra el dato almacenado en la variable
“Dato_RX” en la posición especificada en la rutina Lcd_Chr(), luego hace una pausa
de 1 segundo para poder ver la información presentada antes de proceder a cargar el
siguiente Byte almacenado en el Buffer, en la variable correspondiente.
Cuando el tiempo de espera de 1 segundo vence, retornamos a la subrutina
“Recepción” y se produce un salto incondicional a la etiqueta “Recepción”.
Si existe más de un Byte almacenado en el Buffer, se repite el proceso anterior hasta
que el Buffer se encuentre vacío.
Hagamos una prueba enviando la siguiente cadena de caracteres desde la terminal de
comunicaciones:
“123456789”

_______________________________________________________________________________________
257
Figura 9.3
Se puede ver en la figura anterior que hemos escrito la cadena en el campo correspondiente
a “Comunicación” o envío de datos. Seguidamente hacemos clic en “Send” para enviar la
cadena al microcontrolador vía RS232.
El Buffer en el microcontrolador se carga hasta su capacidad máxima de tres Bytes y se
desborda deteniendo la recepción de datos. Al evaluar el Buffer a través de la condición “If
(UART1_Data_Ready() = 1) Then”, sabremos que éste ha sido cargado con nuevos datos, los
cuales podremos extraer uno a uno a través de la rutina “UART1_Read()” en la variable
“Datos_RX”.
Observe que cada vez que extraemos un Byte del Buffer, hacemos un salto a la rutina
“Imprimir” para mostrar el mismo en la pantalla LCD. Un segundo después, ocurre el retorno
a la rutina “Recepción” y se evalúa nuevamente el Buffer para ver si aún quedan datos en él.
El proceso se repite hasta que el Buffer queda vacío:
“1 2 3”

_______________________________________________________________________________________
258
Cuando enviamos una cadena de caracteres vía RS232 al microcontrolador con mas de tres
Bytes, el Buffer se llena y se desborda deteniendo la recepción, por lo tanto, en este caso
obtendremos de la cadena de caracteres solamente los tres primeros Bytes.
Para lograr almacenar y visualizar una cadena completa, debemos realizar algunos cambios
sobre el programa.
El primer cambio importante que hemos hecho, ha sido la creación de una sub-función, la
cual deberá ir antes del cuerpo principal del programa, es decir, antes de la etiqueta “main”,
y la cual se encargará de recoger los datos uno a uno, almacenados en el Buffer de la UART
cada vez que ésta sea llamada a cumplir con su tarea.
Asumiendo que en este ejemplo enviaremos una cadena de nueve caracteres, hemos
realizado una pequeña rutina de recolección de datos la cual se ejecutará hasta que se
cumpla una condición conocida. Las instrucciones dentro de un lazo “do-loop
Until(condición)” se repetirán hasta que dicha condición sea verdadera.
Por último, creamos una rutina de visualización de datos a través de un lazo “For-Next”, la
cual imprimirá cada caracter almacenado en el arreglo de variables definidas previamente en
la pantalla LCD.
Analice y lea detenidamente los comentarios del siguiente programa:
program RS232
Dim Datos_RX As Byte[10] ' Arreglo de variables para almacenar los datos.
acumulador As Byte ' Variable para condicional "loop Until..."
X As Byte ' Variable para lazo For-Next.
' Configuración de pines de control y datos de la pantalla LCD:
sub function LeerCaracter As Byte ' Recoje un caracter de UART
do ' Cuando el dato esta listo, carga el resultado
loop Until UART1_Data_Ready = 1 ' en la variable "LeerCaracter", de lo contrario
' se queda en el lazo esperando.

_______________________________________________________________________________________
259
Result = UART1_Read() ' Lee el dato en la USART y el resultado es cargado en la
' variable "LeerCaracter".
End sub
main: ' Programa Principal.
Lcd_Out(1, 1, "Datos: ") ' Se imprime "Datos: " en la primera línea
' de la pantalla.
Recepcion:
Lcd_Out(2, 1, "Buffer Vacio...!") ' Mensaje de estado del Buffer.
acumulador = 1 ' inicializamos la variable "acumulador"
do
Datos_RX[acumulador] = LeerCaracter ' Llama la sub-función "leerCaracter y
' y carga el dato en la variable.
acumulador = acumulador + 1 ' Incrementa la variable "acumulador".
loop Until (acumulador = 10) ' Si la variable no es igual a 10,
' continúa cargando caracteres.
Lcd_Out(2, 1, "Mostrando Datos!") ' Mensaje de estado del Buffer.
For X = 1 To 9 ' For-Next para presentar los datos desde
' la primera variable hasta la última cargada.
Lcd_Chr(1, 8, Datos_RX[X]) ' Mostramos el equivalente ASCII del valor cargado
Delay_ms(1000) ' Retardo de 1 segundo.
Next X
Lcd_Out(2, 1, " Fin ") ' Mensaje de finalización del proceso.
End.
Analizando el programa a partir de la etiqueta “Recepción” tenemos que:
Escribimos un mensaje de estado del Buffer; en este caso el mensaje será “Buffer
Vacío” ya que aún no hemos recolectado información del mismo.
Inicializamos la variable acumulador = 1, la cual nos ayudará a llevar la cuenta de la
cantidad de Bytes almacenados en el Buffer.
En el lazo “do-loop Until(condición)”, podemos observar que el primer paso será
almacenar el primer dato en la variable que corresponda según el valor que trae
cargado el “acumulador”, es decir, si “acumulador” es igual a 1, entonces el valor
extraído desde la sub-función “LeerCaracter” será almacenado en la variable
“Datos_RX[1]”.

_______________________________________________________________________________________
260
Aumentamos en una unidad la variable “acumulador”, y verificamos si se cumple la
condición “loop Until(acumulador = 10)”. Si la variable “acumulador” viene con un
valor cargado igual a 1 y la incrementamos en una unidad, es decir, “acumulador = 2”,
entonces podremos ver que la condición no se cumple aún, por lo tanto el programa
vuelve a hacer un llamado a la sub-función “LeerCaracter”, cargando el siguiente Byte
capturado del Buffer en la variable que corresponda en este momento según el valor
del “acumulador”. Esto significa que este segundo Byte será cargado en
“Dato_RX[2]”.
El proceso se repite hasta que la condición “loop Until(acumulador = 10)” se cumpla.
Al terminar el proceso de captura de datos en el arreglo de variables “Datos_RX[n],
mostramos un nuevo mensaje en la segunda línea de la pantalla LCD (“Mostrando
Datos”), y a través de un lazo “For-Next” presentamos el contenido de cada variable,
desde “Datos_RX[1] hasta “Datos_RX[9], con un intervalo de tiempo de un segundo.
Al terminar, cambiamos el mensaje que indica el estado del proceso y el programa
termina.
En este punto podemos decir que si enviamos una cadena de nueve Bytes, entonces el
Buffer se habrá vaciado tres veces al terminar el programa.
La rutina para enviar datos desde el microcontrolador a través de la UART es:
9.2.6.- UART1_Write(“Variable tipo Byte”)
A través de esta rutina podemos enviar datos almacenados en una variable tipo “Byte” a
través del puerto serial hacia el PC o cualquier otro dispositivo o circuito que soporte
comunicación RS232.
Para comprobar su funcionamiento y dar continuidad al ejemplo anterior, enviaremos de
vuelta al PC la cadena de caracteres que hemos estado recibiendo desde la terminal de
comunicaciones de mikroBasic.
En vista de que estamos recibiendo una cadena de nueve caracteres en este ejemplo,
haremos un lazo “For-Next” adicional, a través del cual enviaremos el contenido almacenado
en el arreglo de variables, “Datos_RX[1] hasta “Datos_RX[9]”. Hacer este lazo simplifica en
gran medida el código de programa, ya que de otra forma tendríamos que escribir una rutina
de envío de datos para cada una de las variables.
El código a añadir en nuestro programa sería el siguiente:
For X = 1 To 9 ' For-Next para enviar los datos desde
UART1_Write(Datos_RX[X]) ' Enviamos el dato cargado en la variable.
Next X

_______________________________________________________________________________________
261
Estas líneas pueden ser agregadas después de la recolección de datos, o incluso después
de presentar los mismos en la pantalla LCD:
program RS232
' Configuración de pines de control y datos de la pantalla LCD:
sub function LeerCaracter As Byte ' Recoje un caracter de UART
Result = UART1_Read() ' Lee el dato en la USART y lo carga en la
End sub
Lcd_Out(1, 1, "Datos: ") ' Se imprime "Datos: " en la primera línea
' de la pantalla.
Recepcion:
Lcd_Out(2, 1, "Buffer Vacio...!") ' Mensaje de estado del Buffer.
do
Datos_RX[acumulador] = LeerCaracter ' Llama la sub-función "leerCaracter y
For X = 1 To 9 ' For-Next para enviar los datos desde

_______________________________________________________________________________________
262
UART1_Write(Datos_RX[X]) ' Enviamos el dato cargado en la variable.
Next X
Lcd_Out(2, 1, "Mostrando Datos!") ' Mensaje de estado del Buffer.
For X = 1 To 9 ' For-Next para presentar los datos desde
Lcd_Chr(1, 8, Datos_RX[X]) ' Mostramos el equivalente ASCII del valor cargado
Delay_ms(1000) ' Retardo de 1 segundo.
Next X
Lcd_Out(2, 1, " Fin ") ' Mensaje de finalización del proceso.
End.
Al enviar la cadena de datos desde la terminal de comunicaciones hacia el microcontrolador,
podremos ver que los datos almacenados en la variables “Datos_RX[1] a “Datos_RX[9]” han
sido reenviados de vuelta al PC, tal y como se demuestra en la figura 9.4, comprobando de
esta manera que la transmisión y recepción ha sido exitosa.
Figura 9.4

_______________________________________________________________________________________
263
9.3.- Cómo extraer información específica de una cadena de datos.
En muchos diseños electrónicos en los cuales requeriremos de comunicación serial,
seguramente vamos a necesitar extraer de una cadena larga de caracteres cierta
información específica atrapada en ella. En otras palabras, se pudiera dar el caso en el cual
tenemos un dispositivo periférico entregando constantemente información de la cual solo
nos interesa cierta parte de ella.
Para entender claramente lo planteado, observe la siguiente cadena de caracteres de
ejemplo:
“1234567890/XYZmikroBasic para PIC!12345678901234”
Ésta es una cadena de 48 caracteres, dentro de los cuales encontraremos la frase
“mikroBasic para PIC!”, la cual consta de tan solo 20 caracteres y la cual es precisamente el
bloque de información que deseamos extraer. Sin importar su ubicación dentro de la cadena,
como podríamos lograr extraer estos 20 caracteres y desechar el resto?
En muchos casos podremos también observar que estos dispositivos envían algunos
caracteres dentro de la cadena que identifican cada bloque de información, por ejemplo, en
nuestra cadena de 48 caracteres podremos ver que hemos asignado como caracteres de
cabecera del bloque de información los siguientes:
“1234567890/XYZmikroBasic para PIC!12345678901234”
“XYZ” serán la cabecera y nos ayudarán a identificar la posición del bloque de datos que nos
interesa extraer, entonces, si el la cabecera y el bloque de datos estuviesen en esta posición
u otra diferente de la cadena, seguramente podremos hacer un código de programa para
identificar la cabecera “XYZ” y seguidamente almacenar los siguientes 20 caracteres en un
arreglo de variables:
“1234567890/123456789XYZmikroBasic para PIC!01234”
Básicamente el procedimiento a seguir sería el siguiente:
Almacenamos toda la cadena en un arreglo de variables a las cuales llamaremos
“Cadena[n]”, donde “n” representa el número de caracteres conocido de la cadena.
Seguidamente, analizamos la cadena desde el primer Byte, buscando los caracteres
de cabecera de nuestro bloque de información deseado. Esto significa que debemos
hacer una rutina de descarte de información, en la cual estaremos comparando cada
Byte en la cadena con el valor decimal correspondiente a cada caracter de la
cabecera, es decir, en nuestra cadena de ejemplo, deberíamos comparar cada Byte
con el primer valor conocido de cabecera, que en este caso será “X” o su valor
decimal correspondiente “88” (Ver tabla ASCII).

_______________________________________________________________________________________
264
Comparando cada Byte con el primer valor de cabecera “88” o “X”, podremos saber si
debemos continuar con la búsqueda del mismo, o si finalmente algún Byte en la
cadena coincide con éste valor.
Si este primer valor coincide con un Byte en la cadena, entonces podremos pasar a
comparar el siguiente Byte con el valor “89” o “Y”. Si este valor no coincide,
simplemente debemos reiniciar todo el proceso de búsqueda debido a que los Bytes
de cabecera del bloque de información deseado deberán estar siempre juntos, de otra
forma, estaríamos capturando información errada dentro de la cadena.
Sólo cuando encontremos los tres Bytes consecutivos de cabecera de la cadena será
cuando procederemos a almacenar los 20 bytes del bloque de información en un
arreglo de variables que definiremos para este fin y que en nuestro ejemplo
llamaremos “Datos_RX[n]”, donde “n” representa el numero de Bytes de información
dentro del bloque deseado.
En este ejemplo, nuestro dispositivo periférico conectado al puerto serial del
microcontrolador PIC será nuestro PC, y la cadena de datos la estaremos enviando desde la
terminal de comunicaciones de mikroBasic.
Este ejemplo podrá ser verificado en base al diagrama esquemático de la figura 9.2. Sin
embargo, no haremos uso de la pantalla LCD debido a que estaremos enviando los datos
extraídos de la cadena de caracteres vía RS232 hacia la terminal de comunicaciones de
mikroBasic.
La velocidad de transmisión será de 2400 bps.
Adicionalmente a esto, haremos uso de una nueva rutina de la librería UART para transmitir
texto directamente a la terminal y de esta forma poder saber en que estado se encuentra el
proceso de transmisión y recepción de datos:
UART1_Write_Text(“Texto a enviar vía RS232”)
Esta rutina envía el texto cargado dentro de las comillas, o caracteres almacenados en
variables tipo “string”, vía RS232.
Analice detenidamente el siguiente programa, leyendo los comentarios en cada línea:
program RS232
Cadena As Byte[48] ' Arreglo de variables para almacenar la cadena.
acumulador As Byte ' Variable para llevar conteo en condicional "loop Until..."

_______________________________________________________________________________________
265
i As Byte ' Variable auxiliar para conteo en subrutinas.
sub function LeerCaracter As Byte ' Recoje un caracter de la UART.
' se queda en el lazo “do-loop” esperando.
End sub
UART1_Write_Text("Buffer Vacio...!") ' Mensaje de estado del Buffer enviado via RS232.
UART1_Write_Text("Esperando Datos...") ' Mensaje de estado del Buffer enviado via RS232.
Recepcion:
do
Cadena[acumulador] = LeerCaracter ' Llama la sub-función "leerCaracter y
' y carga el dato obtenido del Buffer en la variable.
loop Until (acumulador = 48) ' Si la variable “acumulador” no es igual a 10,
' continúa cargando datos en el arreglo “Cadena[n]”.
' Cuando “acumulador” sea igual a 48, entonces ya
' tendremos cardados todos los Bytes de la cadena en
' en el arreglo “cadena[n]”
i = 0 ' Inicializamos la variable i = 0.
verifica_1:
i = i + 1 ' Incrementamos en una unidad la variable "i".
If Cadena[i] = 88 Then ' 88 equivale al simbolo ASCII "X". Si el Valor
' cargado en Cadena[i] es 88, verifica el siguiente
GoTo verifica_2 ' caracter en la subrutina "verifica_2".
Else ' Si no ha sido el dato correcto, verifica si "i"
If i = 48 Then ' es mayor a la cantidad de bytes de la Cadena.
GoTo main ' Si "i" es mayor al numero de bytes de la Cadena,
End If ' entonces reiniciamos todo el proceso desde "main".
GoTo verifica_1 ' Si "i" no ha superado el valor de la cantidad de
End If ' bytes de la Cadena, entonces continúa verificando
' en busca del caracter "X".
verifica_2:
If Cadena[i] = 89 Then ' 89 equivale al simbolo ASCII "Y". Si el Valor
' en busca del caracter "Y".
verifica_3:
If Cadena[i] = 90 Then ' 90 equivale al simbolo ASCII "Z". Si el Valor
GoTo Almacena ' caracter en la subrutina "verifica_2".

_______________________________________________________________________________________
266
' en busca del caracter "Z".
Almacena:
For X = 1 To 20
i = i + 1 ' Incremento de una unidad en "i".
Datos_RX[X] = Cadena[i] ' Carga el dato de la Cadena en "Datos_RX[X]"
UART1_Write(Datos_RX[X]) ' Enviamos el dato cargado en la variable vía RS232.
delay_ms(100) ' Retardo de 100 ms para visualizar mejor los datos
' en la terminal de comunicaciones.
Next X
UART1_Write_Text("Fin...!") ' Mensaje de estado de la transmisión.
GoTo Recepcion ' Hace un salto a “Rcepción” para quedar a la espera de
' una nueva cadena de datos.
End.
Para comprobar el funcionamiento de este programa, enviamos la cadena de caracteres del
ejemplo través de la terminal de comunicaciones de mikroBasic como se observa en la
siguiente figura:
Figura 9.5

_______________________________________________________________________________________
267
También podremos ver en la figura anterior el mensaje de estado enviado desde el
microcontrolador hacia el PC cuando éste se encuentra a la espera de la cadena de
caracteres.
Al enviar la cadena desde el PC hacia el microcontrolador, los caracteres contenidos en el
bloque de datos anteriormente especificado, aparecerán uno a uno en la pantalla hasta
recibir finalmente el mensaje de estado final de la transmisión.
Figura 9.6
En este momento, resulta importante mencionar que el ejemplo anterior será la base para
establecer las comunicaciones entre el microcontrolador a través de su UART y un módulo
GPS (Global Positioning System), propuesto en uno de los próximos ejemplos de este
capítulo y a través del cual podremos obtener las coordenadas geográficas del dispositivo
las cuales son transmitidas a una frecuencia conocida y bajo el protocolo RS232.

_______________________________________________________________________________________
268
9.4.- Módulo de comunicaciones BlueTooth.
Haciendo uso de un módulo para comunicaciones inalámbricas Bluetooth, de tal manera que
podamos eliminar la conexión física entre nuestro circuito y nuestro PC la cual por cierto
también deberá contar con un módulo de comunicaciones Bluetooth que por lo regular viene
integrado de fábrica.
Figura 9.7
En caso de con contar con un módulo Bluetooth integrado en nuestro PC, también es
posible utilizar un adaptador Bluetooth USB como el que mostramos a continuación:
Figura 9.8
El módulo Bluetooth recomendado para las comunicaciones desde el microcontrolador es el
siguiente:
Figura 9.9 (Fuente: www.sparkfun.com)

_______________________________________________________________________________________
269
Empresa: Sparkfun Electronics
Website: http://www.sparkfun.com
Modelo: Bluetooth Modem - BlueSMiRF Gold
Código: WRL-00582
Figura 9.10
Este módulo de fácil conexionado maneja niveles de voltaje en sus pines de comunicaciones
RS232 de 5 voltios, por lo cual también podremos eliminar de nuestro circuito el MAX232
que veníamos utilizando para acoplar el puerto serial del PC. El diagrama esquemático
modificado según los cambios planteados se vería de la siguiente forma:
Figura 9.11

_______________________________________________________________________________________
270
Enlazar el módulo Bluetooth que proporciona Sparkfun con el módulo Bluetooth de nuestro
PC es muy simple, siempre y cuando contemos con el software para la administración de
dispositivos Bluetooth en nuestra PC. A continuación veremos una breve explicación acerca
de la instalación de uno de tantos software disponibles para administrar dispositivos
Bluetooth desde Windows.
9.4.1.- Widcomm Bluetooth Software 5.0.1.3900
Este software nos permitirá escanear dispositivos Bluetooth como el módulo recomendado
para este ejemplo práctico. A través de él podremos administrar algunos servicios
disponibles como transferencia de archivos, servicios de impresión, acceso a Red, pasarela
de audio, auriculares, puerto serial Bluetooth entre otros. Veamos a continuación la
secuencia de instalación del software. Lea los mensajes en las ventanas del software para
seguir correctamente los pasos:
Figura 9.12

_______________________________________________________________________________________
271
Figura 9.13
Figura 9.14

_______________________________________________________________________________________
272
Figura 9.15
Figura 9.16

_______________________________________________________________________________________
273
Figura 9.17
Figura 9.18

_______________________________________________________________________________________
274
Al reiniciar la sesión de Windows, continúa el proceso de configuración del software:
Figura 9.19
Figura 9.20

_______________________________________________________________________________________
275
Figura 9.21
Figura 9.22

_______________________________________________________________________________________
276
En este punto nos debemos asegurar de seleccionar la opción “Puerto de serie Bluetooth”.
Figura 9.23
Figura 9.24

_______________________________________________________________________________________
277
Cuando se realiza la búsqueda de dispositivos Bluetooth, es probable que aparezcan otros
como nuestros teléfonos móviles, mouse o teclados Bluetooth, auriculares y todo aquel
dispositivo que esté al alcance de nuestro PC. Podremos identificar el nuestro bajo el
nombre de “BlueRadios” como se observa en la siguiente figura. Seleccionamos el
dispositivo y continuamos, haciendo clic en “Siguiente”.
Figura 9.25

_______________________________________________________________________________________
278
Figura 9.26
En la configuración por defecto de este software se solicita que los dispositivos Bluetooth
encontrados sean “emparejados” a través de un código que por lo regular es suministrado
por el fabricante del equipo. En nuestro caso, el código por defecto del módulo Bluetooth
suministrado por Sparkfun es “1234”.

_______________________________________________________________________________________
279
Figura 9.27
Si no contamos con el código de seguridad para emparejar el dispositivo, entrar en la
configuración del puerto serial Bluetooth y deseleccionar la opción “Conexión segura”.
Figura 9.28

_______________________________________________________________________________________
280
También es de suma importancia observar cual ha sido el puerto COM asignado a este
servicio (Ver figura 9.30). En nuestro caso nos ha sido asignado el puerto COM6, el
tomaremos en cuenta a la hora de seleccionar el puerto serial en la terminal de
comunicaciones de mikroBasic.
Figura 9.29
Figura 9.30

_______________________________________________________________________________________
281
Terminado el proceso de configuración, estamos listos para ver nuestro módulo Bluetooth
conectado a nuestro PC, tal y como se observa en la siguiente figura:
Figura 9.31
También es posible ver el estado de la conexión Bluetooth a través de dos Leds en la base
del módulo Bluetooth de nuestro circuito:
Un LED de color verde estará en un estado de intermitencia mientras el módulo se
encuentra a la espera de una conexión.
Un LED de color Rojo nos indicará que la conexión ha sido exitosa y que el módulo se
encuentra preparado para transmitir y recibir datos.

_______________________________________________________________________________________
282
9.4.2.- Comunicación Serial inalámbrica BlueTooth.
Sin realizar ninguna modificación sobre el último programa que hemos cargado en el
microcontrolador, podremos ver en funcionamiento las comunicaciones a través de esta
pasarela inalámbrica, cuando enviamos la cadena de datos desde la terminar de
comunicaciones de mikroBasic hasta el microcontrolador PIC.
En la siguiente figura se puede observar que lo único que hemos cambiado ha sido la
configuración para la conexión del puerto, donde COM6 representa la conexión a través del
módulo Bluetooth del PC.
Figura 9.32

_______________________________________________________________________________________
283
Figura 9.33

_______________________________________________________________________________________
284
9.5.- Módulo GPS (OEM), comunicación serial RS232.
Hoy en día es posible adquirir a través de Internet módulos
GPS (OEM, abreviatura del inglés “Original Equipment
Manufacturer”) de muy bajo costo y con una eficiencia que
puede sorprender a cualquiera que desee incluirlos en sus
proyectos electrónicos, debido a que son sumamente precisos y
muy fáciles de acoplar.
Básicamente, estos módulos son capaces de capturar la
información necesaria de una red de satélites, a través de los
cuales determinan su posición geográfica en el planeta. Esta
información es entregada por el dispositivo a través de un protocolo estándar denominado
NMEA 0183. Esta información sale del puerto serial del dispositivo a una frecuencia
conocida, que por lo regular es igual a 1 Hz. Esto significa que podemos obtener la
ubicación geográfica actualizada de nuestro dispositivo cada 1 segundo. También existen
módulos GPS que entregan dicha información a frecuencias mayores, por ejemplo a 5Hz, 10
Hz e incluso a 20 Hz.
Los módulos GPS que utilizaremos a continuación tienen una salida de datos Serial
Asíncrona con niveles de voltaje en su salida entre 0 y 5 voltios. Requieren además de una
antena “activa” la cual podremos encontrar en dos modalidades; montada directamente
sobre el módulo GPS, o separada y encapsulada para protegerla del clima cuando
deseamos que la misma esté lejos del circuito principal o circuito de control.
El objetivo principal en los próximos ejemplos será la obtención de los siguientes datos
extraídos del “string” o cadena de datos en la salida del GPS:
UTC Time (Universal Time Coordinated) o Tiempo Universal Coordinado. Este es el
tiempo de la zona horaria a través del cual se calcula el tiempo en diferentes partes
del mundo.
Ubicación geográfica (Latitud y Longitud). Es la ubicación del dispositivo sobre el
planeta, medida en ángulos; grados, minutos y segundos de arco.
Satélites detectados. Es la cantidad de satélites que el dispositivo GPS ha podido
capturar en momento determinado.
Altura del dispositivo sobre el nivel del mar.
Si no está familiarizado con estos conceptos, sería recomendable leer al respecto en algún
libro especializado o a través de Internet, donde podrá encontrar suficiente información útil y
detallada.
Sin embargo estudiemos un poco acerca del protocolo NMEA, coordenadas geográficas y su
representación numérica.

_______________________________________________________________________________________
285
9.5.1.- Protocolo NMEA.
Como dijimos anteriormente, podemos obtener la ubicación geográfica del dispositivo en
términos de Latitud y Longitud.
La latitud determina la distancia angular entre un punto en el planeta y el ecuador y puede
pertenecer tanto al hemisferio Norte como al hemisferio Sur.
La longitud geográfica determina la distancia angular entre un punto del planeta y el
meridiano de Greenwish. En este caso y según su ubicación en el planeta, podremos extraer
del dispositivo una longitud Este o una longitud Oeste según sea el caso.
Esta información la podemos extraer a través una cadena de caracteres ASCII en formato
de comunicación NMEA.
NMEA cuenta con varias sentencias las cuales empiezan con los caracteres “$GP” seguidas
del nombre de la misma, además de los datos capturados por el dispositivo desde la red de
satélites, cada uno de ellos presentados en campos separados por comas. También
podremos encontrar al final de la sentencia el resultado de una operación de dos dígitos
denominada “Checksum” justo después del símbolo “*”.
El “Checksum” se calcula a través de una operación lógica (XOR) realizada tantas veces
como sea necesario según la cantidad de dígitos en la cadena, a través de la cual podemos
determinar si la transmisión de datos desde el modulo GPS hacia el microcontrolador PIC ha
sido correcta. El resultado de esta operación queda expresado a través de dos caracteres
ASCII, los cuales representan un valor Hexadecimal.
Cada vez que el modulo GPS envía una de estas sentencias a través de su salida,
automáticamente termina la misma con <CR> y <LF> (Carrie Return y Line Feed), lo cual
resulta ser muy útil cuando deseamos ver esta información en un terminal de
comunicaciones, ya que cada sentencia será visualizada en una nueva línea en el área de
recepción de datos, y no de forma continua y desordenada.
Uno de los módulos o dispositivos GPS que hemos utilizado como ejemplo ha sido el
Garmin 18-5Hz, de Garmin International Inc., en su versión OEM.
Veamos una de las sentencias NMEA que nos entrega este dispositivo en su salida:
GGA = Global Positioning System Fix Data
$GPGGA,<1>,<2>,<3>,<4>,<5>,<6>,<7>,<8>,<9>,M,<10>,M,<11>,<12>*hh
Los campos representados por números, contienen información en un formato conocido el
cual podremos encontrar detallado en la hoja de especificaciones técnicas del fabricante.

_______________________________________________________________________________________
286
Veamos:
El campo <1> para la sentencia GGA almacena el “Tiempo Universal Coordinado” o
“UTC Time” bajo un formato predefinido: hhmmss.s
El campo <2> almacena la latitud bajo el formato: ddmm.mmmmm
El campo <3> almacena el hemisferio Norte o Sur, es decir: N ó S.
El campo <4> almacena la longitud bajo el formato: ddmm.mmmmm
El campo <5> almacena el hemisferio Este ó hemisferio Oeste: E ó W.
El campo <6> almacena el estado de la sincronización con el sistema de
posicionamiento global. 0 = no hay posición, 1 = posición disponible para GPS no-
diferencial, 2 = posición disponible para DGPS o GPS diferencial.
El campo <7> almacena el número de satélites en uso, entre 00 y 12. Los ceros
siempre serán representados en la cadena de datos, es decir, si la cantidad de
satélites es igual a “cero”, entonces podremos ver los caracteres “00” en este campo.
(Esta característica aplica para todos los campos de la cadena).
El campo <8> almacena la Imprecisión en el plano de superficie.
El campo <9> almacena la altitud del dispositivo sobre el nivel del mar.
Seguidamente veremos la unidad de medida del campo <9>, “M” o metros.
El campo <10> almacena la Superficie gravitacional equipotencial, seguida de su
unidad “M” o metros.
Los campos <11> y <12> son reservados o nulos.
Veamos un ejemplo de esta sentencia con valores reales:
$GPGGA,212529.4,5042.52892,N,12238.40770,W,2,09,1.1,9.7,M,-11.4,M,,*61
UTC Time: 21 horas, 25 minutos, 29.4 segundos.
Latitud: 50º 42.52892”.
Hemisferio de Latitud: Norte.
Longitud: 112º 38.40770”.
Hemisferio de Longitud: Oeste.

_______________________________________________________________________________________
287
Estado de la sincronización: 2, posición disponible para DGPS.
Satélites en uso: 9 satélites.
Imprecisión en el plano de superficie: 1.1
Altitud del dispositivo o antena sobre el nivel del mar: 9.7 metros.
Superficie equipotencial gravitacional: -11.4 metros.
Esta sentencia es una de varias sentencias que son entregadas por este dispositivo GPS a
través de su salida digital, a una frecuencia constante de 5 Hz.
Si conectamos el dispositivo GPS directamente al puerto serial del computador,
configuramos correctamente los parámetros de comunicación, podremos ver continuamente
las sentencias NMEA como se observa en la figura 9.34.
Figura 9.34

_______________________________________________________________________________________
288
La latitud y longitud están calculadas normalmente bajo el sistema centesimal en el sistema
de medidas relativas a ángulos.
Las coordenadas expresadas en sistema centesimal son completamente compatibles con
sistemas de información geográfica (GIS), como Google Earth (http://earth.google.com).
Descargue este programa gratuitamente de la dirección señalada.
Con este programa podremos tomar información relativa a coordenadas geográficas e
introducirlas en Google Earth para obtener la ubicación geográfica del dispositivo sobre el
mapa.
Dicho esto, tomemos las coordenadas de la cadena de caracteres de ejemplo, y demos el
formato adecuado para que Google Earth sea capaz de reconocerlas:
Coordenada Geográfica: N50 42.52892 W112 38.40770
Al introducir estos datos bajo este formato en la casilla de búsqueda de Google Earth, el
programa nos llevará a la posición exacta en la cual se encuentra nuestro dispositivo GPS
(Figura 9.36).
Figura 9.35
N50 42.52892 W112 38.40770

_______________________________________________________________________________________
289
Figura 9.36
Para realizar esta tarea de extraer ciertos datos de la cadena de caracteres enviada por el
módulo GPS a una frecuencia conocida, a través de un microcontrolador PIC, debemos
analizar la cadena completa y observar cada cuantos caracteres se da una repetición de la
misma.
En la siguiente imagen podemos ver la salida del módulo GPS Garmin 18-5Hz. Si
observamos bien, notaremos que tenemos una larga cadena de datos que se repite
constantemente:

_______________________________________________________________________________________
290
Figura 9.37
La cadena de datos señalada será la que estaremos analizando en busca de la sentencia
NMEA que mas nos interesa, y a través de la cual obtendremos los datos anteriormente
comentados, como coordenadas geográficas, número de satélites en uso, altitud entre otros.
Los módulos GPS vienen configurados de fábrica para enviar una cierta cantidad de
sentencias NMEA a través de su salida. Esta configuración podría ser cambiada a través de
un software proporcionado por el fabricante, en caso de que estemos interesados en obtener
una sentencia NMEA específica de todo el repertorio que encontraremos en el manual del
módulo GPS que estemos usando. Pero en nuestro caso, la cadena de caracteres o datos
esta compuesta por tan solo cuatro sentencias NMEA: VTG, RMC, GGA y GSA. Juntas
conforman una solo cadena de caracteres que se repite constantemente, no mayor a 256
bytes, y de la cual sólo deseamos extraer los datos de la sentencia GGA para la próxima
práctica de programación.

_______________________________________________________________________________________
291
En este ejemplo se requiere extraer de la cadena de caracteres proporcionada por el módulo
GPS las coordenadas geográficas (latitud y longitud) y el número de satélites en uso. Lo
primero que debemos tomar en cuenta para extraer los datos, será almacenar la cadena
completa dentro de un arreglo de variables de tamaño conocido, según la cantidad de
caracteres totales en ella. En nuestro ejemplo, tenemos una cadena de 183 caracteres, por
lo cual estaremos declarando en nuestro programa un arreglo de variables que cubra esta
cantidad.
Repacemos del programa anterior la subrutina encargada de almacenar una cadena de
caracteres:
do
Lo primero que podemos ver en ella, es la variable “acumulador” inicializada con un valor
igual a 1.
Seguidamente, un lazo dentro del cual se llama a una sub-función, la cual habíamos
denominado “Leercaracter”, encargada de extraer un byte del Buffer de la UART, el cual
será cargado en la variable cadena[acumulador], o cadena[1]. Luego se realiza un
incremento de la variable “acumulador” y se verifica la condición del lazo. Si la condición no
se cumple, se procede a cargar el siguiente byte extraído del Buffer de la UART en la
variable cadena[acumulador], o cadena[2] y así sucesivamente hasta que la condición
“acumulador = 184” se cumpla.
Si se ha preguntado porqué la condición es “acumulador = 184”, sabiendo de ante mano que
la cadena cuenta con tan solo 183 caracteres, la respuesta sería la siguiente:
Si la condición fuese “loop Until(acumulador = 183)”, el último caracter de la cadena (es
decir, el carácter # 183), nunca se cargaría en la variable “cadena[183]”, debido a que la
carga de datos extraídos del Buffer se realiza antes del incremento de la variable
“acumulador”.
Una vez almacenada la cadena, procedemos a realizar la búsqueda de los caracteres que
conforman la cabecera de la sentencia deseada, es decir, $GPGGA. En el programa de
ejemplo, estos caracteres se comparan uno por uno y en secuencia con los caracteres de la
cadena. Si uno de estos caracteres falla, la búsqueda se reinicia desde el primer caracter “$”
a partir del la posición en la cual se halló la diferencia, esto con la finalidad de terminar de
analizar el resto de la cadena.

_______________________________________________________________________________________
292
Al encontrar la cabecera completa, procedemos entonces a almacenar el resto de los
caracteres de la sentencia GGA, para luego ser mostrados a través de algún periférico
conectado al microcontrolador y el cual en nuestro caso será una pantalla LCD.
' La variable “i” representa el valor de una pocisión de la cadena, a partir
' del último caracter de la cabecera de la sentencia GGA.
Almacena:
i = i + 1 ' Incrementamos de una unidad la variable "i".
For X = 1 To 64 ' En esta línea definimos cuantos datos deseamos de
' obtener de la Cadena a partir de la cabecera "$GPGGA"
delay_ms(50) ' Retardo de 50 milisegundos.
Next X
Si extraemos la cadena de caracteres de la figura 9.37, podremos notar que la sentencia
NMEA deseada, es decir, GGA, se encuentra ubicada entre otras dos sentencias; RMC y
GSA.
$GPVTG,,T,,M,,N,,K*4E
$GPRMC,004013.0,V,5042.52892,N,12238.40770,W,,,071209,008.4,W*71
$GPGGA,212529.4,5042.52892,N,12238.40770,W,2,09,1.1,9.7,M,-11.4,M,,*61
$GPGSA,A,1,,,,,,,,,,,,,,,*E1
Al realizar el análisis de la cadena tal y como lo hicimos en el ejemplo de programación
anterior, estaremos desechando las sentencias VTG, RMC y GSA junto con sus datos.
Si por ejemplo quisiéramos extraer tan solo los campos de coordenadas geográficas y
cantidad de satélites en uso de la sentencia GGA para mostrados por la pantalla LCD, lo
apropiado sería mostrar tan sólo el contenido de las variables correspondientes a cada
carácter.
$GPGGA,212529.4,5042.52892,N,12238.40770,W,2,09,1.1,9.7,M,-11.4,M,,*61
Esto significa que según la subrutina de almacenamiento de datos que vimos anteriormente
y según los caracteres correspondientes marcados en “negrilla” en la cadena, la variables
que debemos tomar para extraer estos campos serían las señaladas a continuación dentro
del arreglo “Datos_RX[X]:

_______________________________________________________________________________________
293
Datos_RX[1] , Datos_RX[33] 7
Datos_RX[2] 2 Datos_RX[34] 0
Datos_RX[3] 1 Datos_RX[35] ,
Datos_RX[4] 2 Datos_RX[36] W
Datos_RX[8] . Datos_RX[40] 0
Datos_RX[10] , Datos_RX[42] ,
Datos_RX[12] 0 Datos_RX[44] .
Datos_RX[19] 9 Datos_RX[51] M
Datos_RX[21] , Datos_RX[53] -
Datos_RX[22] N Datos_RX[54] 1
Datos_RX[27] 3 Datos_RX[59] M
Datos_RX[29] . Datos_RX[61] ,
Datos_RX[30] 4 Datos_RX[62] *
Figura 9.38
Al tomar cada una de estas variables e imprimirlas en pantalla ordenadamente, y de una
forma personalizada, entonces estaremos cumpliendo con el objetivo principal del tema
planteado anteriormente.
En esta ocasión utilizaremos un microcontrolador PIC18F452, debido a que requerimos de
una mayor capacidad en memoria RAM, además de hecho de que seguramente se buscará
expandir las funciones programadas para realizar tareas mas avanzadas.

_______________________________________________________________________________________
294
Toda la programación se hará en base al siguiente diagrama esquemático:
Figura 9.39
Dependiendo de las características técnicas del módulo GPS, es posible que éste pueda ser
alimentado directamente de la fuente de 5 voltios que alimenta nuestro circuito, así como
también es posible que debamos incluir en el diseño de nuestro circuito un MAX232 para
acoplar el módulo al microcontrolador. Algunos otros modelos requerirán de un regulador de
voltaje de 3.3 voltios, he incluso podremos prescindir del MAX232, ya que la salida de datos
puede venir diseñada de diferentes maneras en diferentes modelos o marcas.
Con esto queremos dar a entender que siempre será importante estar seguros de cuales
son los parámetros suministrados por el fabricante para su conexionado, puesto que estos
módulos suelen ser muy sensibles a los errores o niveles de voltaje que apliquemos a ellos.

_______________________________________________________________________________________
295
Analice el siguiente programa que a continuación presentamos y lea detenidamente los
comentarios en cada línea:
program GPS_RS232
' Configuración de los pines de la LCD
' Fin de la configuración de conexiones.
Caracter As Byte ' Variable para almacenar datos temporalmente.
Y As Byte ' Variable para ubicar datos en una posición determinada
' de la pantalla LCD
Dim Datos_RX As Byte[64] ' Arreglo de variables para almacenar los datos del GPS.
Cadena As Byte[184] ' Arreglo de variables para almacenar los cadena completa del GPS.
i As Byte ' Variable para acumulador temporal.
sub function LeerCaracter As Byte ' Recoje un caracter de la UART.
End sub
LCD_Init()
LCD_Out(1,1,"La:") ' Imprime en la linea 1 y columna 1
LCD_Out(2,1,"Lo:") ' Imprime en la linea 2 y columna 1
Recepcion:
do
i = 0 ' Inicializamos la variable i = 0.

_______________________________________________________________________________________
296
verifica_1:
If Cadena[i] = 36 Then ' 36 equivale al simbolo ASCII "$". Si el Valor
Else ' Si no ha sido el simbolo correcto, verifica si "i"
' en busca del caracter "$".
verifica_2:
If Cadena[i] = 71 Then ' 71 equivale al simbolo ASCII "G". Si el Valor
' en busca del caracter "G".
verifica_3:
If Cadena[i] = 80 Then ' 80 equivale al simbolo ASCII "P". Si el Valor
' en busca del caracter "P".
verifica_4:
verifica_5:

_______________________________________________________________________________________
297
verifica_6:
If Cadena[i] = 65 Then ' 65 equivale al simbolo ASCII "A". Si el Valor
GoTo Almacena ' caracter en la subrutina "verifica_2".
' en busca del caracter "A".
' Una vez identificada la cabecera completa de la sentencia NMEA, procedemos a cargar
' el resto de la información en el arreglo de variables Datos_RX[X]:
Almacena:
For X = 1 To 64 ' En esta línea definimos cuantos datos deseamos de
' obtener de la Cadena a partir de la cabecera "$GPGGA"
Next X
PantallaGLCD: ' Esta sub-rutina se encargara de mostrar los datos en un orden
' específico en la pantalla. Es muy importante prestar atención
' a las posiciones en las cuales se están imprimiendo los datos
' para no confundirnos.
LCD_Out(1,1,"La:") ' Imprime una etiqueta en la linea 1 y columna 1
LCD_Out(2,1,"Lo:") ' Imprime una etiqueta en la linea 2 y columna 1
Caracter = Datos_RX[22] ' Letra correspondiente al Hemisferio N ó S.
Lcd_Chr(1, 4, Caracter) ' Escribimos el contenido de la variable "Caracter"
' en la columna 4 (Línea 1) de la pantalla LCD.
Caracter = Datos_RX[36] ' Letra correspondiente al Hemisferio E ó W.
' en la columna 4 (Línea 2) de la pantalla LCD.
' Datos para la Latitud:
Caracter = Datos_RX[11] ' Primer Caracter del campo "Latitud" en la Cadena.
' en la columna 5 de la pantalla LCD.
Caracter = Datos_RX[12] ' Segundo Caracter del campo "Latitud" en la Cadena.
' en la columna 6 de la pantalla LCD.
Y = 8 ' Con este valor especificaremos la posición de la
' variable que deseamos imprimir en la pantalla.

_______________________________________________________________________________________
298
For X = 13 To 20 ' Hacemos un For-Next debido a que deseamos imprimir
' los siguientes 8 caracteres de la lalitud seguidos, de
' esta forma ahorramos líneas de programación.
Caracter = Datos_RX[X] ' Carga el contenido de la variable deseada en "Caracter"
Lcd_Chr(1, Y, Caracter) ' Escribimos el contenido de la variable "Caracter"
' en la columna "Y" (valor cargado en Y) de la pantalla LCD.
Y = Y + 1 ' Incrementamos el valor de "Y" en una unidad para la
' nueva posición del próximo digito a imprimir.
Next X
' Datos para la Longitud:
Caracter = Datos_RX[24] ' Primer Caracter del campo "Longitud" en la Cadena.
Caracter = Datos_RX[25] ' Segundo Caracter del campo "Longitud" en la Cadena.
Lcd_Chr(2, 6, Caracter) ' Escribimos el contenido de la
Caracter = Datos_RX[26] ' Tercer Caracter del campo "Longitud" en la Cadena.
Y = 9 ' Con este valor especificaremos la posición de la
' variable que deseamos imprimir en la pantalla.
For X = 27 To 34 ' Hacemos un For-Next debido a que deseamos imprimir
' los siguientes 8 caracteres de la lalitud seguidos.
Caracter = Datos_RX[X] ' Carga el contenido de la variable deseada en "Caracter"
Lcd_Chr(2, Y, Caracter) ' Escribimos el contenido de la variable "Caracter"
' en la columna "Y" (Línea 2) de la pantalla LCD.
Y = Y + 1 ' Incrementamos el valor de "Y" en una unidad para la
' nueva posición del próximo digito a imprimir.
Next X
delay_ms(5000) ' Pausa de 5 segundos para visualizar los datos en
' la pantalla LCD.
' Mostramos a continuación la cantidad de Satélites en uso. Debido a que este
' campo en la Cadena está conformado por dos dígitos, debemos imprimir el contenido
' de las dos variables correspondientes a éste.
LCD_Out(1,1,"Satelites en Uso") ' Imprime una etiqueta en la linea 1, columna 1
' de la pantalla LCD.
Caracter = Datos_RX[40] ' Carga el contenido de la variable deseada en "Caracter"
' en la columna 8, línea 2 de la pantalla.
Caracter = Datos_RX[41]
' en la columna 9, línea 2 de la pantalla.
delay_ms(5000) ' Retardo de 5 segundos para visualizar
' la información presentada en pantalla.
GoTo Recepcion ' Hacemos un salto a la etiqueta "Recepción" para
' recoger nuevos datos del modulo GPS.
End.

_______________________________________________________________________________________
299
9.6.- Programación en Visual Basic 6.0 para ejemplos de comunicación serial RS232.
Cuando se trata de proyectos de comunicación serial RS232, es muy probable que
necesitemos de una interfase personalizada para el control de nuestros dispositivos
electrónicos. Una forma sencilla y efectiva de realizar esto es a través de la programación de
módulos de control en Visual Basic.
A continuación explicamos paso a paso como llegar a programar un sencillo módulo de
comunicaciones encargado de enviar datos al microcontrolador PIC a través del puerto serial
RS232 del PC.
Para esto emplearemos el diagrama esquemático de la figura 9.54, a través del cual
podremos observar los datos enviados desde el PC en la pantalla LCD.
Para crear un nuevo proyecto en Visual Basic, debemos empezar haciendo clic en el menú
Archivo Nuevo Proyecto y seleccionamos la opción “EXE estándar” (figura 9.40).
Figura 9.40
Figura 9.41

_______________________________________________________________________________________
300
Figura 9.42
Una vez creado un nuevo proyecto, será importante activar el componente para manejar la
comunicación serial “Microsoft Comm Control 6.0”. Esto se realiza haciendo clic en el menú
Proyectos Componentes Controles.
Figura 9.43
Al hacer clic en el botón “Aceptar” veremos que en la barra de herramientas aparece un
nuevo icono representado por un teléfono.

_______________________________________________________________________________________
301
Figura 9.44
Inserte en el formulario el icono “MsComm” como se muestra en la figura 9.45, y configure
los siguientes parámetros en la ventana de propiedades:
CommPort: 1 (ver figura 9.46)
Settings: 9600,n,8,1 (ver figura 9.47)
Figura 9.45
Figura 9.46 Figura 9.47

_______________________________________________________________________________________
302
Seguidamente haga doble clic sobre el formulario para visualizar la ventana de código en la
cual introduciremos las siguientes líneas de programa, las cuales se encargarán de abrir el
puerto serial del PC (Figura 9.48).
Figura 9.48
Utilice el icono “CommandButton” en la barra de herramientas para agregar botones en el
formulario:
Figura 9.49

_______________________________________________________________________________________
303
Para cambiar el nombre del botón, busque la celda “Caption” en la ventana de propiedades
del mismo (ver figura 9.50):
Figura 9.50
Este procedimiento se repite hasta lograr obtener un formulario con 12 botones debidamente
identificados como se observa en la figura 9.51:
Figura 9.51
El siguiente paso es designar a cada botón la instrucción que se encargará de enviar un
dato específico a través del puerto serial RS232 del PC. Haga doble clic en el primer botón
del formulario y agregue la siguiente línea de comando (ver figura 9.52):
Figura 9.52

_______________________________________________________________________________________
304
Se repite el paso anterior para el resto de los botones:
Botón #2: MSComm1.Output = Chr$(50)
Por último, haga clic en el botón “Iniciar” (ver figura 9.53), para hacer funcionar el teclado
3x4 desde el cual se enviarán datos hacia el microcontrolador.
Al hacer clic en cualquiera de los botones del teclado, estará enviando al microcontrolador el
dato correspondiente (Valor equivalente al caracter ASCII en la tecla)b el cual podrá ser
observado en la pantalla LCD de su circuito.
Figura 9.53

_______________________________________________________________________________________
305
Por último, generamos el archivo ejecutable desde el menú Archivo Generar “Nombre del
archivo.exe”
El programa para el ejemplo planteado esta basado en el diagrama esquemático de la figura
9.54:
program RS232
Recepcion:
If (UART1_Data_Ready() = 1) Then ' Si recibe datos en el puerto...
Datos_RX = UART1_Read() ' Almacena el dato en la variable "Datos_RX"
GoSub Imprime ' Salta a la subrutina de Impresión.
Else
Lcd_Out(1, 1, "Esperando Dato!") ' Mensaje de estado del Buffer.
End If
GoTo Recepcion ' Repetimos el proceso.
Imprime:
Lcd_Out(2, 1, "Tecla: ") ' Mensaje de estado del Buffer.
Lcd_Chr(2, 8, Datos_RX) ' Transmitimos de vuelta el valor cargado
Delay_ms(1000) ' Retardo de 1.5 segundos.
Return
End.

_______________________________________________________________________________________
306
Básicamente el microcontrolador estará esperando un dato desde el PC el cual será
mostrado en la segunda línea de la pantalla LCD.
Al presionar cualquiera de las teclas del módulo que hemos realizado en Visual Basic, el
caracter correspondiente aparecerá en la pantalla para luego quedar a la espera del
siguiente dato.
En base a los conocimientos adquiridos hasta ahora, realizaremos a continuación un circuito
capaz de medir un voltaje variable aplicado a una de las entradas del conversor A/D de un
PIC16F877, el cual a su vez deberá enviar el resultado de la conversión en decimal a una
pantalla LCD, y enviar este mismo resultado a un PC, a través del puerto serial donde los
datos serán recibidos y “convertidos”, en una hoja de cálculo (Excel), para posteriormente
graficar el conjunto de datos de una muestra de diez lecturas acumuladas.
Figura 9.54

_______________________________________________________________________________________
307
Del capítulo de conversión A/D podemos extraer el programa base para llegar al objetivo de
este ejercicio. Lo único que tendremos que hacer será agregar una rutina para transmitir vía
RS232 el resultado de la conversión A/D hacia el PC.
Antes de realizar la programación en Excel, vamos a realizar las pruebas de conversión A/D
mostrando los resultados en la pantalla LCD y en el terminal de comunicaciones de
mikroBasic.
Analicemos el siguiente programa, leyendo cuidadosamente los comentarios realizados en
cada línea:
program RS232_A/D
' Sección de Declaración
' Configuración de los pines de la LCD
Dim texto As String[20] ' Declaramos una variable tipo String en la cual
' cargaremos un mensaje de un máximo de 20 caracteres.
Dim dato As Word ' Variable de 16 bits para cargar el valor de la
' conversión A/D.
Dim DatoStr As string[4] ' Variable para conversión datos.
main:
Lcd_Init() ' Inicializamos la pantalla.
LCD_Cmd(_LCD_Clear) ' Limpia la pantalla LCD.
LCD_Cmd(_LCD_Cursor_Off) ' Apaga el cursor en la pantalla.
ADCON1 = 0 ' Configura el puerto A como analógico,
' VDD es el voltaje de referencia --> Vref.
TRISA = $FF ' Configura el puerto A como entrada.
While (TRUE)
dato = Adc_Read(2) ' Carga el resultado de la conversión de
' 10 bits en la variable.
LCD_Out(1,1,"Conversion A/D: ") ' Imprime un título en la linea 1.
wordtostr(dato, DatoStr) ' Conversión de word a string.
Lcd_Out(2, 5, DatoStr) ' Imprime el dato cargado en "DatoStr".

_______________________________________________________________________________________
308
UART1_Write_Text(DatoStr) ' Enviamos el dato vía RS232.
Wend
End.
En el programa se puede observar cómo hemos definido el conexionado de la pantalla LCD,
así como también la configuración básica establecida para el conversor A/D, el cual hará la
conversión a 10 bits con el fin de obtener una mayor resolución en el proceso de medición
del voltaje aplicado al pin RA2.
Una vez iniciada la conversión, se puede observar que el resultado de la misma es
almacenada en la variable “Dato”, la cual hemos declarado como una variable de 16 bits
(word), debido a que el resultado de la conversión requiere mas de ocho bits de datos.
Este resultado de la conversión es mostrado en la pantalla LCD e inmediatamente enviado a
través del puerto serial del microcontrolador el cual ha sido inicializado a una velocidad de
transmisión de datos de 9600 bps. En la figura 9.55 podemos observar como se verá el dato
resultado de la conversión en la pantalla.
Figura 9.55
El siguiente paso en el programa consiste en enviar el dato obtenido al PC a través del
puerto serial, para luego hacer una pequeña pausa de 500 milisegundos y empezar
nuevamente el proceso para una nueva lectura.
Un paso importante en este punto, una vez obtenido el resultado de la conversión A/D en la
pantalla LCD, será verificar la transferencia de datos hacia el PC con la ayuda de la terminal
de comunicaciones de mikroBasic.

_______________________________________________________________________________________
309
En la siguiente imagen podemos ver los datos capturados por el PC desde la ventana de
recepción en la terminal:
Figura 9.56
Recuerde seleccionar la opción “ASCII”, para visualizar los valores obtenidos de la
conversión A/D adecuadamente. En este punto ya podemos estar seguros que la conversión
en RA2 y el envío de datos hacia el PC están correctos.
Pero la idea principal de esta práctica, será llevar estos datos a una hoja de Excel, en la cual
podamos realizar los cálculos para expresar estos valores en unidades de voltaje para
luego tomar una muestra significativa y graficarlos como se observa en la figura 9.57.

_______________________________________________________________________________________
310
Figura 9.57
El primer paso para configurar la hoja de Excel, será ubicar las herramientas de Visual Basic
y agregar a la hoja de cálculo el control “Microsoft communications control, Version 6.0”.
Para esto debemos seguir los siguientes pasos:
1.- Al abrir la hoja de cálculo, podemos ver un menú de opciones en la parte superior de la
ventana denominado “Herramientas”. Haga clic en el menú “Herramientas” y seleccione la
opción “Personalizar”.

_______________________________________________________________________________________
311
Figura 9.58
Al seleccionar esta opción podrá observar que en la ventana “Personalizar” hay tres fichas
de configuración. Seleccione la ficha “Barra de herramientas” como se muestra en la figura
9.59.
Figura 9.59

_______________________________________________________________________________________
312
En esta ficha encontrará una serie de opciones disponibles, de las cuales deberá
seleccionar “Visual Basic”. Haga clic en al botón “Cerrar” y verá que aparece en la hoja de
cálculo una caja de herramientas nueva llamada “Visual Basic” (Figura 9.60), la cual
podemos trasladar a la parte superior de la hoja de cálculo, la cual contiene el resto de las
herramientas típicas usadas en Excel (Figura 9.61).
Figura 9.60

_______________________________________________________________________________________
313
Figura 9.61
Haga clic en el botón “Cuadro de controles” y desplace la caja de herramientas
nuevamente a la parte superior de la hoja de cálculo junto con el resto de herramientas
comunes de Excel (Figura 9.62).

_______________________________________________________________________________________
314
Figura 9.62
En esta serie de botones, podremos encontrar uno denominado “Mas controles” (ver
Figura 12.35), el cual despliega una lista de opciones. Ubique el siguiente control:
“Microsoft communications control, Version 6.0”.
Al hacer doble clic en este control la lista de opciones desaparece y es en este momento en
el cual debemos agregar el mismo sobre la hoja de cálculo. Para esto, debe mantener el
botón izquierdo del mouse activado y arrastrar el puntero hasta que aparezca un pequeño
recuadro. Al soltar el botón izquierdo el control aparece sobre la hoja. La figura de un
Teléfono sobre un “MODEM” lo identifica claramente, como se muestra en la figura 9.63.

_______________________________________________________________________________________
315
Figura 9.63
El siguiente paso será agregar un botón en el cual se configura el código necesario para la
apertura del puerto serial en el PC (Figura 9.64).
Figura 9.64

_______________________________________________________________________________________
316
Al hacer doble clic sobre el nuevo botón, estamos entrando al editor de Visual Basic, en el
cual podemos agregar las siguientes líneas de programa, las cuales permitirán abrir el
puerto al hacer clic sobre el botón que hemos agregado para tal fin:
Private Sub CommandButton1_Click()
'abre el puerto de comunicación
If Hoja1.MSComm1.PortOpen = False Then
Hoja1.MSComm1.PortOpen = True
End If
End Sub
Observe la figura 9.65, en la cual se puede ver el campo “Caption”, correspondiente a la
etiqueta del botón de comando que estamos configurando, la cual podemos personalizar con
un nombre adecuado como “Abrir Puerto” o “Abrir Comm1”.
Figura 9.65

_______________________________________________________________________________________
317
En figura 9.65 también podemos apreciar las líneas de programación agregadas al botón de
comando, y el icono que nos permitirá regresar a la hoja de cálculo para continuar con la
programación.
Al regresar a la hoja de cálculo podremos notar el cambio en la etiqueta del botón de
comando, como se muestra en la figura 9.66:
Figura 9.66
Ahora solo nos queda configurar el evento OnComm, relativo a la recepción de datos,
haciendo doble clic sobre el control de comunicaciones (figura 9.67):
Figura 9.67

_______________________________________________________________________________________
318
Veremos a continuación la ventana del editor de Visual Basic (Figura 9.68):
Figura 9.68
Recordemos que para almacenar datos en una variable, es importante considerar la
declaración de la misma antes de ejecutar cualquier otra línea de programa que así la
requiera. Es por esto que para este ejemplo, el primer paso en la configuración del control
de comunicaciones ha sido la declaración de dos variables, las cuales hemos denominado
“Apuntador” y “datainput”.
La variable “Apuntador” será declarada como “Byte” y la variable “datainput” será declarada
como “String”.
Analice el uso de la variable “Apuntador” en el código del evento OnComm, el cual
detallamos unas líneas más adelante. Esta variable se usa básicamente como acumulador y
determina la posición en un rango predeterminado de las filas en la hoja de cálculo. Esto se

_______________________________________________________________________________________
319
debe a que estamos interesados en mantener una muestra de los diez últimos valores
capturados en el puerto para poder realizar una gráfica de líneas suavizadas, la cual se
estará actualizando cada 500 milisegundos.
Para almacenar un dato presente en el puerto serial (Comm1), utilizamos el comando
“MSComm1.Input”, entonces, para almacenar un dato en la variable “datainput”, debemos
realizar el siguiente arreglo:
datainput = MSComm1.Input
Luego para llevar el dato almacenado en la variable a una celda en la hoja de cálculo,
podemos utilizar el siguiente comando:
Hoja1.Cells(Fila, Columna)
Un punto importante a considerar es que la variable “datainput” por estar declarada como
“String”, almacenará una serie de datos consecutivos uno tras otro. Podemos extraer un
dato de la cadena de caracteres almacenada en la variable “datainput” de la siguiente
manera:
Hoja1.Cells(Fila, Columna) = Mid(Variable, Bit de inicio, longitud)
Ejemplo:
Si datainput = 643645650681701718745776
Para extraer los tres primeros caracteres y llevarlos por ejemplo a la celda (40,2) debemos
hacer el siguiente arreglo:
Hoja1.Cells(40, 2) = Mid(datainput, 1, 3)
Para mantener este dato y capturar uno mas actualizado, simplemente debemos hacer un
arreglo para desplazar el contenido de la celda (40,2) a la celda (39,2). Cuando llegue el
próximo dato actualizado, el contenido de esta celda deberá pasar a la celda (38,2) y así
sucesivamente. Al repetir el desplazamiento de celdas diez veces, podremos tomar estos
valores y graficarlos en la hoja de cálculo.
Veamos a continuación el código para el evento OnComm:
Private Sub MSComm1_OnComm()
'Declara variable
Dim Apuntador As Byte
Dim datainput As String
datainput = MSComm1.Input
For Apuntador = 30 To 40
Hoja1.Cells(Apuntador, 2) = Hoja1.Cells(Apuntador + 1, 2)
Next

_______________________________________________________________________________________
320
Hoja1.Cells(40, 2) = Mid(datainput, 1, 4)
End Sub
Figura 9.69
Analice cuidadosamente el contenido del código en el evento OnComm. Verifique la rutina
encargada de apilar los datos entre las celdas (40,1) y (30, 1). Por último, analice la
extracción de datos de la cadena de caracteres almacenada en la variable “datainput”.
Completados todos estos pasos, lo siguiente será volver a la hoja de cálculo y salir del modo
de diseño, haciendo clic en el icono señalado en la siguiente figura:
Figura 9.70

_______________________________________________________________________________________
321
Cuando se sale del modo de diseño, el control de comunicaciones desaparece de la hoja de
cálculo. Ahora, haciendo clic en el botón “Abrir Comm1” y activando el circuito, podremos ver
que aparecen los datos de la conversión A/D del microcontrolador en la pantalla LCD y en la
hoja de cálculo, específicamente en las celdas B40, B39, B38, B37, B36, B35, B34, B33,
B32, B31 y B30.
En la figura 9.71 se pueden ver unos datos de prueba almacenados en las celdas
anteriormente mencionadas. Estos datos pueden ser identificados poniendo un nombre o
encabezado en la celda B29, por ejemplo, podemos escribir la palabra “Lecturas: “.
En la columna C de la hoja de cálculo, haremos la conversión de datos para expresar los
valores obtenidos en Voltios. Para esto aplicaremos la siguiente formula en las celdas C40,
C39, C38, C37, C36, C35, C34, C33, C32, C31 y C30:
=(B40*5)/1024 para la celda C40

_______________________________________________________________________________________
322
Figura 9.71
Figura 9.72

_______________________________________________________________________________________
323
Observe en la figura 9.72, la formula para la celda C40. Observe también que hemos
ocultado una serie de filas de la hoja de cálculo, las cuales hemos reservado para agregar
un gráfico de líneas suavizadas.
Para graficar esta serie de datos, seleccionamos las diez celdas (desde la celda C30 hasta
la celda C40) y hacemos clic en el icono “Asistente para Gráficos” (Figura 9.73), donde
aparecerá una ventana en la cual podremos elegir el tipo de gráfico que deseamos utilizar.
Seleccione la ficha “Tipos personalizados” y haga clic en la opción “Líneas suavizadas” de la
lista (Figura 9.74).
Figura 9.73
Figura 9.74

_______________________________________________________________________________________
324
En la siguiente ventana podemos ver el rango de datos que será graficado (Figura 9.75):
Figura 9.75
Si se desea personalizar aún mas el gráfico, se puede hacer en la ficha “Serie”, en cual es
posible editar el recuadro que contiene la leyenda. En la siguiente ventana encontraremos
una serie de fichas con una gran variedad de opciones que nos permitirán añadir detalles
como el título del gráfico, identificar los ejes, agregar líneas de división, y algunos otros
detalles útiles para mejorar la apariencia del gráfico. (figura 9.76).
Figura 9.76

_______________________________________________________________________________________
325
Seguidamente, podemos seleccionar si el gráfico será colocado en una hoja nueva, o en la
hoja de cálculo en la cual hemos estado trabajando (figura 9.77):
Figura 9.77
Finalmente podremos ver en la hoja de Excel los datos enviados desde el microcontrolador,
los cuales a su vez serán graficados constantemente, como se puede observar en la figura
9.78
Figura 9.78

Microcontroladores: mikroBasic para microcontroladores PIC 2da parte

Microcontroladores: mikroBasic para microcontroladores PIC 2da parte

Recomendados

Recomendados

Más contenido relacionado

Similar a Microcontroladores: mikroBasic para microcontroladores PIC 2da parte

Similar a Microcontroladores: mikroBasic para microcontroladores PIC 2da parte (20)

Más de SANTIAGO PABLO ALBERTO

Más de SANTIAGO PABLO ALBERTO (20)

Último

Último (20)

Microcontroladores: mikroBasic para microcontroladores PIC 2da parte