Instalando y Grabando microcontroladores PIC con Pk2cmd en Linux [Mediafire].
Que tal amigos?
En el día de hoy vamos a ver como grabar microcontroladores PIC en Linux; para esto vamos a necesitar de un programa llamada Pk2cmd, este programa no es más si el mismo Pickit2 sino que para linux, funciona mediante la terminal. Para que se den una mejor idea les dejaré el siguiente tutorial de la instalación y uso de este Pickit2 (pk2cmd) para linux:
Bueno y para terminar les voy a dejar los link's de descarga y la contraseña, que es la dirección de mi blog; solo copienla y pegenla
Curso de MPLABX y XC8 #6: Modulo PWM CCP2 Pic18f2550.
Buenas compañeros.
Antes
de iniciar el sexto capitulo del curso de programación en C para pic's
con MPLABX y XC8, les recomiendo ver los capítulos anteriores siguiendo
el siguiente LINK.
Ya vistos los anteriores capítulos y una vez teniendo todos los software
necesarios procederemos a explicar de que tratar esta clase.
Modulación de ancho de pulso (PWM).
La modulación de ancho de pulso ó PWM es una técnica que consiste en transferir una carga a un dispositivo con una señal cuadrada; esta señal se componen por dos estados, uno alto y uno bajo, para un microcontrolador estos estados se representarían como 5v voltios en estado alto y 0 voltios en estado bajo; esta señal puede variar dependiendo de la frecuencia a la que es enviada y la amplitud de la tensión a la que es enviada; para entender mejor este concepto veremos la siguiente imagen:
La anterior imagen corresponde a un pwm el cual se le asigna diferentes frecuencias para variar la velocidad de salida de la carga; esto se puede utilizar para el control de velocidad de motores y otro tipos de elementos.
Configuración PWM Pic18f2550:
Para configurar los pines CCP en modo PWM debemos tener clara las características de los módulos CCP en el microcontrolador a utilizar; en este caso es el pic18f2550.
Modulo CCPx Pic18f2550:
Sacado de: PIC18F2455/2550/4455/4550-Data Sheet, 15.0 CAPTURE/COMPARE/PWM
(CCP) MODULES. Página; 143.
PIC18F2455/2550/4455/4550 todos los dispositivos tienen dos Módulos CCP (Captura/Comparación/ PWM ) .
Cada módulo contiene un registro de 16 bits , que puede funcionar como un registro de 16 bits de captura , de comparación o de PWM.
Estas son las características básicas del modulo CCPx en los microcontroladores de la familia PIC18F.
Ya que el módulo CCP posee tres funciones básicas debemos configurarlas, ya que no se pueden utilizar al mismo tiempo, por eso hay un registro que posee 8 bit para configurar los diferentes modos que soporta el modulo CCPx; este registro es CCPxCON. Ahora veremos sus diferentes configuraciones:
bit 06 al 07 --------------NO SE IMPLEMENTA: Se lee como '0'
bit 04 al 05 ------------- DCxB1:DCxB0: PWM Ciclo de trabajo. El bit 1 y el bit 0 para el Módulo CCPx.
Modo de captura:-----------------No usado.
Modo de comparación:-----------No usado.
El modo PWM: -------------------Estos bits son los dos bits menos significativos (bit 1 y bit 0) del ciclo de trabajo PWM 10-bit. Los ocho MSB de la obligación ciclo se encuentran en CCPR1L.
bits 03 al 0 -------------- CCPxM3: CCPxM0: Modo Módulo CCPx bits de selección 0000 = Captura / Comparación / PWM desactivado/a (restablece módulo CCPx) 0001 = Reservado 0010 = modo Comparación: palanca de salida en partido (bit CCPxIF está establecido) 0011 = Reservado 0100 = Modo de captura: cada flanco de bajada 0101 = Modo de captura: cada flanco ascendente 0110 = Modo de captura: cada flanco ascendente cuarto 0111 = Modo de captura: cada flanco ascendente 16a 1000 = modo de comparación: inicializa pin CCPx baja;comparar, pin vigor CCPx alta (CCPxIF bit se pone) 1001 = modo de comparación: inicializa pin CCPx alta; comparar, pin vigor CCPx baja (CCPxIF bit se pone) 1010 = modo Compare: genera interrupción por software en comparación (bit CCPxIF se establece,
Pin CCPx refleja I / O Estado) 1011 = modo de comparación: desencadenar eventos especiales, restablecer temporizador, iniciar la conversión A / D en el partido CCP2
(CCPxIF bit se pone) 11xx = modo PWM Nota 1: Estos bits no se aplican en los dispositivos 28 patillas y se leen como '0'.
Bien, estos son los bits de configuración con sus respectivas configuraciones del registro CPPxCON;
recordemos que a la hora de programar este registro se tiene que agregar el número del modulo a utilizar; como vamos a utilizar CCP2 en este caso el registro quedaría CCP2CON.
Ya que tenemos claro este registro vamos a ver el siguiente vídeo para ver en forma practica la configuración e implementación de este modulo:
Recuerden que el CCP2 en los microcontroladores de la familia pic18f, es multiplexada, así que se encuentra en dos puertos, esto se configura a través de los bits de configuración del micro, en el vídeo se explica como hacerlo.
Eso es todo; espero que les halla gustado este capitulo del curso de programación en C para microcontroladores PIC con MPLABX y XC8 Compiler.
Si encuentran algún error por favor dejar un comentario en el blog, así podré solucionarlo e informar correctamente a todos; también si tienen algo que aportar con gusto será bienvenido; y por otro lado la traducción no es muy exacta, pero en el vídeo trato de explicar sin necesidad de ella; aún así también son bienvenidas las traducciones corregidas.
Esto es todo por hoy, Sigue mi blog y visita mi próxima entrada!
NOTA: se les recuerda a los lectores que se utilizo la versión del compilador XC8 Versión 1.34 la cual trae las peripheral libraries incluidas en él; el pdf de estas lo pueden encontrar en la parte de etiquetas del blog en la etiqueta llamada Documentación.
Curso de MPLABX y XC8 #05: Modulo Timer0 Pic18f2550 Parte#02.
Buenas compañeros.
Antes
de iniciar la segunda parte del Quinto capitulo del curso de programación en C para pic's
con MPLABX y XC8, les recomiendo ver los capítulos anteriores siguiendo
el siguiente LINK.
Ya vistos los anteriores capítulos y una vez teniendo todos los software
necesarios procederemos a explicar de que tratar esta clase.
Procedimiento para el uso del TIMER0 como Temporizador:
Ya que vinos en la parte #01 del modulo Timer0 la configuración de este por medio del registro T0CON, en esta Parte #02 veremos los pasos correctos para poder utilizar el Timer0 como Temporizador; para esto vamos a proponer un breve ejercicio.
Resolver:
Se tiene un microcontrolador Pic18f2550, un led y un interruptor; se necesita hacer prender el led por medio de la bandera de desbordamiento del modulo Timer0 que se encuentra en el pic, este modulo será activado a través de un interruptor. Para este ejercicio se utilizará como condición solo el puerto B del micro.
Antes de empezar hay que tener en cuenta habilitar las interrupciones globales;
esto se hace de la siguiente forma:
Luego es hora de conocer la interrupción por medio del timer0, esta se produce cuando se registra desbordamientos en el timer0, al producirse un desbordamiento se pone en alto el bit TMR0IF del registro INTCON; cuando se desborda, este bit solo puede ser vuelto a cero por software; esto se hace de la siguiente forma:
INTCONbits.TMR0IF = 0; //Limpiamos bandera de desborde
Y por ultimo les recomiendo que activen unas interrupciones perimetrales y la más importante, habilitamos la interrupción del timer0, esto se hace de la siguiente forma:
Bien! ya planteado el problema y conociendo los anteriores datos, vamos a ver el siguiente vídeo donde se dará solución al problema:
Esto sería todo del quinto capitulo de programación en C con XC8
Compiler y MPLABX, de pronto en el vídeo tuve algunos errores, o mal
pronunciamiento, pero la finalidad de este blog es corregir esto y
profundizar un poco más en el tema; espero que les sirva!
Esto es todo por hoy, Sigue mi blog y visita mi próxima entrada!
NOTA: se les recuerda a los lectores que se utilizo la versión del compilador XC8 Versión 1.34 la cual trae las peripheral libraries incluidas en él; el pdf de estas lo pueden encontrar en la parte de etiquetas del blog en la etiqueta llamada Documentación.
Curso de MPLABX y XC8 #05: Modulo Timer0 Pic18f2550 Parte#01.
Buenas compañeros.
Antes
de iniciar el Quinto capitulo del curso de programación en C para pic's
con MPLABX y XC8, les recomiendo ver los capítulos anteriores siguiendo
el siguiente LINK.
Ya vistos los anteriores capítulos y una vez teniendo todos los software
necesarios procederemos a explicar de que tratara esta clase.
Modulo Timer0 PIC18F2550: Registro T0CON
El registro T0CON controla todo aspectos de la operación del módulo, incluyendo la selección de preescala. A la vez permite la lectura y escritura. El módulo Timer0 incorpora las siguientes características:
• Software de operación seleccionable como un temporizador o contador en ambos modos de 8 bits o de 16 bits
• registros de lectura y escritura
• Dedicado 8 bits, software programable prescaler
• fuente de reloj seleccionable (interno o externo)
• Edge seleccionar para reloj externo
• Interrumpir el desbordamiento por medio de una flag o bandera.
Configuración de los bits en el registro T0CON:
bit 7 TMR0ON: Timer0 El bit / Off Control
1 = Habilita Timer0
0 = Detiene Timer0
bit 6 T08BIT: Timer0 8-Bit / 16-Bit Bit de control
1 = Timer0 se configura como una de 8 bits de temporizador / contador
0 = Timer0 se configura como un 16-bit de temporizador / contador
bit 5 T0CS: Timer0 Reloj de selección de fuente poco
1 = transición en el pin T0CKI
0 = reloj ciclo de instrucción interna (CLKO)
bit 4 T0SE: Timer0 Fuente Edge Selección bits
1 = Incremento en la transición de alto a bajo en el pin T0CKI
0 = Incremento de bajo a alto transición en el pin T0CKI
bit 3 PSA: Timer0 de divisor bits Asignación
1 = TIMER0 prescaler NO se le asigna. Entrada de reloj Timer0 no pasa por prescaler.
Se asigna 0 = Timer0 prescaler. Entrada de reloj Timer0 proviene de salida de prescaler.
bits 2-0 T0PS2: T0PS0: Timer0 de divisor bits de selección
111 = 1/256 Valor preescaler
110 = 1/128 Valor preescaler
101 = 1/64 Valor preescaler
100 = 1/32 Valor preescaler
011 = 1/16 Valor preescaler
010 = 1/8 Valor preescaler
001 = 1/4 Valor preescaler
000 = 1/2 Valor preescaler
Bien! ya que sabemos para que sirve cada bit del registro T0CON, vamos a ver como nuestro compilador XC8 nos permite configurar este registro y sus formas básicas:
T0CON ==> Con esta instrucción podemos configurar todos los bits del registro T0CON en forma binaria.
T0CON = 0b11011011;
Pero también se puede hacer bit por bit de la siguiente forma:
T0CONbits. y seleccionamos el bit a configurar, esto sería:
T0CONbits.TMR0ON: 1 ó 0
T0CONbits.T0SE: 1 ó 0
T0CONbits.PSA: 1 ó 0
T0CONbits.T0PS0: 1 ó 0
T0CONbits.T0PS1: 1 ó 0
T0CONbits.T0PS2: 1 ó 0
ETC...
Para saber la carga máxima que se le puede dar al timer0 con respecto al modo de bits que este utilizando se utiliza el siguiente calculo:
(2^16)-1=65535 Modo 16.
(2^8)-1=255 Modo 8 bits.
El 2 se refiere a los dos registros que acumulan la carga los cuales son Timer0L y Timer0H; y luego se eleva al modo de bits del timer0 a utilizar; luego se le resta uno para no acudir a la bandera de desbordamiento del timer0.
Bien para complementar y entender mejor esta clase, los invito a que
vean el siguiente vídeo donde se mostrará y profundizará más acerca del
Modulo TIMER0 del PIC18F2550:
Esto sería todo del quinto capitulo de programación en C con XC8
Compiler y MPLABX, de pronto en el vídeo tuve algunos errores, o mal
pronunciamiento, pero la finalidad de este blog es corregir esto y
profundizar un poco más en el tema; espero que les sirva!
Esto es todo por hoy, Sigue mi blog y visita mi próxima entrada!
NOTA: se les recuerda a los lectores que se utilizo la versión del compilador XC8 Versión 1.34 la cual trae las peripheral libraries incluidas en él; el pdf de estas lo pueden encontrar en la parte de etiquetas del blog en la etiqueta llamada Documentación.
Curso de MPLABX y XC8 #07: Conversión Análoga Digital.
Buenas compañeros.
Antes
de iniciar el septimo capitulo del curso de programación en C para pic's
con MPLABX y XC8, les recomiendo ver los capítulos anteriores siguiendo
el siguiente LINK.
Ya vistos los anteriores capítulos y una vez teniendo todos los software
necesarios procederemos a explicar de que tratara esta clase.
En esta clase veremos que es una conversión análoga digital, su funcionamiento en los microcontroladores pic, y como podemos implementar esta herramienta en los pic a través del lenguaje de programación C para pic's con XC8 Compiler y la IDE de MPLABX; para comenzar debemos saber que es una conversión análoga digital.
Conversión Análoga Digital:
La conversión análoga digital, es una herramienta que poseen diferentes dispositivos, entre ellos una gran variedad de microcontroladores, la cual nos permite por medio de un puerto leer una señal analógica en forma de voltaje,
y a su vez convertirla en una señal digital, con el fin de poder procesar las señales y así poder representarla en forma digital; para poder entender mejor este concepto procederemos a analizar la siguiente imagen:
Bien! ya que tenemos claro el concepto de la conversión análoga digital, vamos a
ver como podemos implementar esta herramienta a nuestros programas a través del siguiente vídeo:
Una vez que ya hemos estudiado el vídeo, vamos a ver cada una de las instrucciones y así mismo la configuración del modulo ADC cn estas; empecemos:
Configuración Del conversor analogo digital (ADC).
Para esta configuración se utiliza la instrucción OpenADC( ), en ella se especifica todas las configuraciones que tiene el modulo adc en el microcontrolador, por eso vamos a ver un breve resumen de ellas:
* Frecuencias de funcionamiento y relog del ADC tabla 21-1 pag 265 datasheet pic18XXXX
* Los resultados se justifican hacia la derecha
* Tiempo de adquisición
* Canales
* Interrupción
* ADC referencia de voltaje
Como ven son pocas y facilmente se pueden configurar, primero vamos a ver la tabla de frecuencias en el datasheet que nos muestra anteriormente, el datasheet lo pueden encontrar en la parte de etiquetas, en la etiqueta de documentación.
Bien! como ya vimos en la tabla vemos que tiempos de operación se pueden usar con respecto a la frecuencia con la que se este trabajando en el microcontrolador; como en este caso estmos utilizando un cristal de 20MHz nos correspondería 16 Tosc quedando asi:
OpenADC( ADC_FOSC_16 & XXXXXX)
Listo ahora vamos a ver como se justifican los resultados:
* ADC_RIGHT_JUST Justificamos a la derecha
* ADC_LEFT_JUST Justificamos a la izquierda
* ADC_RESULT_MASK Oculto o enmascarado el resultado
por ejemplo vamos a justificarlo a la derecha, esto quedaría con lo anterios asi:
OpenADC( ADC_FOSC_16 & ADC_RIGHT_JUST & xxxxxx)
Perfecto! ahora que ya tenemos esto, queda lo más facil, y es el tiempo de adquisición, este en base a la frecuencia quedaría de 16 y se pondría asi:
Para terminar vamos a seleccionar que cantidad de pines estarán disponibles para el moduloo ADC, esto se hace mirando la libreria y mirando cuantos pines estan disponibles para el modulo; para no profundizar tanto escogeré solo un pin analogo, ya que solo voy a utilizar un canal; esto se hace con la siguiente instruccion:
Y con esto quedaría nuestra configuración completa; ahora vamos a ver las instrucciones básicas con las cuales manipularemos el modulo ADC.
int dato = 0; // Variable llamada dato
ConvertADC(); // Iniciamos la conversión ADC
while(BusyADC()); // Esperamos a que finalice la conversión ADC
dato = ReadADC(); // En esta parte lo que hacemos es guardar lo que recibio la lectura del modulo ADC en una variable llamada dato
Ya con estas instrucciones se terminaria todo lo referente ADC, ahora lo que queda es manipular lo que se guardo en la variable, para ellos se utilizan muchas formas, para diferentes aplicaciones, es distinta la forma en manejar este dato para mostrar un voltaje en el lcd, a manejar un voltaje que proviene de un sensor como por ejemplo el lm35 que es un sensor de temperatura.
Espero que les halla gustado y que hallan aprendido mucho el día de hoy; con esto finalizamos el curso de MPLABX y el compilador XC8
Atentos a mi blog, nuevos cursos comenzarán! NOTA: se les recuerda a los lectores que se utilizo la versión del compilador XC8 Versión 1.34 la cual trae las peripheral libraries incluidas en él; el pdf de estas lo pueden encontrar en la parte de etiquetas del blog en la etiqueta llamada Documentación.
Antes de iniciar el cuarto capitulo del curso de programación en C para pic's con MPLABX y XC8, les recomiendo ver los capítulos anteriores siguiendo el siguiente LINK.
Ya vistos los anteriores capítulos y una vez teniendo todos los software
necesarios procederemos a explicar de que tratara esta clase.
Primero vamos a saber algo del hardware a utilizar:
LCD: Las pantallas de cristal líquido LCD o display LCD para mensajes (Liquid Cristal Display) tienen la capacidad de mostrar cualquier carácter alfanumérico, permitiendo representar la información que genera cualquier equipo electrónico
de una forma fácil y económica. La pantalla consta de una matriz de caracteres (normalmente de 5x7 o 5x8 puntos) distribuidos en una, dos, tres o cuatro líneas de 16 hasta 40 caracteres cada línea. El proceso de visualización es gobernado por un microcontrolador incorporado a la pantalla, siendo el Hitachi 44780 el modelo de controlador más utilizado.
Bien, ya que sabemos que es un LCD y para que sirve, ahora vamos a pasar a la parte de configuración; para esta parte vemos a ver unas instrucciones de XC8 las cuales se utilizan para configurar el LCD y darle los comandos básico.
Para que el compilador pueda ejecutar estos comandos solo basta con incluir la siguiente libreria:
#include <xlcd.h> // Librería LCD a incluir
WriteCmdXLCD(XXXXXXX):
Este comando es muy importante ya que da las configuraciones básicas del LCD; entre ellas destacamos las siguientes:
0b00001111 // Display on
0b00001011 // Display off
0b00001111 // Cursor on
0b00001101 // Cursor off
0b00001111 // Cursor Blink
0b00001110 // Cursor No Blink
0b00000001 // Borrar lcd
0b11000000 // Cambio de línea
El modo de uso de este comando con respecto a las funciones sería:
WriteCmdXLCD(0b00000001); // Borramos LCD
SetDDRamAddr(XXX):
Este
comando se utiliza para dar la posición del LCD donde se imprimirán los
caracteres que necesitamos; para saber las posiciones con la que
contamos les mostraré el siguiente diagrama:
/* Tabla de posiciones del LCD 2x16
* ===============================================
* |00|01|02|03|04|05|06|07|08|09|0A|0B|0C|0D|0E|0F|
* ===============================================
* |40|41|42|42|44|45|46|47|48|49|4A|4B|4C|4D|4E|4F|
* ===============================================
*/
Conociendo las posiciones el uso correcto de SetDDRamAddr( ) sería el siguiente:
SetDDRamAddr(0x00); // Primera fila, Primera columna
putrsXLCD("XXX"):
Este comando es el que nos permitirá enviar a SetDDRamAddr los caracteres a imprimir, su uso es muy sencillo como se vera a continuación:
putrsXLCD("Hola Mundo!"); // Imprimimos el mensaje Hola Mundo!
Bien! estos son los comandos básico para poder manipular nuestro LCD; pero antes de eso debemos saber que para que se inicialice el LCD debemos configurar unos retardos mientras que se carga el controlados de este, para eso basta con colocar una rutina sencilla al inicio y al final del programa, y también una librería <delays.h> quedando de la siguiente forma:
========== Aquí va la configuración del LCD =========
========================================
WriteCmdXLCD(0b00000001); // Borramos LCD
SetDDRamAddr(0x00); // Primera línea
putrsXLCD("Hola Mundo!"); // Imprimimos Mensaje
// Retardos necesarios para el driver para la LCD
void DelayFor18TCY(void)
{
Delay10TCYx(120);
}
void DelayPORXLCD(void)
{
Delay1KTCYx(180);
retundir;
}
void DelayXLCD(void)
{
Delay1KTCYx(60);
return;
}
Listo! ya estamos en lo ultimo, la configuración del LCD; esta configuración se especificará en el siguiente vídeo:
NOTA: Diferencias entre conexión de 4 bits y 8 bits en el LCD.
Modo de 4 bits utiliza 4 E / S pines del puerto de datos y dos o tres pines de E / S adicionales para el control.
Modo de 8 bits utiliza 8 E / S pines del puerto de datos y dos o tres pines de E / S adicionales para el control.
El modo de 4 bits requiere dos transferencias de 4 bits para cada instrucción y el carácter que se envía a la pantalla.
Modo de 8 bits requiere sólo una transferencia de 8 bits para cada instrucción y el carácter que se envía a la pantalla.
La implicación es que, las transferencias de datos de 4 bits tendrán el doble de tiempo para transferir en comparación a las transferencias de datos de 8 bits.
Las transferencias de datos de 4 bits también requieren un poco más de código, necesitará el nibble inferior para ser desplazado en el nibble superior con cada comando y carácter de transferencia.
Esto sería todo del cuarto capitulo de programación en C con XC8 Compiler y MPLABX, de pronto en el vídeo tuve algunos errores, o mal pronunciamiento, pero la finalidad de este blog es corregir esto y profundizar un poco más en el tema; espero que les sirva!
Esto es todo por hoy, Sigue mi blog y visita mi próxima entrada!
NOTA: se les recuerda a los lectores que se utilizo la versión del compilador XC8 Versión 1.34 la cual trae las peripheral libraries incluidas en él; el pdf de estas lo pueden encontrar en la parte de etiquetas del blog en la etiqueta llamada Documentación.
Curso de MPLABX y XC8 #03: Manejo de Retardos [Tiempos en Led].
Bien, para iniciar con el tercer capitulo del curso de programación en C con MPLABX y el compilador XC8, les recomiendo ver los capítulos anteriores siguiendo el siguiente LINK.
Ya vistos los anteriores capítulos y una vez teniendo todos los software necesarios procederemos a explicar de que tratara esta clase.
Primero que todo hay que saber que los tiempos en programación para los microcontroladores pic son muy reducidos y dependen de un cristal para su funcionamiento, aunque en unos casos se pueda trabajar con un cristal interno, en este curso se trabajará con un cristal externo; para saber más acerca de los cristales en los microcontroladores pic visita el siguiente LINK.
Ya sabiendo que función cumple un cristal en un microcontrolador, y sabiendo que los tiempos en los micros son muy reducidos lo que vamos a hacer es crear una rutina que nos multiplique el tiempo; para programar u tiempo o retardo en un programa con XC8 se hace de la siguiente forma:
__delay_ms(X); ========> Donde X es el tiempo en milisegundos
__delay_us(X); ========> Donde X es el tiempo en microsegundos
__delaywdt_ms(X); ========> Solicita un retraso X en milisegundos
__delaywdt_us(X); ========> Solicita un retraso X en microsegundos
Bien, pero por que no hay en segundos?
Sencillo! lo que sucede es que los retardo funciona con ciclos, y cada familia de microcontroladores tiene un número máximo de ciclo que puede usar, por ejemplo:
Familia Pic16 ========> 50.462.464 ciclos
Familia Pic18 ========> 197.120 ciclos
Entonces para saber cual es el tiempo máximo que podemos utilizar en nuestro delay debemos utilizar la siguiente formula:
Tcy * Ciclos Max. = Tiempo Máximo
Donde tcy = 4*(1/FOSC).
Donde Ciclos = Varia entre las familias.
Por ejemplo si necesitamos saber cual es el tiempo máximo soportado por el pic18f2550 con un cristal de 20Mhz se haría de la siguiente forma:
Tcy = 4*(1/20)= 0.2Tcy
Ciclos = 197.120 para la familia pic18
Entonces:
Tiempo Max = 0.2 * 197.120 = 39.424 milisegundos.
Ya que sabemos esto, necesitamos una formula la cual nos sirva para hacer retardos mayores de estos 39 ms. esta formula se explicara en el siguiente vídeo tutorial.
Esto es todo por hoy, Sigue mi blog y visita mi próxima entrada!
NOTA: se les recuerda a los lectores que se utilizo la versión del compilador XC8 Versión 1.34 la cual trae las peripheral libraries incluidas en él; el pdf de estas lo pueden encontrar en la parte de etiquetas del blog en la etiqueta llamada Documentación.
Cualquier duda, trabajo, tutoria personalizada, etc por correo.
