La creación de una señal PWM Usando un PIC 16F84 Hay muchos pequeños mecanismos, en particular los servomotores, que utilizan codificación PWM como un medio de entrada. señales PWM también se pueden utilizar para variar el voltaje aplicado a un dispositivo mediante la consecución de una tensión media efectiva. Con tantas aplicaciones, por lo tanto, es necesario contar con un medio confiable para generar una señal PWM.
MOTIVACIÓN Y PÚBLICO El objetivo de este tutorial es demostrar un método para generar una señal PWM utilizando un PIC 16F84. Este tutorial le enseñará:
¿Qué es una señal PWM. Cómo escribir código para generar una señal PWM utilizando un PIC 16F84. Para ello, se supone que ya:
Han completado "una vía rápida a la programación del PIC" . El resto del tutorial se presenta de la siguiente manera:
Lista de piezas y fuentes Fondo Programación aplicaciones Ultimas palabras LISTA DE PIEZAS Y FUENTES Con el fin de completar este tutorial debe tener el circuito desde el tutorial "una vía rápida a la programación del PIC" (menos los interruptores DIP y los circuitos
de resistencia LED). Este circuito será la única parte requerida para este tutorial. También necesitará un adaptador de corriente y el acceso a un osciloscopio para observar la señal.
FONDO
Figura 1 Una señal PWM es simplemente un impulso de longitud variable, en efecto, una onda rectangular. Esto se ilustra en la Figura 1, que también muestra cómo un servo puede reaccionar a diferentes entradas PWM. Para nuestro circuito, la tensión máxima será emitida +5 V CC, y la mínima será 0 V CC. La longitud del impulso generado es algunas veces charcterized por un ciclo de trabajo. El ciclo de trabajo es el porcentaje de la señal que la salida permanece alta. Por ejemplo, una constante de + 5V sería equivalente a un ciclo de trabajo del 100%. Una salida de onda cuadrada típica de un generador de funciones tiene un ciclo de trabajo del 50%. 0 V correspondería a un ciclo de trabajo 0%.
PROGRAMACIÓN PWM.asm ; ; ; ; ;
ARCHIVO: PWM.asm AUTH: Keith Sevcik FECHA: 5/21/03 DESC: Este programa genera una forma de onda PWM. NOTA: Probado en PIC16F84-04 / P
; --------------------------------------------------------------------; equipara la CPU (mapa de memoria) Lista P = 16F84 hexagonal radix ; ---------------------------------------------------------------------
PORTB equ 0x06; b equivale puerto 0x0c equ deber; longitud del ciclo de trabajo temp 0x0D equ; longitud del ciclo de trabajo ; -------------------------------------------------------------------c equ 0;
bit de estado para comprobar después de la sustracción
; -------------------------------------------------------------------org 0x000 movlw 0x00; carga W con 0x00 hacer salida del puerto B PORTB tris; copiar de triple W a las salidas del puerto B movlw 0x00; w llenar con ceros PORTB movwf; Configure el puerto b salidas a la baja Rstrt movlw d'0 ' movwf PORTB movlw d'157 '; Deber duración del ciclo deber movwf b0loop deber MOVF, w temp movwf PORTB BSF, 0 PWMA nop nop nop nop nop nop nop nop nop nop nop nop temp DECFSZ Goto PWMA movlw d'255 ' temp movwf deber MOVF, w temp SUBWF, f PORTB millones de pies cúbicos, 0 nop pwmb nop nop nop nop nop nop nop nop nop nop nop
temp DECFSZ pwmb Goto Goto Rstrt ; --------------------------------------------------------------------fin ; --------------------------------------------------------------------; en el tiempo de combustión, seleccione: ; memoria uprotected ; temporizador de vigilancia desactivado ; cristal estándar (4 MHz) ; power-up Timer On
Encabezado y equivale La primera parte del código es el encabezado y el registro equivale. Para obtener más información sobre el significado de la cabecera ver el tutorial anterior. Lista P = 16F84 hexagonal radix ; --------------------------------------------------------------------PORTB equ 0x06; b equivale puerto 0x0c equ deber; longitud del ciclo de trabajo temp 0x0D equ; longitud del ciclo de trabajo ; -------------------------------------------------------------------c equ 0;
bit de estado para comprobar después de la sustracción
; -------------------------------------------------------------------org 0x000
La única equate de signifficance aquí es PWM. Este registro se utiliza para almacenar la longitud de la señal PWM se genere. INSTRUCCIONES La siguiente porción de código contiene las instrucciones reales que cuentan la PIC qué hacer.
iniciar movlw PORTB movlw PORTB
0x00; carga W con 0x00 hacer salida del puerto B tris; copiar de triple W a las salidas del puerto B 0x00; w llenar con ceros movwf; Configure el puerto b salidas a la baja
Estas líneas configurar el puerto B como salidas. Todas las salidas se establecen a continuación, a la baja. Rstrt movlw d'0 ' movwf PORTB movlw d'157 '; deber movwf
Deber duración del ciclo
Después de configurar los puertos, se inicia el bucle principal. Al comienzo del bucle principal, todos los pines del puerto B se ajustan a la baja sólo en caso de que son altos cuando no deberían ser. El ciclo de trabajo se ajusta entonces a 157 (un ciclo de trabajo del 50%. 255 corresponde a 100% y el 0 corresponde a 0%). b0loop deber MOVF, w temp movwf PORTB BSF, 0 PWMA nop nop nop nop nop nop nop nop nop nop nop nop temp DECFSZ Goto PWMA
El siguiente fragmento de código es el bucle para la señal PWM generada con B0 pasador. El bucle pwm1a genera la parte alta de la señal PWM. El ciclo de trabajo se almacena en la temperatura y luego el pasador está en lo alto. después de una pausa, la temperatura se reduce y en tanto que es imposible llegar a cero la pausa se repite y la temperatura se reduce de nuevo. Después de temp llega a cero, el código continúa. movlw d'255 ' temp movwf deber MOVF, w
temp SUBWF, f PORTB millones de pies cúbicos, 0 nop pwmb nop nop nop nop nop nop nop nop nop nop nop temp DECFSZ pwmb Goto Goto Rstrt
La siguiente parte del código genera la parte baja de la señal PWM. El valor 255 se almacena en temp, y el ciclo de trabajo se resta de este. Esto le da a la longitud restante de la señal que se genera.Temperatura se decrementa entonces de la misma manera que antes, esta vez con el conjunto de B0 a bajo. Una vez que se ha generado toda la señal PWM, el código se repite. Este código hace que una señal de PWM para ser generado con un ciclo de trabajo proporcional a el conjunto de valores. La frecuencia de la señal también se puede ajustar mediante la variación del retardo (el número de nop de utilizado).
APLICACIONES Una aplicación común de las señales de PWM es control del motor. Al variar el ciclo de trabajo de una señal PWM enviado a un motor, se puede variar la potencia efectiva de la señal y por lo tanto reducir la velocidad del motor o acelerar el motor hasta dependiendo de la duración de un pulso se envía al motor. La señal generada por el PIC no se puede conectar directamente al motor, sin embargo, debido a que el PIC es incapaz de manejar la potencia requerida por el motor. Por tanto, es necesario utilizar un transistor para regular el flujo de corriente al motor. Un transistor es como un interruptor eléctrico. Cuando se envía un estado lógico alto (+ 5V) para el transistor, que permite que la corriente fluya. Cuando se envía un lógico bajo (0 V), que restringe el flujo de corriente. Para las señales digitales, esto significa que la señal puede ser reproducido con exactitud, excepto la nueva señal se escala hasta una corriente mucho más grande. La figura 2 muestra un esquema de control de un motor utilizando un transistor NPN TIP31.
Figura 2 Como muestra el esquemáticas, la salida de la recogida está conectado a la base. El terminal negativo del motor se conecta a la base y el colector está conectado a tierra. Cuando el PWM otuput de la PIC se envía al transistor, se le dará la vuelta al transistor encendido y apagado y posteriormente generar la misma señal PWM al motor, lo que permite controlar el motor con una señal PWM.
ULTIMAS PALABRAS Después de completar esta guía debe estar familiarizado con las señales PWM y cómo programar un PIC 16F84 para generarlos. Si tiene alguna pregunta acerca de este tutorial que me puede enviar por correo electrónico a
[email protected] . http://www.pages.drexel.edu/~kws23/tutorials/PWM/PWM.html
Fast Track a la programación del PIC
Usted puede saber que cuando se trata de máquinas, la programación se utiliza a menudo para indicar a la máquina cómo interactuar con su mundo. Pero alguna vez se preguntó cómo se implementa realmente físicamente esta programación? Una forma es utilizar las fotografías (controladores programables de interrupción). Estos chips permiten escribir código que lee las señales de entrada, realiza funciones y envía señales a las salidas basándose en las condiciones que se definan. Este tutorial se explica el proceso básico de la escritura de programas para las fotos y "quema" esos programas en el dispositivo.
MOTIVACIÓN Y PÚBLICO El objetivo de este tutorial es conseguir rápidamente familiarizado con los PIC para que pueda empezar a utilizarlos en sus aplicaciones. Como tal, este tutorial te enseñará cómo:
Escribir código para definir salidas. Escribir código para leer las entradas y el uso de dichos insumos para afectar a las salidas.
Escribir código para reaccionar a un ciclo de reloj. "Burn" código en el dispositivo. Para ello, se supone que usted ya sabe cómo:
Leer un esquema eléctrico. Construir y soldar un circuito eléctrico sobre una placa de prototipos.
El resto del tutorial se presenta de la siguiente manera:
Lista de piezas y fuentes Construcción Programación "Burning" código en un PIC
Ultimas palabras LISTA DE PIEZAS Y FUENTES
Se requerirá la mayoría de las piezas para construir un circuito para probar sus programas en. Las piezas que se indican en la Tabla 1 son los consumibles utilizados en el circuito: TABLA 1 PARTE DESCRIPCIÓN
VENDEDO PARTE PRECIO (2002) R
PIC16F84-04 / P
Jameco
145.1 5.95 11
1
40-PIN ZIF
Jameco
10402 10.95 9
1
Interruptor pulsador
Jameco
71642 1.49
1
8-POSICION DIP
Jameco
38842 0,79
1
4 MHz Reloj de cristal OSCILLATOR Jameco
27967 1.89
1
0,1 UF PAC
Jameco
15111 1.00 PARA 6 BOLSA DE 10
1
0.1 ENCABEZADOS PULGADAS
Jameco
160.8 0.39 81
1
SIPP 30-PIN SOCKET WIREWRAP
Jameco
104.0 1.95 53
1
T1-3 / 4 LED VERDE
Jameco
104.2 0.29 56
1
CANT
100 ohmios
1
RESISTENCIA 10 kilos OHM
1
220 ohmios
9
RESISTENCIA 3.3 KILO OHM
8
JUNTA DE 6 PULGADAS PROTOTIPADO CIRCUITO
RADIO SHACK
276170
2.99
1
2-3 / 4 x 3-3 / 4 PROTOTIPADO CIRCUITOS
RADIO SHACK
276158
2.39
1
El PIC vamos a utilizar (PIC16F84) fue elegido porque es un PIC muy común y porque puede ser programado y reprogramado sin hardware adicional (muchos PIC debe ser expuesto a la luz UV para borrar los programas existentes). Para construir el circuito, también necesitará:
un soldador con una punta fina materiales para soldadura (soldadura, flujo, etc.) alambre de calibre pequeño pelacables multímetro Fuente de alimentación DC Los elementos enumerados por encima de todo se pueden comprar en una tienda de electrónica como Radio Shack. Algunos dispositivos de hardware tales como Home Depot llevar herramientas como pelacables y multímetros. Hay muchas utilidades para escribir, compilar y quemar código PIC. En este tutorial se utiliza el siguiente software / hardware para programar el PIC:
MPLAB para Windows (Microchip) Programador de dispositivos PICSTART Plus El software MPLAB contiene el editor de texto, compilador (MPASM) y el software programador de dispositivos (PICSTART Plus) en un solo programa, centralizando así todas sus necesidades de programación del PIC. El libro Fácil Pic'n por David Benson es
también un recurso muy valioso en el aprendizaje de cómo utilizar los PIC. En este tutorial se refiere al libro para aclarar una parte del código. CONSTRUCCIÓN El circuito utilizado para probar los programas PIC se representa en la figura 1.
Figura 1
Este circuito está configurado para probar y mostrar las funciones básicas del CFP. En este tutorial, Puerto B en el PIC (prendedores 6- 13) se utiliza como una salida. Los LED están conectados a todos los 8 de las líneas del puerto B, y se iluminarán cuando la línea se establece en un nivel lógico alto o "1". Port A (patillas 17, 18, 1, 2 y 3) se utiliza como una entrada. Sus líneas están conectadas a los interruptores DIP, que fijará la línea a un lógico alto cuando el interruptor está en la posición "On". Se recomienda que los circuitos LED y el interruptor dip ser construidos sobre una tabla separada y conectados al PIC a través de un cable. Esto le permite construir circuitos más complicados en el futuro y cambiar fácilmente entre los circuitos. Un ZIF (fuerza de inserción cero) toma se utiliza para hacer la instalación y retirada repetidas de la PIC fácil, y para ayudar a prevenir las patillas de la PIC se dañe.
PROGRAMACIÓN Lo que sigue son unos pocos códigos de ejemplo que ilustran la funcionalidad del PIC. En cada caso, se le dará el código, seguido de una explicación de cómo funciona el código.
Ejemplo 1: Dar salida a los LEDs En este ejemplo aprenderá cómo definir pines como salida y cómo configurar los pines a una lógica alta o baja lógica. El siguiente código establece pasadores correspondientes a B0, B2, B4, B6 a un lógico bajo y botones correspondientes a B1, B3, B5, B7 a una cadena lógica. outLed.asm ; ; ; ; ; ;
ARCHIVO: outLed.asm AUTH: (Su nombre aquí) FECHA: (fecha) DESC: Hace B0, B2, B4, B6 y B1 baja, B3, B5, B7 hi NOTA: Probado en PIC16F84-04 / P. Refs: Fácil Pic'n p. 23 (Predko p. 173 es falsa?) Lista P = 16F84 hexagonal radix
; --------------------------------------------------------------------; equipara la CPU (mapa de memoria) myPortB equ 0x06; (p. 10 define la dirección del puerto) ; --------------------------------------------------------------------org 0x000 iniciar movlw 0x00; carga W con 0x00 hacer salida del puerto B (p. 45) tris myPortB; copia de triple W, salidas del puerto B (p. 58) b'10101010 movlw '; carga W con el patrón de bits (pág. 45) movwf myPortB; myPortB carga con el contenido de W (p. 45) Goto círculo círculo;
hecho
fin ; --------------------------------------------------------------------; en el tiempo de combustión, seleccione: ; memoria uprotected ; temporizador de vigilancia desactivado ; cristal estándar (4 MHz) ; power-up Timer On
Al evaluar el código de seguridad, en primer lugar, es importante darse cuenta de que todo lo que después de un punto y coma es un comentario y es ignorado por el compilador. El código real utilizado por el compilador para programar el PIC se muestra a continuación: Lista P = 16F84 hexagonal radix myPortB equ 0x06 org 0x000 iniciar movlw 0x00 tris myPortB b'10101010 movlw ' movwf myPortB Goto círculo círculo fin
ENCABEZAMIENTO La primera parte del código se llama la cabecera. Esta información ayuda al compilador para formatear el código correctamente. En nuestro caso, cada cabecera será idéntico. La primera línea Lista p = 16F84
describe el tipo de dispositivo que el programa se va a grabar a. La línea hexagonal radix
le dice al compilador qué números están en formato menos que se especifique lo contrario. En este caso, el formato es hexadecimal. equivale La siguiente sección del programa se llama los equipara. Esto es similar a la declaración de variables en otros lenguajes de programación. Las etiquetas se asignan a las direcciones. Más tarde, cada vez que la etiqueta se hace referencia en el programa, el compilador busca su dirección. La línea
PORTB equ 0x06
cesionarios 'PORTB' en el registro de archivo que se encuentra en el 0x06. Puerto B se encuentra siempre en este registro de archivos. ORG En la linea org 0x000
org es sinónimo de origen. La función org tiene algunos usos especiales, pero este tutorial sólo se utiliza la sentencia org como se muestra. Cuando se utiliza de esta manera, la declaración org define el principio del código. INSTRUCCIONES La siguiente porción de código contiene las instrucciones reales que cuentan la PIC qué hacer. iniciar movlw 0x00
Esta línea está etiquetado como el inicio del código. La función 'movlw' mueve un literal (un número) al registro W. archivo No se puede asignar directamente los valores de presentar registros. Todos los valores deben primero pasar a través del registro W. tris myPortB
Este comando es obsoleto, aunque aún es compatible con la versión de software en uso. El comando 'tris' le dice al compilador que el valor W actual mapa de las líneas del puerto seleccionado como entradas o salidas (un '1' en W significa de entrada, un '0' en W significa salida). b'10101010 movlw '
Este comando mueve el número binario '10101010' al registro W. movwf myPortB
El contenido del registro W se asignan ahora al puerto B, el establecimiento de los pines correspondientes como de alta o baja.
Goto círculo círculo
Este comando etiquetas de la línea de código como "círculo", y luego se refiere bac a sí mismo, estableciendo así el programa en un bucle continuo. FIN Por último, el compilador se le dice que ha llegado al final del código con una declaración final. fin
Todos los programas deben tener una declaración final. Ejemplo 2: Introducción de los interruptores DIP Ahora que usted tiene los fundamentos abajo, este programa va a ilustrar cómo Introduciendo se utiliza para controlar las salidas. En este ejemplo, todos los pines en el puerto A se definen como entradas (y tiene que ser conectado a los interruptores DIP). Cuando un interruptor DIP está encendido, su valor se pasa a la salida correspondiente en el puerto B, iluminando de esta manera un LED. Dip2Led.asm ; ; ; ; ; ;
ARCHIVO: Dip2Led.asm AUTH: (Su nombre aquí) FECHA: (fecha) DESC: Leer Puerto Un interruptor DIP y la pantalla LED de puerto B NOTA: Probado en PIC16F84-04 / P. Refs: Fácil Pic'n p. 60 Lista P = 16F84 hexagonal radix
; --------------------------------------------------------------------; equipara la CPU (mapa de memoria) myPortA equ 0x05 myPortB equ 0x06; (p. 10 define la dirección del puerto) ; --------------------------------------------------------------------org 0x000 iniciar movlw 0x00; carga W con 0x00 hacer salida del puerto B (p. 45) tris myPortB; copiar de triple W a las salidas del puerto B (p. 58)
movlw 0xFF; carga W con 0xFF hacer el puerto A de entrada tris myPortA; copiar de triple W al puerto A MOVF myPortA, w; leer el puerto A DIP y almacenar en W movwf myPortB; escribir el valor W de LED del puerto B círculo Goto empezar;
bucle infinito
fin ; --------------------------------------------------------------------; en el tiempo de combustión, seleccione: ; memoria uprotected ; temporizador de vigilancia desactivado ; cristal estándar (4 MHz) ; power-up Timer On
Este código es muy similar al código anterior. Puerto B se declara como salidas de la misma manera. En este caso, el puerto A se define como entradas por el código movlw 0xFF tris myPortA
Esto llena el registro W con 1 de, y utiliza los de 1 a declarar el puerto A como entradas. En lugar de asignar un literal al puerto B, el puerto A se lee en el registro W. MOVF myPortA, w
Este comando dice mover el archivo de registro 'myPortA' en el registro W. Y como antes, el contenido del registro W se asignan a los LED en el puerto B movwf myPortB
El código a continuación, se le dice que volver al inicio y ejecutar de nuevo. Ejemplo 3: En respuesta a un ciclo de reloj Hay otra funcionalidad importante para el PIC que puede ser extremadamente útil. El PIC ha incorporado un contador cuya frecuencia depende del oscilador externo en el circuito y en ciertas opciones que haya configurado. Estas opciones, junto con los cálculos para determinar la frecuencia se explican a continuación. Clock.asm
; ; ; ; ; ; ; ; ; modo ; ;
ARCHIVO: Clock.asm AUTH: (Su nombre aquí) FECHA: (fecha) DESC: 1.0 - Temporizador interno, comenzará a parpadear cada 32,8 ms NOTA: Probado en PIC16F84-04 / P. 4 rendimientos de cristal MHz 1 MHz de frecuencia de reloj interno. "opción" está configurado para dividir el reloj interno por 256. Esto da lugar a 1 MHz / 256 = 3906,25 Hz o 256 us. TMR0 bits de 0 a 7 se comprueba (255 decimal), produciendo de este Bucle de retardo 255 * 256 us = 65,28 ms Refs: Fácil Pic'n p. 113 Lista P = 16F84 hexagonal radix
; --------------------------------------------------------------------; equipara la CPU (mapa de memoria) PORTB equ 0x06; (p. 10 define la dirección del puerto) Timer0 equ 0x01 ; --------------------------------------------------------------------org 0x000 iniciar CLRWDT; temporizador de vigilancia clara b'11010111 movlw '; asignar pre-escalador, el reloj interno ; y dividir por 256 véase p. 106 opción movlw 0x00; set w = 0 tris PORTB; el puerto B se emite clrf PORTB; el puerto B todos bajos ir BSF PORTB, 0; RB0 = 1, el LED de este modo en la p. 28 retardo de llamada retardo de llamada BCF PORTB, 0; RB0 = 0, por lo tanto LED apagado retardo de llamada retardo de llamada ir a ir ; repetir para siempre retrasar Timer0 clrf; clara Timer0, se inicia el recuento nuevo BTFSS Timer0, 0; si el bit 0 = 1 Ir de nuevo; no, entonces puedes volver a intentarlo BTFSS Timer0, 1; si el bit 1 = 1 Ir de nuevo; no, entonces puedes volver a intentarlo BTFSS Timer0, 2; si el bit 2 = 1 Ir de nuevo; no, entonces puedes volver a intentarlo BTFSS Timer0, 3; si el bit 3 = 1 Ir de nuevo; no, entonces puedes volver a intentarlo BTFSS Timer0, 4; si el bit 4 = 1 Ir de nuevo; no, entonces puedes volver a intentarlo BTFSS Timer0, 5; si el bit 5 = 1 Ir de nuevo; no, entonces puedes volver a intentarlo BTFSS Timer0, 6; si el bit 6 = 1 Ir de nuevo; no, entonces puedes volver a intentarlo BTFSS Timer0, 7; si el bit 7 = 1 Ir de nuevo; no, entonces puedes volver a intentarlo
regreso ;
tiempo de salida demás
fin ; --------------------------------------------------------------------; en el tiempo de combustión, seleccione: ; memoria uprotected ; temporizador de vigilancia desactivado ; cristal estándar (4 MHz) ; power-up Timer On
Lo primero que destaca de este código es un nuevo equate Timer0 equ 0x01
Esta es una de 8 bits, contador de lectura / escritura se almacena a este registro de archivo en particular. En nuestro caso, la frecuencia de reloj interna es 1 MHz (frecuencia externa se divide por 4). Esta frecuencia se puede dividir aún más mediante el establecimiento de un valor pre-escalador (el valor de la frecuencia interna será dividido por). Sobre la base de la configuración de 3 bits de opción, el valor pre-escalador se puede variar entre 8 valores que van de 1 a 256. En nuestro caso, se establecen los 3 bits de opciones, que divide la frecuencia del reloj interno por 256. Esto da la frecuencia del contador a ser de 1 MHz / 256 = 3906,25 Hz. El siguiente comando iniciar CLRWDT
Despeja el temporizador de vigilancia y el valor pre-escalador. Los siguientes comandos b'11010111 movlw ' opción
establecer los bits de opciones. El significado de los bits de opciones son las siguientes: Propósito bits 0 Valor de divisor 1 Valor de divisor 2 Valor de divisor 3 de divisor Asignación (0 = Timer0, 1 = temporizador de vigilancia) 4 Timer0 reloj borde externo seleccionar (0 = ascendente, 1 = cayendo) 5 Timer0 fuente de reloj (0 = ciclo de instrucción interna, 1 = externo) borde 6 de interrupción de selección (0 = caída, 1 = aumento) 7 Puerto B Pullup Enable (0 = habilitado, 1 = deshabilitado)
Como se puede ver, en este código, los bits de divisor se establecen en 111 (dividir por 256), pre-escalador se envía al Timer0, incrementos TMR0 en el flanco de subida, la fuente Timer0 es el reloj de ciclo de instrucción interna, las interrupciones se producen en los flancos ascendentes y Puerto B pull-ups están desactivados.
Procediendo a través del código, la siguiente parte define el puerto B como salidas, como se ha visto en los ejemplos anteriores. El código siguiente que es la carne de este programa. ir BSF PORTB, 0 retardo de retardo de bcf PORTB, retardo de retardo de ir a ir
llamada llamada 0 llamada llamada
Este bucle se convierte en un LED de vez en cuando en repetidas ocasiones. En primer lugar, el bit 0 en el puerto B está establecido (hecha a hi lógico). Una subrutina de retardo se denomina a continuación (explicado más adelante) para hacer una pausa en el programa durante un rato. se borra entonces el bit 0 (hecho a menor lógico). El programa se retrasa una vez más, y luego el proceso se repite. El nuevo concepto que se presenta es la de una subrutina retardo clrf TMR0 nuevo BTFSS Timer0, 0 Goto nuevo BTFSS Timer0, Goto nuevo BTFSS Timer0, Goto nuevo BTFSS Timer0, Goto nuevo BTFSS Timer0, Goto nuevo BTFSS Timer0, Goto nuevo BTFSS Timer0, Goto nuevo BTFSS Timer0, Goto nuevo regreso
1 2 3 4 5 6 7
Cuando se llama retardo, el programa salta a esta parte del código. TMR0 (el contador) se borra primero (y luego empieza a contar). El código restante pone a prueba cada bit en Timer0 para ver si se ajusta a hi. Si no es así, vuelve al 'nuevo'. Si se establece a alta, se salta la siguiente línea de código ( "Ir de nuevo") y los testículos el siguiente bit. Este bucle continúa hasta que se alcanza la instrucción de retorno, en cuyo caso la subrutina se sale y el código de producto de que cualquier demora se llamó originalmente. Como puede verse, la subrutina de retardo continuará hasta que todos los bits iguales TMR0 '1', o hasta que los recuentos de TMR0 a 255.
CÓDIGO "quemar" en un PIC
Ahora que ya sabe cómo escribir código, lo que necesita saber cómo obtener el código en el PIC. El proceso de programación de un PIC se refiere a menudo como "quemado". Para grabar el código en el PIC, vamos a utilizar la versión para Windows de MPLAB. En el programa MPLAB, toda la información acerca de su programa se almacena en unos archivos de proyecto. Los archivos de proyecto contienen información sobre el programa, el dispositivo que está utilizando, uno o más códigos de lenguaje ensamblador y los archivos compilados hexagonales. El proceso de grabación de un PIC contiene tres pasos principales. La primera es que escribir el código en lenguaje ensamblador. Una vez que el código está escrito, debe ser compilado en un archivo hexadecimal para la programación en el dispositivo. Después de compilar el código correctamente, el último paso es programar el dispositivo. Comience por abrir el programa MPLAB. Crear un nuevo proyecto por ir a Project> Nuevo proyecto. En el nuevo cuadro de diálogo proyecto seleccionar un directorio para colocar el proyecto y dar al nuevo proyecto un nombre. Cuando haya terminado, haga clic en "Aceptar". Ahora verá el cuadro de diálogo Editar Proyecto. Seleccione el dispositivo apropiado, y establecer el modo de desarrollo de MPLAB-SIM Simulador. En la ventana de archivos de proyecto haga clic en el archivo que tiene el nombre de su archivo con la extensión .hex. Haga clic en el botón Propiedades de nodos y en la ventana que aparece, haga clic en "Aceptar". Esto establece las propiedades del nodo por defecto y le permite añadir nodos más tarde. Salir del cuadro Editar propiedades haciendo clic en "Aceptar". Ahora usted puede crear código ensamblador. Conseguido a Archivo> Nuevo. Un editor de cuadros de texto en blanco debería aparecer. Introduce el código de ensamblado en esta ventana. Cuando haya terminado, guarde el código (Archivo> Guardar, dar el código de un nombre y haga clic en "Aceptar"). Ahora debe asignar el código fuente que acaba de hacer con el proyecto. Ir al proyecto> Editar Proyecto. En el cuadro de diálogo Editar proyecto, haga clic en el botón Añadir nodo. Busque el código de montaje que acaba de encontrar. Seleccionarlo y hacer clic en "Aceptar". El nombre de archivo del código ensamblador debe aparecer ahora en la ventana. Haga clic en "Aceptar" para cerrar el cuadro de edición del proyecto.
Ahora que el código fuente está asociada con el proyecto, es hora de compilar el código. Ir a Proyecto> Proyecto. Si la compilación tiene éxito, verá la ventana de generación resultados aparecen con el mensaje "Construcción completada con éxito". Si hubo errores que se muestran en la ventana. Después de compilar con éxito, guardar el proyecto (Proyecto> Guardar proyecto). El paso final es para programar el dispositivo. Seleccionar PICSTART Plus> Activar programador. El cuadro de diálogo Programador de estado debería aparecer. En este punto, usted debe tener el programador de dispositivos PICSTART Plus enchufado y TH cable serie conectado al puerto serie del ordenador. Coloque el PIC en el zócalo ZIF con la pata 1 en la esquina superior izquierda, y bloquearlo en su sitio. La parte más importante de este paso es asegurar la configuración de bits se establecen de manera apropiada. Si se han fijado, al final de cada código de ejemplo fue una nota que indica cómo se deben establecer los bits de configuración ; ; ; ; ;
en el tiempo de combustión, seleccione: memoria uprotected temporizador de vigilancia desactivado cristal estándar (4 MHz) power-up Timer On
temporizador de vigilancia se debe establecer en "off", el oscilador debe estar ajustado a "XT" (este es el escenario de cristal estándar), la configuración de la memoria debe establecerse en y el temporizador del encendido "off" se debe establecer en "on". Cuando los bits de configuración están configurados correctamente, haga clic en "Programa" y esperar a que el programador para finalizar. Si el programador se realiza correctamente, el código se encuentra ahora en el PIC. ULTIMAS PALABRAS
Después de completar este tutorial serás capaz de programa de un PIC para enviar salidas, leer las entradas, y crear funciones usando un reloj. Después de crear un programa en código ensamblador, usted debería ser capaz de grabar ese programa en el dispositivo para su uso en su aplicación. Los conceptos que se muestran aquí se presentan en situaciones relativamente triviales. Sin embargo, estos conceptos son fundamentales para el uso del PIC para aplicaciones más grandes y complejas.
Si tiene alguna pregunta acerca de este tutorial que me puede enviar por correo electrónico a
[email protected] . Feliz PIC'n!
