Los microcontroladores PIC son una herramienta muy útil y versátil para usar en muchos proyectos electrónicos. Son muy económicos y fáciles de encontrar. También son muy potentes y muchos son capaces de alcanzar velocidades de hasta 64 MIPS utilizando el bloque oscilador interno, aproximadamente 16 veces más rápido que la mayoría de los microcontroladores AVR comparables. Los PIC también son fáciles de programar, sin embargo, configurar el proyecto a veces puede ser complicado. Estas instrucciones lo guiarán a través del proceso de configuración del software, la creación de un nuevo proyecto y la programación de algunas funciones muy simples para probar la configuración y garantizar que todo funcione. Están diseñados para ser muy abiertos; Una vez creado el proyecto y finalizado lo básico, se recomienda al lector que explore todas las funciones y extras que no se incluyen en estas instrucciones. También encontrará que estas instrucciones comenzarán a caminar paso a paso, pero a medida que las instrucciones se acerquen al final, se alienta al lector a explorar otras formas de llevar a cabo las tareas y hacer que el proyecto sea suyo.

Lo que necesitará Para construir un proyecto con un microcontrolador PIC solo se requieren algunos elementos.

• Microcontrolador PIC
  • Estas instrucciones son para programar una MCU de la serie PIC18F, aunque otras son similares.
  • Obtenido del sitio web de Microchips.
  • ¡Microchip permite a los estudiantes con direcciones de correo electrónico .edu válidas muestras de PIC gratis!
  • El PIC que estoy usando para crear estas instrucciones es un PIC18F22K80
• PICkit 3 depurador en circuito
  • Disponible de Microchip.
  • Cuesta $ 45 para el público en general, y # 34 con descuento para estudiantes si tiene una dirección de correo electrónico .edu.
  • También hay otros programadores que funcionarán igual de bien; Sin embargo, este es el mejor para comenzar.
• Pan y alambres de tablero
• LED, botones, potenciómetros o cualquier otra cosa que desee conectar al PIC

Paso 1: construir hardware

Antes de hacer cualquier programación, el primer paso es construir el hardware. Aunque la cartera PIC18F es muy grande, muchos de los chips tienen varios puntos en común. Para obtener información más detallada, consulte la sección "Directrices para comenzar a utilizar los microcontroladores PIC18Fxxxx" en la hoja de datos de sus dispositivos. Para obtener información detallada sobre los pines del microcontrolador PIC, consulte la sección "Diagrama de pines" en la hoja de datos de sus dispositivos.

Nota: VDD = Voltaje positivo y VSS = Tierra.

1. Conecte el pin MCLR a través de una resistencia de 1kΩ a VDD.
2. Conecte un condensador de 0.1μF entre cada par de pares VDD-VSS contiguos o pares AVDD-AVSS.
3. Conecte un condensador de 10 μF entre VCAP y Vss.
4. Conecte el pin MCLR al pin 1 del PICkit 3.
5. Conecte VDD al pin 2 del PICkit 3.
6. Conecte VSS al pin 3 del PICkit 3.
7. Conecte el pin PGD al pin 4 del PICkit 3.
8. Conecte el pin PGC al pin 5 del PICkit 3.
9. Deje el pin 6 del PICkit 3 sin conectar.
10. Conecte cualquier entrada analógica a los pines con funcionalidad ANx donde x es un número.
11. Conecte cualquier entrada o salida digital a los pines con funcionalidad Rxy donde x es una letra que identifica el puerto e y es un número que identifica el bit.

Para mi ejemplo, tengo un LED conectado entre RA0 y tierra, el limpiador de un potenciómetro conectado a AN1 y un interruptor DPST conectado a RA2. Puede que le resulte más fácil programar el PIC si ha esbozado un esquema de su circuito.

Paso 2: Obtenga software

Estas instrucciones utilizarán el compilador XC8 y MPLAB X IDE de Microchip. Este paso explicará cómo obtener estas herramientas y garantizar que se hayan instalado correctamente.

1. Para obtener la última versión del software, visite el sitio web de Microchips en //www.microchip.com/pagehandler/en-us/family/mplabx/
2. Seleccione el software para su sistema operativo y siga las instrucciones de instalación estándar.

Nota: Si está utilizando Windows 8, es posible que deba ejecutar los instaladores en modo de compatibilidad para Windows 7.

3. Una vez que el software esté instalado, inicie MPLAB X
4. En la barra de menú, seleccione Herramientas-> Opciones
5. En el cuadro de diálogo Opciones, seleccione la pestaña Integrado y asegúrese de que XC8 aparezca en la lista de la Cadena de herramientas.
6. Si aparece en la lista, seleccione Aceptar y continúe con el siguiente paso.
7. Si no aparece en la lista, asegúrese de que la instilación se haya completado y haga clic en el botón Buscar herramientas de compilación.
8. Si aún no aparece en la lista, busque en el foro de Microchips para obtener ayuda con su problema específico.

Paso 3: crear un nuevo proyecto

En este paso crearemos un nuevo proyecto basado en una plantilla de Microchip.

1. En la barra de menú, seleccione Archivo-> Nuevo proyecto ...
2. En el cuadro de diálogo de archivo nuevo, expanda Muestras y seleccione Microchip Embedded
3. En el cuadro del proyecto, seleccione PIC18 C Template
4. Seleccione Siguiente
5. Dale al proyecto el nombre que quieras
6. Elija una ubicación para guardar el proyecto en el cuadro Ubicación del proyecto
7. Deje la carpeta del proyecto como opciones predeterminadas
8. Marque la casilla "Establecer como proyecto principal"
9. Seleccionar acabado

El proyecto ahora aparecerá en Project Explore en el lado izquierdo de la pantalla.

Paso 4: construir parámetros

Antes de que podamos comenzar a programar, necesitamos establecer los parámetros de compilación.
Crear configuración

1. Haga clic derecho en el nombre del proyecto en la barra de herramientas de proyectos.
2. En el cuadro de diálogo Propiedades del proyecto, seleccione Administrar configuraciones ...
3. En el cuadro de diálogo Configuraciones, seleccione Nuevo
4. En el cuadro de diálogo Nuevo nombre de configuración, ingrese Predeterminado y haga clic en Aceptar
5. En el cuadro de diálogo Configuraciones, asegúrese de que Predeterminado esté seleccionado y haga clic en Establecer activo
6. Haga clic en Aceptar en el cuadro de diálogo Configuraciones

Establecer propiedades de configuración

1. En el cuadro de diálogo Propiedades del proyecto, seleccione "Conf: [Predeterminado]" en la lista Categorías
   1. En el cuadro Dispositivo, escriba el nombre del dispositivo que está utilizando. En mi caso PIC18F26K80
   2. En la lista Herramientas de hardware, seleccione PICkit3
   3. En la cadena de herramientas del compilador, seleccione XC8 (v ...) Donde ... es la versión que ha instalado.
   4. Seleccione Aplicar
2. En Conf: [Predeterminado] seleccione PICkit 3
   1. Para las categorías de opciones, seleccione Potencia
   2. Verifique "Circuito de objetivo de potencia de PICkit3
   3. Seleccione Aplicar
3. En Conf: [Predeterminado] seleccione el compilador XC8
   1. Para las categorías de Opciones, seleccione Optimizaciones
   2. Establezca "Conjunto de optimización" en "ninguno"
   3. Seleccione Aplicar
4. Haga clic en Aceptar para cerrar el cuadro de diálogo.

Probar la configuración Para probar la configuración, haga clic en el botón limpiar y construir (el que tiene el martillo y la escoba). El texto comenzará a desplazarse en la ventana de salida en la parte inferior de la página. Si todo tiene éxito, este texto dirá CONSTRUIR CON ÉXITO (tiempo total: ...) . Si recibe un error, vuelva a este paso asegurándose de que no se haya perdido nada y de que todo se haya aplicado.

Paso 5: Establecer bits de configuración

El siguiente paso es configurar los bits de configuración. Los bits de configuración le indican a la MCU sus condiciones iniciales para cuando se enciende. Se utilizan para configurar la fuente y la velocidad del reloj, la configuración del tiempo de vigilancia y otras características similares. Los bits de configuración dependen del dispositivo, por lo que debe consultar la hoja de datos del chip que está utilizando para obtener más información.

1. En el explorador de proyectos, expanda Archivos fuente y abra configuration_bits.c
2. Elimine todo el texto debajo de la línea #endif
3. Observe que se abrió una nueva pestaña en la parte inferior de la pantalla
4. Establezca los bits según sea necesario para su proyecto. Dado que estos dependen del chip, consulte la hoja de datos para obtener más información sobre lo que hace cada uno. Siguen algunas configuraciones comunes:
   1. Conjunto de instrucciones extendido: se debe establecer en OFF cuando se usa la plantilla
   2. Oscilador: se utiliza para seleccionar el procesador. A menos que esté utilizando un cristal externo, déjelo configurado como oscilador RC interno. Consulte la hoja de datos para otras configuraciones de oscilador. Nota: CLKOUT permitirá una depuración más fácil y debe activarse si está disponible.
   3. Habilitar PLL: permitirá el uso futuro de PLL. Nota: esto no activará el PLL, solo lo habilitará. Se recomienda habilitarlo.
   4. Temporizador de vigilancia: el temporizador de vigilancia se utiliza para garantizar que el procesador no se bloquee. Sin embargo, hace que sea mucho más difícil de depurar. Se recomienda deshabilitarlo mientras se programa inicialmente, y solo habilitarlo después de que el proyecto esté casi terminado.
   5. Protección de escritura / lectura de código / tabla: se utiliza para deshabilitar la escritura o lectura en ciertos rangos de memoria. Deje todo esto deshabilitado.
   6. Si no está seguro acerca de una configuración, generalmente es seguro dejarla predeterminada.
5. Una vez que se hayan establecido todos los bits de configuración, haga clic en el botón "Generar código fuente a salida" en la parte inferior del panel.
6. El panel ahora cambiará a la pestaña Salida. Seleccione todo el texto en esta pestaña y cópielo en el portapapeles
7. Pegarlo en la parte inferior del archivo configuration_bits.c y guardar pres.
8. Limpie y vuelva a construir el proyecto haciendo clic en el icono de la escoba y el martillo.
9. Asegúrese de que la compilación haya sido exitosa. Compruebe también para asegurarse de que no haya errores en la salida

Si todo ha funcionado, pase al siguiente paso. Si hay errores o advertencias, corríjalos antes de continuar.

Paso 6: configurar el oscilador

El siguiente paso es comenzar a programar; sin embargo, antes de llegar al código de la aplicación, debemos programar el código del sistema. El código del sistema son las funciones de bajo nivel, como la configuración del oscilador y las funciones básicas de retardo.

Determinando la configuración

Antes de que podamos programar la configuración, debemos elegir a qué velocidad nos gustaría correr. Para este ejemplo, usaré 16MHz ya que la mayoría de los PIC pueden funcionar a esta velocidad. Para mi configuración, usaré el post-llamador de 4MHz del HF-INTOSC, y el 4x PLL que da una frecuencia de salida de 4MHz * 4x = 16MHz

1. En la hoja de datos, busque la sección denominada Configuraciones del oscilador
2. Lo primero que se enumera en esta sección es Tipos de osciladores. Si está utilizando el oscilador interno, utilice las configuraciones relacionadas con INTIO1
3. En la página o dos siguientes encontrará un dibujo esquemático del oscilador similar al que se muestra. Es útil rastrear la señal en este dibujo para garantizar que se seleccione la velocidad correcta.
4. El siguiente paso es programar estas configuraciones en la MCU. Esto se hace estableciendo registros. El primer registro para establecer es OSCCON.
   1. IDLEN: se utiliza para controlar la acción del comando de suspensión. Se puede dejar como predeterminado.
   2. IRCF - Selección del oscilador. Como estoy usando HF-INTOSC / 4 (4MHz), tendré que configurar esto en un valor binario de 101
   3. OSTS: bit de solo lectura
   4. HFIOFS: bit de solo lectura
   5. SCS - bits de selección de reloj. Como estoy usando el oscilador interno, estableceré 1x donde x puede ser 0 o 1
5. El siguiente registro es OSCCON2; sin embargo, este registro es principalmente de solo lectura y no es importante en este momento
6. El último registro de configuración del oscilador es OSCTUNE. No ajustaremos la frecuencia de este proyecto, sin embargo, debemos usar este registro para activar el PLL usando el bit PLLEN.

Aplicando Configuraciones

1. Regresar a MPLAB
2. En el explorador de proyectos en Archivos fuente, abra system.c
3. En la parte inferior de este archivo está la función ConfigureOscillator. Elimine los comentarios en esa función.
4. Para establecer los bits de un tipo de registro en mayúsculas, el nombre del registro, seguido de los bits de palabras en minúscula y luego un punto y el nombre del bit.
5. Para establecer los bits, siga eso con un signo igual. Para usar el tipo binario 0bXXXX donde XXXX es el número binario. Por último, termina la línea con un punto y coma.
6. Establezca todos los bits como se determinó anteriormente para el registro OSCCON. Ejemplo: OSCCONbits.IRCF = 0b101;
7. Haga lo mismo para todos los demás registros de oscilador necesarios. Vea a continuación un ejemplo de una función ConfigureOscillator finalizada.
8. Cuando termine de compilar y verifique si hay advertencias / errores

 / ** * Configure la fuente del reloj y la velocidad * / void ConfigureOscillator (void) {OSCCONbits. IRCF = 0b101; OSCCONbits. SCS = 0b00; OSCTUNEbits. PLENO = 0b1; } 

Paso 7: espera la función de milisegundos

Una de las funciones más útiles es wait_ms. Sin embargo, esta no es una función en la biblioteca estándar y deberá ser programada por usted. Para esta implementación, habrá un bucle que mantendrá el procesador hasta que haya pasado el tiempo dado.

Los microcontroladores PIC18F necesitan 4 ciclos de reloj para ejecutar una línea de código de ensamblaje. Por lo tanto, con un reloj de 16MHz, las líneas se ejecutarán a 4 millones de líneas por segundo = 4000 líneas por milisegundo. Dado que un bucle for tomará una instrucción cada vez para la comparación, y dos para la operación uno para el cuerpo del bucle, funcionará perfectamente. Solo necesitamos el bucle for para recorrer 1000 veces por milisegundo.

1. En system.c, cree una nueva función en la parte inferior del archivo de tipo void wait_ms (uint16_t time)
2. A continuación se muestra la función completada

 / ** * Espere un número determinado de milisegundos utilizando el esquema de espera ocupada. * @param time: tiempo en ms para esperar. * / void wait_ms (uint16_t time) {static long timel = 0; timel = tiempo * 1000l; for (; timel; timel -); // sin condición inicial, mientras que el tiempo es> 0, disminuya el tiempo en cada bucle} 

1. Abra system.h en la carpeta Archivos de encabezado en el navegador del proyecto
2. Al final agregue la línea void wait_ms (uint16_t); para prototipar la función.
3. Cambie la línea 8 de 8000000L a 16000000L
4. Cree y compruebe si hay errores / advertencias

Paso 8: parpadea un LED

La mejor manera de comprobar que todo está configurado correctamente es parpadear una luz LED. Si la luz parpadea a la velocidad esperada, entonces todo se ha configurado correctamente. En este ejemplo, el LED está conectado al PUERTO A, Pin 0 (RA0 en la hoja de datos). Si tiene su LED conectado a un pin diferente, use los registros y bits apropiados.

1. Abra main.c en el visor de proyectos en archivos de origen.

La función void main (void) es el punto de entrada principal del programa. Cuando la MCU se enciende por primera vez, entrará en esta función. La primera línea llama a la función ConfigureOscillator que completó para configurar la fuente y la velocidad del reloj. La siguiente línea llama a InitApp, una función que completaremos en breve, y finalmente entra en un bucle infinito. Como no hay un sistema operativo para que la función regrese, no hay una llamada de retorno al final.
La función final debería verse así:

1. Inmediatamente encima del ciclo while agregue el siguiente código.
   1. Establezca el pin LED como salida - TRISAbits.TRISA0 = 0; // establecer un bit TRIS en 0 conjuntos como salida, establecer en 1 conjuntos como entrada
2. Dentro del bucle while agrega el siguiente código
   1. Ajuste el LED en OFF - LATAbits.LATA0 = 0; // los bits LAT controlan la salida de un pin. 0 = BAJO, 1 = ALTO
   2. Espere 1/2 segundo - wait_ms (500);
   3. Ajuste el LED en ON - LATAbits.LATA0 = 1;
   4. Espere 1/2 segundo - wait_ms (500);

 void main (void) {/ * Configure el oscilador para el dispositivo * / ConfigureOscillator (); / * Inicializar E / S y periféricos para la aplicación * / InitApp (); TRISAbits.TRISA0 = 0; // establece el pin como salida mientras que (1) {LATAbits.LATA0 = 0; // establecer pin BAJO wait_ms (500); // espera 0.5 segundos LATAbits.LATA0 = 1; // establecer pin HIGH wait_ms (500); // espera 0.5 segundos}} 

1. Cree el programa y verifique si hay errores o advertencias
2. Asegúrese de que el PICkit esté conectado correctamente al PIC y a la computadora
3. Haga clic en el botón hacer y programar dispositivo (el botón a la derecha del botón limpiar y construir)
4. Si se le solicita, seleccione PICkit 3 y haga clic en Aceptar
5. Cuando la advertencia muestra doble verificación, tiene el PIC correcto en el circuito y haga clic en Aceptar
6. Si aparece una advertencia sobre la ID del dispositivo de destino, haga clic en Aceptar para ignorarla

Paso 9: lectura de un valor analógico

Hasta ahora, el programa puede parpadear un LED. A continuación, démosle alguna entrada al usuario. Utilizaremos un potenciómetro para crear una señal analógica que cambiará la velocidad del LED. El ADC toma un voltaje analógico y genera un valor digital.

1. En el navegador de proyectos, abra user.c en Archivos de origen
2. Por encima de la función InitApp, cree una nueva función void init_adc(void)
3. Ingrese el siguiente código para inicializar el módulo ADC

 / ** * Inicializar el convertidor analógico a digital. * / void init_adc (void) {TRISAbits. TRISA1 = 0b1; // establece el pin como entrada ANCON0bits. ANSEL1 = 0b1; // establece el pin como ADCON1bits analógico. VCFG = 0b00; // establece v + referencia a Vdd ADCON1bits. VNCFG = 0b0; // establece v- referencia a GND ADCON1bits. CHSN = 0b000; // establece la entrada negativa a GND ADCON2bits. ADFM = 0b1; // justifica a la derecha la salida ADCON2bits. ACQT = 0b110; // 16 TAD ADCON2bits. ADCS = 0b101; // usa Fosc / 16 para la fuente de reloj ADCON0bits. ADON = 0b1; // enciende el ADC} 

4. Luego, cree otra función inmediatamente después de llamar a uint16_t adc_convert(uint8_t channel)

 / ** * Realice una conversión de analógico a digital. * @param channel El canal de entrada ADC a usar. * @return El valor de la conversión. * / uint16_t adc_convert (canal uint8_t) ADRESL; // devuelve el resultado 

5. En la función InitApp, agregue la línea init_adc()
6. En el archivo user.h agregue el prototipo uint16_t adc_convert(uint8_t);
7. Cambie main para que coincida con lo siguiente:

 void main (void) {uint16_t adc_value; // variable para mantener el resultado de conversión ADC en / * Configurar el oscilador para el dispositivo * / ConfigureOscillator (); / * Inicializar E / S y periféricos para la aplicación * / InitApp (); TRISAbits. TRISA0 = 0; // establece el pin como salida mientras que (1) {LATAbits. LATA0 = 0; // establecer pin BAJO adc_value = adc_convert (1); // conversión de preformas A / D en el canal 1 wait_ms (adc_value>> 2); // espera 0.5 segundos LATAbits. LATA0 = 1; // establecer pin HIGH adc_value = adc_convert (1); // conversión de preformas A / D en el canal 1 wait_ms (adc_value>> 2); // espera 0.5 segundos}} 

8. Compila y descarga el código. A medida que gira el POT, la velocidad del parpadeo del LED debe cambiar

Paso 10: lea un valor digital

A continuación, obtengamos una entrada digital desde el interruptor. Cuando el interruptor esté apagado, haremos que el programa haga lo que ha estado haciendo todo el tiempo, y cuando el interruptor esté encendido, el programa encenderá el LED fijo hasta que el interruptor se apague nuevamente.

1. Para establecer un pin como entrada, escriba un 1 en el bit de registro TRIS de los pines - TRISAbits.TRISA2 = 1;
2. Si un pin comparte características analógicas, puede ser necesario configurarlo en digital borrando el bit apropiado en el registro ANCONx
3. Al escribir un valor en un pin, use el registro LAT; sin embargo, cuando lea un valor de un pin, use el registro PORT - value = PORTAbits.RA2;
4. Cambiar principal a lo siguiente:

 void main (void) {uint16_t adc_value; // variable para mantener el resultado de conversión ADC en / * Configurar el oscilador para el dispositivo * / ConfigureOscillator (); / * Inicializar E / S y periféricos para la aplicación * / InitApp (); TRISAbits. TRISA0 = 0; // establece el pin como TRISAbits de salida. TRISA2 = 1; // establece el pin como entrada ANCON0bits. ANSEL2 = 0; // establece el pin como digital mientras que (1) {if (PORTAbits. RA2) // si el pin es alto {LATAbits. LATA0 = 1; // establece el pin como alto} else // si el pin es bajo {// parpadea los LED LATAbits. LATA0 = 0; // establecer pin BAJO adc_value = adc_convert (1); // conversión de preformas A / D en el canal 1 wait_ms (adc_value>> 2); // espera un poco de LATAbits. LATA0 = 1; // establecer pin HIGH adc_value = adc_convert (1); // conversión de preformas A / D en el canal 1 wait_ms (adc_value>> 2); // Espera algún tiempo } } } 

¡Eso es! Ahora tiene los conocimientos básicos sobre cómo configurar un nuevo proyecto, leer y escribir en pines digitales y cómo leer desde pines analógicos. Estas tres características le permitirán realizar el 90% de los proyectos utilizando PIC en Internet. Además, a medida que continúe su exploración en los microcontroladores PIC, encontrará que la mayoría de las otras características requieren pasos muy similares para configurar periféricos y leer y acceder directamente a los registros.