Comunicaión PC a 16F84A con Visual C#

[REHome]

Hola:

Quiero hacer un proyecto con un PIC 16F84A que lo controla desde el PC por el puerto serie.

C#===>PC===>RS232===>MAX232===>PIC-16F84A

Tengo un Form1, un Butto1 y un control PuertoSerie1

Si en las entradas del PIC16F84A se activa unos series de bits d entrada por ejemplo 101, en su salida del PIC muestra 0 0 0 1 1 1 ; (Configuración 5).

En resumen, quiero controlar el PIC desde el PC con el C#. Con el HyperTerminal si se puede, pero es pésimo, prefiero uno propio con C#.

Si encuentran Web con estos tema, también se lo agradezco. Gracias.

;********************************** Indexado.asm *************************************
;
; Implementar una tabla de la verdad mediante el manejo de tablas grabadas en ROM.
; Por ejemplo, la tabla será de 3 entradas y 6 salidas tal como la siguiente:
; 
; 		C  B     A  |   S5   S4   S3   S2   S1   S0
; 		-----------|---------------------------
; 		0   0   0   |   0    0    1    0    1    0	; (Configuración 0).
; 		0   0   1   |   0    0    1    0    0    1	; (Configuración 1).
; 		0   1   0   |   1    0    0    0    1    1	; (Configuración 2).
; 		0   1   1   |   0    0    1    1    1    1	; (Configuración 3).
; 		1   0   0   |   1    0    0    0    0    0	; (Configuración 4).
; 		1   0   1   |   0    0    0    1    1    1	; (Configuración 5).
; 		1   1   0   |   0    1    0    1    1    1	; (Configuración 6).
; 		1   1   1   |   1    1    1    1    1    1	; (Configuración 7).
;
; Las entradas C, B, A se conectarán a las líneas del puerto A: RA2 (C), RA1 (B) y RA0 (A).
; Las salidas se obtienen en el puerto B:
; RB5 (S5), RB4 (S4), RB3 (S3), RB2 (S2), RB1 (S1) y RB0 (S0).
;
; ZONA DE DATOS **********************************************************************

	LIST		P=16F84A
	INCLUDE		<P16F84A.INC>
	__CONFIG	_CP_OFF &  _WDT_OFF & _PWRTE_ON & _XT_OSC

; ZONA DE CÓDIGOS ********************************************************************

	ORG 	0					; El programa comienza en la dirección 0.
Inicio
	bsf		STATUS,RP0			; Acceso al Banco 1.
	clrf	TRISB				; Las líneas del Puerto B se configuran como salida.
	movlw	b'00011111'			; Las 5 líneas del Puerto A se configuran como entrada.
	movwf	TRISA
	bcf		STATUS,RP0			; Acceso al Banco 0.
Principal
	movf	PORTA,W				; Lee el valor de las variables de entrada.
	andlw	b'00000111'			; Se queda con los tres bits de entrada.
	addwf	PCL,F				; Salta a la configuración adecuada.
Tabla
	goto	Configuracion0
	goto	Configuracion1
	goto	Configuracion2
	goto	Configuracion3
	goto	Configuracion4
	goto	Configuracion5
	goto	Configuracion6
	goto	Configuracion7
Configuracion0
	movlw 	b'00001010'			; (Configuración 0).
	goto	ActivaSalida
Configuracion1
	movlw 	b'00001001'			; (Configuración 1).
	goto	ActivaSalida
Configuracion2
	movlw 	b'00100011'			; (Configuración 2).
	goto	ActivaSalida
Configuracion3
	movlw 	b'00001111'			; (Configuración 3).
	goto	ActivaSalida
Configuracion4
	movlw 	b'00100000'			; (Configuración 4).
	goto	ActivaSalida
Configuracion5
	movlw 	b'00000111'			; (Configuración 5).
	goto	ActivaSalida
Configuracion6
	movlw 	b'00010111'			; (Configuración 6).
	goto	ActivaSalida
Configuracion7
	movlw 	b'00111111'			; (Configuración 7).
ActivaSalida
	movwf	PORTB				; Visualiza por el puerto de salida.
	goto 	Principal

	END

[REHome]

Para que lo entiendan. Estoy haciendo una interfaz con Visual C# 2008 que desde ahí pueda activar y desactivar los puertos de entrada del 16F84A, es decir, controlar el PIC desde el puerto serie.

Mientras activo y desactivo las entradas del PIC desde la interfaz hecho con C#, físicamente puedo controlar el PIC y la salida que muestra el PIC físicamente también en la Interfaz se ve las salidas activadas y desactivadas.

Lo de arriba que dije, es lo que quiero hacer. Lo que no se, es cómo programar desde la Interfaz en C# que entienda o que comunique con el PIC por el puerto serie COM1.


1- Al ejecutar la aplicación como muestra abajo en la imagen, se ve que los puertos están desactivado debido que no encuentra dispositivo.


2- Primero se configura.


3- Al activar una serie de entradas por ejemplo la 101, muestra a su salida la 000111. Rojo significa 1 activado y la verde significa 0 desactivado.


4- Las entradas que no se usan se quedan como están.


Aquellos que se atrevan a aventurarse a este mundillo, les dejo el código fuente de una plantilla no funcional ya preparado para que lo programen a ver si alguien es capaz de controlar el PIC desde el PC y al revés.

Código fuente hecho con Visual C# 2008 Express

PD:No sabía que esto esté tan complicado.

[bactering]

Lo primero que veo es que tienes que colocarle una comunicacion por software al pic para que se comunique.
No indicas la velocidad ni reloj del pic.
hay software para la comunicación en http://www.x-robotics.com/
para el pic.

[REHome]

;***************************** Librería "RS232.INC" *

;
; Estas subrutinas permiten realizar las tareas básicas de control de la transmisión
; seríe asincrona según normas RS-232.
;
; Los parámetros adoptados para la comunicación son los siguientes:
; - Velocidad de transmisión de 9600 baudios. La duración de cada bit será 104 µs.
; - Un bit de inicio o Start a nivel bajo.
; - Dato de 8 bits.
; - Sin paridad.
; - Dos bits de final o Stop a nivel alto.
;
; El tiempo entre bit y bit  debe coincidir con el periodo de la señal leída o enviada.
; Como la velocidad de transmisión o recepción es de 9600 baudios, el periodo será:
; 1/9600 Baudios = 104 µs. Se utilizará pues la subrutina Retardos_100micros.

   CBLOCK
   RS232_ContadorBits
   RS232_Dato
   ENDC

#DEFINE  RS232_Entrada   PORTA,4      ; Línea por la que se reciben los datos.
#DEFINE  RS232_Salida   PORTA,3      ; Línea por la que se envían los datos.
;
; Subrutina "RS232_Inicializa" -------------------------------------------------------------
;
; Configura las líneas de salida y entrada del microcontrolador.

RS232_Inicializa
   bsf   RS232_Salida            ; Al principio salida en alto para resposo.
   bsf   STATUS,RP0
   bsf   RS232_Entrada            ; Esta línea se configura como entrada.
   bcf   RS232_Salida            ; Esta línea se configura como salida.
   bcf   STATUS,RP0
   return

; Subrutina "RS232_LeeDato" -------------------------------------------------------------
;
; El microcontrolador lee el dato por la línea de entrada comenzando por el bit de menor
; peso. El dato leído se envía finalmente en el registro de trabajo W.
;
; El ordenador parte siempre de un nivel alto, que es el estado que tiene cuando no
; envía información. La secuencia utilizada es:
; 1º   Espera que se ejecute el pulso negativo del bit Start o flanco de bajada.
; 2º   Deja pasar un tiempo una y media veces mayor que el periodo de transmisión para
;      saltarse el bit de Start y lee el primer bit en su mitad.
; 3º   Lee el resto de los bits de datos, esperando un tiempo igual a la duración del
;      período entre lectura y lectura para testearlos en mitad del bit.
;
; Salida: En el registro de trabajo W el byte leído.

RS232_LeeDato
   movlw   d'8'               ; Número de bits a recibir.
   movwf   RS232_ContadorBits
RS232_EsperaBitStart
   btfsc   RS232_Entrada          ; Lee la entrada y espera a que sea "0".
   goto   RS232_EsperaBitStart   ; No, pues espera el nivel bajo.
   call    Retardo_100micros      ; El primer bit debe leerlo un tiempo igual a una
   call    Retardo_50micros       ; vez y media el periodo de transmisión.
RS232_LeeBit
   bcf      STATUS,C            ; Ahora lee el pin. En principio supone que es 0.
   btfsc   RS232_Entrada         ; ¿Realmente es cero?
   bsf      STATUS,C            ; No, pues cambia a "1".
   rrf      RS232_Dato,F         ; Introduce el bit en el registro de lectura.
   call   Retardo_100micros      ; Los siguientes bits los lee un periodo más tarde.
   decfsz    RS232_ContadorBits,F   ; Comprueba que es el último bit.
   goto   RS232_LeeBit         ; Si no es el último bit pasa a leer el siguiente.
   call   Retardo_200micros      ; Espera un tiempo igual al los 2 bits de Stop.
   movf   RS232_Dato,W         ; El resultado en el registro W.
   return   

; Subrutinas "RS232_EnviaDato" y "RS232_EnviaNúmero" -------------------------------------
;
; El microcontrolador envía un dato por la línea de salida comenzando por el bit de menor
; peso. En dato enviado será el que le llegue a través del registro de trabajo W.
; 1º.   Envía un "0" durante un tiempo igual al periodo de la velocidad de transmisión.
;      Este es el bit de "Start".
; 2º.   Envía el bit correspondiente:
;       - Si va a enviar un "0" permanece en bajo durante el periodo correspondiente.
;      - Si va a escribir un "1" permanece en alto durante el periodo correspondiente.
; 3º.   Envía dos bits "1" durante un tiempo igual al período de la velocidad de
;      transmisión cada uno. Estos son los dos bits de Stop.
;
; Entrada:   En (W) el dato a enviar.

RS232_EnviaNumero               ; Envía el código ASCII de un número.
   addlw   '0'                  ; Lo pasa a código ASCII sumándole el ASCII del 0.
RS232_EnviaDato
   movwf   RS232_Dato            ; Guarda el contenido del byte a transmitir.
   movlw   d'8'               ; Este es el número de bits a transmitir.
   movwf   RS232_ContadorBits
   bcf      RS232_Salida         ; Bit de Start.
   call   Retardo_100micros
RS232_EnviaBit                  ; Comienza a enviar datos.
   rrf      RS232_Dato,F         ; Lleva el bit que se quiere enviar al Carry para
   btfss   STATUS,C            ; deducir su valor. ¿Es un "1" el bit a transmitir?
   goto   RS232_EnviaCero         ; No, pues envía un "0".
RS232_EnviaUno
   bsf      RS232_Salida         ; Transmite un "1".
   goto   RS232_FinEnviaBit
RS232_EnviaCero
   bcf      RS232_Salida         ; Transmite un "0".
RS232_FinEnviaBit
   call   Retardo_100micros      ; Este es el tiempo que estará en alto o bajo.
   decfsz    RS232_ContadorBits,F   ; Comprueba que es el último bit.
   goto   RS232_EnviaBit         ; Como no es el último bit repite la operación.
   bsf      RS232_Salida         ; Envía dos bits de Stop.
   call   Retardo_200micros
   return

[REHome]

;************************************ RS232_01.asm **************************************
;

;
; En la pantalla del modulo LCD se visualizarán los caracteres que se reciban a través del
; puerto serie del ordenador. Lo que se escriba por el teclado del ordenador aparecerá en
; la pantalla del sistema con microcontrolador.
;
; Se utilizará un programa de comunicaciones para que el ordenador pueda enviar datos a
; través de su puerto serie. Este programa puede ser el Hyperterminal de Windows o alguno
; similar.
;
; ZONA DE DATOS *************************************************************************

LIST P=16F84A
INCLUDE <P16F84A>
__CONFIG _CP_OFF & _WDT_OFF & _PWRTE_ON & _XT_OSC

CBLOCK 0x0C
ENDC

; ZONA DE CÓDIGOS ***********************************************************************

ORG 0
Inicio
call LCD_Inicializa ; Inicializa el LCD y las líneas que se
call RS232_Inicializa ; van a utilizar en la comunicación con el puerto
Principal ; serie RS232.
call RS232_LeeDato ; Espera recibir un carácter.
call LCD_Caracter ; Lo visualiza.
goto Principal ; Repite el proceso.

INCLUDE <RS232> ; Subrutinas de control de la comunicación con el
INCLUDE <LCD_4BIT> ; puerto serie RS232 del ordenador.
INCLUDE <RETARDOS>
END

[REHome]

;**************************** Librería "LCD_4BIT.INC" *
;

;
; Estas subrutinas permiten realizar las tareas básicas de control de un módulo LCD de 2
; líneas por 16 caracteres, compatible con el modelo LM016L.
;
; El visualizador LCD está conectado al Puerto B del PIC mediante un bus de 4 bits. Las
; conexiones son:
; -   Las 4 líneas superiores del módulo LCD, pines <DB7>  se conectan a las 4
;   líneas superiores del Puerto B del PIC, pines <RB7>.
; -   Pin RS del LCD a la línea RA0 del PIC.
; -   Pin R/W del LCD a la línea RA1 del PIC, o a masa.
; -   Pin Enable del LCD a la línea RA2 del PIC.
;
; Se utilizan llamadas a subrutinas de retardo de tiempo localizadas en la librería
; RETARDOS.INC.
;
; ZONA DE DATOS *********************************************************************

   CBLOCK
   LCD_Dato
   LCD_GuardaDato
   LCD_GuardaTRISB
   LCD_Auxiliar1
   LCD_Auxiliar2
   ENDC

LCD_CaracteresPorLinea   EQU   .16         ; Número de caracteres por línea de la pantalla.

#DEFINE  LCD_PinRS   PORTA,0
#DEFINE  LCD_PinRW   PORTA,1
#DEFINE  LCD_PinEnable   PORTA,2
#DEFINE  LCD_BusDatos   PORTB

; Subrutina "LCD_Inicializa" ------------------------------------------------------------
;
; Inicialización del módulo LCD: Configura funciones del LCD, produce reset por software,
; borra memoria y enciende pantalla. El fabricante especifica que para garantizar la
; configuración inicial hay que hacerla como sigue:
;
LCD_Inicializa
   bsf      STATUS,RP0            ; Configura las líneas conectadas al pines RS,
   bcf      LCD_PinRS            ; R/W y E.
   bcf      LCD_PinEnable
   bcf      LCD_PinRW
   bcf      STATUS,RP0
   bcf      LCD_PinRW            ; En caso de que esté conectado le indica
                           ; que se va a escribir en el LCD.
   bcf      LCD_PinEnable         ; Impide funcionamiento del LCD poniendo E=0.
   bcf    LCD_PinRS            ; Activa el Modo Comando poniendo RS=0.
   call   Retardo_20ms
   movlw   b'00110000'   
   call   LCD_EscribeLCD         ; Escribe el dato en el LCD.
   call   Retardo_5ms   
   movlw   b'00110000'   
   call   LCD_EscribeLCD
   call   Retardo_200micros
   movlw   b'00110000'   
   call   LCD_EscribeLCD
   call   Retardo_20micros      ; Este retardo es necesario para simular en PROTEUS.
   movlw   b'00100000'            ; Interface de 4 bits.
   call   LCD_EscribeLCD
   call   Retardo_20micros      ; Este retardo es necesario para simular en PROTEUS.
   
; Ahora configura el resto de los parámetros:

   call   LCD_2Lineas4Bits5x7      ; LCD de 2 líneas y caracteres de 5x7 puntos.
   call   LCD_Borra            ; Pantalla encendida y limpia. Cursor al principio
   call   LCD_CursorOFF         ; de la línea 1. Cursor apagado.
   call   LCD_CursorIncr         ; Cursor en modo incrementar.
   return

; Subrutina "LCD_EscribeLCD" -----------------------------------------------------------
;
; Envía el dato del registro de trabajo W al bus de dato y produce un pequeño pulso en el pin
; Enable del LCD. Para no alterar el contenido de las líneas de la parte baja del Puerto B que
; no son utilizadas para el LCD (pines RB3:RB0), primero se lee estas líneas y después se
; vuelve a enviar este dato sin cambiarlo.

LCD_EscribeLCD
   andlw   b'11110000'            ; Se queda con el nibble alto del dato que es el
   movwf   LCD_Dato            ; que hay que enviar y lo guarda.
   movf   LCD_BusDatos,W         ; Lee la información actual de la parte baja
   andlw   b'00001111'            ; del Puerto B, que no se debe alterar.
   iorwf   LCD_Dato,F            ; Enviará la parte alta del dato de entrada
                           ; y en la parte baja lo que había antes.
   bsf      STATUS,RP0            ; Acceso al Banco 1.
   movf   TRISB,W               ; Guarda la configuración que tenía antes TRISB.
   movwf   LCD_GuardaTRISB
   movlw   b'00001111'            ; Las 4 líneas inferiores del Puerto B se dejan
   andwf   PORTB,F               ; como estaban y las 4 superiores como salida.
   bcf      STATUS,RP0            ; Acceso al Banco 0.
;
   movf   LCD_Dato,W            ; Recupera el dato a enviar.
   movwf   LCD_BusDatos         ; Envía el dato al módulo LCD.
   bsf      LCD_PinEnable         ; Permite funcionamiento del LCD mediante un pequeño
   bcf      LCD_PinEnable         ; pulso y termina impidiendo el funcionamiento del LCD.
   bsf      STATUS,RP0            ; Acceso al Banco 1. Restaura el antiguo valor en
   movf   LCD_GuardaTRISB,W      ; la configuración del Puerto B.
   movwf   TRISB
   bcf      STATUS,RP0            ; Acceso al Banco 0.
   return

; Subrutinas variadas para el control del módulo LCD -----------------------------------------
;
;Los comandos que pueden ser ejecutados son:
;
LCD_CursorIncr                  ; Cursor en modo incrementar.
   movlw   b'00000110'
   goto   LCD_EnviaComando
LCD_Linea1                     ; Cursor al principio de la Línea 1.
   movlw   b'10000000'            ; Dirección 00h de la DDRAM
   goto   LCD_EnviaComando
LCD_Linea2                     ; Cursor al principio de la Línea 2.
   movlw   b'11000000'            ; Dirección 40h de la DDRAM
   goto   LCD_EnviaComando
LCD_Linea3                     ; Cursor al principio de la Línea 3
   movlw   b'10010100'            ; Dirección 14h de la DDRAM
   goto   LCD_EnviaComando
LCD_Linea4                     ; Cursor al principio de la Línea 4
   movlw   b'11010100'            ; Dirección 54h de la DDRAM
   goto   LCD_EnviaComando
LCD_PosicionLinea1               ; Cursor a posición de la Línea 1, a partir de la
   iorlw   b'10000000'            ; dirección 00h de la DDRAM más el valor del
   goto   LCD_EnviaComando      ; registro W.
LCD_PosicionLinea2               ; Cursor a posición de la Línea 2, a partir de la
   iorlw   b'11000000'            ; dirección 40h de la DDRAM más el valor del
   goto   LCD_EnviaComando      ; registro W.
LCD_OFF                        ; Pantalla apagada.
   movlw   b'00001000'
   goto   LCD_EnviaComando
LCD_CursorON                  ; Pantalla encendida y cursor encendido.
   movlw   b'00001110'
   goto   LCD_EnviaComando
LCD_CursorOFF                  ; Pantalla encendida y cursor apagado.
   movlw   b'00001100'
   goto   LCD_EnviaComando
LCD_Borra                     ; Borra toda la pantalla, memoria DDRAM y pone el
   movlw   b'00000001'            ; cursor a principio de la línea 1.
   goto   LCD_EnviaComando
LCD_2Lineas4Bits5x7               ; Define la pantalla de 2 líneas, con caracteres
   movlw   b'00101000'            ; de 5x7 puntos y conexión al PIC mediante bus de
;   goto   LCD_EnviaComando      ; 4 bits.

; Subrutinas "LCD_EnviaComando" y "LCD_Caracter" ------------------------------------
;
; "LCD_EnviaComando". Escribe un comando en el registro del módulo LCD. La palabra de
; comando ha sido entregada a través del registro W.  Trabaja en Modo Comando.
; "LCD_Caracter". Escribe en la memoria DDRAM del LCD el carácter ASCII introducido a
; a través del registro W. Trabaja en Modo Dato.
;
LCD_EnviaComando
   bcf      LCD_PinRS            ; Activa el Modo Comando, poniendo RS=0.
   goto   LCD_Envia
LCD_Caracter
   bsf      LCD_PinRS            ; Activa el "Modo Dato", poniendo RS=1.
   call   LCD_CodigoCGROM         ; Obtiene el código para correcta visualización.
LCD_Envia
   movwf   LCD_GuardaDato         ; Guarda el dato a enviar.
   call   LCD_EscribeLCD         ; Primero envía el nibble alto.
   swapf   LCD_GuardaDato,W      ; Ahora envía el nibble bajo. Para ello pasa el
                           ; nibble bajo del dato a enviar a parte alta del byte.
   call   LCD_EscribeLCD         ; Se envía al visualizador LCD.
   btfss   LCD_PinRS            ; Debe garantizar una correcta escritura manteniendo
   call   Retardo_2ms            ; 2 ms en modo comando y 50 µs en modo cáracter.
   call   Retardo_50micros
   return   

; Subrutina "LCD_CodigoCGROM" -----------------------------------------------------------
;
; A partir del carácter ASCII número 127 los códigos de los caracteres definidos en la
; tabla CGROM del LM016L no coinciden con los códigos ASCII. Así por ejemplo, el código
; ASCII de la "Ñ" en la tabla CGRAM del LM016L es EEh.
;
; Esta subrutina convierte los códigos ASCII de la "Ñ", "º" y otros, a códigos CGROM para que
; que puedan ser visualizado en el módulo LM016L.
;
; Entrada:   En (W) el código ASCII del carácter que se desea visualizar.
; Salida:   En (W) el código definido en la tabla CGROM.

LCD_CodigoCGROM
   movwf   LCD_Dato            ; Guarda el valor del carácter y comprueba si es
LCD_EnheMinuscula               ; un carácter especial.
   sublw   'ñ'                ; ¿Es la "ñ"?
   btfss   STATUS,Z
   goto   LCD_EnheMayuscula      ; No es "ñ".
   movlw   b'11101110'            ; Código CGROM de la "ñ".
   movwf   LCD_Dato
   goto   LCD_FinCGROM
LCD_EnheMayuscula
   movf   LCD_Dato,W            ; Recupera el código ASCII de entrada.
   sublw   'Ñ'                ; ¿Es la "Ñ"?
   btfss   STATUS,Z
   goto   LCD_Grado            ; No es "Ñ".
   movlw   b'11101110'            ; Código CGROM de la "ñ". (No hay símbolo para
   movwf   LCD_Dato            ; la "Ñ" mayúscula en la CGROM).
   goto   LCD_FinCGROM   
LCD_Grado
   movf   LCD_Dato,W            ; Recupera el código ASCII de entrada.
   sublw   'º'                ; ¿Es el símbolo "º"?
   btfss   STATUS,Z
   goto   LCD_FinCGROM         ; No es "º".
   movlw   b'11011111'            ; Código CGROM del símbolo "º".
   movwf   LCD_Dato
LCD_FinCGROM
   movf   LCD_Dato,W            ; En (W) el código buscado.
   return

; Subrutina "LCD_DosEspaciosBlancos" y "LCD_LineaBlanco" --------------------------------
;
; Visualiza espacios en blanco.

LCD_LineaEnBlanco
   movlw   LCD_CaracteresPorLinea
   goto   LCD_EnviaBlancos
LCD_UnEspacioBlanco
   movlw   .1
   goto   LCD_EnviaBlancos
LCD_DosEspaciosBlancos
   movlw   .2
   goto   LCD_EnviaBlancos
LCD_TresEspaciosBlancos
   movlw   .3
LCD_EnviaBlancos
   movwf   LCD_Auxiliar1         ; (LCD_Auxiliar1) se utiliza como contador.
LCD_EnviaOtroBlanco   
   movlw   ' '                  ; Esto es un espacio en blanco.
   call   LCD_Caracter         ; Visualiza tanto espacios en blanco como se
   decfsz   LCD_Auxiliar1,F         ; haya cargado en (LCD_Auxiliar1).
   goto   LCD_EnviaOtroBlanco
   return

; Subrutinas "LCD_ByteCompleto" y "LCD_Byte" --------------------------------------------
;
; Subrutina "LCD_ByteCompleto", visualiza el byte que almacena el registro W en el
; lugar actual de la pantalla. Por ejemplo, si (W)=b'10101110' visualiza "AE".
;
; Subrutina "LCD_Byte" igual que la anterior, pero en caso de que el nibble alto sea cero
; visualiza en su lugar un espacio en blanco. Por ejemplo si (W)=b'10101110' visualiza "AE"
; y si (W)=b'00001110', visualiza " E" (un espacio blanco delante).
;
; Utilizan la subrutina "LCD_Nibble" que se analiza más adelante.
;
LCD_Byte
   movwf   LCD_Auxiliar2         ; Guarda el valor de entrada.
   andlw   b'11110000'            ; Analiza si el nibble alto es cero.
   btfss   STATUS,Z            ; Si es cero lo apaga.
   goto   LCD_VisualizaAlto      ; No es cero y lo visualiza.
   movlw   ' '                  ; Visualiza un espacio en blanco.
   call   LCD_Caracter
   goto   LCD_VisualizaBajo

LCD_ByteCompleto
   movwf   LCD_Auxiliar2         ; Guarda el valor de entrada.
LCD_VisualizaAlto
   swapf   LCD_Auxiliar2,W         ; Pone el nibble alto en la parte baja.
   call   LCD_Nibble            ; Lo visualiza.
LCD_VisualizaBajo
   movf   LCD_Auxiliar2,W         ; Repite el proceso con el nibble bajo.
;   call   LCD_Nibble            ; Lo visualiza.
;   return

; Subrutina "LCD_Nibble" ----------------------------------------------------------------
;
; Visualiza en el lugar actual de la pantalla, el valor hexadecimal que almacena en el nibble
; bajo del registro W. El nibble alto de W no es tenido en cuenta. Ejemplos:
; - Si (W)=b'01010110', se visualizará "6".
; - Si (W)=b'10101110', se visualizará "E".
;
LCD_Nibble
   andlw   b'00001111'            ; Se queda con la parte baja.
   movwf   LCD_Auxiliar1         ; Lo guarda.
   sublw   0x09               ; Comprueba si hay que representarlo con letra.
   btfss   STATUS,C   
   goto   LCD_EnviaByteLetra
   movf   LCD_Auxiliar1,W
   addlw   '0'                  ; El número se pasa a carácter ASCII sumándole
   goto    LCD_FinVisualizaDigito   ; el ASCII del cero y lo visualiza.
LCD_EnviaByteLetra
   movf   LCD_Auxiliar1,W
   addlw   'A'-0x0A            ; Sí, por tanto, se le suma el ASCII de la 'A'.
LCD_FinVisualizaDigito
   goto   LCD_Caracter         ; Y visualiza el carácter. Se hace con un "goto"
                           ; para no sobrecargar la pila.

[REHome]

;**************************** Librería "RETARDOS.INC"

;
; Librería con múltiples subrutinas de retardos, desde 4 microsegundos hasta 20 segundos.
; Además se pueden implementar otras subrutinas muy fácilmente.
;
; Se han calculado para un sistema microcontrolador con un PIC trabajando con un cristal
; de cuarzo a 4 MHz. Como cada ciclo máquina son 4 ciclos de reloj, resulta que cada
; ciclo máquina tarda 4 x 1/4MHz = 1 µs.
;
; En los comentarios, "cm" significa "ciclos máquina".
;
; ZONA DE DATOS *********************************************************************

   CBLOCK
   R_ContA                  ; Contadores para los retardos.
   R_ContB
   R_ContC
   ENDC
;
; RETARDOS de 4 hasta 10 microsegundos ---------------------------------------------------
;
; A continuación retardos pequeños teniendo en cuenta que para una frecuencia de 4 MHZ,
; la llamada a subrutina "call" tarda 2 ciclos máquina, el retorno de subrutina
; "return" toma otros 2 ciclos máquina y cada instrucción "nop" tarda 1 ciclo máquina.
;
Retardo_10micros            ; La llamada "call" aporta 2 ciclos máquina.
   nop                     ; Aporta 1 ciclo máquina.
   nop                     ; Aporta 1 ciclo máquina.
   nop                     ; Aporta 1 ciclo máquina.
   nop                     ; Aporta 1 ciclo máquina.
   nop                     ; Aporta 1 ciclo máquina.
Retardo_5micros               ; La llamada "call" aporta 2 ciclos máquina.
   nop                     ; Aporta 1 ciclo máquina.
Retardo_4micros               ; La llamada "call" aporta 2 ciclos máquina.
   return                  ; El salto del retorno aporta 2 ciclos máquina.
;
; RETARDOS de 20 hasta 500 microsegundos ------------------------------------------------
;
Retardo_500micros            ; La llamada "call" aporta 2 ciclos máquina.
   nop                     ; Aporta 1 ciclo máquina.
   movlw   d'164'            ; Aporta 1 ciclo máquina. Este es el valor de "K".
   goto   RetardoMicros      ; Aporta 2 ciclos máquina.
Retardo_200micros            ; La llamada "call" aporta 2 ciclos máquina.
   nop                     ; Aporta 1 ciclo máquina.
   movlw   d'64'            ; Aporta 1 ciclo máquina. Este es el valor de "K".
   goto   RetardoMicros      ; Aporta 2 ciclos máquina.
Retardo_100micros            ; La llamada "call" aporta 2 ciclos máquina.
   movlw   d'31'            ; Aporta 1 ciclo máquina. Este es el valor de "K".
   goto   RetardoMicros      ; Aporta 2 ciclos máquina.
Retardo_50micros            ; La llamada "call" aporta 2 ciclos máquina.
   nop                     ; Aporta 1 ciclo máquina.
   movlw   d'14'            ; Aporta 1 ciclo máquina. Este es el valor de "K".
   goto   RetardoMicros      ; Aporta 2 ciclos máquina.
Retardo_20micros            ; La llamada "call" aporta 2 ciclos máquina.
   movlw   d'5'            ; Aporta 1 ciclo máquina. Este es el valor de "K".
;
; El próximo bloque "RetardoMicros" tarda:
; 1 + (K-1) + 2 + (K-1)x2 + 2 = (2 + 3K) ciclos máquina.
;
RetardoMicros
   movwf   R_ContA            ; Aporta 1 ciclo máquina.
Rmicros_Bucle
   decfsz   R_ContA,F         ; (K-1)x1 cm (cuando no salta) + 2 cm (al saltar).
   goto   Rmicros_Bucle      ; Aporta (K-1)x2 ciclos máquina.
   return                  ; El salto del retorno aporta 2 ciclos máquina.
;
;En total estas subrutinas tardan:
; - Retardo_500micros:   2 + 1 + 1 + 2 + (2 + 3K) = 500 cm = 500 µs. (para K=164 y 4 MHz).
; - Retardo_200micros:   2 + 1 + 1 + 2 + (2 + 3K) = 200 cm = 200 µs. (para K= 64 y 4 MHz).
; - Retardo_100micros:   2     + 1 + 2 + (2 + 3K) = 100 cm = 100 µs. (para K= 31 y 4 MHz).
; - Retardo_50micros :   2 + 1 + 1 + 2 + (2 + 3K) =  50 cm =  50 µs. (para K= 14 y 4 MHz).
; - Retardo_20micros :   2     + 1     + (2 + 3K) =  20 cm =  20 µs. (para K=  5 y 4 MHz).
;
; RETARDOS de 1 ms hasta 200 ms. --------------------------------------------------------
;
Retardo_200ms               ; La llamada "call" aporta 2 ciclos máquina.
   movlw   d'200'            ; Aporta 1 ciclo máquina. Este es el valor de "M".
   goto   Retardos_ms         ; Aporta 2 ciclos máquina.
Retardo_100ms               ; La llamada "call" aporta 2 ciclos máquina.
   movlw   d'100'            ; Aporta 1 ciclo máquina. Este es el valor de "M".
   goto   Retardos_ms         ; Aporta 2 ciclos máquina.
Retardo_50ms               ; La llamada "call" aporta 2 ciclos máquina.
   movlw   d'50'            ; Aporta 1 ciclo máquina. Este es el valor de "M".
   goto   Retardos_ms         ; Aporta 2 ciclos máquina.
Retardo_20ms               ; La llamada "call" aporta 2 ciclos máquina.
   movlw   d'20'            ; Aporta 1 ciclo máquina. Este es el valor de "M".
   goto   Retardos_ms         ; Aporta 2 ciclos máquina.
Retardo_10ms               ; La llamada "call" aporta 2 ciclos máquina.
   movlw   d'10'            ; Aporta 1 ciclo máquina. Este es el valor de "M".
   goto   Retardos_ms         ; Aporta 2 ciclos máquina.
Retardo_5ms                  ; La llamada "call" aporta 2 ciclos máquina.
   movlw   d'5'            ; Aporta 1 ciclo máquina. Este es el valor de "M".
   goto   Retardos_ms         ; Aporta 2 ciclos máquina.
Retardo_2ms                  ; La llamada "call" aporta 2 ciclos máquina.
   movlw   d'2'            ; Aporta 1 ciclo máquina. Este es el valor de "M".
   goto   Retardos_ms         ; Aporta 2 ciclos máquina.
Retardo_1ms                  ; La llamada "call" aporta 2 ciclos máquina.
   movlw   d'1'            ; Aporta 1 ciclo máquina. Este es el valor de "M".
;
; El próximo bloque "Retardos_ms" tarda:
; 1 + M + M + KxM + (K-1)xM + Mx2 + (K-1)Mx2 + (M-1) + 2 + (M-1)x2 + 2 =
; = (2 + 4M + 4KM) ciclos máquina. Para K=249 y M=1 supone 1002 ciclos máquina
; que a 4 MHz son 1002 µs = 1 ms.
;
Retardos_ms
   movwf   R_ContB            ; Aporta 1 ciclo máquina.
R1ms_BucleExterno
   movlw   d'249'            ; Aporta Mx1 ciclos máquina. Este es el valor de "K".
   movwf   R_ContA            ; Aporta Mx1 ciclos máquina.
R1ms_BucleInterno
   nop                     ; Aporta KxMx1 ciclos máquina.
   decfsz   R_ContA,F         ; (K-1)xMx1 cm (cuando no salta) + Mx2 cm (al saltar).
   goto   R1ms_BucleInterno   ; Aporta (K-1)xMx2 ciclos máquina.
   decfsz   R_ContB,F         ; (M-1)x1 cm (cuando no salta) + 2 cm (al saltar).
   goto   R1ms_BucleExterno    ; Aporta (M-1)x2 ciclos máquina.
   return                  ; El salto del retorno aporta 2 ciclos máquina.
;
;En total estas subrutinas tardan:
; - Retardo_200ms:   2 + 1 + 2 + (2 + 4M + 4KM) = 200007 cm = 200 ms. (M=200 y K=249).
; - Retardo_100ms:   2 + 1 + 2 + (2 + 4M + 4KM) = 100007 cm = 100 ms. (M=100 y K=249).
; - Retardo_50ms :   2 + 1 + 2 + (2 + 4M + 4KM) =  50007 cm =  50 ms. (M= 50 y K=249).
; - Retardo_20ms :   2 + 1 + 2 + (2 + 4M + 4KM) =  20007 cm =  20 ms. (M= 20 y K=249).
; - Retardo_10ms :   2 + 1 + 2 + (2 + 4M + 4KM) =  10007 cm =  10 ms. (M= 10 y K=249).
; - Retardo_5ms  :   2 + 1 + 2 + (2 + 4M + 4KM) =   5007 cm =   5 ms. (M=  5 y K=249).
; - Retardo_2ms  :   2 + 1 + 2 + (2 + 4M + 4KM) =   2007 cm =   2 ms. (M=  2 y K=249).
; - Retardo_1ms  :   2 + 1     + (2 + 4M + 4KM) =   1005 cm =   1 ms. (M=  1 y K=249).
;
; RETARDOS de 0.5 hasta 20 segundos ---------------------------------------------------
;
Retardo_20s                  ; La llamada "call" aporta 2 ciclos máquina.
   movlw   d'200'            ; Aporta 1 ciclo máquina. Este es el valor de "N".
   goto   Retardo_1Decima      ; Aporta 2 ciclos máquina.
Retardo_10s                  ; La llamada "call" aporta 2 ciclos máquina.
   movlw   d'100'            ; Aporta 1 ciclo máquina. Este es el valor de "N".
   goto   Retardo_1Decima      ; Aporta 2 ciclos máquina.
Retardo_5s                  ; La llamada "call" aporta 2 ciclos máquina.
   movlw   d'50'            ; Aporta 1 ciclo máquina. Este es el valor de "N".
   goto   Retardo_1Decima      ; Aporta 2 ciclos máquina.
Retardo_2s                  ; La llamada "call" aporta 2 ciclos máquina.
   movlw   d'20'            ; Aporta 1 ciclo máquina. Este es el valor de "N".
   goto   Retardo_1Decima      ; Aporta 2 ciclos máquina.
Retardo_1s                  ; La llamada "call" aporta 2 ciclos máquina.
   movlw   d'10'            ; Aporta 1 ciclo máquina. Este es el valor de "N".
   goto   Retardo_1Decima      ; Aporta 2 ciclos máquina.
Retardo_500ms               ; La llamada "call" aporta 2 ciclos máquina.
   movlw   d'5'            ; Aporta 1 ciclo máquina. Este es el valor de "N".
;
; El próximo bloque "Retardo_1Decima" tarda:
; 1 + N + N + MxN + MxN + KxMxN + (K-1)xMxN + MxNx2 + (K-1)xMxNx2 +
;   + (M-1)xN + Nx2 + (M-1)xNx2 + (N-1) + 2 + (N-1)x2 + 2 =
; = (2 + 4M + 4MN + 4KM) ciclos máquina. Para K=249, M=100 y N=1 supone 100011
; ciclos máquina que a 4 MHz son 100011 µs = 100 ms = 0,1 s = 1 décima de segundo.
;
Retardo_1Decima
   movwf   R_ContC            ; Aporta 1 ciclo máquina.
R1Decima_BucleExterno2
   movlw   d'100'            ; Aporta Nx1 ciclos máquina. Este es el valor de "M".
   movwf   R_ContB            ; Aporta Nx1 ciclos máquina.
R1Decima_BucleExterno
   movlw   d'249'            ; Aporta MxNx1 ciclos máquina. Este es el valor de "K".
   movwf   R_ContA            ; Aporta MxNx1 ciclos máquina.
R1Decima_BucleInterno         
   nop                     ; Aporta KxMxNx1 ciclos máquina.
   decfsz   R_ContA,F         ; (K-1)xMxNx1 cm (si no salta) + MxNx2 cm (al saltar).
   goto   R1Decima_BucleInterno   ; Aporta (K-1)xMxNx2 ciclos máquina.
   decfsz   R_ContB,F         ; (M-1)xNx1 cm (cuando no salta) + Nx2 cm (al saltar).
   goto   R1Decima_BucleExterno   ; Aporta (M-1)xNx2 ciclos máquina.
   decfsz   R_ContC,F         ; (N-1)x1 cm (cuando no salta) + 2 cm (al saltar).
   goto   R1Decima_BucleExterno2   ; Aporta (N-1)x2 ciclos máquina.
   return                  ; El salto del retorno aporta 2 ciclos máquina.
;
;En total estas subrutinas tardan:
; - Retardo_20s:   2 + 1 + 2 + (2 + 4N + 4MN + 4KMN) = 20000807 cm = 20 s.
;         (N=200, M=100 y K=249).
; - Retardo_10s:   2 + 1 + 2 + (2 + 4N + 4MN + 4KMN) = 10000407 cm = 10 s.
;         (N=100, M=100 y K=249).
; - Retardo_5s:      2 + 1 + 2 + (2 + 4N + 4MN + 4KMN) =  5000207 cm =  5 s.
;         (N= 50, M=100 y K=249).
; - Retardo_2s:      2 + 1 + 2 + (2 + 4N + 4MN + 4KMN) =  2000087 cm =  2 s.
;         (N= 20, M=100 y K=249).
; - Retardo_1s:      2 + 1 + 2 + (2 + 4N + 4MN + 4KMN) =  1000047 cm =  1 s.
;         (N= 10, M=100 y K=249).
; - Retardo_500ms:   2 + 1     + (2 + 4N + 4MN + 4KMN) =   500025 cm = 0,5 s.
;         (N=  5, M=100 y K=249).