capitulo i generalidades - Repositorio Digital-UPS

UNIVERSIDAD POLITÉCNICA
SALESIANA
FACULTADAD DE INGENIERÍAS
SEDE QUITO-CAMPUS SUR
CARRERA DE SISTEMAS
DISEÑO E IMPLEMENTACIÓN DE UN SISTEMA DE
COMUNICACIÓN BASADO EN MICROCONTROLADORES PARA
UNA AULA DE NIÑOS CON INSUFICIENCIA MOTRIZ
CEREBRAL DE LA FUNDACIÓN FUDRINE
TESIS PREVIA A LA OBTENCIÓN DEL TÍTULO DE INGENIERO DE
SISTEMAS MENCIÓN EN ROBÓTICA E INTELIGENCIA ARTIFICIAL
CLAVIJO PLACENCIA LUIS FERNANDO
QUILLUPANGUI VARGAS LUIS AUGUSTO
DIRECTOR: Ing. CARLOS PILLAJO
DECLARACIÓN
Nosotros, Luis Fernando Clavijo Placencia y Luis Augusto Quillupangui Vargas,
declaramos bajo juramento que el trabajo aquí descrito es de nuestra autoría,
que no ha sido previamente presentado para ningún grado o calificación
profesional y que hemos consultado las referencias bibliográficas que se
incluyen en este proyecto.
A través de la presente declaración cedemos nuestros derechos a propiedad
intelectual correspondientes a este trabajo, a la Universidad Politécnica
Salesiana, según lo establecido por la ley de propiedad intelectual, por su
reglamento y por la normativa institucional vigente.
------------------------------
---------------------------------
Luis Clavijo Placencia
Luis Quillupangui Vargas
CERTIFICACIÓN
Certifico que la presente tesis de ingeniería fue desarrollada por Luis Fernando
Clavijo Placencia y Luis Augusto Quillupangui Vargas bajo mi dirección.
----------------------------Ingeniero Carlos Pillajo
Director de Tesis
DEDICATORIA
A nuestros padres quienes con su amor y dedicación hicieron posible la
culminación de nuestra carrera convirtiéndonos no solo en profesionales sino
en personas con grandes valores y pensamientos, encaminándonos hacia una
nueva etapa en nuestras vidas, con la predisposición de utilizar de forma
correcta valores y conocimientos para el beneficio de la sociedad en que
vivimos y nuestra.
TEMARIO
Introducción
CAPITULO I Generalidades
1.1 Insuficiencia motora de origen cerebral (IMOC)
1.2 Descripción de la IMOC
CAPITULO II
Fundamentos Teóricos
2.1 Video
2.1.1 Señal de video
2.1.2 Sistema PAL
2.1.3 Sistema NTSC
2.2 Microcontroladores
2.2.1 Introducción
2.2.2 Historia de los PICs.
2.2.3 Elección del microcontrolador para nuestro sistema
2.2.4 Descripción general
CAPITULO III
Teoría
3.1 Estudio de hardware y comunicación teclado computador
3.1.1 Funcionamiento
3.1.2 Conector del teclado
3.1.3 Comunicación del teclado al computador
3.2 Como funciona la comunicación RS-232
3.2.1 Introducción
3.2.2 Norma RS-232
3.2.3 Chip MAX 232
3.3 Diseño y construcción de hardware
3.3.1 Creación de las placas del circuito impreso
3.3.2 Diseño de la placa
3.3.3 Impresión del circuito
3.3.4 Preparación de la placa
3.3.5 Planchado del diseño sobre la placa de cobre
3.3.6 Ataque químico de la placa de cobre
3.3.7 Recorte y perforado de la placa de cobre
3.4 Diseño y construcción del hardware para el teclado
3.4.1 Esquemáticos teclados
3.4.2 Esquemáticos video
CAPITULO IV
Software
4 Diseño y Construcción de Software
4.1 Compilador Pic C Compiler
4.1.1 Introducción
4.1.2 Elementos del software
4.1.3 Operadores y expresiones
4.1.4 Descripción de instrucciones
4.2 Manual WINPIC800
4.2.1 Configuración de hardware
4.2.2 Escoger hardware
4.2.3 Escoger microcontrolador
4.2.4 Cargar el archivo
4.2.5 Grabación del pic
CAPITULO V
Implementación y Resultados
5.1 Pruebas realizadas
5.2 Resultados obtenidos
5.3 Análisis de costos
5.3.1 Costos de fabricación
5.3.2 Costos de mano de obra
5.3.3 Producción en serie
CAPITULO VI
Conclusiones y Recomendaciones
6.1 Beneficio Social
6.2 Conclusiones
6.2.1 Conclusiones del proyecto
6.2.2 Conclusiones de la utilización del proyecto
6.3 Recomendaciones
6.4 Bibliografía
6.4.1 Referencias de Internet
ANEXOS
Índice de contenido
Introducción
CAPITULO I
Generalidades
1.1 INSUFICIENCIA MORIZ DE ORIGEN CEREBRAL (IMOC) .........................1
1.2 DESCRIPCIÓN DE LA IMOC.......................................................................2
CAPITULO II Fundamentos Teóricos
2.1 VIDEO
2.1.1 SEÑAL DE VIDEO ..................................................................................22
2.1.2 SISTEMA PAL ........................................................................................39
2.1.3 SISTEMA NTSC......................................................................................44
2.2 MICROCONTROLADORES
2.2.1 INTRODUCCION ....................................................................................52
2.2.2 HISTORIA DE LOS PIC's........................................................................53
2.2.3 ELECCIÓN DEL MICROCONTROLADOR PARA EL SISTEMA .............53
2.2.4 DESCRIPCIÓN GENERAL .....................................................................57
CAPITULO III
Teoría
3.1.1 FUNCIONAMIENTO ...............................................................................63
3.1.2 LOS CONECTORES DEL TECLADO .....................................................65
3.1.3 COMUNICACIÓN DEL TECLADO AL COMPUTADOR ..........................65
3.2 COMO FUNCIONA LA COMUNICACIÓN RS-232
3.2.1 INTRODUCCIÓN ....................................................................................71
3.2.2 NORMA RS232.......................................................................................72
3.2.3 El CHIP MAX 232....................................................................................74
3.3 DISEÑO Y CONSTRUCCIÓN DE HARDWARE
3.3.1 CREACIÓN DE PLACAS DE CIRCUITO IMPRESO ...............................80
3.3.2 DISEÑO DE LA PLACA ..........................................................................84
3.3.3 IMPRESIÓN DEL CIRCUITO..................................................................87
3.3.4 PREPARACIÓN DE LA PLACA ..............................................................89
3.3.5 PLANCHADO DEL DISEÑO SOBRE LA PLACA DE COBRE.................89
3.3.6 ATAQUE QUÍMICO DE LA PLACA DE COBRE .....................................92
3.3.7 PERFORADO DE LA PLACA .................................................................95
3.4 DISEÑO Y CONSTRUCCION DEL HARDWARE PARA EL TECLADO
3.4.1 ESQUEMATICOS TECLADO .................................................................97
3.4.2 ESQUEMATICO CONCENTRADOR ....................................................101
3.4.3 ESQUEMATICO VIDEO........................................................................104
3.4.4 EXPLICACACION DEL PROGRAMA DEL PROYECTO .......................107
CAPITULO IV
Software
4 DISEÑO Y CONSTRUCCIÓN DE SOFTWARE
4.1.1 MANUAL PIC C COMPILER .................................................................140
4.1.2 ELEMENTOS DEL SOFTWARE...........................................................141
4.1.3 OPERADORES Y EXPRESIONES .......................................................145
4.1.4 DESCRIPCIÓN DE INSTRUCCIONES .................................................149
4.2 MANUAL WINPIC800
4.2 OPERADORES Y EXPRESIONES ..........................................................163
4.2.1 CONFIGURACIÓN DE HARDWARE ....................................................163
4.2.2 ESCOGER HARDWARE ......................................................................164
4.2.3 ESCOGER MICROCONTROLADOR....................................................164
4.2.4 CARGAR EL ARCHIVO (.HEX).............................................................165
4.2.5 GRABACIÓN DE PIC............................................................................165
CAPITULO V
Implementación y Resultados
5.1 PRUEBAS REALIZADAS.........................................................................167
5.2 RESULTADOS OBTENDIDOS ................................................................168
5.3 ANÁLISIS DE COSTOS...........................................................................169
5.3.1 COSTOS DE FABRICACIÓN................................................................169
5.3.2 COSTOS DE MANO DE OBRA ............................................................170
5.3.3 PRODUCCIÓN EN SERIE ....................................................................170
CAPITULO VI
Conclusiones y Recomendaciones
6.1 BENEFICIO SOCIAL................................................................................172
6.2 CONCLUSIONES ....................................................................................172
6.2.1 CONCLUSIONES DEL PROYECTO.....................................................172
6.2.2 CONCLUSIONES DE LA UTILIZACIÓN DEL PROYECTO...................173
6.3 RECOMENDACIONES ............................................................................174
6.4 BIBLIOGRAFÍA ........................................................................................174
6.4.1 REFERENCAS DE INTERNET.............................................................174
ANEXOS
Índice de gráficos
CAPITULO I
Generalidades
1.1 Insuficiencia motriz de origen cerebral (IMOC)
Figura 1.1-1 Trastorno psicomotor ....................................................................1
Figura 1.1-2 Pruebas de desarrollo muscular en el cuello .................................9
Figura 1.1-3 Pruebas de elasticidad sedente (sentado) ....................................9
CAPITULO II
Fundamentos Teóricos
2.1 Video
2.1.1 Señal de video
Figura 2.1.1-1 Estructura interna de componentes de la pantalla ....................23
Figura 2.1.1-2 Barrido entrelazado líneas impares ..........................................24
Figura 2.1.1-3 Barrido entrelazado líneas pares .............................................25
Figura 2.1.1-4 Estructura interna del cañon de colores (RGB) ........................26
Figura 2.1.1-5 Escaneo progresivo ..................................................................27
Figura 2.1.1-6 Tabla de generación de barra de colores ..................................31
Figura 2.1.1-7 Escaneo del haz de electrones de la pantalla ...........................32
Figura 2.1.1-8 Parámetros de transmisión de la señal de video .......................34
Figura 2.1.1-9 Escaneo campo impar y par .....................................................35
Figura 2.1.1-10 Barrido entrelazado.................................................................36
Figura 2.1.1-11 Barrido no entrelazado............................................................36
Figura 2.1.1-12 Generador de líneas ...............................................................37
Figura 2.1.1-13 Generador de puntos ..............................................................37
Figura 2.1.1-14 Distribución mundial del sistema de televisión ........................38
2.1.2 Sistema PAL
Figura 2.1.2-1 Diagrama de tiempos del sistema PAL .....................................43
2.1.3 Sistema NTSC
Figura 2.1.3-1 Barrido impar ............................................................................46
Figura 2.1.3-2 Barrido par ................................................................................46
Figura 2.1.3-3 Combinación barrido progresivo ...............................................46
Figura 2.1.3-4 Diagrama de tiempos del sistema NTSC ..................................48
Figura 2.1.3-5 Tiempos de escaneo de la imagen............................................50
Figura 2.1.3-6 Diagrama de sincronismos........................................................51
2.2 Microcontroladores
2.2.2 Historia de los PIC’s
Figura 2.2.2-1 Arquitectura de la memoria interna del microcontrolador (pic)...53
2.2.3 Elección del microcontrolador para nuestro sistema
Figura 2.2.3-1 Segmentación de la memoria interna para la ejecución de
instruccciones …….. ........................................................................................54
2.2.4 DESCRIPCIÒN GENERAL
Figura 2.2.4-1 PIC 16F628A ............................................................................57
Figura 2.2.4-2 Distribución de pines PIC 16F628A..........................................58
Figura 2.2.4-3 PIC 18F2525.............................................................................60
Figura 2.2.4-4 Distribución de pines PIC 18F2525 ...........................................60
CAPITULO III
Teoría
3.1 Estudio de hardware y comunicación teclado computador
3.1.1 Funcionamiento
Figura 3.1.1-1 Identificación fila y columna d la tecla pulsada ..........................63
Figura 3.1.1-2 Pulsador ...................................................................................64
Figura 3.1.1-3 Pulsador de lámina de plástico .................................................64
Figura 3.1.1-4 Pulsador de bobedilla metálica .................................................64
Figura 3.1.1-5 Pulsador capacitivo...................................................................65
3.1.2 Conectores de teclado
Figura 3.1.2-1 Descripción del conector Din de 5 pines AT..............................86
Figura 3.1.2-2 Descripción del conector Mini Din de 6 pines PS/2 ...................86
3.1.2 Conectores de teclado
Figura 3.1.2-1 Descripción del conector Din de 5 pines AT..............................65
Figura 3.1.2-2 Descripción del conector Mini Din de 6 pines PS/2 ...................65
Figura 3.1.3-3 Código de escaneo interno del teclado .....................................89
Figura 3.1.3-4 Códigos de caracteres imprimibles y no imprimibles por el
teclado...............................................................................................................91
3.1.3 Comunicación teclado computador
Figura 3.1.3-1 Diagrama de sincronismos reloj y dato del teclado al host
(computador)…. ...............................................................................................66
Figura 3.1.3-2 Teclao PS/2 ..............................................................................67
Figura 3.1.3-3 Código de escaneo interno del teclado .....................................68
Figura 3.1.3-4 Códigos de caracteres imprimibles y no imprimibles por el
teclado...............................................................................................................70
3.2 Como funciona la comunicación RS-232
3.2.1 Introducción
Figura 3.2.1-1 Formato de envío de datos vía RS-232.....................................71
Figura 3.2.1-2 Visualización del envío de la trama de datos ............................72
3.2.2 Norma RS232
Figura 3.2.2-1 Conexión ordenador móden......................................................72
Figura 3.2.2-2 Esquema ilustrativo conexión pc y microcontrolador .................73
Figura 3.2.2-3 Distribución de pines conector DB9 hembra ............................73
Figura 3.2.2-4 Distribución de pines conector DB9 Macho..............................73
3.2.3 Chip MAX 232
Figura 3.2.3-1 Conexión de pines chip Max 232 ..............................................74
Figura 3.2.3-2 Distribución de pines y conexión pc a pic..................................75
Figura 3.2.3-3 Cable de conexión DB9 macho.................................................76
Figura 3.2.3-4 Conector DB9 hembra ..............................................................76
Figura 3.2.3-5 Construcción cable plano con conector DB9 .............................76
Figura 3.2.3-6 Cable de conexión telefónico RJ11 macho ...............................77
Figura 3.2.3-7 Conector telefónico RJ11 hembra .............................................77
Figura 3.2.3-8 Esquema de ponchado cable telefónico RJ11 ..........................77
Figura 3.2.3-9 Esquema de conexión conector RJ11 y conector DB9..............78
Figura 3.2.3-10 Distribución de pines conector DB9 ........................................78
Figura 3.2.3-11 Conector RJ11 ........................................................................79
Figura 3.2.3-12 Distribución de pines conector RJ11 .......................................79
3.3 Diseño y construcción de Hardware
3.3.1 Creación de placas de circuito impreso
Figura 3.3.1-1 Placa de cobre ..........................................................................80
Figura 3.3.1-2 Papel térmico ............................................................................80
Figura 3.3.1-3 Ácido cloruro férrico ..................................................................81
Figura 3.3.1-4 Recipiente de plástico ...............................................................81
Figura 3.3.1-5 Pinzas plásticas ........................................................................81
Figura 3.3.1-6 Impresora láser .........................................................................82
Figura 3.3.1-7 Plancha.....................................................................................82
Figura 3.3.1-8 Lana de acero ...........................................................................82
Figura 3.3.1-9 Lima de acero ...........................................................................83
Figura 3.3.1-10 Taladro....................................................................................83
Figura 3.3.1-11 Marcador indeleble .................................................................83
Figura 3.3.1-12 Disolvente ...............................................................................84
3.3.2 Diseño de la placa
Figura 3.3.2-1 Visualización diagrama en Proteus (ISIS) .................................85
Figura 3.3.2-2 Visualización esquema componentes en Proteus (ARES) ........85
Figura 3.3.2-3 Placa sin relleno de cobre.........................................................86
Figura 3.3.2-4 Placa con relleno de cobre........................................................86
3.3.3 Impresión del circuto
Figura 3.3.3-1 Impresión soldadura (I) y Componentes (D)..............................87
3.3.4 Preparación de la placa
Figura 3.3.4-1 Lijado de la placa de cobre .......................................................88
Figura 3.3.4-2 Placa sin lijar ............................................................................88
Figura 3.3.4-3 Placa lijada ...............................................................................88
Figura 3.3.4-4 Limpiar placa con tiñer .............................................................89
3.3.5 Planchado del diseño sobe la placa de cobre
Figura 3.3.5-1 Colocar papel térmico impreso sobre la placa de cobre ............89
Figura 3.3.5-2 Planchar el papel sobre la placa de cobre ................................90
Figura 3.3.5-3 El papel se pegara sobre el cobre.............................................90
Figura 3.3.5-4 Visualización de zonas no brillantes..........................................91
Figura 3.3.5-5 Planchado totalmente terminado...............................................91
Figura 3.3.5-6 Dejar enfriar la placa en agua ...................................................91
Figura 3.3.5-7 Retirar el papel de la placa de cobre.........................................91
Figura 3.3.5-8 Retirar los restos de papel con unasponja ................................92
Figura 3.3.5-9 Placa totalmente sin papel ........................................................92
3.3.6 Ataque químico a la placa de cobre
Figura 3.3.6-1 Recortar la placa.......................................................................92
Figura 3.3.6-2 Lijar los bordes de la placa .......................................................92
Figura 3.3.6-3 Introducir la placa de cobre en el recipiente con ácido ..............93
Figura 3.3.6-4 Lavar la placa con agua ............................................................94
Figura 3.3.6-5 Retira toner con disolvente .......................................................94
Figura 3.3.6-6 Lista la placa para la perforación ..............................................94
3.3.7 Perforado de la placa de cobre
Figura 3.3.7-1 Perforado de pad de la placa ....................................................95
Figura 3.3.7-2 Placa terminada ........................................................................95
Figura 3.3.7-3 Montaje de elementos impresos ...............................................96
Figura 3.3.7-4 Visualizción a contra luz............................................................96
3.4 Diseño y construcción de hardware para teclado
3.4.1 Esquemático teclado
Figura 3.4.1-1 Diagrama esquemático de hardware de teclado .......................97
Figura 3.4.1-2 Diagrama de bloque..................................................................98
Figura 3.4.1-3 Diagrama por módulo................................................................99
Figura 3.4.1-2 Disposición de elementos .......................................................100
Figura 3.4.1-3 Disposición de soldadura ........................................................100
3.4.2 Esquemático concentrador
Figura 3.4.2-1 Diagrama esquemático de red ................................................101
Figura 3.4.2-2 Diagrama de bloque................................................................102
Figura 3.4.2-3 Diagrama por módulo..............................................................102
Figura 3.4.2-4 Disposición de elementos de red ............................................103
Figura 3.4.2-5 Diagrama esquemático de la fuente........................................103
3.4.3 Esquemático video
Figura 3.4.3-1 Diagrama esquemático de video.............................................104
Figura 3.4.3-2 Diagrama de bloque................................................................104
Figura 3.4.3-3 Diagrama por módulo..............................................................105
Figura 3.4.3-4 Disposición de elementos de video, red y fuente ....................106
Figura 3.4.3-5 Disposición de soldadura de video, red y fuente .....................107
3.4.4 Explicación del hardware de proyecto
Figura 3.4.4-1 Tabla de imagen del carácter A ..............................................114
Figura 3.4.4-2 Tabla de almacenamiento de la imagen del carácter A en Uc.114
Figura 3.4.4-3 Diagrama de variables y funciones .........................................133
Figura 3.4.3-4 Diagrama de actividades.........................................................134
Figura 3.4.4-5 Diagrama de secuencias.........................................................135
Figura 3.4.4-6 Diagrama de funciones ...........................................................137
Figura 3.4.3-7 Diagrama de actividades.........................................................138
Figura 3.4.4-8 Diagrama de secuencias.........................................................138
CAPITULO IV
Software
4 Diseño y construcción de software
4.1 Manual compilador Pic C Compiler
4.1.1 Introducción
Figura 4.1.1-1 Pantalla inicial compilador Pic C Compiler ..............................140
4.1.2 Elementos de software
Figura 4.1.2-1 Barra de herramientas ............................................................141
Figura 4.1.2-2 Creación de un nuevo proyecto ..............................................142
Figura 4.1.2-3 Escoger donde guardar el proyecto ........................................142
Figura 4.1.2-4 Configuración de parámetros internos del código ...................143
Figura 4.1.2-5 Pestañas de configuración de parámetros ..............................143
Figura 4.1.2-6 Visualización de parámetros seteados ....................................144
Figura 4.1.2-7 Proceso de compilación de código..........................................144
4.1.3 Operadores y expresiones
Figura 4.1.3-1 Cuadro de asignación de operación .......................................145
Figura 4.1.3-2 Descripción de los operadores ................................................146
Figura 4.1.3-3 Cuadro de operadores de relación .........................................146
Figura 4.1.3-4 Cuadro de operadores lógicos ...............................................147
Figura 4.1.3-5 Cuadro de operadores de bit...................................................147
Figura 4.1.3-6 Cuadro de operadores de incremento, decremento ................148
Figura 4.1.3-7 Cuadro de desplazamiento de bit ...........................................148
Figura 4.1.3-8 Cuadro de representación de formatos ..................................148
4.1.4 Descripción de instrucciones
Figura 4.1.4-1 Instrucción es en assembler ...................................................150
Figura 4.1.4-2 Opciones de la instrucción Interrupción ..................................152
Figura 4.1.4-3 Opciones de la instrucción #USE RS232 ..............................154
Figura 4.1.4-4 Opciones de la instrucción PRINTF ......................................157
Figura 4.1.2-2 Barra de herramientas ............................................................165
Figura 4.1.2-3 Creación de un nuevo proyecto ..............................................166
Figura 4.1.2-4 Escoger donde guardar el proyecto ........................................166
Figura 4.1.2-5 Configuración de parámetros internos del código ...................167
Figura 4.1.2-6 Pestañas de configuración de parámetros ..............................167
Figura 4.1.2-7 Visualización de parámetros seteados ....................................168
Figura 4.1.2-8 Proceso de compilación de código..........................................168
4.2 Manual WINPIC 800
Figura 4.2-1 Pantalla de presentación ...........................................................163
4.2.1 Configuración de hardware
Figura 4.2.1-1 Configurar el programador .....................................................163
4.2.2 Escoger hardware
Figura 4.2.2-1 Escoger el programador..........................................................164
4.2.3 Escoger el microcontrolador
Figura 4.2.3-1 Selección del pic .....................................................................164
4.2.4 Cargar el archivo (.hex)
Figura 4.2.4-1 Barra de herramientas ............................................................165
4.2.5 Grabación de Pic
Figura 4.2.5-1 Grabación del código .hex ......................................................165
INTRODUCCIÓN
La necesidad de adquirir habilidades para desempeñar un papel útil en la
sociedad actual, pone en relieve las dificultades que padece una proporción
significativamente grande de niños en edad escolar, una de estas dificultades
es la IMOC (Insuficiencia motora de origen cerebral).
El niño con IMOC puede ser crónicamente propenso a accidentes, y también
puede ser de movimientos motores muy pobres, al niño se le puede dificultar
mucho tomar un lápiz entre sus dedos y batallar tremendamente con la
escritura, además con el continuo avance tecnológico los niños deben ir
familiarizándose con herramientas que se hacen indispensables en la
cotidianidad de la sociedad, un claro ejemplo es el continuo uso de un
instrumento como lo es el computador.
Hemos visto la necesidad de diseñar un teclado que supla las necesidades
autónomas de educación del niño con IMOC y que a su vez al ser producido en
nuestro país disminuya notablemente su precio, este teclado podrá ser utilizado
y adaptado según la necesidad que el niño con IMOC presente.
Las herramientas de tecnología que se encuentran actualmente en el mercado
presentan un alto costo y sus características nos muestran que tratan de ser de
propósito general, sin embargo esta característica impide explotar las
capacidades de los niños con IMOC para utilizar el computador como
herramienta para con su entorno.
Por tal razón decidimos crear e implementar el presente proyecto:
El dispositivo que se implementará es una herramienta diseñada para los niños
con IMOC, este dispositivo les facilitará acceder a las funciones de teclado
permitiendo al niño aprovechar las características del computador como una
herramienta de comunicación con su entorno.
La realización del presente proyecto se hace con el fin de brindarles a los niños
que padezcan de algún problema de movimientos motrices y comunicación
(lenguaje) denominado en el campo medico como Insuficiencia motora de
origen cerebral (IMOC), una herramienta de autoaprendizaje que les permita
una adquisición de conocimientos por medio de un instrumento tecnológico e
informático como lo es el televisión y el teclado.
Esta herramienta consistirá en un teclado común y corriente, un televisor con
entrada de video que le permitirá al niño un fácil acceso a las opciones
creadas, puesto que por su deficiencia en la coordinación de movimientos
motrices y lenguaje le es muy complicado acceder a esta herramienta
informática sin la ayuda de una persona que no presente este
tipo de
problema.
Para tal fin se ha propuesto el diseño y la implementación de un teclado
especialmente diseñado para niños que presenten una deficiencia en los
movimientos de sus extremidades superiores, este teclado contará con la
capacidad de generar por la presión que el niño realice sobre una tecla va a ser
transmitida a un microcontrolador que se encargara de convertir la señal de
interrupción en un código de exploración que enviará a un concentrador el que
se encargará en reconocer que tecla se presionó y posteriormente enviarlo a la
señal de video del televisor, y este a su vez visualizará el carácter oprimido en
la pantalla del televisor.
Además del teclado (que son 4 en total), el niño podrá contar con líneas de
texto independientes que le ayudará a llevar de una mejor forma su complejo
proceso de aprendizaje, este software será enfocado en el área de la escritura
(abecedario), matemáticas (las opciones básicas), que serán presentadas de
una manera didáctica para provocar un mayor grado de atención del infante,
con esto se generará un agradable ambiente educativo y un aprendizaje más
lúdico en el niño.
Por último, el diseño del teclado va a presentar características tales como la
opción de dejar la tecla “Shift” activada o desactivada, es decir solo minúsculas
o mayúsculas dependiendo de la necesidad para que el niño tenga la facilidad
de escribir sin tener que estar oprimida mecánicamente la tecla anteriormente
mencionada para cambiar el estilo de letra , esto para aquellas personas que
no puedan mantener oprimida más de una tecla al mismo tiempo.
Otra característica especial va a ser el control de la velocidad de repetición del
teclado desde este mismo, esto va a facilitar el correcto uso del teclado para
personas que se les dificulten el movimiento o el entorno dentro del sistema.
CAPÍTULO I
Generalidades
CAPITULO I GENERALIDADES
1.1 INSUFICIENCIA MOTORA DE ORIGEN CEREBRAL (IMOC)
Figura 1.1-1 Trastorno psicomotor
Los trastornos del desarrollo psicomotor son muy difíciles de definir, reflejan
siempre alteraciones en las que se ven afectados varios aspectos del
desarrollo del niño; de ahí la importancia de intervenir cuanto antes, pues el
trastorno puede ir repercutiendo negativamente en otras áreas del niño,
agravando y comprometiendo el desarrollo del niño.
Podemos decir que, de modo general, los trastornos psicomotrices están muy
ligados al mundo afectivo de la persona; de ahí, que en la valoración se deba
contemplar la globalidad del individuo.
Definiciones
•
Es un defecto o una lesión del cerebro inmaduro (0 – 5 años). No es una
enfermedad, sino, que es considerada como un conjunto de síntomas;
no es progresiva, no es genética, no ocasiona la muerte.
•
Enfermedad psico-neuromuscular, causada por una lesión motora
cerebral y ocurrida antes, durante o inmediatamente después del parto.
Incluye aislada o conjuntamente espasticidad, debilidad, incoordinación,
1
•
atetosis o temblor, con frecuencia asociado con retraso mental,
trastornos sensoriales, crisis convulsivas y trastornos visuales, auditivos
y del lenguaje.
•
La American Academy of Cerebral Palsy, la define como cualquier
alteración anormal del movimiento o de la función motora por defecto,
lesión o enfermedad del tejido nervioso contenido en la cavidad craneal,
pero esto es muy limitado para la gran complejidad etiopatogénica y
sintomatológica de este proceso. 1
1.2 DESCRIPCIÓN DE LA IMOC
Debilidad motriz
Básicamente, estos niños siempre presentan tres características:
Torpeza de movimientos (movimientos pobres y dificultad en su realización).
•
Paratonía: el niño no puede relajar el tono de sus músculos de forma
voluntaria; incluso en vez de relajarlos, los contrae exageradamente.
Este rasgo es el más característico de este trastorno.
•
Sincinesias: A veces, también presentan inestabilidad motriz, tics,
tartamudeo.
Este trastorno afecta a diferentes áreas del niño: al afectivo, la sensorial, al
psíquico y al motor.
--------------------------1 Rehabilitación Médica. Rafael González Mas. Editorial Masson, S.A..
http://www.aurasalud.com/
2
Inestabilidad motriz
El niño con inestabilidad motriz es incapaz de inhibir sus movimientos, así
como la emotividad que va ligada a éstos.
Es incapaz de mantener un esfuerzo de forma constante; se muestra muy
disperso.
Suele predominar la hiperactividad y las alteraciones en los movimientos de
coordinación motriz. Hay una constante agitación motriz.
Incidencia
Depende de la clase de cuidados prenatales, condiciones socioeconómicas de
los padres, peculiaridades del entorno y el tipo de asistencia obstétrica y
pediátrica recibida por la madre y el niño. Es 27 veces más frecuente en niños
con menos de 1500 grs. En el nacimiento, que en los que pesan más de 2500
grs.
Etiología: (Estudio de las causas de las enfermedades)
1. Prenatales: 30% según Perlstein y Hood.
•
Infección materna: cuando padecen rubéola o infecciones víricas al
comienzo del embarazo (defectos congénitos cerebrales).
•
Anoxia
prenatal:
por
intoxicación,
anemia,
hipotensión,
asfixia,
hemorragia, entre otros.
•
Trastornos metabólicos: la toxicoadicción de la madre o el padecimiento
de trastornos metabólicos como DM (Diabetes Mellitus) o trastornos de
tiroideos.
•
Embarazos múltiples: mayor incidencia. Gemelos (6%).
•
Prematuridad: en un tercio.
•
Edad de la madre: a mayor edad mayor riesgo según Yannet.
3
•
Sexo: mayor porcentaje en niños que en niñas. El 57% son niños según
Illingworth.
•
Raza: mayor en blancos.
2. Perinatales (Que precede o sigue inmediatamente al nacimiento): 60%
según Perlstein y Hood.
•
Anoxia: una tercera y la media parte nacen con signos anóxicos,
llegando al 13% los que no respiran espontáneamente durante 6
minutos o más; por obstrucción mecánica respiratoria, atelectasias,
anestésicos y drogas, placenta previa, parto de nalgas, entre otros.
•
Traumatismos y hemorragias: en el 60% de los casos son partos
complicados (aplicaciones incorrectas de forceps, inductores químicos
del parto sin suficiente control y partos prolongados.
•
Prematuridad: porque el cerebro del niño es altamente sensible a la
asfixia, lo mismo que el aparato respiratorio no es capaz de asimilar bien
el oxígeno, lo cual lleva a depresión respiratoria y ésto, a lesión del
cerebro.
3. Postnatales: 10% según Perlstein y Hood.
•
Traumatismos craneales.
•
Infecciones: meningitis tuberculosa o piógena y encefalitis (víricas).
•
Intoxicaciones: con degeneración nerviosa.
•
Accidentes vasculares: encefalopatía hipertensiva, embolias y trombosis.
•
Anoxia: por estrangulamiento, hipoglucemia, grandes alturas, entre
otros.
Clasificación:
1. Según la localización (topografía)
•
Diplejía simétrica congénita.
4
•
Paraplejía congénita.
•
Tetraplejía o hemiplejía bilateral.
•
Triplejía.
•
Hemiplejía.
2. Según el tipo de trastorno (fisiológica – tono muscular)
Espástica: daño en área 4, 4s, 5 y 6 (piramidal).
•
Reflejos patológicos (Hoffman, Clonus, Babinsky).
•
ROT (Reflejos osteotendinosos) aumentados.
•
Signo de navaja.
•
Dedo cortical.
•
Contracción excesiva de agonistas.
•
Sobreexcitación de alfa.
Rigidez: alteración del sistema extrapiramidal.
•
No reflejos patológicos.
•
ROT normales o disminuidos.
•
Signo de rueda dentada o caño de plomo.
•
Coocontracción de agonistas y antagonistas.
•
Sobreexcitación de gamma y en menor grado de alfa.
Flácido: agenesia del cuerpo calloso.
•
Disminución de la función del sistema inmunológico.
•
Dura
máximo
1
año
(incompatible
con
la
vida,
complicaciones respiratorias y procesos infecciosos).
Corea: sistema extrapiramidal (putamen y caudado).
5
mueren
por
•
Movimientos
incordiándoos,
amplios,
incontrolados,
rápidos,
de
estructuras proximales.
•
No ceden con el reposo.
Atetosis: sistema extrapiramidal (ganglios basales).
•
Movimientos lentos, de rango pequeño, de estructuras distales, ceden
con el reposo.
•
Tono fluctuante, aumento anormal de movimientos involuntarios.
•
Incoordinación en movimientos.
Ataxia: alteración del cerebelo (sistema propioceptivo).
•
No percepción de sentido de posición de articulaciones.
•
Mejor pronóstico, evoluciona más rápido.
•
Base de sustentación amplia, mirada al piso.
•
Hipotonía muscular e hipermovilidad articular.
•
Incoordinación por la alteración del sentido cinestésico o del equilibrio.
•
La acción de los antagonistas está falta de una regulación adecuada,
así, cuando se contraen agonistas, los antagonistas se relajan súbita y
totalmente, en vez de hacerlo de manera gradual (le lleva a inestabilidad
y aumento de la amplitud de movimiento).
Trastornos asociados
•
Trastornos convulsivos.
•
Deficiencia mental.
•
Trastornos auditivos.
•
Trastornos sensoriales.
•
Trastornos visuales (estrabismo, nistagmo, tics, entre otros).
•
Trastornos de percepción.
•
Trastornos dentales y de nutrición.
6
•
Trastornos de personalidad (sentimiento de inseguridad, miedos
excesivos,
•
sentimientos de inferioridad, pérdida de la motivación, entre otros).
•
Trastornos del lenguaje: 73% por afectación de músculos de laringe,
tórax, diafragma, abdomen, trastornos auditivos e intelectivos, lesión
cortical, disfunciones musculares de lengua y anomalías de diente y
paladar.
Pronóstico
•
No va a haber curación total.
•
Los patrones reflejos primitivos van desapareciendo con la maduración
del SNC (Sistema Nervioso Central), pueden persistir durante un largo
período o para toda la vida.
•
Si un niño se sienta antes de los dos años generalmente aprende a
caminar independientemente.
•
Si se sienta de 2 – 4 años, sus posibilidades son del 50%.
•
Si no se sienta antes de los 4 años, rara vez se para y camina.
•
También ayuda para la marcha, si se controla cabeza a los 9 meses y
gatea antes de 30 meses.
•
El promedio general de vida es de 20 – 30 años.
Prevención
•
Desde el proceso gestacional.
•
Educando a la madre.
•
Vacunas.
•
Alimentación.
•
Evitando infecciones.
•
Buen y adecuado control prenatal.
•
Que no consuma drogas, alcohol.
•
Que sea un niño deseado (intervención psicológica).
7
Diagnóstico
1. Pruebas en posición SUPINA (para mayores de 2 meses).
•
Miembro Superior: retracción de hombros, flexión de codo y muñeca.
•
Miembros Inferiores: extensión de cadera, plantiflexión, patrón en tijera.
No levanta brazos, no manipula objetos en línea media, no es capaz de
disociar movimientos ni de girar la cabeza.
“HIPERTONÍA EXTENSORA”
2. Pruebas en posición PRONA.
•
Miembro Superior: hombros protruídos, flexión de codo y muñeca,
cabeza fija en cama, atrapado en su propio cuerpo.
•
Si se le levanta o tracciona de los hombros, se genera la misma actitud
de los brazos y no manipula objetos.
•
Si es levantado de la pelvis, el Miembro Inferior (MI) queda en abducción
y extensión (como en el Landaw).
“HIPERTONÍA FLEXORA”
3. Pruebas en posición SEDENTE
•
No paracaídas frontal y lateral.
•
No sostiene ni adopta la posición.
•
Cuando es traccionado desde su posición supina a sedente, su cabeza
queda atrás, luego se nivela con el tronco y luego se cae (flexión).
4. Pruebas en posición de pié y suspensión vertical
•
Abducción de cadera y extensión de rodilla.
•
Pié con plantiflexión.
8
5. Para cuadriplejía atetoide
•
El tono es fluctuante (por poca inervación recíproca).
•
Instauración de la espasticidad.
•
Desarrolla el Tónico Asimétrico del Cuello (afecta Miembros Superiores
e inferiores, genera alteraciones de postura llevando a escoliosis).
•
Pruebas en supino: opistótonos (éste es de mal pronóstico)
Figura 1.1-2 Pruebas de desarrollo muscular en el cuello
•
Pruebas en prono: no levanta la cabeza, gira sin levantarla, los
hombros son protruídos.
•
Pruebas en sedente: al traccionarlo deja la cabeza atrás, se
nivela y luego cae.
Figura 1.1-3 Pruebas de elasticidad sedente (sentado)
6. Para hemiplejía
•
Asimetría de postura y movimiento.
•
Cara girada hacia el lado sano.
•
Hombro con retracción y descenso.
•
Mano cerrada y dedo cortical (pulgar en oposición).
•
Piernas en flexión, abducción y dedos en garra.
1. Pruebas en prono: no descarga peso en el lado afectado, no hay
reacción de paracaídas.
2. Pruebas en sedente: se extiende la pierna afectada.
9
7. Desarrollo de la espasticidad
•
Cuando es severa, realiza opistótonos.
1. Pruebas en supino: retracción de hombro, flexión muñeca y codo.
Espasticidad flexora (altera control de cabeza). Imposibilita
extender columna, cabeza y cadera.
2. Pruebas en sedente: cabeza y columna con inclinación anterior.
3. Pruebas en bípedo: patrón flexor en Miembro Superior
(retracción y flexión) y extensor en Miembro Inferior (rotación
interna, aducción y extensión).
Evaluación neurológica en pediatría
1. Anamnesis
•
Datos personales, antecedentes patológicos, familiares, quirúrgicos,
procedimiento del parto, si hubo complicaciones, semanas de nacido,
entre
otras
(para
reconocer
la
patología,
etiología
y
formular
posteriormente el tratamiento).
2. Diagnóstico Médico
3. Problemas asociados
•
Se toman en cuenta los que presente de los mencionados anteriormente
(lenguaje, auditivos, motores, entre otros, para tener más claro el
pronóstico y formular el tratamiento).
4. Tono Muscular
•
A la palpación, observación al movimiento, desplazamiento articular con
respecto a la gravedad.
10
•
Una forma fácil es coger el Miembro Superior (MS) como si fuéramos a
evaluar el ROT tricipital, se balancea el brazo y si hay resistencia se
considera espasticidad; cuando el AMA (amplitud de movilidad articular)
está aumentado, se siente el brazo flojo y pesado, se considera
hipotonía.
5. Inervación Recíproca
6. Actividad Refleja
Para mirar el grado de maduración.
•
Medulares: lesión en Núcleos de Daiters a ramas del vestibular
7. Son fásicos y respuestas automáticas e involuntarias
1.- Retracción Flexora (0 – 2 meses)
•
Se estimula en planta de pié, de talón a dedos y se hace presión.
•
Respuesta: flexión de MI.
•
Inhibición: rotación interna en MI y se hace el estímulo.
•
Interferencia Refleja: pataleo.
2.- Reflejo de Extensión (0 – 2 meses)
•
Se estimula en planta de pié con MI flejado.
•
Respuesta: extensión de MI.
•
Inhibición: rotación externa de MI y se hace el estímulo.
•
Interferencia Refleja: pataleo.
3.- Extensión Cruzada (0 – 2 meses)
•
Presión en tendón de aductores, parte media o proximal.
•
Respuesta: cruza el MI opuesto.
•
Inhibición: abducción, rotación externa de MMII y se estimula.
•
Interferencia: marcha y bipedestación.
11
4.- Flexo – extensión alterna (0 – 2 meses)
•
Flexión de un miembro.
•
Respuesta: extiende el otro.
•
Interferencia: pataleo.
5.- Apoyo negativo (0 – 2 meses)
•
Estímulo en planta o dorso de pié.
•
Respuesta: flexiona el MI.
•
Interferencia: bipedestación y marcha.
6.- Tónico Laberíntico en Supino (0 – 2 meses)
•
Aumento del tono extensor.
•
Inhibición: cabeza, MS e I en flexión.
•
Interferencia: trabajo en línea media.
7.- Tónico Laberíntico en Prono (0 – 2 meses)
•
Aumento del tono flexor.
•
Inhibición: extensión de MI, MS y cabeza.
8.- Tónico Asimétrico (0 – 3 o 4 meses)
•
Gira la cabeza hacia un lado.
•
Respuesta: extensión del lado rostral y flexión del craneal.
•
Inhibición: fija cabeza (se trabaja MS línea media, y MI movimientos de
flexión). Fijar MS (se trabaja cabeza y MI). Fijar MI (llevándolos a
abducción, rotación externa o flexión).
•
Interferencia: control de cabeza, tronco, sedente, giros y trabajos en
línea media.
9.- Tónico Simétrico en Flexión (0 – 3 o 4 meses)
•
Flexión de cabeza.
•
Respuesta: flexión de MS y extensión en MI.
•
Inhibición: principalmente fijar cabeza en neutro. Fijar MS (meter brazos
por debajo del cuerpo). Fijar MI (se llevan contra el pecho).
12
•
Interferencia: control cabeza, sedente, tronco, giros y trabajo en línea
media.
10.- Tónico Simétrico en Extensión (0 – 3 o 4 meses)
•
Extensión de cabeza.
•
Respuesta: extensión de MS y flexión de MI.
•
inhibición: cabeza neutro. Fijar MS en flexión y fijar MI extensión y
rotación interna para evitar que se flejen.
•
Interferencia: controles, giros y trabajos en línea media.
11.- Apoyo Positivo (0 – 6 o 7 meses)
•
Estímulo en dorso o planta del pié.
•
Respuesta: extensión de MI.
•
Inhibición: flejar rodillas, rotación externa apoyado en colchoneta y se
hace tapping de presión evitando la plantiflexión porque se fatiga la zona
donde se desencadena el reflejo.
•
Interferencia: bipedestación y marcha.
12.- Reacción de Enderezamiento Laberíntico
•
Prono: ojos cerrados, se deja caer la cabeza. Respuesta: alinea o lleva a
extensión (2 meses).
•
Supino: ojos cerrados, se deja caer la cabeza. Respuesta: alinea o lleva
a flexión (6 meses).
•
Lateral: ojos cerrados, se deja caer la cabeza. Respuesta: alinea o lleva
la cabeza a inclinación (7 meses).
13.- Reacción de Enderezamiento ópticas
•
Prono: 2 meses.
•
Supino: 6 meses.
•
Lateral: 7 meses.
NOTA: estas dos sirven para control de cabeza y equilibrio.
14.- Reacción de Enderezamiento del Cuello (0 – 6 meses)
13
•
Gira la cabeza.
•
Respuesta: gira en bloque.
•
Promoverlo: girar en ambos lados y luego el cuerpo.
•
Para rolados y giros.
15.- Reacción de Enderezamiento del Cuerpo sobre el Cuerpo (6 – 18 meses)
•
Gira la cabeza, luego cintura escapular y luego cintura pélvica.
•
Promoverlo: fijar pelvis y mover cintura escapular o viceversa.
•
Para rolados y giros.
16.- Reacciones de Equilibrio
•
Sedente: 8-10 meses. Estímulos desestabilizadores.
•
Cuadrúpedo: 10-12 meses. Estímulos desestabilizadores A-P y laterales.
•
Bípedo: 15-18 meses.
•
Dorsiflexión: 18 meses. Estimular, coger por debajo de las axilas, se
lleva a dorsiflexión y no se deja caer.
17.- Moro (0 – 3 mese)
•
Estímulo sonoro, vibración, cabeza.
•
Respuesta: abducción y llanto.
•
Inhibición: MS debajo del tronco o cadera.
•
Interferencia: bípedo, marcha, controles, giros, trabajo en línea media.
18.- Prensión Palmar (0 – 3 meses)
•
Estímulo: Presión cabeza MC (METACARPIANOS).
•
Respuesta: prensión.
•
Inhibición: antebrazo en supino, extender codo y rotación externa y se
hace el estímulo.
•
Interferencia: ausente ------ agarres.
•
Presente ----- no suelta agarres.
19.- Prensión Plantar (0 – 8 meses)
•
Estímulo: Presión en cabeza de MT (Metatarsianos).
14
•
Respuesta: prensión (fleja dedos).
•
Inhibición: extender dedos y estimular.
•
Interferencia: marcha.
20.- Landaw (6 – 18 meses)
•
En prono se deja como caer.
•
Respuesta: aumento del tono extensor.
•
Se promueve: para el control sedente y tronco.
21.- Paracaídas (6 meses en adelante)
•
En prono se deja caer sin soltar o con un objeto abajo.
•
Respuesta: extiende brazos o los apoya.
•
Promover de igual forma.
22.- Reacción Anfibia (6 – 10 meses)
•
En prono se realiza una presión en la ingle.
•
Respuesta: eleva la pelvis o cadera.
•
Inhibición: llevar a retroversión de cadera y no dejar que la levante.
•
Interferencia: arrastre y gateo.
23.- Babinsky (0 – 24 meses)
•
Se estimula el borde externo del pié hasta el hallux.
•
Respuesta: extiende el hallux y los otros dedos puede ir o no en
abanico.
•
Inhibición: flejar hallux y estimular.
•
Interferencia: marcha y bipedestación.
24.- Galant (0 – 2 meses)
•
Roce desde la 12ª costilla a cresta iliaca en prono.
•
Respuesta: inclinación a ese lado.
25.- Patrón de Marcha (9 – 12 meses)
•
Inclinar hacia delante en bípedo.
15
•
Respuesta: intenta dar pasos.
7. R.O.T. (Reflejos OsteoTendinosos)
8. A.M.A. (Amplitud de Movilidad Articular)
•
Puede estar limitado por aumento del tono muscular.
•
Atrofia o daño articular por incapacidad de movimiento o inadecuada
posición.
•
Pasivo: para mirar si necesita cirugía o aditamentos.
9. Retracciones Musculares
•
Por falta de movilidad o por tono muscular inadecuado.
10. Valoración Funcional Muscular
•
Para mirar incapacidad o dificultad para ciertos movimientos.
•
Para mirar control cortical de los movimientos a si los realiza en el patrón
normal.
11. Desarrollo Motor y Conducta Motora
12. Postura
Para deducir posibles deformidades funcionales, se observa:
•
Desviaciones posturales (asimetrías, escoliosis…).
•
Aditamentos.
•
Mediciones (cefálica, facial, torácica, MI)
13. Equilibrio
16
14. Coordinación
Habilidad para realizar conductas motoras adecuadamente de forma lenta,
rápida, gruesa y/o fina.
15. Marcha
Si la realiza.
16. Función de la Mano
Agarres, pinzas.
17. Sensibilidad
Es subjetiva.
18. Funciones Vitales
Deglución, masticación, succión, respiración, ojos.
19. Observaciones: (patrón, movimientos…)
20. Diagnóstico Fisioterapéutico: deficiencia, discapacidad y minusvalía
Como cargar los niños
•
Espástico Flexor: en prono, se coge el pecho y extender cabeza y la otra
mano extiende la pelvis.
•
Espástico extensor: manos debajo de axilas y los brazos de él en
abducción, se llevan alrededor del cuello de uno y las piernas van
abiertas a un lado.
Atetósicos: se colocan mirando hacia el frente, se fija el cuerpo y la cara.
17
Deformidades
Causas
•
Por inmovilidad.
•
Por el tono.
•
Por debilidad.
•
Por actividad refleja anormal.
•
En espásticos: escoliosis, cifoescoliosis, flexión de cadera y rodillas, pié
equino-varo o equino-valgo, subluxación de cadera por espasticidad en
aducción y rotación interna de cadera, deformidad en patrón flexor de
MS.
•
En atetósicos: tendencia a subluxaciones, dislocaciones de articulación
de mandíbula, hombro, cadera y dedos por su hipermovilidad.
Tratamiento
Objetivo General: mejorar la calidad de vida del paciente mediante diferentes
técnicas y métodos fisioterapéuticos que le ayuden al niño a obtener la mayor
independencia funcional posible en todas las actividades de la vida diaria
Objetivos específicos
•
Modular tono.
•
Mejorar propiocepción.
•
Mejorar esquema corporal.
•
Inhibir interferencias reflejas.
•
Aumentar A.M.A..
•
Evitar retracciones, contracturas y/o disminuirlas.
•
Facilitar movimientos.
•
Modular sensibilidad superficial y profunda.
•
Aumentar fuerza muscular.
•
Mejorar coordinación.
18
•
Mejorar equilibrio en diferentes posiciones.
•
Mejorar postura.
•
Adquisición de conductas motoras (rolados, sedente, bípedo, marcha…).
•
Evitar deformidades.
•
Manejar ayudas externas y/o aditamentos cuando se requieran.
Métodos utilizados
•
MÉTODO DE KABAT.
•
MÉTODO DE BOBATH.
•
MÉTODO DE ROOD.
•
MÉTODO DE TEMPLE FAY:
Utiliza reflejos patológicos para obtener esquemas de movimientos, postura,
propiocepción y estímulos periféricos.
Método de phelps
•
Educar el sistema motor para ejecutar actividades en un orden correcto,
para luego alcanzar habilidad para las AVD (Actividades de la Vida
Diaria)
•
Trabaja en este orden: relajación, modulación de tono, movimiento,
descanso, relajación, equilibrio, alcance y prensión, destreza. 1
------------------------------------------------------1 Rehabilitación Médica. Rafael González Mas. Editorial Masson, S.A..
http://www.aurasalud.com/
19
Método de pohl
Utiliza la concienciación muscular, función muscular y coordinación, con el fin
de obtener una relajación muscular, enseñar el control muscular voluntario y
construir un patrón de desarrollo. 1
Método de schwartz
Debe ser estimulado voluntariamente a intentar diversas actividades, esto
depende del nivel emocional, intelectual y físico. 2
Método de deaver
•
Máxima utilización de las manos.
•
Obtener un lenguaje adecuado.
•
Habilidad para ejecutar desplazamientos.
•
Adquirir una apariencia normal o casi normal.
•
Mantener máxima movilidad articular y preparar al niño para la ejecución
de movimientos coordinados y voluntarios, más necesarios para la vida
diaria. 3
Método de collis
•
Busca desde las edades más precoces una seguridad postural, que
sirva como base de coordinación muscular.
•
Considera que el empleo de aparatos ortopédicos es contraproducente
por interferir en el aprendizaje del equilibrio y la función motora. 4
------------------------------------------------------1,2,3,4 Rehabilitación Médica. Rafael González Mas. Editorial Masson, S.A..
http://www.aurasalud.com/
20
CAPÍTULO II
Fundamentos
Teóricos
21
CAPITULO II
FUNDAMENTOS TEÓRICOS
2.1 VIDEO
2.1.1 SEÑAL DE VIDEO
Para entender cualquier cosa sobre la generación de las señales video en
tiempo real, debemos
saber sobre las señales de video y como trabajan
detalladamente, así que antes de que miremos cualquier código tendremos que
hablar sobre el funcionamiento del televisor.
Para intentar comprender cómo se almacena y se muestra el vídeo debemos
retroceder en el tiempo y fijarnos en una tecnología muy obsoleta: la televisión
por tubo de rayos catódicos.
Un tubo de un televisor es un gran trozo de metal que no tiene aire dentro,
tenemos un cátodo que emite electrones cuando se calienta (por eso la imagen
tarda un rato en aparecer cuando se enciende la TV, el cátodo debe calentarse
primero hasta que la temperatura sea apropiada para emitir electrones), hay
también un fuerte campo electromagnético que acelera a los electrones hacia
la parte frontal del tubo, y que posiciona el haz de electrones (son muchos
electrones los que se lanzan hacia la parte frontal del tubo).
La parte frontal del tubo está cubierta de fósforo y cuando los electrones la
golpean, emite la luz hacia el otro lado (el lado en el que estarás tú). Debajo
puedes ver un esquema de un CRT (Cathodic Ray Tube, Tubo de rayos
catódicos).
22
Figura 2.1.1-1 Estructura interna de componentes de la pantalla
En un principio las televisiones eran sólo en blanco y negro, con lo que era
suficiente con un sólo haz de electrones, ahora para poder ver una película
debes escribir esta por toda la pantalla, así que el haz de electrones debe
barrer la pantalla, la frecuencia de barrido se conoce normalmente como tasa
de refresco (refresh rate). La tasa de refresco se escogió de acuerdo con los
ciclos de los sistemas eléctricos que se usaban:
•
Norteamérica y parte de Japón usan 60 Hz.
•
Europa, Oriente Medio y partes de Asia usan 50 Hz.
Esto dio lugar a dos sistemas de TV que compiten entre sí:
1.- NTSC: National Television Standard Committee
También conocido como "Never the same color" (nunca el mismo color) porque
no hay dos imágenes NTSC que se vean igual, el sistema NTSC tiene 525
líneas horizontales de las cuales apenas 487 se ven en la pantalla y tiene una
tasa de refresco de 60 Hz entrelazada (veremos esto más adelante).
23
2.- PAL: Phase Alternating Line
El sistema PAL tiene 625 líneas horizontales, de las cuales apenas 540 se ven
en la pantalla y tiene una tasa de refresco de 50 Hz entrelazada.
Ahora, en la época en la que aparecieron en el mercado las primeras TVs, la
tecnología que permitía escribir 525 líneas 60 veces por segundo, o 625 líneas
50 veces por segundo tenía un precio prohibitivo que no era adecuado para el
mercado de masas. Reducir la tasa de refresco habría requerido circuitos más
complicados y no era una opción tampoco, además la mente humana tiene un
límite inferior para lo que acepta como movimiento continuo.
Pero los ingenieros de TV tuvieron una idea: ¿Qué pasaría si escribiésemos
únicamente una de cada dos líneas en cada barrido, y escribiésemos la otra
mitad durante el siguiente barrido? De este modo sólo necesitaríamos 25/30
imágenes por segundo (lo que implica menos ancho de banda, lo que implica
más cadenas de TV en la misma banda de frecuencia), y el ojo humano
seguiría aceptando esto como movimiento continuo.
A esta idea de dividir la imagen en dos partes se la llamó entrelazado
(interlacing), ya a las imágenes divididas, campos (fields), visto de modo
gráfico, un campo es básicamente una imagen con una línea negra de cada
dos (o blanca).
Pero aquí esta una imagen para que puedan imaginar mejor lo que está
pasando:
Figura 2.1.1-2 Barrido entrelazado líneas impares
24
Figura 2.1.1-3 Barrido entrelazado líneas pares
Durante el primer barrido, el campo superior se escribe en la pantalla, como se
puede ver, se escriben las líneas 1, 3, 5, etc, y después de escribir cada línea,
el haz de electrones se mueve a la izquierda antes de escribir la siguiente
línea.
Como se ve a la izquierda, ahora la imagen muestra un efecto de "peinado",
parece que se esta viendo a través de un peine, cuando la gente habla de
artefacto entrelazado (interlacing artifacts) o dicen que su imagen está
entrelazada, se suelen referir a esto.
Una vez que se han escrito todas las líneas impares, el haz de electrones
regresa a la esquina superior izquierda de la pantalla y comienza a escribir las
pares, Como el fósforo tarda un momento en dejar de emitir luz y dado que el
cerebro humano es demasiado lento, en vez de dos campos distintos, lo que
vemos es una combinación de los dos, en otras palabras la imagen original.
Cuando finalmente llegó la TV en color, la tecnología de entrelazado siguió
siendo la misma, pero se necesitaba un tubo de rayos catódicos más
sofisticado. En vez de emitir un único haz de electrones, se emiten 3 haces de
electrones, con los colores rojo, verde y azul. Cuando colocas puntos de
distintos colores lo suficientemente cerca unos de otros, el ojo humano no verá
puntos individuales, sino un solo punto y unirá los colores para crear un nuevo
color. Debajo se puede preciar un esquema de un CRT en color.
25
Figura 2.1.1-4 Estructura interna del cañón de colores (RGB)
La pantalla se divide en tres colores: rojo, verde y azul, no obstante aquí
discutiremos El haz electrónico que dibuja la pantalla las dos imágenes de cada
parte se convierten en una imagen entera.
En el mundo del NTSC el cambio al color requirió un cambio más: la tasa de
refresco debía disminuirse ligeramente, de 60 Hz a 59.97 Hz (quedando en
29.97 imágenes por segundo) para ajustarse a los colores por este motivo
tenemos estas tasas de refresco tan extrañas en el mundo del NTSC en la
actualidad.
Ahora, antes de que procedamos a ver cómo filmaron las películas de
Hollywood, echemos un vistazo a los monitores de los PCs, el CRT tradicional
de un PC es distinto de las pantallas de TV, cuando los PCs aparecieron en el
mercado, se pudo finalmente escribir una imagen entera en un barrido, esto
también se llama escaneado progresivo (escaneado porque el haz de
electrones "escanea" cada línea de izquierda a derecha), los primeros
monitores de PC aún utilizaban modos entrelazados, pero el mayor contraste y
el brillo de los fondos nos daba tal dolor de cabeza que ahora tenemos la
suerte de que la mayoría de las pantallas ya no emplean este modo, hoy en día
todas las pantallas de PC escriben una imagen así:
26
Figura 2.1.1-5 Escaneo progresivo
Recientemente ha habido pantallas de TV que trabajan en modo de escaneo
progresivo, estos modelos sin embargo, son muy raros, y requieren una señal
distinta, ya que el modo tradicional de conectar los vídeos, reproductores de
DVD o cámaras a la TV no trabaja con imágenes progresivas, las pantallas de
LCD y de plasma sólo pueden escribir imágenes progresivas, cuando reciben
una imagen entrelazada necesitan trucos técnicos para mostrar una imagen
razonable, a estas técnicas se las llama normalmente desentrelazado
(deinterlacing).
Las TVs antiguas tenían tubos que no eran en absoluto planos, cuanto más nos
alejamos del centro del tubo (el punto en el cual el haz de electrones iría
directamente a la capa de fósforo sin desviarse), más complicado es escribir
una imagen geométricamente correcta y precisa, incluso en la actualidad no se
ve el tubo entero, las últimas pulgadas se esconden tras la carcasa de la TV,
esa es la razón por la que ambos formatos de TV tienen más líneas de las que
podemos ver, el resto de las líneas está y siempre estará escondido, pero estas
líneas se usan: los canales de TV transmiten páginas de texto en estas líneas,
pueden contener señales que estropean el amplificador (gain controller)
automático de tu aparato de vídeo (el sistema de protección anti-copia
analógico Macrovision), etc. 1
----------------------------------1
"http://es.wikipedia.org/wiki/NTSC"
Síntesis: Mtro. Jorge Arturo Pardiñas Mir.
27
La mayoría de las películas destinadas al cine se graban en un material similar
al que usamos en la fotografía tradicional, en un segundo se hace una escena
con 24 imágenes, así que en teoría podrías rodar una película con tu cámara
de fotos, sólo que tendrías que cambiar de rollo cada segundo o segundo y
medio (y normalmente las cámaras de fotos no pueden hacer 24 fotos en un
segundo;). Cuando vemos estas películas en el cine vemos 24 imágenes (o
frames) por segundo.
Pero cuando compramos estas películas en cinta de vídeo VHS, o en DVD
para verlas en nuestras pantallas de TV tenemos un problema, las pantallas
PAL necesitan 25 imágenes por segundo y cada imagen debe dividirse en 2
campos, pero dado que 25 no es mucho mayor que 24, lo que se suele hacer
en los países en los que usa PAL es tomar la película original a 24 fps (frames
por segundo) y acelerarla a 25 fps, esto implica que las voces y la música
tienen un tono más agudo y que la película es un poco más corta, pero a no ser
que compares una con otra, apenas se nota.
Ahora vamos con el NTSC. Aquí necesitamos 29.97fps, no se puede acelerar
la película ya que la diferencia de velocidad sería demasiado grande para que
la gente no la notase, así que lo que se hace es que tras dividir los frames en
campos, se repiten ciertos campos para obtener una mayor tasa de refresco,
básicamente 4 frames se convierten en 10 campos..
Generador de patrones de video
Introducción
El objetivo de este proyecto ha sido la construcción de un generador de
caracteres (letras del (abecedario, números y caracteres especiales) de video,
cuyas aplicaciones se extienden desde el campo de la enseñanza de la señal
de video hasta el ajuste de equipos receptores de televisión, no se ha
pretendido la realización de un equipo con fines comerciales, ya que no se
garantizan las especificaciones de un generador de video profesional, si bien
se a logrado un equipo de muy alta calidad.
28
Especificaciones
Patrones
: Caracteres, Raster, Cross-hatch, Puntos.
Controles
: Monocromático, luminancia, crominancia y burst de color
independientes.
Salida de video
: Video compuesto, 1 Vp-p en carga de 75 ohms.
Sistema de color : NTSC (opcional PAL-B/G/I cambiando el oscilador de
croma).
Sistema de barrido: Entrelazado (Barras y Raster), no entrelazado (Crosshatch y Puntos).
Alimentación
: 12 Vdc (Fuente de poder).
Consumo máximo : 70 mA (Raster blanco).
Aplicaciones
: Envío, recepción y visualización de caracteres por medio
del video del televisor.
Generalidades
El ojo humano es capaz de percibir imágenes mediante receptores ubicados en
la retina, hay dos tipos de receptores según su función:
Los bastones.- encargados de percibir imágenes en blanco y negro.
Los conos.- a cargo de la percepción del color.
Si nos concentramos en el estudio de los conos, veremos que hay de tres tipos:
los que reaccionan frente a la luz roja, los que lo hacen frente a luz verde y
finalmente los que son sensibles a la luz azul, solo se perciben tres colores, sin
embargo nosotros “vemos” todos los colores que nos rodean.
Aquí se hace evidente una regla básica del color:
Para conocer la información de color de un objeto basta con tener la proporción
de los tres colores básicos: Rojo, Verde y Azul, por esta razón a dichos colores
se los conoce como Colores Primarios, ya que con la combinación de los
mismos se pueden obtener todos los demás.
29
Ecuaciones
LUZ ROJA + LUZ VERDE + LUZ AZUL = LUZ BLANCA
Si los sumamos de a dos:
LUZ ROJA + LUZ VERDE = LUZ AMARILLA
LUZ ROJA + LUZ AZUL = LUZ MAGENTA
LUZ VERDE + LUZ AZUL = LUZ CIAN
CIAN + MAGENTA + AMARILLO = NEGRO
Los colores en televisión
La imagen en un televisor a colores se forma mediante la emisión de luz
resultante de la excitación de la película de fósforo, que recubre internamente
la pantalla, al ser alcanzada por un haz de electrones que barre periódicamente
la superficie visible, si hablamos de “emisión de luz”, inmediatamente debemos
pensar en procesos “aditivos”, lo cual nos lleva a concluir que en televisión los
colores primarios son el Rojo, Verde y Azul (RVA o en inglés RGB).
Efectivamente, dentro del tubo de televisión se emiten tres haces de
electrones, destinados cada uno a excitar una franja de fósforo en la pantalla,
la cual responderá emitiendo un color característico al fósforo empleado,
naturalmente como no podía ser de otro modo estos colores son Rojo, Verde y
Azul.
Todos los demás colores (y realmente “todos”) se pueden obtener combinado
estos tres primarios en distintas proporciones, un generador de barras básico
podría hacer lo siguiente:
•
Tener tres salidas, una para cada color primario
•
Cada una de estas salidas se conecta a la correspondiente entrada del
televisor
•
El equipo generará combinaciones de sus salidas, según la siguiente
tabla:
30
Figura 2.1.1-6 Tabla de generación de barra de colores
En esta tabla un “1” significa “presencia” del color, en tanto que un “0” es su
“ausencia”, en la práctica estos “unos” y “ceros” se representan por niveles de
tensión, por ejemplo 5V y 0V respectivamente.
Como se observa, es muy sencillo construir un generador de este tipo, ya que
basta un mínimo de electrónica digital para obtener estas barras, entonces,
¿por qué complicarse más?
La mayoría de los equipos de televisión y video no poseen entradas directas de
Rojo, Verde y Azul, estas quedan reservadas para monitores destinados al
campo profesional, lo habitual es que los equipos hogareños tengan una
entrada de “Video Compuesto”, denominada usualmente como “Video in”. Por
esta razón, nuestro generador debe poder convertir los componentes Rojo,
Verde y Azul en ese “Video Compuesto”.
Video compuesto
Las señales de Rojo, Verde y Azul (de ahora en más la llamaremos
simplemente RGB) contienen toda la información de la imagen, pero ocuparían
un ancho de banda considerable si se transmitieran, lo cual justamente es el
objetivo de una “transmisión” de televisión, para reducir este ancho de banda,
31
además de mantener la compatibilidad entre transmisiones en “Blanco y Negro”
y “Color”, se creó la señal de Video Compuesto.
En esta señal va la información de “luminosidad” (Luminancia) de una imagen,
su color (Crominancia), y además todos los sincronismos necesarios para
generar correctamente la imagen en la pantalla del televisor.
¿Cuáles son estos sincronismos?.
Figura 2.1.1-7 Escaneo del haz de electrones de la pantalla
Para contestar esta pregunta veamos primero como se forma una imagen en el
televisor, un haz de electrones (consideremos uno solo, sabemos que son tres)
recorre la pantalla de izquierda a derecha y de arriba a abajo, según
lo
muestra el esquema adjunto.
A medida que recorre la pantalla excita en mayor o menor grado al fósforo que
la recubre, generando una imagen, como se ve si bien la imagen aparece en
una pantalla de dos coordenadas (un plano), en realidad se genera mediante
líneas sucesivas, del mismo modo ingresa al equipo línea a línea.
Por lo tanto, es indudable que se necesita “sincronizar” el haz de electrones
que barre la pantalla con el barrido generado en el estudio de televisión, si no
se hiciera esto las imágenes aparecerían cortadas, con barras inclinadas, con
colores incorrectos (basta con ver un “canal codificado” para tener una idea de
lo que se quiere decir, ya que una manera de codificar la señal es quitarle los
sincronismos).
32
Sincronicemos entonces el barrido del haz, hay que informarle donde empieza
una nueva imagen (sincronismo Vertical o “V”) y donde comienza cada línea
(sincronismo Horizontal o “H”), evidentemente el sincronismo Horizontal es un
componente de mayor frecuencia que el Vertical, ya que dentro de cada
imagen hay muchas líneas de barrido.
¿Cuántas líneas hay dentro de una imagen? La respuesta es: “depende de la
norma de transmisión que estemos considerando”.
Normas de transmisión
Una norma es un conjunto de parámetros adoptados como regla dentro de
determinado grupo o región a fin de mantener una relación clara y sin
ambigüedades entre las partes, en televisión es exactamente eso, las normas
establecen los parámetros que deben seguir tanto los equipos transmisores de
señal como los receptores, a fin de que se establezca una comunicación
segura y sin errores entre ambos, entre los muchos parámetros que se fijan
consideraremos solo los que atañen a nuestro proyecto.
•
Frecuencia Horizontal (H): Frecuencia a la que se repiten las líneas de
imagen.
•
Sincronismo Horizontal (H Sync): Pulso que indica el comienzo de
una línea de imagen.
•
Frecuencia Vertical (V): Frecuencia a la que se repiten las imágenes
(campos).
•
Sincronismo Vertical (V Sync.): Pulso que indica el comienzo de una
imagen (campo).
•
Líneas Horizontales: cantidad de líneas que forman una imagen
completa (cuadro).
•
Subportadora de Color (SC): Frecuencia a la que se modula para
enviar la información de color.
•
“BURST” de Color: ráfaga de la SC que “sincroniza” la demodulación
del color.
33
•
“Front Porch”: intervalo de señal sin información de imagen previo al H.
Sync.
•
“Back Porch”: intervalo de señal posterior al H Sync., donde se coloca
el BURST.
Todo esto se resume en el siguiente diagrama:
Figura 2.1.1-8 Parámetros de transmisión de la señal de video
En la información anterior se hizo referencia a dos palabras que aún no han
sido definidas:
Campo y Cuadro: Para comprender su definición debemos primero aclarar el
concepto de “Barrido Entrelazado”, como ya se dijo para reconstruir la imagen
en la pantalla del televisor, el haz de electrones recorre la misma línea a línea
de arriba abajo, bastaría una pasada completa del haz de electrones para tener
una imagen formada en pantalla, sin embargo no es así, se requiere que el haz
de electrones “barra” dos veces la pantalla para formar una imagen completa.
Veamos esto con más detenimiento
Cuando la cámara de video en el estudio de televisión “escanea” la imagen que
va a transmitir, lo hace dividiendo la imagen en líneas horizontales, estas líneas
serán posteriormente transmitidas al receptor de televisión para que este las
reproduzca secuencialmente en la pantalla, sin embargo no se transmiten las
34
líneas consecutivamente (línea 1, 2, 3, 4, …) sino que primero se transmiten las
impares (línea 1, 3, 5, …) y luego las pares (línea 2, 4 ,6, …).
Del mismo modo recorre el haz de electrones la pantalla, reproduciendo
primero las líneas impares y luego las pares, por este motivo se requiere que el
haz recorra 2 veces toda la pantalla para formar una imagen completa, a las
dos “semi-imagenes” se les denomina Campos (Impar y Par respectivamente) y
a la imagen completa Cuadro, esto se esquematiza en la figura adjunta.
Figura 2.1.1-9 Escaneo campo impar y par
En esta figura se ha denominado I al Campo Impar y II al Campo Par, en el
diagrama se puede observar que el campo impar termina en media línea
horizontal y el par comienza con media línea horizontal, esta característica la
veremos a continuación cuando analicemos las dos formas de barrido que
pueden encontrarse:
35
Barrido Entrelazado y Barrido No Entrelazado
Figura 2.1.1-10 Barrido entrelazado
Figura 2.1.1-11 Barrido no entrelazado
El ejemplo que acabamos de ver corresponde a una imagen generada con
Barrido Entrelazado, su nombre proviene del “entrelazamiento” de las líneas de
barrido de dos campos sucesivos.
¿Qué ventaja tiene?, obtener una mayor frecuencia de repetición de imágenes
sin aumentar el ancho de banda.
¿Cómo es esto?, por el canal de transmisión se envían una cierta cantidad de
imágenes por segundo (digamos por ejemplo 25), en el televisor se reproducen
estas 25 imágenes por segundo, pero barriendo la pantalla 50 veces por
segundo.
Para nuestro ojo es como si se hubieran generado 50 imágenes en un
segundo, haciendo imperceptible el “parpadeo” de la imagen, como dato
adicional, en el cine ocurre lo mismo las películas antiguas corrían a 16
cuadros por segundo, y en ellas era muy notorio el parpadeo.
Actualmente se filma a 24 cuadros por segundo, y el obturador se abre dos
veces en cada cuadro durante la proyección, con el mismo propósito de
disminuir el “parpadeo”.
36
Volviendo a la televisión, si este método es tan bueno, no tiene sentido insistir
con el Barrido No Entrelazado, sin embargo, el entrelazamiento que ha probado
ser insustituible en imágenes en movimiento, falla en imágenes fijas.
¿Por qué?, Imaginemos una línea blanca horizontal quieta sobre un fondo
negro en medio de la pantalla, cuando se barre el campo impar la línea
aparecerá a determinada altura, en tanto que cuando se barra el campo par la
misma aparecerá naturalmente una línea horizontal más arriba o más abajo
que la anterior.
Al sucederse los campos, la línea se verá “temblar” en sentido vertical, en
forma poco perceptible, pero muy molesta si uno debe fijar la vista en la
pantalla.
¿Cómo se soluciona?, fácil, se utiliza el Barrido No Entrelazado. Este es mucho
más sencillo, simplemente las líneas de barrido se superponen campo tras
campo, esta técnica es muy utilizada en monitores de computación y en
generadores de patrones cuando se utilizan señales como el “Cross-hatch”
(líneas) y “Puntos”.
Figura 2.1.1-12 Generador de líneas
Figura 2.1.1-13 Generador de puntos
37
Diferentes estándares de televisión (distribución mundial)
Figura 2.1.1-14 Distribución mundial del sistema de televisión
Un el mapa se muestra los diferentes tipos de televisión usados en el mundo
estándares de vídeo: NTSC y PAL. 1
El vídeo que vemos en una pantalla de televisión sigue unas normas
establecidas en los años 50 del siglo pasado, cuando apareció la televisión en
color, los formatos más importantes utilizados hoy en día son NTSC (National
Television System Committee) y PAL (Phase Alternating Line).
En términos generales, NTSC es el estándar utilizado en América del Norte y
del Sur y en Japón, mientras que PAL se utiliza en Europa, Australia, Oriente
Medio y Asia.
Tamaño de fotogramas: NTSC y PAL tienen tamaños de imagen diferentes.
Velocidad de reproducción de fotogramas: NTSC y PAL utilizan diferentes
velocidades de reproducción de fotogramas para mostrar imágenes proporción
de aspecto de píxeles.
----------------------------------1Tutorial Pc y Pic
http://conket.com/modules.php?name=Sections&op=viewarticle&artid=14
38
Píxeles: NTSC y PAL comparten la misma proporción de aspecto de píxeles
(conocida como proporción de aspecto D1, que es básicamente rectangular).
Visualización:
NTSC
y PAL constan de
dos
campos
"entrelazados"
independientes, mientras que los monitores de equipos informáticos muestran
imágenes "progresivas".
2.1.2 SISTEMA PAL
El sistema PAL deriva directamente del NTSC con algunas correcciones
técnicas.
PAL es la sigla de Phase Alternating Line (línea alternada en fase), este es el
nombre con que se designa al sistema de codificación empleado en la
transmisión de señales de televisión en color en la mayor parte del mundo, de
origen alemán, se utiliza en la mayoría de los países africanos, asiáticos y
europeos (entre ellos España), además de Australia.
El sistema PAL surgió en el año 1963, de manos del Dr. Walter Bruch en los
laboratorios de Telefunken en su intento por mejorar la calidad y reducir los
defectos en los tonos de color que presentaba el sistema NTSC.
No obstante, los conceptos fundamentales de la transmisión de señales han
sido adoptados del sistema NTSC.
Detalles técnicos
El nombre "Phase Alternating Line" (línea alternada en fase) describe el modo
en que la información de crominancia (color) de la señal de vídeo es invertida
en fase en cada línea, permitiendo la correción automática de los posibles
errores en fase al cancelarse entre sí, en la transmisión de datos por
radiofrecuencia, los errores en fase son comunes, y se deben a retardos de la
señal en su llegada o procesado.
39
Aprovechando que habitualmente el contenido de color de una línea y la
siguiente es similar, en el receptor se compensan automáticamente los errores
de tono de color tomando para la muestra en pantalla el valor medio de una
línea y la anterior, dado que el posible error de fase existente será contrario
entre una línea y la siguiente. De esta forma dicho error, en lugar de un
corrimiento del tono como ocurriría en NTSC, queda convertido en un ligero
defecto de saturación de color que es mucho menos perceptible al ojo humano.
Esta es la gran ventaja del sistema PAL frente al sistema NTSC.
Las líneas en que la fase está invertida respecto a cómo se transmitirían en
NTSC se llaman a menudo líneas PAL, y las que coincidirían se denominan
líneas NTSC.
El funcionamiento del sistema PAL implica que es constructivamente más
complicado de realizar que el sistema NTSC, esto es debido a que si bien los
primeros receptores PAL aprovechaban las imperfecciones del ojo humano
para cancelar los errores de fase, sin la corrección electrónica explicada arriba
(toma del valor medio), esto daba lugar a un efecto muy visible de "peine" si el
error excedía los 5º, la solución fue introducir una línea de retardo en el
procesado de la señal de luminancia de aproximadamente 64 µs que sirve para
almacenar la información de crominancia de cada línea recibida; la media de
crominancia de una línea y la anterior es lo que se muestra por pantalla.
Los dispositivos que eran capaces de producir este retardo eran relativamente
caros en la época en la que se introdujo el sistema PAL, pero en la actualidad
se fabrican receptores a muy bajo costo, esta solución reduce la resolución
vertical de color en comparación con NTSC, pero como la retina humana es
mucho menos sensible a la información de color que a la de luminancia o brillo,
este efecto no es muy visible.
Los televisores NTSC incorporan un corrector de matiz de color (en inglés, tint
control) para realizar esta corrección manualmente, finalmente en el sistema
PAL es más probable que el aparato receptor malinterprete una señal de color
como señal de luminancia, o viceversa, que en el sistema NTSC, en
40
consecuencia el sistema NTSC es técnicamente superior en aquellos casos en
los que la señal es transmitida sin variaciones de fase (y, por tanto, sin los
defectos de tono de color anteriormente descritos), por ejemplo en la televisión
por cable, por satélite, en videojuegos, en reproductores de vídeo, y en general
en todas las aplicaciones en banda base.
Formatos del sistema PAL
El sistema de color PAL se usa habitualmente con un formato de vídeo de 625
líneas por cuadro (un cuadro es una imagen completa, compuesta de dos
campos entrelazados) y una tasa de refresco de pantalla de 25 cuadros por
segundo, entrelazadas, como ocurre por ejemplo en las variantes PAL-B, G, H,
I y N, algunos países del Este de Europa que abandonaron el sistema SECAM
ahora emplean PAL D o K, adaptaciones para mantener algunos aspectos
técnicos de SECAM en PAL.
Norma N
Actualmente en el mundo hay muchas normas de transmisión de televisión,
denominadas con letras desde la “A” a la “N”, algunas ya no se utilizan, pero la
mayoría siguen vigentes veamos ahora los valores que se han establecido
para los parámetros que hemos definido enla norma N, utilizada en solo tres
países del mundo: Argentina, Uruguay y Paraguay.
Frecuencia Horizontal (H)
: 15626 Hz (duración de una línea: 64
µseg.)
Sincronismo Horizontal (H Sync) : 4.8 µseg.
Frecuencia Vertical (V)
: 50 Hz (duración de un campo: 20 mseg.)
Sincronismo Vertical (V Sync.)
: 2.5 líneas horizontales
Líneas Horizontales
: 625 por cuadro (312.5 por campo)
Subportadora de Color (SC)
: 3.582056 MHz
“BURST” de Color
: 9 a 11 ciclos de SC
“Front Porch”
: 1.9 µseg.
“Back Porch”
: 5 µseg.
41
Si comparamos estos valores con normas en uso en Europa (B, G, I) veremos
que hay una gran similitud, excepto por el valor de la subportadora de color (en
estos sistemas es 4.43 MHz), para concluir con el tema de las normas, veamos
un esquema que representa una señal real de video norma N, utilizando los
dos métodos de barrido ya analizados.
Concentrémonos solamente en el método entrelazado. Se ve claramente como
el pulso de sincronismo vertical abarca 2½ líneas horizontales (la 1, 2, y mitad
de la 3 en el Campo I). Pero además se ve algo no mencionado hasta ahora:
parecieron unos pulsos de Pre y Pos-Ecualización.
¿Qué es esto?, la detección del sincronismo vertical en el televisor se realiza
integrando la señal de video que llega, y cuando esta alcanza un determinado
valor se dispara el barrido vertical, la integración se lleva a cabo mediante un
circuito RC, y se monitorea la carga del capacitor para decidir cuando disparar
el vertical.
Dependiendo de la imagen previa al pulso de sincronismo vertical, el capacitor
podrá estar más o menos cargado, haciendo que los barridos verticales no se
disparen siempre en un mismo punto, provocando inestabilidades en la imagen
(temblor vertical),
para evitar esto se colocan los pulsos de pre y pos-
ecualización, cuya función es llevar la carga del capacitor a valores fijos antes y
después del pulso vertical, el hecho de hacerlo también después evita disparos
erráticos del sistema.
Los pulsos de pre y pos-ecualización tienen una frecuencia igual al doble de la
horizontal y su duración es la mitad de la del H Sync, se aplican durante un
tiempo igual a 2½ líneas horizontales, finalmente los pulsos positivos que
aparecen dentro del pulso de sincronismo vertical se denominan “Serrated
Pulses”, y su función es mantener enganchado al oscilador horizontal durante
este período. Su duración es igual al H Sync.
42
Cuadro de pulsos
Figura 2.1.2-1 Diagrama de tiempos del sistema PAL
----------------------------------1.- Tutorial Pc y Pic
http://conket.com/modules.php?name=Sections&op=viewarticle&artid=14
43
1
2.1.3 SISTEMA NTSC
NTSC
Es un sistema de codificación y transmisión de televisión analógica
desarrollado en Estados Unidos en torno a 1940, y que se emplea en la
actualidad en la mayor parte de América y Japón, entre otros países, el nombre
viene del comité de expertos que lo desarrolló, el National Television System(s)
Committee.
Vídeo NTSC
El formato NTSC consiste en la transmisión de 29.97 cuadros de vídeo en
modo entrelazado con un total de 525 líneas de resolución y una velocidad de
actualización de 30 cuadros de vídeo por segundo y 60 campos de alternación
de líneas.
Para garantizar la compatibilidad con el sistema NTSC en blanco y negro, el
sistema NTSC de color mantiene la señal monocromática en blanco y negro
como componente de luminancia de la imagen en color, mientras que las dos
componentes de crominancia se modulan con una modulación de amplitud en
cuadratura sobre una subportadora de 3,579545 MHz.
La demodulación de las componentes de crominancia es necesariamente
síncrona, por lo tanto se envía al inicio de cada línea una señal sinusoidal de
referencia de fase conocida como "salva de color", "burst" o "colorburst".
Esta señal tiene una fase de 180º y es utilizada por el demodulador de la
crominancia para realizar correctamente la demodulación, a veces el nivel del
"burst" es utilizado como referencia para corregir variaciones de amplitud de la
crominancia. Generación de una señal eléctrica con la información de una
imagen.
44
El sistema de televisión utilizado NTSC (National Television Systems
Commitee), tiene algunos de parámetros de la señal de video definidos en el
sistema que son los siguientes:
La imagen a reproducir se confina a una forma rectangular horizontal con una
relación de dimensiones consistente en 4 unidades horizontales por 3 unidades
verticales. La imagen es proyectada hacia un dispositivo que convertirá la
información de aquella en señal eléctrica que permita su posterior
reproducción.
La información de la imagen es obtenida en el dispositivo de conversión a
través de explorar o hacer un barrido de esta por medio de líneas, de izquierda
a derecha y comenzando con la esquina superior izquierda.
La imagen se forma por el barrido de 525 líneas horizontales, estableciéndose
como distancia de observación adecuada entre 4 y 8 veces la altura de la
imagen, la continuidad del movimiento se logra presentando 30 (29.97)
imágenes por segundo.
La frecuencia de barrido de las líneas horizontales es de 525 x 29.97 =
15,734.25 Hz (Usualmente se hace referencia al valor de frecuencia obtenido
redondeando el número de imágenes por segundo a 30: 525 x 30 = 15,750 Hz.
Cada imagen se divide en dos partes denominadas campos. Cada campo es
barrido por lo tanto a una velocidad de 60 por segundo, el doble de una imagen
completa, con lo que se consigue eliminar el efecto visual de parpadeo.
Cada campo contiene únicamente 262.5 líneas, pero estas líneas no son
continuas, sino que se toman de manera entrelazada: si la imagen consiste en
525 líneas y estas se numeran consecutivamente, un campo se forma
solamente por las líneas de número impar, mientras que el otro por las líneas
de número par. A este método se le denomina barrido entrelazado el barrido
vertical se realiza de manera continua mientras se realiza el barrido horizontal.
45
La información de la imagen sólo se obtiene durante el barrido horizontal de
izquierda a derecha, el tiempo de barrido horizontal de izquierda a derecha es
mayor que el tiempo de regreso para comenzar a barrer la siguiente línea.
A continuación se muestran gráficas de los barridos realizados para formar una
imagen completa. En la primera se tiene que se ha barrido en el primer 1/60 de
segundo las líneas impares de la imagen, mientras que en la segunda gráfica
se presenta el siguiente 1/60 de segundo con el barrido de las líneas impares,
resultando la imagen completa de 525 líneas después de 1/30 de segundo.
46
Radiodifusión
Un canal de televisión transmitido en el sistema NTSC utiliza alrededor de 6
MHz de ancho de banda, para contener la señal de vídeo, más una banda de
resguardo de 250 khz entre la señal de vídeo y la de audio. Los 6 Mhz de
ancho de banda se distribuyen de la siguiente forma:
1,25Mhz para la portadora de vídeo principal con dos bandas laterales de
4,2Mhz; las componentes de color a 3,579545 Mhz sobre la portadora de vídeo
principal, moduladas en cuadratura; la portadora de audio principal de 4,5 Mhz
transmitida sobre la señal de video principal y los últimos 250 Khz de cada
canal para la señal audio estereofónica en frecuencia modulada. La señal de
crominancia en la norma NTSC se transmite en una frecuencia subportadora
FM en los 3.58 Mhz
Inconvenientes
Los problemas de transmisión e interferencia tienden a degradar la calidad de
la imagen en el sistema NTSC, alterando la fase de la señal del color, por lo
que en algunas ocasiones el cuadro pierde a su equilibrio del color en el
momento de ser recibido, esto hace necesario incluir un control de tinte, que no
es necesario en los sistemas PAL o SECAM. Por eso en broma se le denomina
"NTSC: Never The Same Color" ("NTSC: Nunca el mismo color").
Otra de sus desventajas es su limitada resolución, de solo 525 líneas de
resolución vertical, la más baja entre todos los sistemas de televisión, lo que da
lugar a una imagen de calidad inferior a la que es posible enviar en el mismo
ancho de banda con otros sistemas. Además, la conversión de los formatos
cinematográficos a NTSC requiere un proceso adicional conocido como "
pulldown de 3:2 ".
47
Ntsc digital
Lo dicho anteriormente se refiere al sistema NTSC en dispositivos analógicos.
En los dispositivos digitales, como televisión digital, consolas de videojuegos
modernas, DVD, etc., ni siquiera importa la codificación de color empleada, y
ya no hay diferencia entre sistemas, quedando el significado de NTSC reducido
a un número de líneas igual a 480 líneas horizontales (240 para mitad de
resolución, como VCD) con una tasa de refresco de la imagen de 29.97
imágenes por segundo, o el doble en campos por segundo para imágenes
entrelazadas.
Diagrama de tiempos
Figura 2.1.3-4 Diagrama de tiempos del sistema NTSC
48
Detalles de símbolos de sincronismo de video
Símbolos Características
NTSC
H
Periodo de línea (µs)
63.5555
a
Borrando (µs)
10.9±0.2
b
Tiemopo de dato (0H) y pulso de
borrado (µs)
9.2 to 10.3
c
Front porch (µs)
1.27 to 2.22
d
Synchronizing pulse (µs)
4.7±0.1
e
Borrado de pulso (µs)
<0.48
f
Sincroniza pulso (µs)
<0.25
g
Señal de portador (µs)
5.3 (4.71 to 5.71)
h
Duración de portador (µs)
2.23 to 3.11(9±1 cycles)
Descripción
Representación de la intensidad de luz en la señal eléctrica
Parte importante de la información que se obtiene de una imagen para permitir
su reproducción es la intensidad de luz de cada punto de la imagen. La señal
de video contiene la información de la intensidad de luz, siendo su amplitud
directamente proporcional a esta y de manera tal que valores de amplitud de
señal eléctrica mayor correspondan a mayores intensidades de luz.
En la señal de video sólo se incluye la información de la intensidad de luz
obtenida durante el barrido horizontal de izquierda a derecha, omitiéndose
durante el tiempo de regreso para barrer la siguiente línea horizontal y durante
el tiempo de regreso para comenzar a barrer el siguiente campo.
49
Borrado y sincronía
Durante los tiempos de retroceso horizontal y vertical la señal de video se
mantiene durante un tiempo en un estado denominado como de borrado,
correspondiendo a un valor de intensidad menor al menor valor de intensidad
posible de la imagen.
Durante otro lapso de tiempo, dentro del mismo intervalo de borrado, el
dispositivo convertidor de imagen a señal eléctrica incluye en la señal de video
que se está generando niveles de voltaje que indican el momento en que se
considera que la línea horizontal se ha terminado y debe de realizarse el
retroceso, información que se le denomina como pulso de sincronía horizontal y
vertical.
En la siguiente figura se muestra la forma de la señal de video correspondiente
a una línea horizontal, incluidos los períodos de borrado, sincronía y el inicio de
la siguiente línea, así como los valores proporcionales de tiempo y amplitud,
todos ellos de acuerdo al estándar NTSC.
Figura 2.1.3-5 Tiempos de escaneo de la imagen
50
Durante el retroceso vertical se introduce también en la señal de video un pulso
de sincronía vertical, sólo que en este caso el pulso de sincronía vertical debe
permitir que no se deje de tener sincronía horizontal, razón por la cual el pulso
de sincronía vertical tiene las siguientes características:
El intervalo de tiempo correspondiente al retroceso vertical tiene una duración
de 9 líneas horizontales, las 3 primeras líneas forman una zona denominada
como de igualación, las 3 líneas centrales son en sí el pulso de sincronía y las
últimas 3 líneas horizontales forman otra vez una zona de igualación.
En todo el intervalo de retroceso vertical los pulsos de sincronía se producen al
doble de la frecuencia: 31,468.5 Hz, en las zonas de igualación los pulsos de
sincronía son invertidos en su forma (observar detalle en figura).
Figura 2.1.3-6 Diagrama de sincronismo
51
2.2 MICROCONTROLADORES
2.2.1 INTRODUCCIÓN
La evolución de la electrónica desde la aparición del circuito integrado ha sido
constante. Actualmente podemos encontrar dispositivos cada vez más
complejos ubicados en encapsulados cada vez más pequeños, un ejemplo de
esto son los microcontroladores.
Un microcontrolador, es un dispositivo electrónico encapsulado en un chip,
capaz de ejecutar un programa. El microcontrolador reúne en un solo
integrado: microprocesador, memoria de programa, memoria de datos y
puertos de entrada/salida. Además, también suelen disponer de otras
características especiales como: puertos serie, comparadores, convertidor
analógico-digital, etc.
En el mercado existen gran variedad de
microcontroladores de marcas y
características distintas que podremos utilizar dependiendo de la aplicación a
realizar.
Un microcontrolador ejecuta instrucciones. El conjunto de instrucciones es lo
que llamamos programa. Las instrucciones son leídas de la memoria de
programa para ejecutarlas una detrás de otra. La memoria de programa
contiene las instrucciones que queremos que el microcontrolador ejecute.
Programar un microcontrolador consiste en introducir el programa en la
memoria del microcontrolador. Las instrucciones son operaciones simples
como sumar, restar, escribir en un puerto, activar un bit de un dato, etc.
Mediante estas instrucciones básicas podemos realizar operaciones más
complejas y así llegar al objetivo de la aplicación.
En este capítulo nos vamos a centrar en los microprocesadores de la casa
Microchip Technology, es decir los PICs. Este tipo de microprocesadores están
muy extendidos actualmente en el mercado gracias a su gran variedad y bajo
52
costo. Otra razón del éxito de los PICs es su utilización, ya que una vez se ha
aprendido a utilizar uno, conociendo su arquitectura y juego de instrucciones,
es muy fácil emplear otro modelo diferente.
2.2.2 HISTORIA DE LOS PIC’s
En 1965 GI formó una división de microelectrónica destinada a generar las
primeras arquitecturas viables de memoria EPROM y EEPROM. A principios de
1970 se creó el CP1600 que era un microprocesador bastante bueno pero no
manejaba muy bien los puertos de E/S, por esta razón en 1975 se creó el PIC
que era un chip que funcionaba en combinación con este microprocesador para
controlar las E/S.
Alrededor de 1980 GI reestructuró la empresa y creó la GI Micro electronics
que finalmente fue vendida a un grupo de inversores de capital de riesgo que
crearon la actual Arizona Microchip Technology y centraron su negocio en la
fabricación de PICs, memorias EEROM y EPROM. Actualmente Microchip ha
realizado un gran número de mejoras a la arquitectura original de los PICs,
adaptándola a las actuales tecnologías y al bajo costo de los semiconductores.
Figura 2.2.2-1 Arquitectura de la memoria interna del microcontrolador (pic)
2.2.3 ELECCIÓN DEL MICROCONTROLADOR PARA NUESTRO SISTEMA
Para la elección de un
microcontrolador
debemos primero conocer las
bondades de cada uno de los tipos, conociendo sus ventajas y características
que ayudarán a realizar un trabajo mucho más eficiente y reduciendo su
tamaño y principalmente el costo.
53
Características de los PICs
Las características más destacadas de los PICs las enumeramos en los
siguientes puntos:
1ª. La arquitectura del procesador sigue el modelo Harvard
Tradicionalmente, las computadoras y microprocesadores siguen el modelo
propuesto por John Von Neumann, en el cual la unidad central de proceso, o
CPU, esta conectada a una memoria única que contiene las instrucciones del
programa y los datos.
El tamaño de la unidad de datos o instrucciones esta fijado por el ancho del bus
de la memoria. Esto limita la velocidad de operación del microprocesador, ya
que no se puede buscar en la memoria una nueva instrucción, antes de que
finalicen las transferencias de datos que pudieran resultar de la instrucción
anterior.
2ª. Se aplica la técnica de segmentación ("pipe-line") en la ejecución de
las instrucciones
La segmentación permite al procesador realizar al mismo tiempo la ejecución
de una instrucción y la búsqueda del código de la siguiente. De esta forma se
puede ejecutar cada instrucción en un ciclo (un ciclo de instrucción equivale a
cuatro ciclos de reloj).
Figura 2.2.3-1 Segmentación de la memoria interna para la ejecución de instrucciones
54
3ª. El formato de todas las instrucciones tiene la misma longitud
Todas las instrucciones de los microcontroladores de la gama baja tienen una
longitud de 12 bits. Las de la gama media tienen 14 bits y más las de la gama
alta. Esta característica es muy ventajosa en la optimización de la memoria de
instrucciones y facilita enormemente la construcción de ensambladores y
compiladores.
4ª. Procesador RISC (Computador de Juego de Instrucciones Reducido)
Dependiendo de la gama del procesador (baja, media o alta) tienen más o
menos número de instrucciones. Los modelos de la gama baja disponen de un
repertorio de 33 instrucciones, 35 los de la gama media y unas 76 los de la alta.
5ª. Todas las instrucciones son ortogonales
Cualquier instrucción puede manejar cualquier elemento de la arquitectura
como fuente o como destino.
6ª. Arquitectura basada en un banco de registros
Esto significa que todos los
objetos
del sistema (puertos de
E/S,
temporizadores, posiciones de memoria, etc.) están implementados físicamente
como registros.
7ª. Diversidad de modelos de microcontroladores con prestaciones y
recursos diferentes.
Ventajas del uso de microcontroladores:
•
Gestión eficiente de procesos. (Ejemplo motores de combustión)
•
Aumento de la fiabilidad.
•
Reducción del tamaño, consumo y costo.
•
Mayor flexibilidad (Únicamente se requiere la reprogramación)
55
La única limitación en las aplicaciones es la imaginación de los diseñadores de
sistemas.
Por ejemplo en un hogar pueden encontrarse más de 200 microcontroladores
distribuidos por los aparatos de la casa.
Los campos más destacados son:
•
Periféricos y dispositivos auxiliares de computadores
•
Electrodomésticos
•
Aparatos portátiles (pda, teléfonos, tarjetas,…)
•
Máquinas expendedoras
•
Juguetes
•
Sistemas de seguridad, alarmas
•
Instrumentación
•
Automoción
•
Control industrial y robótica
•
Sistemas de navegación
•
Termorregulación: Aire acondicionado, calderas de calefacción,…
El mayor vendedor mundial de microcontroladores de 8 bits es microchip con la
familia PIC. Razones:
•
Desarrollo con bajo riesgo. Exsite una gran variedad de dispositivos pero
son totalmente compatibles pin a pin. No es necesario rediseñar el
software y un entorno de desarrollo sencillo (MPLAB, PBP, PIC C
COMPILER en nuestro caso).
•
Tiempo de desarrollo reducido. El software es reutilizable. ICSP.
•
Muy bajo costo.
•
Gran variedad de compiladores y herramientas de desarrollo.
56
Otros fabricantes:
•
Motorola: 68HC11
•
Intel, philips: 8051
•
Otros National Semiconductor, SGS-thomson, Texas-inst., Hitachi,
Analog Devices
Por tales razones hemos decidido utilizar los siguientes pic para la realización
del proyecto:
PIC 16F628A (Para el teclado, y recepción de datos).
PIC 18F2525 (Para la generación de video).
2.2.4 DESCRIPCIÒN GENERAL
Microcontrolador PIC 16F628A
Figura 2.2.4-1 PIC 16F628A
El PIC16F62A es un miembro basado en la tecnología Flash de 18 pines es
perteneciente a la familia de la serie PIC16F62x de los microcontroladores 8 bit
completamente estáticos del Cmos.
Las características incluyen un oscilador interno de 4 megahercios, memoria de
128, EEPROM, capture/compare/PWM, USART, 2 comparadores, y referencia
programable del voltaje.
57
Características Del Microcontrolador Del Microchip PIC16F62A
Figura 2.2.4-2 Distribución de pines PIC 16F628A
CPU de alto rendimiento del Risc
•
Velocidad de funcionamiento: 20 MHZ
•
Voltaje de funcionamiento: 3.0-5.5V
•
Gama de temperatura industrial (-40° a +85°C)
•
Capacidad de interrupción
•
8 niveles de stack
•
Modos de dirección directos, indirectos y relativos
•
35 instrucciones
Características Especiales Del Microcontrolador
•
Memoria : 3584 octetos (2048 palabras)
•
Datos SRAM: 224 octetos
•
Datos EEPROM: 128 octetos
•
Opciones internas y externas del oscilador
o
Oscilador interno de 4 mhz de precisión calibrado en la fábrica
hasta el ±1%
o
Oscilador interno de baja potencia de 48 kilociclos
o
Ayuda externa de oscilador
•
Modo de ahorro de energía
•
Pin Clear/Input multiplexado
58
•
Contador de tiempo, perro guardián con el oscilador independiente
para la operación confiable
•
Programación de baja tensión
•
Programación serial en el circuito (vía dos pines)
•
Protección programable de código
•
Reajuste Del Brown-out
•
Energía de reajuste
•
Contador de tiempo de ciclo inicial y contador de tiempo de inicio del
oscilador
•
Célula de la Alto-Resistencia Flash/EEPROM
o
100.000 escriben Flash
o
1.000.000 escriben EEPROM
o
Retención de los datos de 40 años.
Características Periféricas
•
16 pines de I/O con control individual de la dirección
•
Alta corriente directa para encender LED
•
Módulo de comparador análogo
o
Dos comparadores análogos
o
Módulo programable
o
Referencia interna o externa seleccionable
o
Las salidas del comparador son externamente accesibles
•
Timer0: timer/counter 8-bit con el prescaler programable 8-bit
•
Timer1: timer/counter 16-bit con capacidad externa de crystal/clock
•
Timer2: timer/counter 8-bit con el registro, el prescaler y el postscaler
8-bit del período
•
La captura, compara, módulo de PWM
o
Capture/Compare 16-bit
o
10-bit PWM
59
•
USART/SCI Direccionable
Microcontrolador PIC 18F2525
Figura 2.2.4-3 PIC 18F2525
Características Del Microcontrolador De Microchip PIC18F2525
Figura 2.2.4-4 Distribución de pines PIC 18F2525
CPU De alto rendimiento Risc
•
Velocidad de funcionamiento: 40 MHZ
•
Voltaje de funcionamiento: 4.2-5.5V
•
Gama de temperatura industrial (-40° a +85°C)
•
Memoria de programa hasta 2 MBYTES
•
Oscilador de 4-10 Mhz con PLL
•
Instrucciones amplias de16-bit
•
75 instrucciones
Características Especiales Del Microcontrolador
•
Memoria Flash: 32 kilobytes (16.384 palabras)
60
•
Datos SRAM: 1536 octetos
•
Datos EEPROM: 256 octetos
•
Opciones seleccionables de oscilador, incluyendo:
o
•
Entrada de reloj secundaria del oscilador (32 kilociclos)
Convertidor de analógico a digital con5-canales (disponible durante
ahorro de energía)
•
Modo de ahorro de energía
•
Contador de tiempo, perro guardián
•
Programación serial vía dos pines
•
Protección programable del código
•
Energía reajustale
•
Contador de tiempo de ciclo inicial y contador de tiempo del
encendido del oscilador
Características Periféricas
•
22 pines de I/O; 3 puertos de I/O
•
Alta corriente 25 mA/25 mA
•
Tres pines externos de la interrupción
•
Timer0: 8-bit/16-bit timer/counter con escala programable de 8-bit
•
Timer1: timer/counter 16-bit
•
Timer2: timer/counter 8-bit con el registro 8-bit Timer3: timer/counter
16-bit
o
Opción secundaria de reloj, oscilador -- Timer1/Timer3
•
Puerto serial síncrono principal con dos modos:
•
USART direccionables
61
CAPITULO III
Teoría
62
CAPITULO 3 TEORIA
3.1 ESTUDIO DE HARDWARE Y COMUNICACIÓN TECLADO
COMPUTADOR
3.1.1 FUNCIONAMIENTO
•
Funcionamiento interno (Hardware)
Figura 3.1.1-1 Identificación fila y columna de la tecla pulsada
Funcionamiento mecánico: cumple la tarea esencialmente de accionar un
contacto el cual envía una señal eléctrica (0 o 5 voltios) y mediante un circuito
decodificador saber en que fila o columna de la matriz interna del teclado se
encuentra para su posterior decodificación.
63
Tipos de pulsadores
Existe una diversa gama de tipos de pulsadores los cuales se han ido creando
para el mejoramiento, comodidad, elegancia y reducción de tamaño de los
primeros teclados a los teclados actuales.
Clasificación:
Funcionamiento interno (Software)
Como vamos a ver, los teclados de Pcs están íntimamente unido a su
hardware, es decir su host ,de hecho solo hay que observar que el teclado y su
host están conectados a través de 4 hilos. (Entiéndase “host” como dispositivo
que se comunica con el teclado intercambiando información con él, en el caso
de un PC, es el propio PC, en nuestro caso el microcontrolador actúa como
host) .
64
La conexión entre un teclado y el PC se realiza a o bien a través de un
conector DIN 5 puntas en 180º o a través de un conector del tipo PS/2 (mini-din
6 puntas). En ambos casos una línea transmite la señal de reloj otra la de datos
y dos más la alimentación +5V y GND.
3.1.2 LOS CONECTORES DEL TECLADO
Existen dos tipos de conectores:
•
DIN de 5 pines usado en el estándar AT
•
Mini DIN de 6 pines usado en estándares PS/2
El chasis metálico va conectado a la malla de protección del cable o un su
defecto a GND, las líneas N/C (No conectadas) se conectan a GND algunas
veces.
3.1.3 COMUNICACIÓN DEL TECLADO AL COMPUTADOR
La comunicación entre el teclado y el host es en modo serie con bit de
arranque, ocho bits de datos, paridad impar y bit de parada. Es además
bidireccional, el teclado informa al host de la actividad en las teclas y el host le
envía
comandos
para
su
configuración,
encendido
de
luces
(BloqMayusculas/BloqNum/BloqDespl), re-inicialización, re-envío etc. Esto hace
65
que la señal de datos pueda ser usada por ambas partes, mientras que el reloj
lo controla siempre el teclado.
Figura 3.1.3-1 Diagrama de sincronismos reloj y dato del teclado al host (computador)
LSB:
Less Significative Bit (Bit menos significativo)
MSB: Most Significative Bit (Bit mas significativo)
P Odd: Paridad Impar
ACK:
Acknowledge (Reconocimiento)
En el diagrama de tiempos superior podemos observar en color azul la señal
controlada por el teclado y en rojo cuando está controlada por el host.
Lo más importante para el problema que nos ocupa es qué la información nos
da el teclado respecto de las pulsaciones. Cuando se pulsa una tecla, el
teclado envía lo que se conoce como scan code, esto es un código asociado
con cada tecla a través de una tabla. Existen tres modalidades o tablas
dependiendo del tipo de teclado.
Scan Code Set 1: Es el usado en teclados del tipo XT de 83 teclas (Las teclas
de función estaban en la parte izquierda).
Scan Code Set 2: Propio de teclados AT de 102 teclas, es el más usado.
Scan Code Set 3: Sólo usado en teclados del tipo PS/2.
66
Formato del teclado
T eclado Multifunción (101 teclas) ó PS/2
Figura 3.1.3-2 Teclado PS/2
El Set 1 se considera obsoleto, aunque algunos controladores de teclado
transforman los scan codes 2 y 3 a este set por compatibilidad con software
escrito para XTs. Lo más común, aunque varía según el fabricante, es que el
teclado acepte trabajar con el Set 2 y 3.
El Set 3 permite además configurar el teclado en una modalidad de respuesta
más afín con las necesidades de nuestro adaptador, por consiguiente es el
modo de funcionamiento que hemos elegido.
Aquí tienes un resumen de los Scan Codes del Set 3 útiles para nuestro
teclado:
67
Códigos de rastreo del teclado
Figura 3.1.3-3 Código de escaneo interno del teclado
Las teclas marcadas con 'Ex' son exclusivas de teclados expandidos; generan
los mismos códigos de rastreo que sus correspondientes teclas «no
expandidas», aunque precedidos de un código de rastreo adicional 0E0h como
mínimo.
Códigos secundarios
A continuación se listan los códigos secundarios. Estos se producen al pulsar
ciertas combinaciones especiales de teclas, a las que el controlador de INT 9
responde colocando un código ASCII 0 en el buffer, a menudo junto al código
de rastreo, para identificarlas; las teclas expandidas provocan frecuentemente
la inserción de un ASCII 0E0h o bien 0F0h. Estos códigos secundarios son el
valor devuelto en AH por las funciones 0, 1, 10h y 11h de la BIOS, cuando
éstas devuelven un carácter ASCII 0 ó 0E0h en AL.
68
Ha de tenerse en cuenta que la BIOS modifica en ocasiones el valor leído del
buffer del teclado, aunque en la siguiente tabla hay pautas para detectar esta
circunstancia si fuera necesario. En primer lugar, cuando se invoca a la BIOS
con las funciones 0 y 1, éste se encarga de simular las teclas normales con las
expandidas,
así
como
de
ocultar
las
combinaciones
exclusivamente
expandidas. Aquellos códigos precedidos de (*) en la tabla son ocultados por la
BIOS (como si no se hubiera pulsado las teclas) al emplear las funciones 0 y 1,
sacándolos del buffer e ignorándolos. En concreto, estos códigos son
almacenados con un código ASCII 0F0h en el buffer del teclado.
Lógicamente, para las funciones 10h y 11h sí existen, aunque la BIOS
devuelve un 0 en AL (y no un 0F0h). A los códigos precedidos por (#) les
sucede lo mismo: sólo existen para las funciones 10h y 11h, al emplear dichas
funciones la BIOS devuelve en AL el valor 0 (el auténtico contenido del buffer
en esta ocasión, sin necesidad de transformarlo). Por último, los códigos
precedidos por (@) existen tanto para las funciones 0 y 1 como para la 10h y la
11h: la ventaja de usar las dos últimas es que devuelven en AL el auténtico
código ASCII del buffer (0E0h), permitiendo diferenciar entre la pulsación de
una tecla normal y su correspondiente expandida.
En general, quien no desee complicarse la vida (debido a una evidente falta de
previsión en el diseño del primer teclado) puede limitarse a emplear las
combinaciones normales (las no marcadas con #, # ni *). Por otra parte, para
emplear las combinaciones señaladas con (#), (@) o (*) hay que asegurarse
previamente de que la BIOS soporta teclado expandido
Para diferenciar las teclas repetidas, en la tabla siguiente, las teclas
entrecomilladas se suponen expandidas o, en su defecto, ubicadas en el
teclado numérico. Por ejemplo: "5" es el 5 del teclado numérico, "<-" es el
cursor izquierdo expandido y <- a secas el normal (esto es, la tecla 4 del
teclado numérico con Num Lock inactivo). Se emplea la notación anglosajona:
Ctrl (Control), Alt (Alt o AltGr), Shift (Mays), Ins (Insert), Del (Supr), Home
(Inicio), End (Fin), PgUp (RePág), PgDn (AvPág).
69
* 01 Alt ESC
58 Shift F5
7F Alt 8
03 Ctrl 2, NUL
* 0E Alt ß
37 Alt -*3B r1
59 Shift F6
5A Shift F7
80 Alt 9
81 Alt 0
0F Shift Tab
10 Alt Ω
11 Alt W
12 Alt E
13 Alt R
14 Alt T
15 Alt Y
16 Alt U
17 Alt I
18 Alt O
19 Alt F
3C r2
3D r3
3E r4
3F r5
40 R6
41 R7
42 R8
43 R9
44 R10
47 None
@ 47 “None”
5B Shift F8
5C Shift F9
5D Shift F10
5E Ctrl F1
5F Ctrl F2
60 Ctrl F3
61 Ctrl F4
62 Ctrl F5
63 Ctrl F6
64 Ctrl F7
65 Ctrl F8
82 Alt ‘
83 Alt ¡
84 Ctrl PgUp
# 85 F11
# 86 F12
# 87 Shift F11
# 88 Shift F12
# 89 Ctrl F11
# 8A Ctrl F12
# 8B Alt F11
# 8C Alt F12
48 ↑
@ 48 “↑”
49 PgUp
@ 49 “PgUp”
* 4A Alt “-“
4B ß
@ 4B “ß”
* 4C “5”
4D à
@ 4D “à”
* 4E Alt “+”
4F End
@ 4F “End”
50 ↓
@ 50 “↓”
51 PgDn
@ 51 “PgDn”
52 Ins
@ 52 “Ins”
53 Del
@ 53 “Del”
54 Shift F1
55 Shift F2
66 Ctrl F9
67 Ctrl F10
68 Alt F1
69 Alt F2
6A Alt F3
6B Alt F4
6C Alt F5
6D Alt F6
6E Alt F7
6F Alt F8
70 Alt F9
71 Alt F10
72 Ctrl Ptr
73 Ctrl ß
74 Ctrl à
75 Ctrl End
76 Ctrl PgDn
77 Ctrl Home
78 Alt 1
79 Alt 2
7A Alt 3
7B Alt 4
7C Alt 5
# 8D Ctrl “↑”
# 8E Ctrl “-”
# 8F Ctrl “‫”ﺬ‬
# 90 Ctrl “↑”
# 91 Ctrl “↓”
# 92 Ctrl “Ins”
# 93 Ctrl “Del”
# 94 Ctrl Tab
# 95 Ctrl “/”
# 96 Ctrl “*”
# 97 Ctrl “Home”
# 98 Ctrl “ß”
# 99 Ctrl “à”
# 9F Ctrl “End”
# A0 Ctrl “↓”
# A1 Ctrl “PgDn”
# A2 Ctrl “Ins”
# A3 Ctrl “Del”
# A4 Ctrl “/”
# A5 Ctrl Tab
# A6 Ctrl “Intro”
* 1A Alt [
* 1B Alt ]
* 1C Alt Intro
1E Alt A
1F Alt S
20 Alt D
21 Alt r
22 Alt G
23 Alt H
24 Alt J
25 Alt K
26 Alt L
* 27 Alt Ñ
* 28 Alt {
* 29 Alt \
* 2B Alt }
2C Alt z
2E Alt x
2F Alt c
30 Alt v
31 Alt N
32 Alt M
* 33 Alt ,
* 34 Alt .
* 35 Alt -
56 Shift F3
57 Shift F4
7D Alt 6
7E Alt 7
Figura 3.1.3-4 Códigos de caracteres imprimibles y no imprimibles por el teclado
Excepciones
Hay un par de teclas que sin tener un código ASCII 0, 0E0h ni 0F0h reciben un
tratamiento especial por parte de la BIOS, que provoca que el código
secundario no sea el de rastreo acostumbrado: el Intro del teclado numérico
genera un código ASCII 0Dh, como cabría esperar, pero su código secundario
es 0E0h; lo mismo sucede con el '/' del teclado numérico. Las funciones 0 y 1
de la BIOS traducen este 0E0h al valor correspondiente a la tecla Intro principal
y al '-' del teclado principal (tecla que ocupa la posición del '/' en los teclados
norteamericanos), para compatibilizar con los teclados no expandidos.
70
3.2 COMO FUNCIONA LA COMUNICACIÓN RS-232
3.2.1 INTRODUCCIÓN
Una manera de conectara dos dispositivos es mediante comunicaciones serie
asíncronas. En ellas los bits de datos se transmiten "en serie" (uno de tras de
otro) y cada dispositivo realiza tiene su propio reloj. Previamente se ha
acordado que ambos dispositivos transmitirán datos a la misma velocidad.
En el documento se muestran los fundamentos de estas comunicaciones, los
pines empleados y ejemplos de los circuitos para conectar el PC con un
microcontrolador, además de mostrar los cables que se pueden emplear.
Comunicaciones serie asíncronas
Los datos serie se encuentran encapsulados en tramas de la forma:
Figura 3.2.1-1 Formato de envío de datos vía RS-232
Primero se envía un bit de start, a continuación los bits de datos (primero el bit
de mayor peso) y finalmente los bits de STOP.
El número de bits de datos y de bits de Stop es uno de los parámetros
configurables, así como el criterio de paridad par o impar para la detección de
errores. Normalmente, las comunicaciones serie tienen los siguientes
parámetros: 1 bit de Start, 8 bits de Datos, 1 bit de Stop y sin paridad.
En esta figura se puede ver un ejemplo de la transmisión del dato binario
10011010. La línea en reposo está a nivel alto:
71
Figura 3.2.1-2 Visualización del envío de la trama de datos
3.2.2 NORMA RS232
La Norma RS-232 fue definida para conectar un ordenador a un modem.
Además de transmitirse los datos de una forma serie asíncrona son necesarias
una serie de señales adicionales, que se definen en la norma. Las tensiones
empleadas están comprendidas entre +15/-15 voltios.
Figura 3.2.2-1 Conexión ordenador móden
Conexión de un microcontrolador al puerto serie del PC
Para conectar el PC a un microcontrolador por el puerto serie se utilizan las
señales Tx, Rx y GND. El PC utiliza la norma RS232, por lo que los niveles de
tensión de los pines están comprendidos entre +15 y -15 voltios. Los
microcontroladores normalmente trabajan con niveles TTL (0-5v). Es necesario
por tanto intercalar un circuito que adapte los niveles:
72
Figura 3.2.2-2 Esquema ilustrativo conexión pc y microcontrolador
Uno de estos circuitos, que se utiliza mucho, es el MAX232.
El conector DB9 del PC
En los PCS hay conectores DB9 macho, de 9 pines, por el que se conectan los
dispositivos al puerto serie. Los conectores hembra que se enchufan tienen una
colocación de pines diferente, de manera que se conectan el pin 1 del macho
con el pin 1 del hembra, el pin2 con el 2, etc.
La información asociada a cada uno de los pines es la siguiente:
Número de pin
Señal
1
DCD (Data Carrier Detect)
2
RX
3
TX
73
4
DTR (Data Terminal Ready)
5
GND
6
DSR (Data Sheet Ready)
7
RTS (Request To Send)
8
CTS (Clear To Send)
9
RI (Ring Indicator)
3.2.3 El chip MAX 232
Este chip permite adaptar los niveles RS232 y TTL, permitiendo conectar un
PC con un microcontrolador. Sólo es necesario este chip y 4 condensadores
electrolíticos de 1UF a 50v. El esquema es el siguiente:
Figura 3.2.3-1 Conexión de pines chip Max 232
Descripción: El MAX232 dispone internamente de 4 conversores de niveles
TTL al bus standard rs232 y viceversa, para comunicación serie como los
usados en los ordenadores y que ahora están en desuso, el Com1 y Com2.
Funcionamiento: El circuito integrado lleva internamente 2 conversores de nivel
de TTL a rs232 y otros 2 de rs232 a TTL con lo que en total podremos manejar
4 señales del puerto serie del PC, por lo general las mas usadas son; TX, RX,
74
RTS, CTS, estas dos ultimas son las usadas para el protocolo handshaking
pero no es imprescindible su uso. Para que el max232 funcione correctamente
deberemos de poner unos condensadores externos, todo esto lo podemos ver
en la siguiente figura en la que solo se han cableado las líneas TX y RX que
son las más usualmente usadas para casi cualquier aplicación.
Usos: Este integrado es usado para comunicar un microcontrolador o sistema
digital con un PC o sistema basado en el bus serie rs232.
Conexión a PC
Figura 3.2.3-2 Distribución de pines y conexión pc a pic
Cable de conexión (I)
Para realizar la conexión entre el PC y nuestro circuito podemos usar diferentes
alternativas. Una manera es utilizar un cable serie macho-hembra no cruzado,
y en el circuito un conector hembra DB9 para circuito impreso:
75
Figura 3.2.3-3 Cable de conexión DB9 macho
Figura 3.2.3-4 Conector DB9 hembra
Cuando conectamos un micro al PC normalmente sólo usamos los pines TX,
RX y GND, sin embargo en este tipo de cables se llevan los 9 pines.
También se puede fabricar un cable serie utilizando cable plano de bus,
conectantando un conector db9 hembra para bus:
Figura 3.2.3-5 Construcción cable plano con conector DB9
Cable de conexión (II): Cable telefónico
Puesto que en la conexión del PC con un micro sólo se usan las señales TX,
RX y GND se puede emplear un cable telefónico, que es sencillo de construir,
fácil de conectar y desconectar y las conexiones son muy fiables. Es necesario
cable telefónico y un conversor de teléfono a DB9:
76
Figura 3.2.3-6 Cable de conexión telefónico RJ11 macho
Figura 3.2.3-7 Conector telefónico RJ11 hembra
El cable de teléfono se tiene que construir o adquirir se esquematiza a
continuación:
Figura 3.2.3-8 Esquema de ponchado cable telefónico RJ11
Este cable tiene una muesca que diferencia las dos caras del cable. La correcta
posición de los conectores telefónicos es como se ha indicado en la figura, con
la muesca del cable hacia arriba.
El conector db9-teléfono que se conecta al PC se compra desmontado. Por un
lado se encuentra la carcasa con el conector hembra de teléfono y por otro lado
el conector DB9 hembra. Los 4 cables que salen de la carcasa se conectan al
DB9 hembra, en los pines que vayamos a utilizar. Como para las conexiones
con los micros sólo usaremos los pines RX, TX y GND (Pines 2,3 y 5).
77
Figura 3.2.3-9 Esquema de conexión conector RJ11 y conector DB9
La manera en la que se conecten estos cables es indiferente, sin embargo,
para tener compatibilidad con el cable de la CT6811, hay que hacerlo de la
siguiente manera:
Figura 3.2.3-10 Distribución de pines conector DB9
El cable que lleva la señal de DTR es opcional, y en la CT6811 se usa para
hacer reset.
Para la conexión al micro se usa un conector telefónico hembra para circuito
impreso:
78
Figura 3.2.3-11 Conector RJ11
Los pines del conector hembra son los siguientes, vistos desde abajo:
Figura 3.2.3-12 Distribución de pines conector RJ11
79
3.3 DISEÑO Y CONSTRUCCIÓN DE HARDWARE
3.3.1 CREACIÓN DE PLACAS DE CIRCUITO IMPRESO
En este documento se explica paso a paso el proceso de creación de placas de
circuito impreso (CI). Es un proceso completamente probado, fiable, con
resultados impecables y sobre todo ¡BARATO!. Se ha intentado describir el
proceso para que sea reproducido sin problemas.
1.- Material.
•
Placa de CI normal de cobre de una o dos caras. Costo: $ 0.80
Figura 3.3.1-1 Placa de cobre
•
Papel térmico Costo: $ 2.40
Figura 3.3.1-2 Papel térmico
80
•
Cloruro Férrico para atacar la placa. Costo: $ 0.50
Figura 3.3.1-3 Ácido cloruro férrico
•
Cubeta de plástico, de 500cc o más. Costo: $ 1
Figura 3.3.1-4 Recipiente de plástico
•
Pinzas de plástico. Costo: $ 1
Figura 3.3.1-5 Pinzas plásticas
81
•
Impresora láser. Samsung ML-1250. Costo: $ 105
Figura 3.3.1-6 Impresora láser
•
Plancha. Costo: $15
Figura 3.3.1-7 Plancha
•
Lana de acero. Costo: $ 0.50
Figura 3.3.1-8 Lana de acero
82
•
Lima. Cost0: 0.50
Figura 3.3.1-9 Lima de acero
•
Mini taladro tipo Dremel mas brocas de 0.8 mm. Costo: $ 30
Figura 3.3.1-10 Taladro
•
Rotulador indeleble. Como el de rotular Cd's. Costo: $ 1.5
Figura 3.3.1-11 Marcador indeleble
83
•
Disolvente universal. Costo: $ 2
Figura 3.3.1-12 Disolvente
3.3.2 DISEÑO DE LA PLACA
Utilizamos el programa ISIS de PROTEUS, El programa no es demasiado
complicado de utilizar, pero te aconsejamos que te leas el manual del proteus
adjunto en los Anexos.
Básicamente con el "ISIS" pones los componentes y los conectas entre si,
chips, resistencias, condensadores etc. Y con el "ARES" enrutas las líneas, y
colocas los componentes en su sitio sobre la placa:
84
Ejemplo vista ISIS
Figura 3.3.2-1 Visualización diagrama en Proteus (ISIS)
Ejemplo vista ARES
Figura 3.3.2-2 Visualización esquema componentes en Proteus (ARES)
85
Placa sin GND
Figura 3.3.2-3 Placa sin relleno de cobre
Placa con GND ¡Recomendado!
Figura 3.3.2-4 Placa con relleno de cobre
86
Consejos: al acabar la placa, crea un polígono que incluya todas las pistas y
componentes, y le asignas la señal de masa, GND, de esta forma, la parte que
deberá ser atacada por el Cloruro Férrico (ClFe) será mínima y el proceso es
mas rápido. Además el resultado es mucho mas profesional.
Fíjate en el botón resaltado en ambas imágenes para saber como crear la
capa GND.
3.3.3 IMPRESIÓN DEL CIRCUITO
Al imprimir sólo necesitas que sean visibles las capas Botton, Pads, Vías y
dimensión. Si haces la placa a dos caras, en la segunda necesitarás imprimir
sólo las capas Top, Pads, Vías y dimensión.
La placa impresa queda tal que así:
Figura 3.3.3-1 Impresión soldadura (I) y Componentes (D)
A la izquierda las pistas, a la derecha la serigrafía. Para un resultado
profesional imprimiremos también la serigrafía de la posición de los
componentes, luego la colocación de los componentes es mucho más sencilla.
Te recomendamos que pongas siempre algún texto en el layout de la placa,
recuerda que al imprimir las letras deberán verse como reflejadas en un espejo,
si no es así no sigas adelante, también que señales las líneas de alimentación
y las líneas de señal mas importantes, para el testeo posterior de la placa.
87
Imprime al máximo de calidad en la impresora láser, si no tienes láser, imprime
en un folio normal y fotocopia este folio sobre la hoja de papel satinado. OJO, a
veces puede atascar la fotocopiadora y en muchos sitios no te hacen las
copias.
3.3.4 PREPARACIÓN DE LA PLACA
Pulir la placa de cobre con la lana de acero.
Figura 3.3.4-1 Lijado de la placa de cobre
Observa la diferencia, la placa debe quedar completamente pulida (parte de la
derecha).
Figura 3.3.4-2 Placa sin lijar Figura
3.3.4-3 Placa lijada
No está de más limar los bordes.
88
Figura 3.3.4-4 Limpiar placa con tiñer
3.3.5 PLANCHADO DEL DISEÑO SOBRE LA PLACA DE COBRE
Mediante el calor de la plancha, trasferiremos el fotolito del papel al cobre.
Figura 3.3.5-1 Colocar papel térmico impreso sobre la placa de cobre
Alinea el papel con la placa, lo ideal es hacerlo en un ángulo recto. NO
RECORTES la placa todavía, debes planchar el papel sobre un trozo de placa
grande, si no es muy difícil conseguir que no se mueva al planchar.
89
Figura 3.3.5-2 Planchar el papel sobre la placa de cobre
Calienta la plancha, la mía sólo tiene 1 y 2, yo la pongo al 2. Aplica la plancha
sobre el papel firmemente, NO MUEVAS EL PAPEL, es muy importante. Con 2
ó 3 pasadas es suficiente, y no es necesario que apretes mucho. Si la plancha
está muy calientes, o pasas muchas veces sobre el mismo sitio o presionas
demasiado, las pistas se deforman. Yo he hecho placas haciendo una única
pasada.
Figura 3.3.5-3 El papel se pegara sobre el cobre
Inspecciona la placa por si hay alguna parte que no se ha pegado. Lo ideal es
que quede bien a la primera, si no es así, tienes muchas posibilidades de que
no salga bien, sin embargo, no todo está perdido. Una forma de saber si se ha
pegado bien, a priori, es mirar la placa de forma que la luz refleje, verás que
donde hay pista, es más brillante. CUIDADO, la placa puede quemar un poco.
90
Deja enfriar la placa, hasta que la toques y no queme, unos minutos. Debe
quedar más o menos como las fotos. Puedes volver a planchar alguna zona,
pero ya no suele pegarse.
Figura 3.3.5-4 Visualización de zonas no brillantes
Figura 3.3.5-5 Planchada totalmente terminada
Para retirar el papel de la placa, debes introducirla en AGUA CALIENTE, es
muy importante, porque mejora los resultados al hacer que el papel se
despegue sin dificultad. Deja la placa unos minutos en remojo, luego el papel
se despega sólo prácticamente. En las fotos no se utilizó agua caliente, por eso
no se despega muy bien. Además, si logramos despegar el papel de una pieza,
podremos ver si hay alguna pista que no se ha pegado bien. Todas las partes
negras que veas en el papel despegado, no se han pegado en el cobre y
deberás dibujarlas con un rotulador indeleble.
Figura 3.3.5-6 Dejar enfriar la placa en agua
Figura 3.3.5-7 Retirar el papel de la placa de cobre
91
Elimina con un trapo los restos de papel adherido al circuito, no te preocupes,
las pistas ya no se despegan, observa como debe quedar. Revisa las pistas y
repasa con rotulador indeleble las que no hayan quedado bien. Si alguna pista
se comunica, utiliza un cuter para rascarla un poco.
Figura 3.3.5-8 Retirar los restos de papel con una esponja
Figura 3.3.5-9 Placa totalmente sin papel
3.3.6 ATAQUE QUÍMICO DE LA PLACA DE COBRE
Recorta la placa, yo utilizo una sierra de metal, porque tiene unos dientes muy
finos.
Figura 3.3.6-1 Recortar la placa
Figura 3.3.6-2 Lijar los bordes de la placa
92
Ya estamos preparados para atacar la placa con Cloruto Férrico (ClFe). Si no
has hecho la mezcla todavía, llena el bote de ClFe con agua y agita hasta que
se disuelvan las bolitas, luego llena el recipiente donde atacarás la placa. En
este recipiente se ha pegado en el fondo un par de difusores de aire de acuario
y mediante un tubo de silicona, se conecta al compresor. El oxígeno y la
temperatura facilitan la reacción, te recomiendo calentar la disolución de ClFe,
al baño María, por ejemplo tengo un calentador de acuario, pero es algo lento...
Coloca el compresor por encima, del recipiente de ClFe, para evitar que el
líquido entre en el compresor. He descubierto, que estrangulando un poco el
tubo, las burbujas salen con mas potencia (con una pinza, pro ejemplo, fíjate en
la primera foto). En unos 5-10 minutos, la placa estará lista. Debes irla
vigilando, porque el cobre se desprende mas de unos sitios que por otros,
debido al flujo de burbujas, por lo que deberás irla moviendo de vez en cuando,
colocándola en distintas posiciones.
Figura 3.3.6-3 Introducir la placa de cobre en el recipiente con ácido
Si tienes buen pulso, puedes dejar la placa flotando justo encima de las
burbujas.
93
Una vez que la placa está lista, limpia el recipiente y los difusores de burbujas,
una vez aclarado el recipiente, lo lleno de nuevo con agua y dejo el compresor
enchufado, para limpiar los difusores. Si no lo haces, los difusores no te
durarán ni dos días.
Comprueba que no quedan restos de cobre en la placa a la vista, métela en
agua para eliminar los restos del ClFe y utiliza un trapo con disolvente para
retirar el toner de la placa.
Figura 3.3.6-4 Lavar la placa con agua
Figura 3.3.6-5 Retira el toner con disolvente
Figura 3.3.6-6 Lista la placa para la perforación
94
3.3.7 PERFORADO DE LA PLACA
Taladramos la placa, al contraluz puedes ver si te has dejado algún pad.
Figura 3.3.7-1 Perforado de pad de la placa
Figura 3.3.7-2 Placa terminada
Procedemos con la serigrafía de la capa superior, el sistema para placas de
doble cara es el mismo, solo que primero se plancha una cara, se agujerea
para alinear la segunda cara, se plancha la segunda cara y luego se ataca con
la disolución de ClFe.
Una vez lista la capa inferior, planchamos la serigrafía en la capa superior.
Ayúdate una vez mas del contraluz para, esta vez, alinear las dos capas. En las
placas de doble cara esto es IMPORTANTÍSIMO, para la serigrafía no tanto.
Una vez planchada la serigrafía, deja enfriar e introduce la placa en agua
caliente, si has sido rápido, todavía estará caliente el agua que has utilizado
antes. Retira el papel adherido y limpia con un trapo los restos de papel de la
placa, puedes utilizar alcohol, tranquilo, a no ser que utilices disolvente, no
borrarás las pistas.
95
Figura 3.3.7-3 Montaje de elementos impresos
Figura 3.3.7-4 Visualización a contra luz
96
3.4 DISEÑO Y CONSTRUCCION DEL HARDWARE PARA EL
TECLADO
3.4.1 ESQUEMATICOS TECLADO
Figura 3.4.1-1 Diagrama esquemático de hardware de teclado
Descripción del circuito
El circuito está compuesto por un PIC16F628A que oscila a 20Mhz, los pines
RB0 y RB7 (de los pic’s correspondientes) se encuentran configurados como
entradas, las cuales reciben las señales provenientes del teclado PS/2.
97
Las señales provenientes son:
•
Clock que se conecta al pin RB0.
•
Data que se conecta al pin RB7.
Y como salida del microcontrolador el pin RB2 (de los pic’s correspondientes),
el cual se conecta al pin 10 ó 11 del circuito integrado MAX232 que son
entradas para la conversión de señales TTL a señal RS232.
Y por último la salida del MAX232 son los pines 14 y 7, los cuales se encargar
de enviar la señal RS232 al módulo concentrador (recepción de datos).
Además el módulo consta de una fuente de voltaje estable regulada a 5v.
Diagrama de bloque
Figura 3.4.1-2 Diagrama de bloque
98
Diagrama por módulo
Figura 3.4.1-3 Diagrama por módulo
Elementos del Módulo
Materiales para Módulos TECLADO – RS232
4 Resistencias
Cantidad: Referencias
4
R1-P1, R1-P2, R2-P1, R2-P2
Valor
330
10 Condensadores
1
4
4
1
C1-F
100uF
C1-MAX, C2-MAX, C3-MAX, C41uF
MAX
C1-P1, C1-P2, C2-P1, C2-P2
33pF
C2-F
10uF
19 Diferentes dispositivos
1
3
2
CI7805
CONN-RJ11,CONN-TECLADO1,
CONN-TECLADO2
CONN-VDD-F, CONN-VDD-PIC
CRYSTAL-P1, CRYSTAL-P2
2
99
7805
CONN-H4
CONN-H2
20Mhz
5
1
2
2
1
LED-F,
LED1-P2,
LED2-P1, LED2-P2
LED1_P1, DIODE-LED
MAX232
PIC_1, PIC_2
R-MCLR_1, R-MCLR_2
RES_LED
MAX232
PIC16F628A
330 Ω
Elementos del módulo teclado- RS232 (Vista de componentes)
Figura 3.4.1-2 Disposición de elementos
Esquema módulo teclado- RS232 (Vista de soldadura)
Figura 3.4.1-3 Disposición de soldadura
100
3.4.2 ESQUEMATICO CONCENTRADOR
Figura 3.4.2-1 Diagrama esquemático de red
Descripción del circuito
El circuito está compuesto por circuito integrado MAX232 el cual por medio de
sus pines de recepción de datos 8 y 13 se encargan de recibir la señal RS232
provenientes del módulo teclado.
Y por medio de los pines de salida 9 y 12, se encargan de transformar las
señales RS232 a señales TTL, que serán entregadas al PIC16F628A.
El PIC16F628A oscila a 20Mhz los pines RA0 (de cada pic), se encuentran
configurados como entradas y tienen la tarea de codificar la señal TTL y
codificarlos a 1 y 0.
101
Para luego enviarlos por medio de los pines RB1 – RB7, que son los
encargados de entregar los datos suficientes para que el pic de video
(PIC18F2525) pueda interpretarlos y presentarlos al video del televisor.
El circuito también consta de una fuente de voltaje regulada a 5v.
Diagrama de bloque
Módulo teclado
MAX232
Entrada de
señal
Señal RS232
Concentrador PIC16F628A
Señal TTL
Señal de
habilitación
Video
Figura 3.4.2-2 Diagrama de bloque
Diagrama por módulo
Figura 3.4.2-3 Diagrama por módulo
102
Elementos del módulo recibir datos de red
Figura 3.4.2-4 Disposición de elementos de red
Módulo fuente
Figura 3.4.2-5 Diagrama esquemático de la fuente
103
3.4.3 ESQUEMATICO VIDEO
Figura 3.4.3-1 Diagrama esquemático de video
Diagrama de bloque
Figura 3.4.3-2 Diagrama de bloque
104
Diagrama por módulo
Receptor
PIC18F2525
Concentrador
PIC 16F628A
Salidas
---------------------RBO
|
RB7
--------------------Entrada
---------------------RB0 (Control)
señales
control
RBO de cada pic
Entradas
---------------------RB0
|
RB6
RB7 (GND)
---------------------Salidas
---------------------RA1
|
RA4
---------------------RA0 + RC0
Televisor
Video
RA0 + RC0
Figura 3.4.3-3 Diagrama por módulo
Elementos del módulo
Materiales para MODULOS VIDEO – FUENTE - RECIBIR DATO DE
RED
8 Resistencias
Cantidad
4
1
1
1
1
Referencia
R1, R1-P1, R1-P2, R2
R1-F
R1-V
R2-V
R3-V
Valor
1k
330
910
450
78
20 Condensadores
8
C1, C1-M, C2, C2-M, C3, C3-M, C4, C4-M
10
1
1
C1-P1, C1-P2, C1-V, C2-P1, C2-P2, C2-V, C5C8
33pF
C1_F
47uF
C2-F
100uF
2 Diodos
105
1uF
1
1
D2
D2-F
1N4148
LED
30 Dispositivos diferentes
1
7805
CI-7805
CONECTOR_VIDEO,CONN-RA1-RA2,
CONN-SIL2
CONN-RS232,
FUENTE,
FUENTE_VIDEO,
PIN-RA1-RA2, PIN-RA3-RA4, VOLTAJE VDD-F,
VOLTA_12V
CONN-SIL1
CONN-12V
5
CONN-PUER-B,
PUER-B4
5
1
2
1
4
1
20MHZ
CRYSTAL-PIC1, CRYSTAL-PIC2, CRYSTAL-V,
X1, X2
1N5357BRL
DZ_5.1V
MAX232-2, MAX232_1
MAX232
MRCL-V
1k
PIC-1, PIC-2, PIC3, PIC4
PIC16F628A
VIDEO
PIC18F2525
1
9
CONN-PUER-B1-CONN- CONN-SIL7
Esquema módulo recibir datos, video (vista componentes)
Figura 3.4.3-4 Disposición de elementos de video, red y fuente
106
Esquema módulo recibir datos, video (vista soldadura)
Figura 3.4.3-5 Disposición de soldadura video, video y red
3.4.4 EXPLICACACION DEL PROGRAMA DEL PROYECTO
Diseño
El problema planteado es el siguiente:
Se debe controlar un monitor de TV analógico mediante un microcontrolador
PIC18F2525 y Dibujar en pantalla el abecedario, números 0 al 9 y operaciones
básicas.
Las especificaciones del problema son las siguientes:
•
Al encender el sistema el monitor de TV debe estar presentando la
pantalla de bienvenida.
•
El
microcontrolador
PIC18F2525
se
comunicará
con
cuatro
PIC16F628A los cuales almacenaran los datos provenientes de un
teclado.
107
Al recibir alguno de las letras del alfabeto minúsculas, mayúsculas, números o
alguno de los comandos de control, transmitida desde uno de los teclados, el
microcontrolador PIC18F2525 deberá desplegar en la pantalla de TV
comenzando desde el extremo superior izquierdo de la pantalla. Se deberá
pasar de línea cada vez que hay 16 caracteres en una línea de texto. Hay 5
líneas de texto como máximo de escritura para cada niño. Existen comandos
de control para el uso del controlador, recordar los comandos de control son
para cada teclado de los 4 existentes.
Los comandos de control son los siguientes:
•
TAB: Limpiar la pantalla.
•
ß: Borrar un carácter.
•
BARRA ESPACIADORA: espacio en blanco.
Por tanto el problema se puede dividir en cuatro problemas más elementales,
los cuales se resolverán separadamente. Estos son:
•
Generación de la señal de sincronización.
•
Generación del video.
•
Lectura de datos del puerto B del PIC que son enviados
por el
teclado.
•
Modificación de la información a desplegar en la TV como función de
lo que se recibe en la puerto B
Generación de la señal de sincronización
Esta señal consta de una sincronización vertical y horizontal.
Sincronización vertical
La sincronización se obtiene mediante la función Pulsos_Campo(), la cual
genera las señales de sincronización vertical tanto para el campo 1 como del
108
campo 2 para lo cual utilizamos la variable int campo para conocer si estamos
en el campo 1 o 2. Además, en esta subrutina se debe recalcar que se dibujan
las líneas de video de 1 a 9.2
Además la señal de sincronización es de 0.3V. El uno en la salida del micro es
de 5V, para bajar ese voltaje se realizará un divisor de tensión, como la
impedancia característica de una línea de coaxial es de 75 ohms, se colocará
la entrada coaxial de la TV en paralelo con una resistencia de 75 ohms.
Entonces con una resistencia de 1K al pin del micro se tendrá el divisor de
tensión.
Para hacer esto se presenta el siguiente código en C:
#use delay(clock=20000000)
#use fast_io(A)
#use fast_io(B)
//Declaración de variables
int8 i,p;
int8 Campo=0;//valor inicial es 0
void Pulsos_Campo_I(){
//6 post-sync
/* pulso bajo = 2,2
pulso alto = 29,2
*/
if(campo==1){
//2,6 sale de tiempo en el if(campo==1)(7 Instrucciones) F+entrara al for(5
Intrucciones )
delay_us(2); //necesito 2,6us para formar el pulso de la linea 262
delay_cycles(1);
output_low(pin_a0); //Sincro //2,6-0,4(2Inst)=2,2 us
//Aqui formamos el primer pulso de sincronismo vertical
delay_us(4); //4,4 genera tiempo para sincro
delay_cycles(2);
output_high(pin_a0); //Negro
109
delay_us(25);//27,2 - 0,6(3 Instr de la variable p y campo )-0,4(Goto else) 1(entrada al for)-= 25,2
delay_cycles(1);//27,2=tiempo de la linea de video(63,6)/2 y restado tiempo de
sincro h y resta 0,2 output
p=4;//p=4 para dibujar 4 pulsos cunado es el campo 2
campo=0;//campo =0 para activar el campo
}
else{
p=5; //p=5 para dibujar 5 pulsos cunado es el campo 1
campo=1;//campo = 1 para activar el campo
}
for(i=1;i<=6;i++){//6
output_low(pin_a0); //Sincro
delay_us(2);
//2,2us para sincro
delay_cycles(1);
output_high(pin_a0); //Negro
delay_us(28);//29,2 - 1,2(Ciclo Intermedio del For)= 28
}
//6 sincros verticales
/* pulso bajo = 26,8
pulso alto = 4,6
*/
output_low(pin_a0); //sincro
delay_us(26);
delay_cycles(4);
output_high(pin_a0); //negro
delay_us(3);
delay_cycles(3); //4,6-1(Ciclo Entrada al For)= 3,6
for(i=1;i<=5;i++){ //5
output_low(pin_a0); //sincro
delay_us(26);
delay_cycles(4);
output_high(pin_a0); //negro
110
delay_us(3);
delay_cycles(2); //4,6-1,2(Ciclo Intermedio del For)=3,4
}
//6 post-sync para los campos
/* pulso alto = 2,2
pulso bajo = 29,2
*/
output_low(pin_a0); //sincro
delay_us(2);
delay_cycles(1);
output_high(pin_a0); //negro
delay_us(28);
//29,2-1(Ciclo Entrada al For)=28,2
delay_cycles(1);
for(i=1;i<=p;i++){
output_low(pin_a0); //sincro
delay_us(2);
delay_cycles(1);
output_high(pin_a0); //negro
delay_us(28); //29,2 - 1,2(Ciclo Intermedio del For)= 28
}
output_low(pin_a0); //sincro
if(campo==0){
delay_us(1); //2,2 -0,4(0,2*2(instruciones entrar if(campo==0) en condicion V))
=1,8
delay_cycles(4);
//Aqui formamos completamente la linea de video 9
output_high(pin_a0); //negro
delay_us(60); //60,8
delay_cycles(4);
output_low(pin_a0); //sincro
111
//Este delay_cycles(3) uso para completar el tiempo de sincronizacion
horizontal para linea 10
delay_cycles(3);//Compenso los 3(Instruc) que usa el if(campo==0) en falso
}
}//Goto 0,4 us
Sincronización horizontal
La sincronización horizontal se a implementado en cada función, es decir cada
función será una línea de video en la cual ya esta implementado sincronismo
horizontal y Front Porch.
Para hacer esto se presenta el siguiente código en C:
Void Draw_Letras(){
//x=numero de líneas a repetir
#endasm
//Sincronización Horizontal (4.4us)+0,2(output)=4,6us
output_low(pin_a0); //sincronismo
delay_us(4);
delay_cycles(2);
//Back porch =4,8us +0,2(output)=5us
output_high(pin_a0); //negro
delay_us(4);
delay_cycles(4);
//Front Porch + 0,2(Output)= 2,2us
output_high(pin_a0); //negro
delay_us(10);// tiempo sobrante o disponible + 1 del //Front Porch
delay_cycles(3);//2us-0,6(Decfsz y Goto)=1,4us
}
112
Generación de video
Una vez que la señal de sincronización se ha dado, el microcontrolador debe
poner en el Pin_C0 del puerto C los píxeles3 correspondientes a la línea i de la
imagen4 del dato entrante por el puerto B. La imagen que representa al dato
serán guardados en un banco de memoria de impresión, cada una compuesto
de 256 registro.
Imagen de un carácter
La imagen que representa a cada dato que ingresa por el puerto B están
almacenados en matrices. Estas matrices se definen así:
•
int8 Matrix_Mayusculas[27][8]
•
int8 Matrix_Numeros04[5][8]
•
int8 Matrix_Minusculas[27][8]
•
int8 Matrix_Numeros59[5][8]
Cada imagen esta compuesta por 8 píxeles de ancho y 8 registros de cada
matriz de alto. Así en una matriz como: Matrix_Mayusculas[27][8] se podrá
almacenar la imagen de 27 caracteres del alfabeto. Por ejemplo el carácter A
utilizara
la fila 0 y las columnas 0 al 7 para guardar la imagen de dicho
carácter.
Entonces lo que hay que guardar en los registros por ejemplo para el carácter
A, en binario, sería:
Fila
columna
Valor Binario
Valor
Bits 765 43210
Hexadecimal
Ancho
1
0
00000000
0x00
1
00011000
0x1C
A
2
00100010
0x22
L
113
3
01000001
0x41
T
4
01111111
0x7F
O
5
01000001
0x41
6
01000001
0x41
7
01000001
0x41
Figura 3.4.4-1 Tabla de imagen del carácter A
Es decir los datos que representan a la imagen del carácter A en la memoria
del microcontrolador se guardarían Así:
Dirección de la memoria de Uc Valor
D00
0x00
D01
0x1C
D02
0x22
D03
0x41
D04
0x7F
D05
0x41
D06
0x41
D07
0x41
Figura 3.4.4-2 Tabla de almacenamiento de la imagen del carácter A en la memoria del Uc
Para hacer esto se presenta el siguiente código en C:
//Declaracion dela Matrix Direccion D00H
int8 Matrix_Mayusculas[27][8]={
//A
0x0,0x1C,0x22,0x41,0x7F,0x41,0x41,0x41
//B
0x00,0x3F,0x63,0x63,0x3F,0x63,0x63,0x3F,
//C
0x00,0x7E,0x7F,0x3,0x3,0x3,0x7F,0x7E,
114
//D
0x00,0x3F,0x43,0x43,0x43,0x43,0x43,0x3F
//E
0x00,0x7F,0x3,0x3,0x3F,0x3,0x3,0x7F,
//F
0x00,0x7F,0x3,0x3,0x3F,0x3,0x3,0x3,
//G
0x00,0x7E,0x43,0x3,0x7B,0x5B,0x43,0x7E,
//H
0x00,0x3,0x63,0x63,0x7F,0x63,0x63,0x63,
//I
0x00,0x7F,0x8,0x8,0x8,0x8,0x8,0x7F,
//J
0x00,0x7E,0x18,0x18,0x18,0x1B,0x1B,0x1E,
//K
0x00,0x63,0x33,0x1F,0xF,0x1F,0x33,0x63,
//L
0x00,0x3,0x3,0x3,0x3,0x3,0x3,0x7F,
};
#Locate Matrix_Mayusculas=0xD00
Y esto seria la imagen para el carácter A.
Por tanto la información sobre los valores que deben cargarse en los bancos
de memoria de impresión para formar un carácter, por ejemplo una ‘a’ o un ‘A’,
será guardada en una matriz de 27 o 5 filas y ocho columnas llamada
Matriz_xxxxx. Cada fila tiene la información para formar cada una de las 27
letras del alfabeto mayúsculas y minúsculas, los 10 dígitos decimales y el
espacio en blanco. Para cada carácter se necesitan, como se vio, 8 elementos
de la matriz.
115
Almacenamiento de la imagen en el banco de memoria de impresión
Ahora que se tiene la forma de desplegar la imagen del carácter guardada en
una matriz, se necesita saber cómo y en qué orden deben ir guardados los
píxeles del carácter en el registro del banco de memoria de impresión para
formar los caracteres, que se introducen por medio del teclado en la pantalla.
Ahora indicaremos la forma como se guardaran las imágenes en el banco de
memoria de impresión.
En pantalla se mostrara 5 líneas de texto que contendrá 16 imágenes de los
caracteres. Las líneas de texto se forma con los primeros 128 registros de uno
de los bancos de memoria de impresión5, obteniendo por cada banco de
memoria de impresión de 256 registros dos líneas de Texto. Por tanto para
obtener 5 líneas de texto utilizaremos 2 ½ Bancos de memoria de impresión del
microcontrolador.
Cada registro se guarda 8 bits. Cada bit será un píxel, por lo que se pueden
guardar 8 píxeles de la imagen total por cada registro. Como se despliegan 16
letras por cada línea de texto, cada línea de texto tendrá 128 registros y por
tanto 1024 píxeles. Una línea de texto esta formada por 8 líneas de video, es
decir cada línea de video imprimirá los primeros 16 registros del Banco de
memoria de impresión, la segunda línea de video imprimirá las siguientes 16
registros del Banco de memoria de impresión y así hasta las 8 líneas de video
en donde abra impreso en pantalla los 128 registros.
Aquí se guardara la imagen actual del dato que ingresa. Para modificar
cualquier píxel de esta imagen se debe alterar el correspondiente registro de
estos bancos de memorias.
Como la matriz tiene guardado en orden cada uno de los píxeles de la imagen
desde el primero al extremo superior izquierdo de la pantalla hasta el último en
el extremo inferior derecho, se debe guardar cada letra que sea parte de la
imagen actual en ese mismo orden.
116
Las imágenes son de ocho píxeles de ancho y además se define que una
imagen tiene ocho líneas de alto, se puede formar los píxeles de una imagen
en la pantalla, guardándolos en el Banco de memoria de impresión. Cada una
de las líneas de video que forman a la imagen están una directamente debajo
de la otra, los píxeles que forman a la imagen deben ser guardados cada 16
registros del Banco de memoria de impresión. Los primeros píxeles (registro)
de la imagen ocupara uno de los registros, de los 16 registros que posee la
primera línea de video, 16 registros después, se tendrá el que tiene los píxeles
de la segunda línea del imagen y así consecutivamente. Entonces, por ejemplo,
si el carácter a desplegar empieza en el registro 0, se necesita guardar las
siguientes los píxeles de la imagen en los siguientes registros del Banco de
memoria de impresión 16,32,64,80,96,112 .
Imagen
Para hacer esto se presenta el siguiente código:
Void LlenarScreen(){
#ASM
CLRF FSR0H
CLRF FSR0L
CLRF FSR1H
CLRF FSR1L
//Cargamos
a
los
registros
los
numeros
base
1=banco1....15=banco 15
//PARA SELECCIONAR EL BANCO SCREEN
MOVLB 0
MOVF DIRi_MATRIX,w //movemos 1 al registro W
MOVWF FSR1H //movemos el registro W a FSR1H
//PARA SELECCIONAR EL BANCO LETRAS y NUMEROS
CLRF W
117
0=banco
0
--
MOVF n_DIRi_SCREEN ,W //movemos EL CONTENIDO DE DIRECCION DEL
BANCO al registro W
MOVWF FSR0H //movemos w al registro FSR0H
//*******************************0****************************************
//INGRESO direccion del VECTOR screen a FSR0
MOVLW 0 //Cargamos el registro w con el valor de 16(ver vector screen)
ADDWF POS_LETRA_SCREEN,W //sumamos W+J
MOVWF FSR0L//movemos el valor de W a FSR0L
//INGRESO la direccion de la matrix a FSR1
MOVF POS_LETRA_MATRIX,W //Movemos el valor de POS _LETRA a W
MOVWF FSR1L
//Movemos W a FSR1L
MOVFF INDF1,INDF0
//*******************************1*****************************************
//INGRESO direccion del VECTOR screen a FSR0
MOVLW 16 //Cargamos el registro w con el valor de 16(ver vector screen)
ADDWF POS_LETRA_SCREEN,W //sumamos W+J
MOVWF FSR0L//movemos el valor de W a FSR0L
//INGRESO la direccion de la matrix a FSR1
INCF FSR1L,F
MOVFF INDF1,INDF0
...
...
Código completo en anexos
}
Por tanto para generar todas las imágenes ya en pantalla de TV, se deben
poner en el Pin 0 del puerto C cada uno de los bits de cada uno de los píxeles
118
del Banco de memoria de impresión. Para hacer esto se presenta el siguiente
código en C:
Void Draw_Letras(){ //x=numero de lineas a repetir
#asm
CLRF FSR0H
CLRF FSR0L
CLRF PORTC
CLRF W
MOVF DIRi_SCREEN ,W //movemos EL CONTENIDO DE DIRECCION DEL
BANCO al registro W
MOVWF FSR0H //movemos w al registro FSR0H
MOVLW
0 //movemos EL CONTENIDO DE DIRECCION DEL BANCO al
registro W
MOVWF FSR0L //movemos w al registro FSR0H
//total = 8(instrucciones de ingreso)
//*************************** INICIO DEL BUCLE *********************************
Loop:
#endasm
//Sincronización Horizontal (4.4us)+0,2(output)=4,6us
output_low(pin_a0); //sincronismo
delay_us(4);
delay_cycles(2);
//Back porch =4,8us +0,2(output)=5us
output_high(pin_a0); //negro
delay_us(4);
delay_cycles(4);
//63,4-4,4-4,8-0,4-2,2=51,6us
119
//******************IMAGEN********** Tiempo disponible = 51,6
delay_us(7);
#asm
//Letra 1
MOVFF INDF0,PORTC //2 ciclos
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
INCF FSR0L,F //total 11(Instrucciones)=
//Letra 2
MOVFF INDF0,PORTC //2 ciclos
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
INCF FSR0L,F //total 11(Instrucciones)=
…………..
#asm
DECFSZ N_LineasVideo,F
GOTO Loop
BCF
0xF89.0 // enceramos pin_a0 sincronismo
CLRF FSR0H
CLRF FSR0L
120
#endasm
DIRi_SCREEN++;
//Tiempo de Salid 7(Instrucciones)=7*0,2=1,4 us
}
Lectura de datos del puerto B introducidos por el teclado
Los datos serán leídos en una variable llamada ‘Dato’.
Debido a que la
mayoría del tiempo el micro esta ocupado generando los píxeles de la imagen
actual, se debe dividir toda esta tarea en segmentos cortos, los cuales el micro
debe ejecutar en menos de 63,4us tiempo máximo del que se puede disponer
mientras el haz de electrones del tubo pinta una línea de video en la pantalla
El código en C para leer un dato se describe a continuación.
La función int LeerDato() permite leer un dato que se encuentre en el puerto B
del Microcontrolador y la almacena en la variable Dato. Esta función
básicamente lee el puerto B por cuarenta 40 us,
void int LeerDato(){
i1=40;//40 valor 2(Inst)
PORTA=U1;//2
//delay_us(4);//quitar
#asm
Loop1:
MOVFF PORTB , DATO //2
DECFSZ i1,F
//1
BRA Loop1
//2
#endasm
//Tiempo
Total=
5(Instruccione)*0.2*i1(=40)
+0,4us(PORTA=U1)+0,4(PORTA=1) =41,2us
//41,2-0,4(Dato1=Dato;)=40,8-4(delay_us(4))=36,8us
PORTA=1;
Dato1=Dato;
}
121
+
0,4us(i1=40)
Traducción del Dato ingresado
Si el dato que esta guardado en la variable Dato es una letra o un dígito
decimal, el mismo deberá ser traducido, para conocer el Banco de memoria
donde esta guardado y su registro de inicio dentro del banco, para lo cual
utilizamos las variables
DIRi_MATRIX y POS_LETRA_MATRIX. El arreglo
matriz contiene la información para formar la imagen de un carácter en cada fila
en el siguiente orden: ‘a’ en la fila 0, ‘b’ en la fila 1, ‘c’ en la fila 2 y así hasta
llegar al ‘z’ en la fila 28. Entonces, si el dato recibido del teclado es un 3, se
debe decodificar en un 24. Esa es la posición donde se encuentra los primeros
píxeles para formar una imagen que se encuentran guardados en matriz. Ese
número (24) se guarda en la variable POS_LETRA_MATRIX.
El código para realizar esta función se muestra a continuación.
Función ClasificarLetra
La función int ClasificarLetra() se emplea para calcular la posición de la letra
en el banco de memoria de letras y números. Recibe como entrada a la
variable Dato y entrega la dirección del banco de memoria y la posición de
inicio de registro donde se encuentra la letra deseada.
void int ClasificarLetra(){
//Clasificacion del dato
//LOS numeros 1 al 1f(32) son la codificacion 0 = A 1=B.....30=/ 31 = *
//Las letras A a la Z y Signos estan en Banco de memoria 6
//LOS numeros 0x20(32 d) al 0x29(41 ) son la codificacion 32 = 0 33=1.....40=8
41 = 9
//Las letras A a la Z y Signos estan en Banco de memoria 6
//********************************************************************
if(DATO >=0x01){
122
if(DATO <=0x20){
Bandera_N_Letra=0;
DIRi_MATRIX=13;
DATO=DATO-1;
POS_LETRA_MATRIX=8*DATO;
}
else{
//total=19(Istrucciones)-9(Instruccinoes)=10(Instrucciones)*0,2=2us
delay_us(2);
}
}
else{
//total=19(Istrucciones)-4(Instruccinoes)=15(Instrucciones)*0,2=3us
delay_us(3);
}//Total=19(Instrucciones)*0,2=3,8us
}
Modificación de la información a desplegar en la TV como función de lo
que se recibe en la Puerto B
Una vez se tiene el valor de el dato se deben tomar decisiones sobre que se
debe hacer, basadas en ese dato leído.
Se debe escoger entre tres posibilidades: Poner un carácter inmediatamente a
la derecha del último carácter introducido, (siempre y cuando no se hallan
escrito 16 caracteres antes en la misma línea de texto), borrar el último carácter
introducido o limpiar la pantalla completamente. Debe haber diferencia al hablar
de línea de pantalla y línea de texto, pues las primeras son las que forman la
imagen, y las segundas son relevantes al tamaño y forma de las letras que se
están visualizando. Recordando los caracteres de control se tiene:
•
TAB: Limpiar la pantalla.
123
•
ß: Borrar un carácter.
•
BARRA ESPACIADORA: espacio en blanco.
Si el dato recibido es un TAB, se debe limpiar la pantalla. Para hacer esto, se
debe cargar 0x00 en los 3 Bancos de memoria de impresión. Para hacer esto
se define las funciones.
void int Borrar_Screen11() //Carga con 0 los registros del banco de memoria
0x100
void int Borrar_Screen12() //Carga con 0 los registros del banco de memoria
0x200
void int Borrar_Screen13() //Carga con 0 los registros del banco de memoria
0x300
La definición de una de esta función se presenta a continuación:
void int Borrar_Screen13(){
//Inico del tiempo de la imagem
if( BorrarScreen==0){
//emplea 3(Ins) el if para entrar en V
int8 Ce[256]={0x0};
#Locate Ce=0x300 //Ocupamos todos los registros del Banco1
//tiempo total=257+3(inicio if)+2(Bra)=262*0,2us=52,4us
BorrarScreen=1;
//delay_cycles(1);
}
else{
//emplea 4(Ins) el if para entrar en F
delay_us(51); //262 - 4 = 258*0,2us=51,6us
delay_cycles(3);
}
}
124
Guardando un carácter en el Banco de memoria de impresión
Si el dato introducido es un carácter válido, el mismo debe ser desplegado
según el orden y lugar ya descrito. Los cambios al Banco de memoria de
impresión deben ser hechos en un orden según la posición final que cada
carácter tendrá en la pantalla. Ya se discutió que las imágenes del Banco de
memoria de impresión asociados a la información de un carácter están
separadas cada 16 imágenes, pues es así como se podrá tener el efecto de
proyectar una línea de píxeles del carácter inmediatamente debajo del anterior.
Dicho espaciamiento entre elementos debe permanecer constante sin importar
la posición del carácter en la pantalla. Sin embargo, de que depende la
posición de un carácter en la pantalla?. La posición de un carácter en la
pantalla depende de cuál es el número de registro que guarda la primera línea
de 8 píxeles del mismo. Por ejemplo, si el primer registro que guarda la
información de un carácter cualquiera es 0x100, ese carácter cualquiera estará
ubicado en la esquina superior izquierda de la pantalla. Una carácter que esté a
su lado derecho sobra la misma línea de texto, tendrá almacenado en 0x101 de
su primer línea de píxeles. Además, un carácter que esté inmediatamente
debajo del carácter correspondiente a 0x100, tendrá su primer registro en
0x110.
Dicho patrón se aplica para hallar la posición de cualquier letra en la pantalla.
Si ubicamos la posición de una letra mediante las variables N_LINEA_TEXTO1
y N_Letra1, donde N_Letra1 contabiliza el número de letras por línea de texto
y N_LINEA_TEXTO1 representa la línea de texto en la cual se encuentra la
letra, se puede calcular el número que corresponde al primer registro
relacionado a un imagen mediante la fórmula:
POS_LETRA_SCREEN=N_LINEA_TEXTO1*128+N_Letra1;
Formula para calcular la última posición de una letra escrita
125
Donde POS_LETRA_SCREEN representa el registro que contiene la primera
línea de píxeles de una letra cualquiera. Los siguientes 7 elementos que
contienen
el
resto
de
la
información
están
en
las
posiciones
POS_LETRA_SCREEN +16, …, POS_LETRA_SCREEN +112. Entonces,
N_LINEA_TEXTO1 y N_Letra1 tienen el registro de la posición de la última
letra escrita.
El código en C que realiza las decisiones sobre cómo calcular y cuándo activar
las banderas de control para la llamada a las funciones anteriores se presenta
a continuación.
Función Tratar_Letra()
La función int Tratar_Letra() se emplea para calcular la posición de la letra en
el banco de memoria de letras y números. Recibe como entrada a la variable
Dato y entrega la dirección del banco de memoria y la posición de inicio de
registro donde se encuentra la letra deseada
void int Tratar_Letraxx(){
//tiene 4(ifs en V)+9(inst)+4(2 BRA) en V=17(Ins)
//tiene 3(if en F)
if(CondisionPresentacion==0){
if(DATO1 == 0){
POS_LETRA_SCREEN =N_LINEA_TEXTO4*128+N_Letra4;
POS_LETRA_MATRIX=0;// posicion del caracter en la memoria 15
DIRi_MATRIX=15;//15
}
else{
//17-5=12*0,2 = 2,4us
delay_us(2);
delay_cycles(2);
}
}
126
else{
//17-3=14*0,2 = 2,8us
delay_us(2);
delay_cycles(4);
}
//*************************If para Borrar screen *****************************
//Este rutina se demora 16(Inst)
//ESTA RUTINA SE ME DEMORA 16 INSTRUCIONES EN V O f tiempo total =
16*0,2=
3,2 us//
if(Borrar4==0){
if(Bandera_N_Letra==0){
//entrar los 2 if en v se demora 4(Inst)
//Borro vector
BorrarScreen4=0;
N_Letra4=0;
N_LINEA_TEXTO4=0;
TN_LINEA_TEXTO4=0; //_aumentado
POS_LETRA_SCREEN=0;
Bandera_N_Letra=1;
Borrar4=1;
}
else{
//entrar los 1 if en v y otro if en f se demora 5(Inst)+2(BRA)=7(Ins)
//16-7=9(Ins)*0,2=1,8
Bandera_N_Letra=1; //2(Ins)*0,2=0,4
delay_us(1);
delay_cycles(2);
}
}
else{
//entrar los primer if en f se demora 3(Inst)=3(Ins)
////16-3=13(Ins)*0,2=2,6
Bandera_N_Letra=1;
delay_us(2);
127
delay_cycles(1);
}
//La variables DIRi_SCREEN se cambia a 4 ,7 o 10 para los demas personajes
DIRi_SCREEN=10;//0,4us
}
La función para poner un carácter en la pantalla se llama LlenarScreen(). Se le
deben pasar los valores de
DIRi_MATRIX: Dirección del Banco de memoria donde se encuentra la
imagen
n_DIRi_SCREEN: Dirección del Banco de memoria donde se guarda la
imagen
POS_LETRA_SCREEN: Posición de inicio de la imagen en el Banco
de memoria de imagen
POS_LETRA_MATRIX : Posición de inicio de registro de una imagen en
matriz
Borrar un carácter
En el caso de que el comando introducido por el teclado sea el de borrar el
último carácter (DATO1 = 127), se mantendrán sin cambio los valores de
N_LINEA_TEXTO1 y N_Letra1 y se grabarán ceros en el Banco de memoria
de imagen
partiendo del valor calculado de POS_LETRA_SCREEN. Se
utilizará la función Tratar_Letra() solamente que se tendrá el valor
que
corresponde al espacio en blanco en la matriz y la función LlenarScreen()
llenara con ceros los registros pertenecientes a esa imagen del carácter.
El código en C que realiza las decisiones:
//*********************BORRAR
UNA
LETRA******************************
if (DATO1 == 127){
//cuando if (DATO == 127) V 3(Ins)
//cuando if (DATO == 127) F 4(Ins)
//********** esta codigo ocupa 17(ins) *******************
128
POS_LETRA_SCREEN=N_LINEA_TEXTO4*128+N_Letra4;
if(TN_LINEA_TEXTO4!=0){//3(Ins) en F
//2(ins) en verdad
if(N_LINEA_TEXTO4==0){//3(Ins) en F
//2(ins) en verdad
if(N_Letra4==0){//3(Ins) en F
//2(ins) en verdad
//6(ins) en verdad todo los if
N_Letra4=16;
N_LINEA_TEXTO4=1;
TN_LINEA_TEXTO4--;
}
else{
//17(Ins)-11(Ins)=6*0,2=1,2us
delay_us(1);
delay_cycles(1);
}
}
else{
//17(Ins)-7(Ins)=10*0,2=2us
delay_us(2);
}
}
else{
//17(Ins)-3(Ins)=14*0,2=2,8us
delay_us(1);
delay_cycles(4);
}
//************************************************************************
if (N_LINEA_TEXTO4==0){
if (N_Letra4==0){//14-8=6(Ins)*0,2)1,2
129
delay_us(1);
delay_cycles(1);
}
else if(N_Letra4!=0){
N_Letra4=N_Letra4-1;
POS_LETRA_MATRIX=8;
DIRi_MATRIX=15;
}
}
else if(N_Letra4==0){
N_LINEA_TEXTO4=N_LINEA_TEXTO4-1;
N_Letra4=15;
POS_LETRA_MATRIX=8;
DIRi_MATRIX=15;
}
else if(N_Letra4!=0){
N_Letra4=N_Letra4-1;
POS_LETRA_MATRIX=8;
DIRi_MATRIX=15;
delay_cycles(1);
}
El código en C que realiza cómo cuándo hacer las llamadas a las funciones
anteriores se presenta a continuación.
Programa principal
Esta rutina permite ejecutar las funciones para generar la señal de video NTSC
de televisión.
Dentro de función principal main se a implementado un while, dentro del este
while se a implementado las funciones que permiten generar las señal de
video, las funciones de lectura del puerto B, los comandos de control para los
cuatro teclados y las funciones que son necesarias para realizar la escritura
en la pantalla de televisión.
130
Toda función se ejecuta en un tiempo aproximado de 63.4us que es el tiempo
que se tarda en dibujar en pantalla una línea horizontal (Ver teoría de video).
Para la lectura de los datos de cada teclado se a utilizado la variable U1 la cual
toma valores de:
•
3:
Activa la interrupción de PIC Teclado 1
•
5:
Activa la interrupción de PIC Teclado 1
•
9:
Activa la interrupción de PIC Teclado 1
•
17: Activa la interrupción de PIC Teclado 1
Con el fin de obtener salidas por el puerto A para activar la interrupción
RB0/INT de cada PIC16F628, el cual le indica que tiene que enviar un dato.
El código en C que realiza estas acciones son:
Se comienza con la definición de las librerías utilizadas y las variables globales.
#include <18F2525.h>
//#fuses
HS,NOWDT,NOPROTECT,NOPUT,NOBROWNOUT,NOLVP
//
Opciones de configuración
#fuses
NOWDT,NOWDT,HS,
NOPROTECT,
NOIESO,
NOBROWNOUT,
BORV21, NOPUT, NOCPD, NOSTVREN, NODEBUG, NOLVP, NOWRT,
NOWRTD, NOEBTR, NOCPB, NOEBTRB, NOWRTC, NOWRTB, NOFCMEN,
NOXINST, NOPBADEN, NOLPT1OSC, NOMCLR
#use delay(clock=20000000)
#use fast_io(A)
#use fast_io(B)
#use fast_io(C)
#include<Cargar_Datos.h> //Cargamos Todas Los Datos de las Matrix y Screen
#include<Cargar_Presentacion.h>
#include <Sincronismov1.h>
#include <Video.h>
#include <Funciones.h>
131
//********************
PROGRAMA PRINCIPAL ***********************************
Void Main() {
set_tris_A (0b00000000);
set_tris_C (0b00000000);
set_tris_B (0b11111111);
output_A(0);
output_B(0);
delay_us(200);
While(TRUE){
//Linea 1 - 9
Pulsos_Campo_I();//Goto usa 0,4 us entrar
//Goto usa 0,4 us salir
//******************************* VIDEO ********************
//LINEA 10
delay_us(3);
//4,4 -0,6(0,2*3(Intruciones del IF(campo==0) en falso)) -
GotoSalir(0,4) =3,4
delay_cycles(2);
output_high(pin_a0); //negro
delay_us(56); //58,6 -entrar funcionLineasBoN(0,8)-entradao for(1) = 56,8
delay_cycles(4);//4
//LINEA 11 - 25
LineasNegras(15);//usa 0,8 /15
//*********************Impresion del 1 niño*****************************
//Linea 26
delay_us(4); //4,4 - GotoSalir(0,4) =4
output_high(pin_a0); //negro
delay_us(57); //58,6 -(0,4)goto funcion LerrDato-0,4(U1=3)=57,8us
delay_cycles(2);//2
U1=3; //esta variable controla las INT 3=PIC1 , 5=PIC2 , 9==PIC3 ,17=PIC4
//Llamada a las funciones
//Cada función es una línea
//Linea 27 a 33
132
LeerDato();
ClasificarLetra();
Tratar_Letra();
Borrar_Screen11();
Borrar_Screen12();
Borrar_Screen13();
LlenarScreen();
//Linea 34
delay_us(4); //4,4 - GotoSalir(0,4) =4
output_high(pin_a0); //negro
delay_us(56); //58,6 -((0,4)goto funcion Draw_Letras+0,2*8(Inst de inicio de la
funcion Draw Letras))=56,6us
delay_cycles(2);
N_LineasVideo=16;
//Linea 35 a la 50
Draw_Letras();//forma 16 lineas
} }
Diagramas
Diagramas del variables y funciones
Figura 3.4.4-3 Diagrama de variables y funciones
133
Diagrama de Actividades
Figura 3.4.4-4 Diagrama de actividades
134
Diagrama de secuencia
Figura 3.4.4-5 Diagrama de secuencias
Lectura de los datos de la señal RS 232 enviados por el teclado
Para comunicarse con el teclado, el microcontrolador PIC16F628 debe
conectarse a través de un chip max232 para acoplar los voltajes. Una vez que
se ha conectado el micro con el teclado, los datos serán leídos en una variable
llamada Dato.
135
El código en C para leer un dato RS-232 se describe a continuación.
#use rs232(baud=57600,rcv=PIN_A0) //Encabezado
dato=getc();
El dato obtenido se recibe en código ASCII.
El dato obtenido lo transformamos para enviarlo al PIC de video, este dato
transformado es el que es utilizado por la función ClasificarLetra() de PIC video
para encontrar la poción que ocupa la letra en matriz.
El código para realizar esta transformación se muestra a continuación.
switch (dato) //Identifica el dato de la entrada y lo relaciona con la variable
matriz
{
case 'A':
c=1;
break;
case 'B':
c=2;
break;
case 'C':
c=3;
break;
case 'D':
c=4;
break; }
Envió del un dato transformado
El envió del dato se lo realiza cada petición de la interrupción RB0/INT
El código para realizar esta el envió del dato es:
#int_EXT
136
EXT_isr(){
set_tris_b(0b00000001);
//SEDEMORA 15(iNS) PARA LLEGAR AL output_B(dato1);
delay_us(1);
delay_cycles(3);
if(i!=0){
output_B(dato1);
delay_us(70);
output_B(0);
i=0;
}
else{
output_B(0);
delay_us(70);
}
set_tris_b(0b11111111);
}
Diagramas
Diagramas del variables y funciones
Figura 3.4.4-6 Diagrama de de funciones
137
Diagrama de Actividades
Figura 3.4.4-7 Diagrama de actividades
Diagrama de secuencia
Figura 3.4.4-8 Diagrama de secuencias
138
CAPITULO IV
Software
139
CAPITULO IV SOTWARE
4 DISEÑO Y CONSTRUCCIÓN DE SOFTWARE
4.1 MANUAL PIC C COMPILER
Índice
•
1.INTRODUCCIÓN
•
2.ELEMENTOS DEL SOTWARE
•
3.OPERADORES Y EXPRESIONES
•
4. DESCRIPCIÓN DE INSTRUCCIONES
4.1.1 INTRODUCCIÓN
Figura 4.1.1-1 Pantalla principal
Si queremos realizar la programación de los microcontroladores PIC en un
lenguaje como el C, es preciso utilizar un compilador de C.
Dicho compilador nos genera ficheros en formato hexadedimal, que es el
necesario
para
programar
(utilizando
microcontrolador de 6, 8, 18 ó 40 pines.
140
un
programador
de
PIC)
un
El compilador de C que vamos a utilizar es el PCW de la casa CCS Inc. A su
vez, el compilador lo integraremos en un entorno de desarrollo integrado (IDE)
que nos va a permitir desarrollar todas y cada una de las fases que se compone
un proyecto, desde la edición hasta la compilación pasando por la depuración
de errores. La última fase, a excepción de la depuración y retoques hardware
finales, será programar el PIC.
Al igual que el compilador de Turbo C, éste "traduce" el código C del archivo
fuente (.C) a lenguaje máquina para los microcontroladores PIC, generando así
un archivo en formato hexadecimal (.HEX). Además de éste, también genera
otros seis ficheros, tal como se observa en la figura de la siguiente página.
Finalmente, presentaremos apuntes en soporte electrónico, es una experiencia
nueva y que como toda prueba tiene sus riesgos, aunque esperamos y
deseamos que, de una u otra forma logremos prender la llama de la ilusión, o
por lo menos despertar el interés por el estudio de la electrónica y en particular
de este mundo maravilloso de la programación en C y los microcontroladores.
4.1.2. ELEMENTOS DEL SOFTWARE
Figura 4.1.2-1 Barra de herramientas
Posee elementos básicos fáciles de manipular como abrir un archivo guardado,
pero unas de las grandes ventajas es la creación rápida, clara y e manera
sencilla de un nuevo proyecto, el compilador es
capaz de setear
automáticamente los parámetros de inicio o cabecera del programa.
141
Crear un nuevo archivo
Figura 4.1.2-2 Creación de un nuevo proyecto
1.- El programa pedirá l ubicación de donde se desee grabar el archivo.
Figura 4.1.2-3 Escoger donde guardar el proyecto
142
2.- Aparece una segunda pantalla que permite definir:
Figura 4.1.2-4 Configuración de parámetros internos del código
•
Pic
•
Oscilador (interno(si el pic posee), externo)
•
Seteos en general
3. En la parte inferior se muestran unas pestañas que permiten ir cambiando
sus valores como por ejemplo:
Figura 4.1.2-5 Pestañas de configuración de parámetros
•
Comunicación RS 232
•
Definir pines del pic (entradas, salidas)
•
Librerías que se puedan incluir.
143
4. Finalmente aceptados, y se mostrará la siguiente cabecera.
Figura 4.1.2-6 Visualización de parámetros seteados
Depuración de código
Figura 4.1.2-7 Proceso de compilación de código
144
Una de las principales características que posee el compilador es la posibilidad
de realizar una depuración fácil y sencilla, también tiene la capacidad de
mostrar la capacidad actual de la memoria interna del microcontrolador y saber
si hay o no espacio para que pueda ser grabado el programa en el pic.
De tal manera se puede saber antes de comprar el microcontrolador si este
tiene la capacidad suficiente y evitar que se pueda hacer una mala elección y
pérdida de dinero.
4.1.3. OPERADORES Y EXPRESIONES
• Operadores de asignación
Una expresión de asignación tradicional es de la forma:
expr1 = expr1 operador expr2 , es decir, i = i + 5
Esta expresión se puede representar por otra forma más corta:
expr1 operador= expr2
siguiendo con el mismo ejemplo i += 5.
Es en las expresiones complejas, y no en una tan simple como la del ejemplo,
donde se puede apreciar la conveniencia de usar esta notación. La siguiente
tabla resume los operadores de asignación compuesta y su significado.
Operador Descripción
Figura 4.1.3-1 Cuadro de asignación de operación
145
Los operadores aritméticos se usan para realizar operaciones matemáticas.
Se listan en la siguiente tabla:
Operador Descripción
Ejemplo
Figura 4.1.3-2 Descripción de los operadores
• Operadores relacionales
Su misión es comparar dos operandos y dar un resultado entero:
1 (verdadero); 0 (falso).
La siguiente tabla ilustra estos operadores:
Figura 4.1.3-3 Cuadro de operadores de relación
146
• Operadores lógicos
Al igual que los operadores relacionales, éstos devuelven 1 (verdadero), 0
(falso) tras la evaluación de sus operandos. La tabla siguiente ilustra estos
operadores.
Figura 4.1.3-4 Cuadro de operadores lógicos
• Operadores de manejo de bits
Estos operadores permiten actuar sobre los operandos a nivel de bits y sólo
pueden ser de tipo entero (incluyendo el tipo char). Son los que siguen:
Figura 4.1.3-5 Cuadro de operadores de bit
• Operadores de incremento y decremento
Aunque estos operadores forman parte del grupo de operadores de
asignación, hemos preferido separarlos en aras a una mayor claridad. Su
comportamiento se asemeja a las instrucciones de incremento incf f,d del
ensamblador del µcontrolador PIC 16F84 o inc variable del Intel 8051.
147
Operador Descripción
Figura 4.1.3-6 Cuadro de operadores de incremento, decremento
• Operadores de desplazamiento de bits
Los operadores de desplazamiento otorgan al C capacidad de control a bajo
nivel similar al lenguaje ensamblador. Estos operadores utilizan dos operandos
enteros (tipo int): el primero es el elemento a desplazar y el segundo, el
número de posiciones de bits que se desplaza. Se resumen en la siguiente
tabla:
Operador Descripción
Figura 4.1.3-7 Cuadro de desplazamiento de bit
• Expresiones
Figura 4.1.3-8 Cuadro de representación de formatos
148
4.1.4 DESCRIPCIÓN DE INSTRUCCIONES
A continuación se describen todas y cada una de las directivas del compilador
que utilizaremos para programar los microcontroladores PIC.
•
#ASM
#ENDASM
Las líneas entre #ASM y #ENDASM se tratan como código ensamblador. La
variable predefinida _RETURN_ puede utilizarse para asignar un valor de
retorno a la función desde el código en ensamblador, hay que tener presente
que cualquier código C después de ^I^B #ENDASM ^i^b y antes del final de la
función puede falsear el valor de retorno. La sintaxis de los comandos en
ensamblador se describen en la tabla.
Ejemplo:
int paridad (int dato) {
int contador;
#asm
movlw 8
movwf contador
movlw 0
lazo:
xorwf dato,w
rrf dato,f
decfsz contador,f
goto lazo
movwf _return_
#endasm }
149
Figura 4.1.4-1 Instrucción es en assembler
•
#ZERO_RAM
Directiva que pone a cero todos los registros internos que pueden usarse para
mantener variables, antes de que comience la ejecución del programa.
•
#IF expresión_constante
#ELSE
#ENDIF
El pre-procesador evalúa la expresión_constante y si es distinta de cero
procesará las líneas hasta el #ELSE que es opcional o en su defecto hasta el
#ENDIF.
150
Ejemplo:
#if (a + b + c) > 8
printf(" Demasiados parámetros ");
#endif
•
#INCLUDE <Nombre_Fichero>
#INCLUDE “Nombre_Fichero”
Esta directiva hace que el compilador incluya en el fichero fuente el texto que
contiene el archivo especificado en <Nombre_Fichero>.
Si el nombre del fichero se incluye entre los símbolos '< >' el compilador busca
el fichero en el directorio INCLUDE.
Si se pone entre comillas dobles " " el compilador busca primero en el directorio
actual o directorio de trabajo y si no lo encuentra, entonces lo busca en los
directorios INCLUDE del compilador.
Ejemplo:
#include <16F54.H>
#include "reg_C84.h"
•
#INT_xxx función_de_interrupción
Estas directivas especifican que la función que le sigue es una función de
interrupción. Las funciones de interrupción no pueden tener ningún parámetro.
Como es natural, no todas las directivas pueden usarse con todos los
dispositivos. Las directivas de este tipo que disponemos son:
151
Figura 4.1.4-2 Opciones de la instrucción Interrupción
El compilador salta a la función de interrupción cuando se detecta una
interrupción. Es el propio compilador el encargado de generar el código para
guardar y restaurar el estado del procesador.
También es el compilador quien borrará la interrupción (el flag). Sin embargo,
nuestro
programa
es
el
encargado
de
llamar
a
la
función
ENABLE_INTERRUPT() para activar previamente la interrupción junto con el
señalizador (flag) global de interrupciones.
•
#USE DELAY (CLOCK=frecuencia)
Esta directiva indica al compilador la frecuencia del procesador, en ciclos por
segundo, a la vez que habilita el uso de las funciones DELAY_MS() y
DELAY_US(). Opcionalmente podemos usar la función restart_WDT() para
que el compilador reinicie el WDT durante el retardo.
Ejemplos:
#use delay (clock=20000000)
#use delay (clock=32000, RESTART_WDT)
152
•
#USE FAST_IO (puerto)
Esta directiva afecta al código que el compilador generará para las instrucciones
de entrada y salida. Este método rápido de hacer I/O ocasiona que el
compilador realice I/O sin programar el registro de dirección. El puerto puede
ser A-G.
Ejemplo:
#use fast_io(A)
•
#USE FIXED_IO (puerto_OUTPUTS=pin_x#, pin_x#...)
Esta directiva afecta al código que el compilador generará para las instrucciones
de
entrada y salida. El método fijo de hacer I/O causará que el compilador genere
código para hacer que un pin de I/O sea entrada o salida cada vez que se
utiliza. Esto ahorra el byte de RAM usado en I/O normal.
Ejemplo:
#use fixed_io(a_outputs=PIN_A2 ,PIN_A3)
•
# USE RS232 (BAUD=baudios, XMIT=pin, RCV=pin)
Esta directiva le dice al compilador la velocidad en baudios y los pines
utilizados para la I/O serie. Esta directiva tiene efecto hasta que se encuentra
otra directiva RS232.
La directiva #USE DELAY debe aparecer antes de utilizar #USE RS232. Esta
directiva habilita el uso de funciones tales como GETCH, PUTCHAR y
PRINTF. Si la I/O no es estándar es preciso poner las directivas FIXED_IO o
FAST_IO delante de #USE RS232
153
Opciones:
Figura 4.1.4-3 Opciones de la instrucción #USE RS232
* #USE STANDARD IO (puerto)
Esta directiva afecta al código que el compilador genera para las instrucciones
154
de entrada y salida. El método estándar de hacer I/O causará que el
compilador genere código para hacer que un pin de I/O sea entrada o salida
cada vez que se utiliza. En los procesadores de la serie 5X esto necesita un
byte de RAM para cada puerto establecido como I/O estándar.
Ejemplo:
#use standard_io(A)
•
c= GETC()
c= GETC()
c= GETC()
Estas funciones esperan un carácter por la patilla RCV del dispositivo RS232 y
retorna el carácter recibido.
Es preciso utilizar la directiva #USE RS232 antes de la llamada a esta función
para que el compilador pueda determinar la velocidad de transmisión y la
patilla utilizada. La directiva #USE RS232 permanece efectiva hasta que se
encuentre otra que anule la anterior.
Los procedimientos de I/O serie exigen incluir #USE DELAY para ayudar a
sincronizar de forma correcta la velocidad de transmisión. Recordad que es
necesario adaptar los niveles de voltaje antes de conectar el PIC a un
dispositivo RS-232.
Ejemplo:
printf("Continuar (s,n)?");
do {
respuesta=getch();
} while(respuesta!='s'&& respuesta!='n');
);
155
•
GETS(char *string)
Esta función lee caracteres (usando GETC()) de la cadena (string) hasta que
encuentra un retorno de carro(valor ASCII 13). La cadena se termina con un 0.
•
PUTC()
PUTCHAR()
Estas funciones envían un carácter a la patilla XMIT del dispositivo RS232. Es
preciso utilizar la directiva #USE RS232 antes de la llamada a esta función para
que el compilador pueda determinar la velocidad de transmisión y la patilla
utilizada. La directiva #USE RS232 permanece efectiva hasta que se encuentre
otra que anule la anterior.
Ejemplo:
if (checksum==0)
putchar(ACK);
else
putchar(NAK); // NAK carácter de respuesta negativa
•
PUTS(string)
Esta función envía cada carácter de string a la patilla XMIT del dispositivo
RS232. Una vez concluido el envío de todos los caracteres la función envía un
retorno de carro CR o RETURN (ASCII 13) y un avance de línea LF o LINE FEED (ASCII 10).
Ejemplo:
puts( " ---------- " );
puts( " | HOLA |" );
puts( " ---------- " );
156
•
PRINTF([function],string,[values])
La función de impresión formateada PRINTF saca una cadena de caracteres al
estándar serie RS-232 o a una función especificada.
El formato está
relacionado con el argumento que ponemos dentro de la cadena (string).
Cuando se usan variables, string debe ser una constante. El carácter % se pone
dentro de string para indicar un valor variable, seguido de uno o más caracteres
que dan formato al tipo de información a representar.
Si ponemos %% obtenemos a la salida un solo %. El formato tiene la forma
genérica %wt, donde w es optativo y puede ser 1,2,...,9. Esto es para
especificar cuántos caracteres son representados; si elegimos el formato
01,...,09 indicamos ceros a la izquierda, o también 1.1 a 9.9 para representación
en punto flotante.
t es el tipo de formato y puede ser uno de los siguientes:
Figura 4.1.4-4 Opciones de la instrucción PRINTF
Ejemplos:
byte x,y,z;
printf (" Hola ");
printf("RTCCValue=>%2x\n\r",get_rtcc());
printf("%2u %X %4X \n\r",x,y,z);
printf(LCD_PUTC, "n=%c",n);
157
•
KBHIT()
Esta función devuelve TRUE si el bit que se está enviando al pin RCV de un
dispositivo RS232, es el bit de inicio de un carácter. Es preciso utilizar la
directiva #USE RS232 antes de la llamada a esta función para que el
compilador pueda determinar la velocidad en baudios y la patilla utilizada. La
directiva #USE RS232 permanece efectiva hasta que se encuentre otra que
anule la anterior.
Ejemplo:
keypress=' ';
while ( keypress!='Q' ) {
// entramos al bucle while
if ( kbhit () )
keypress=getc();
if (!input(PIN_B2))
// en la variable keypress se guardan los caracteres
// inicio del envío de un byte
output_high(PIN_B3);
else
output_low(PIN_B3)
}
•
INPUT(pin)
Devuelve el estado '0' o '1' de la patilla indicada en pin. El método de acceso de
I/O depende de la última directiva #USE *_IO utilizada. El valor de retorno es un
entero corto.
Ejemplo:
while ( !input(PIN_B1) );
•
OUTPUT_BIT(pin,value)
158
Esta función saca el bit dado en value(0 o 1) por la patilla de I/O especificada en
pin. El modo de establecer la dirección del registro, está determinada por la
última directiva #USE *_IO.
Ejemplo:
output_bit( PIN_B0, 0);
// es lo mismo que output_low(pin_B0);
output_bit( PIN_B0,input( PIN_B1 ) );
// pone B0 igual que B1
output_bit( PIN_B0, shift_left(&data, 1, input(PIN_B1)));
// saca por B0 el MSB de 'data' y al mismo tiempo
// desplaza el nivel en B1 al LSB de data.
•
OUTPUT_FLOAT(pin)
Esta función pone la patilla especificada como pin en el modo de entrada.
Esto
permitirá que la patilla esté flotante para representar un nivel alto en una
conexión de tipo colector abierto.
Ejemplo:
// guardamos la lectura del port A en dato
if( (dato & 0x80)==0 )
output_low(pin_A0);
// comprobamos si es '1' el MSB
// si es '1' ponemos a cero el pin A0
else
output_float(pin_A0);
•
// de lo contrario, ponemos el pin A0 a uno
OUTPUT_HIGH(pin)
Pone a 'uno' el pin indicado. El método de acceso de I/O depende de la última
directiva #USE *_IO utilizada.
159
Ejemplo:
output_high(PIN_A0);
•
OUTPUT_LOW (pin)
Pone a 'cero' el pin indicado. El método de acceso de I/O depende de la última
directiva #USE *_IO.
Ejemplo:
output_low(PIN_A0);
•
DELAY_CYCLES(count)
Esta función realiza retardos según el número de ciclos de instrucción
especificado en count; los valores posibles van desde 1 a 255. Un ciclo de
instrucción es igual a cuatro periodos de reloj.
Ejemplo:
delay_cycles( 3 ); // retardo de 3ciclos instrucción; es igual que un NOP
•
DELAY_MS(time)
Esta función realiza retardos del valor especificado en time. Dicho valor de
tiempo es en milisegundos y el rango es 0-65535.
Para obtener retardos más largos así como retardos 'variables' es preciso
hacer llamadas a una función separada; véase el ejemplo siguiente.
Es preciso utilizar la directiva #use delay(clock=frecuencia) antes de la
llamada a esta función, para que el compilador sepa la frecuencia de reloj.
160
Ejemplos:
#use delay (clock=4000000)
delay_ms( 2 );
// reloj de 4MHz
// retardo de 2ms
void retardo_segundos(int n) {
// retardo de 'n' segundos; 0 <= n => 255
for (; n!=0; n--)
delay_ms( 1000 );
// 1 segundo
}
•
DELAY_US(time)
Esta función realiza retardos del valor especificado en time. Dicho valor es en
microsegundos y el rango va desde 0 a 65535. Es necesario utilizar la directiva
#use delay antes de la llamada a esta función para que el compilador sepa la
frecuencia de reloj.
Ejemplos:
#use delay(clock=20000000)
delay_us(50);
int espera = 10;
delay_us(espera);
•
DISABLE_INTERRUPTS(level)
Esta función desactiva la interrupción del nivel dado en level. El nivel GLOBAL
prohíbe todas las interrupciones, aunque estén habilitadas o permitidas. Los
niveles de interrupción son:
Ejemplo:
disable_interrupts(GLOBAL);
/* prohíbe todas las interrupciones */
161
•
ENABLED INTERRUPTS(level)
Esta función activa la interrupción del nivel dado en level. Queda a cargo del
técnico definir un procedimiento o rutina de atención, para el caso que se
produzca la interrupción indicada. El nivel GLOBAL permite todas las
interrupciones que estén habilitadas de forma individual. Véase también
DISABLE_INTERRUPTS.
Ejemplo:
disable_interrupts(GLOBAL).- Prohíbe todas las interrupciones
enable_interrupts(INT_AD).- Quedan habilitadas estas dos interrupciones,
enable_interrupts(INT_I2C).- Pero hasta que no se habilite GLOBAL, no
podrán activarse.
enable_interrupts(GLOBAL).-Ahora sí se pueden producir las interrupciones
anteriores.
•
EXT_INTEDGE(edge)
Esta función determina el flanco de activación de la interrupción externa. El
flanco puede ser de subida (L_TO_H) o de bajada (H_TO_L).
Ejemplo:
ext_int_edge( L_TO_H );
162
4.2 MANUAL WINPIC800
Figura 4.2-1 Pantalla de presentación
4.2.1 CONFIGURACIÓN DE HARDWARE
Figura 4.2.1-1 Configurar el programador
Uno de los primeros pasos el configurar el hardware del programador que
vamos utilizar par l grabación del código (.HEX) que es generado por el
programa Pic C Compiler.
163
4.2.2 ESCOGER HARDWARE
Figura 4.2.2-1 Escoger el programador
Aquí podemos observar la gran gama de programadores de microcontroladores
que soporta el hardware sea vía serial, puerto paralelo ó usb, en nuestro caso
utilizamos el hardware Polivalente que es vía puerto paralelo y que soporta una
la gama de microcontroladores PIC18FXX.
4.2.3 ESCOGER MICROCONTROLADOR
Figura 4.2.3-1 Selección del pic
Como podemos observar en el sub-cuadro de la derecha la gama de pics que
posee además de la capacidad de su memoria interna.
164
4.2.4 CARGAR EL ARCHIVO (.HEX)
Figura 4.2.4-1 Barra de herramientas
Un de sus facilidades es que evita que carguemos programas que no coincidan
con el pic seleccionado.
4.2.5 GRABACIÓN DE PIC
Figura 4.2.5-1 Grabación del código .hex
Y por último se procede a la carga del archivo (.HEX) al pic.
165
CAPITULO V
Implementación
y Resultados
166
5.1 PRUEBAS REALIZADAS
El cronograma de evaluación que se presenta a continuación se desarrolló de
una forma muy práctica y sencilla con el fin de comprender y visualizar la
magnitud de coordinación motriz y comprensión del operador (niños), que van a
trabajar con el proyecto (pizarra electrónica), que han sido realizado con los
Pic’s 16F628A y 18F2525.
Fechas:
Enero 2006
•
Análisis de necesidades de los niños con IMOC.
•
Pruebas de motricidad de los niños.
•
Disponibilidad de elementos a utilizar.
Febrero 2006
•
Presentación de elementos de escritura.
•
Presentación de elementos de visualización.
Marzo - Abril 2006
•
Presentación del primer prototipo.
Mayo 2006
•
Pruebas realizadas proyecto final.
167
5.2 RESULTADOS OBTENDIDOS
Fechas:
Enero 2006
•
Se obtuvo el resultado de que los niños y los profesores requerían una
forma eficiente de comunicación, pasar de la escritura simbólica del un
tablero a un formato visual legible y entendible por ambos (profesor,
alumno).
•
El resultado de las pruebas de motricidad de los niños se obtuvo las
mejores resultados, ya que los niños tienen una gran capacidad
intelectual que facilita las cosas (comprensión), y la capacidad de un
buen movimiento en alguno a varios de sus dedos que facilitarán la
manipulación de elemento de escritura.
•
Por tal razón se realizó la búsqueda de elementos fáciles de manipular y
que se encuentren con facilidad en el mercado.
Febrero 2006
•
Después de analizar se escogió de un elemento de escritura (teclado del
computador), como la opción más factible y fácil de conseguir y sin
necesidad de modificaciones.
•
Y como elemento de visualización se optó por la televisión que brinda la
capacidad de visualización ideal fácil de conseguir y utilizando la entrada
de video, y sin adaptación alguna.
Marzo - Abril 2006
•
Con los elementos escogidos se elaboró el primer prototipo que
constaba con un solo teclado, televisor, software, hardware de
168
adaptación, el cual constaba con la capacidad de escritura, lectura de
letras mayúscula que se visualizaban el en televisor.
•
Pero surgió la necesidad de expandirlo a 4 en total y que se utilizara un
solo televisor por necesidad de costos.
Mayo 2006
•
Por lo tanto se realizó el proyecto final (pizarra electrónica), el cuál ya
constaba de 4 teclados independientes, un televisor, hardware (módulos
teclado, red, video), software (cuatro líneas de texto independientes,
letras minúsculas, mayúsculas, números, operaciones básicas).
•
El proyecto satisfizo las necesidad planteadas y por lo tanto se prosiguió
y su implementación.
5.3 ANÁLISIS DE COSTOS
5.3.1 COSTOS DE FABRICACIÓN
El costo de desarrollo del proyecto (pizarra electrónica), se describe a
continuación, en la tabla se describe los gastos realizados.
PRECIO
DESCRIPCIÓN
COSTO
CANTIDAD TOTAL
PIC 16F628A
3,5
8
28
PIC 18F2525
35
1
35
MAX232
3
4
12
ZOCALO 14 PINES 0,5
4
2
ZOCALO 16 PINES 0,5
8
4
ZOCALO 28 PINES 0,7
1
0,7
BAQUELITA
0,8
6
4,8
PAPEL TERMICO
2,4
3
7,2
ACIDO FERRICO
0,5
6
3
169
CAJAS TECLADO
4
2
8
CAJAS VIDEO
7
1
7
RESISTENCIAS
0,25
20
5
0,5
4
2
CONECTORES
PS/2
TOTAL
118,7
Figura 5.3.1-1 Tabla de costos
Así se define el costo del prototipo desarrollado, cabe recalcar que se obvió la
compra de teclados y televisor los cuales los tenemos en el hogar, lo que
facilitó l reducción de los costos de fabricación.
5.3.2 COSTOS DE MANO DE OBRA
El costo de mano de obra del proyecto y tomando en cuenta, los gastos de
ensayos es el siguiente:
COSTOS DE ENSAYOS
COSTOS
DE
MANO
150
DE
OBRA
250
TOTAL
400
Figura 5.3.1-2 Tabla de costos
Costo total de la fabricación del proyecto $520.
5.3.3 PRODUCCIÓN EN SERIE
Sí el objetivo posterior es la producción en serie, se debe tomar en cuenta que
se deberá comprar los teclados, y el televisor si esto hubiera sido en nuestro
caso el costo subiría a unos $ 800.
170
CAPITULO VI
Conclusión
171
6.1 BENEFICIO SOCIAL
El desarrollo de la tesis (Pizarra electrónica), nace por la necesidad de construir
un
dispositivo útil, que facilite las actividades de educación, trabajo y
entretenimiento a personas que se les dificulta la utilización del computador
debido a la imprecisión de sus movimientos, causada por descoordinación
motriz y factores externos que producen la pérdida de regularidad para realizar
una actividad (escritura).
El hecho de desarrollar un dispositivo que aún siendo sencillo, contribuye con
facilitar y beneficiar a personas que padezcan IMOC, es gratificante saber que
la aplicación que desarrollamos no solo ayudará a una sola persona sino que
ayudará a muchas más personas, facilitando su desarrollo intelectual.
La construcción de este proyecto no tiene fines de lucro, sin embargo si el
prototipo fuera producido en grandes cantidades, debiera orientarse a fines
específicos es decir tomando en cuenta el problema de coordinación de la
persona.
6.2 CONCLUSIONES
6.2.1 CONCLUSIONES DEL PROYECTO
Se ha optado por la utilización de los PIC 16F628A y PIC 18F2525 para el
diseño de nuestro sistema por sus ventajas sobre otros pic.
•
Para el manejo de los teclados, y recepción de datos se optó por la
elección del PIC 16F628A por su tamaño, espacio en memoria 2K y su
capacidad de soportar un cristal oscilador de 20Mhz y su bajo costo.
•
La elección del pic para el manejo video se optó por la elección del PIC
18F2525 por su capacidad de memoria ya que es una nueva gama de
172
pic y dispone de 4.900 K de memoria y soporta un cristal oscilador de
20Mhz.
•
Para el tema de tesis se planteó la re utilización teclado (ps/2), televisor
(video in) y mediante los microcontroladores para su manejo, evitando la
construcción en totalidad de nuevos elementos, debido a que se puede
utilizar sin problemas cualquier teclado común y corriente al igual del
televisor,
estas
características
nos
brindan
la
capacidad
de
transportailidad y fácil manejo.
6.2.2 CONCLUSIONES DE LA UTILIZACIÓN DEL PROYECTO
Es importante indicar que el proyecto satisfizo las expectativas planteadas por
los directivos de la fundación.
•
Una de las principales bondades del proyecto es su capacidad de
emular al computador, es decir, capacidad de escribir el abecedario
completo (mayúsculas y minúsculas), números y operaciones básicas y
poderlos visualizar en un monitor el cual es el televisor.
•
La capacidad de pasar de un tipo de escritura manual como es indicar
letra por letra en un tablero y la poca capacidad de recordancia de los
escrito a una forma más tecnológica como es la visualización de lo que
se escribe y su posterior modificación en casos de errores.
•
El mejor control por parte de los profesores que pueden monitorear
visualmente en conjunto a los niños por medio de las líneas de texto y
evitando estar mucho tiempo con cada niño y optimizar el tiempo para
mejorar la enseñanza.
•
Y por último la felicidad de los niños que un mucho de los casos no está
en las posibilidades de manipular un computador por cuestiones de
costo, aquí lo pueden hacer y mejorar tanto en su motricidad, su
intelecto y muy importante su comunicación.
173
6.3 RECOMENDACIONES
•
Para la utilización del proyecto desarrollado en la tesis se recomienda un
área de trabajo (aula), normal debido a que no se hicieron
modificaciones algunas a los elementos ya descritos (teclado y
televisor), y los módulos que no representan un gran consumo de
espacio, puesto
que están debidamente colocados
en lugares
estratégicos y con la capacidad de ser unidos mediante una red que
puede alcanzar una longitud de hasta 8 metros sin pérdida de
información.
•
Pero uno de los elementos principales del sistema es el PIC18F2525 el
cuál es encargado del manejo del módulo video y es en ocas palabras el
cerebro del proyecto, el inconveniente en casos de fabricación de
nuevos módulos o daño de este es su dificultad de comprar el pic, en
nuestro caso se tuvo que importar desde USA, desde la compañía
Microchip que es l encargada de l fabricación y venta de estos
elementos.
6.5 BIBLIOGRAFÍA
6.4.1 REFERENCAS DE INTERNET
Foro especializado en presentación de artículos, proyectos, información sobre
mcrocontroladores.
•
http://conket.com
1.- Tutorial Pc y Pic
http://conket.com/modules.php?name=Sections&op=viewarticle&artid=14
174
En esta página se puede observar y conocer como es una señal de video, sus
elementos, diagrama de tiempos.
2.- Interfaz teclado y Pc
http://conket.com/modules.php?name=Sections&op=viewarticle&artid=39
En esta dirección podemos conocer como se realiza la conexión básica entre el
teclado y pc, con diagramas de conexión, información de sincronismos de
pulsos y ejemplos aplicativos.
•
Página electrónica proyectos de Richard
Este sitio web es otro foro abierto de proyectos, mucho más completa ya que
consta de foro no solo de pic’s , también con foros de electrónica, y sistios de
descargas.
3.- Manual de usuario del compilador PCW (Compilador de pic’s)
http://conket.com/modules.php?name=Downloads&d_op=viewdownload&cid=3
En la sección download se puede descargar varias cosas en nuestro caso
nosotros se descargó el manual para el compilador Pic C Compiler.
4.- Señales de video
http://216.239.39.104/translate_c?hl=es&u=http://www.rickard.gunee.com/proje
cts/video/pic/howto.php&prev=/search%3Fq%3Dsignal%2Bvideo%2Bmicrocont
roller%26hl%3Des%26lr%3D%26sa%3DG
En este artículo se puede encontrar información sobre la señal de video,
ejemplos, programas aplicativos básicos que facilitarán la iniciación de la
programación en C.
•
Comunidad Modding
175
Este sitio ofrece artículos sobre distintos proyectos con pic’s.
5.- Como es una señal de video
http://www.hardcoremodding.com/modules.php?name=Forums&file=viewtopic&t=26933&postdays=
0&postorder=asc&start=15
•
wikipedia
Enciclopedia en Internet donde podemos consultar conceptos y ver información
de distintas ramas.
http://es.wikipedia.org/wiki
En nuestro caso consultamos sobre sistemas de televisión PAL, NTSC.
•
IMOC documentos
http://www.aurasalud.com/
En esta página podemos encontrar un artículo completo sobre causas
problemas, prevenciones que se deben tener con niños que sufren de
Insuficiencia Motriz de Origen Cerebral.
176
ANEXOS
177
Aquí se presentan los códigos completos de los módulos teclado, red, video,
con su respectiva explicación.
CÓDIGO DEL TECLADO
#include <16F628A.h>
#fuses HS, NOWDT, NOPROTECT, PUT, BROWNOUT, NOLVP
#use Delay(Clock=20000000)
#use standard_io(A)
#use standard_io(B)
#usefixed_io(a_outputs=PIN_A0,PIN_A1,PIN_A2,PIN_A3)
#use fixed_io(b_outputs=PIN_B5)
#users232(baud=57600,parity=N,xmit=PIN_b2,rcv=PIN_b1,bits=8)
#zero_ram
//----------------------------------------------------------------------------// Definiciones globales
//----------------------------------------------------------------------------unsigned char edge, bitcount;
char got_interrupt;
char interrupt_count;
char status_b7;
#bit INTF_BIT = 0x0B.1
//-------- Tabla de caracteres correspondientes a la pulsación de la tecla
//-------- en modalidad normal (sin pulsar SHIFT)
unsigned char const unshifted[68][2] = {
0x0d,9,
0x0e,'º',
0x15,'q',
0x16,'1',
0x1a,'z',
0x1b,'s',
0x1c,'a',
0x1d,'w',
0x1e,'2',
0x21,'c',
0x22,'x',
0x23,'d',
0x24,'e',
0x25,'4',
0x26,'3',
0x29,' ',
0x2a,'v',
0x2b,'f',
0x2c,'t',
0x2d,'r',
0x2e,'5',
0x31,'n',
0x32,'b',
0x33,'h',
0x34,'g',
0x35,'y',
0x36,'6',
.
0x39,',',
0x3a,'m',
0x3b,'j',
0x3c,'u',
0x3d,'7',
0x3e,'8',
0x41,',',
0x42,'k',
0x43,'i',
0x44,'o',
0x45,'0',
0x46,'9',
0x49,'.',
0x4a,'-',
0x4b,'l',
0x4c,'ñ',
0x4d,'p',
0x4e,''',
0x52,'´',
0x54,'`',
0x55,'¡',
0x5a,13,
0x5b,'+',
0x5d,'ç',
0x61,'<',
0x66,8,
0x69,'1',
0x6b,'4',
0x6c,'7',
0x70,'0',
0x71,'.',
0x72,'2',
0x73,'5',
0x74,'6',
0x75,'8',
0x79,'+',
0x7a,'3',
0x7b,'-',
0x7c,'*',
0x7d,'9',
0,0
};
//----------------------------------------------------------------------------// Definición de protipos
//----------------------------------------------------------------------------void init_kb(void);
void decode(unsigned char sc);
#int_ext
void int_ext_isr(void);
//----------------------------------------------------------------------------// Main
//----------------------------------------------------------------------------void main(void)
.
{
init_kb();
//-------- Los pins indicados (B0 y B7) son configurados como entradas.
output_float(PIN_B0);
output_float(PIN_B7);
//-------- Activa pullups sobre todos los pins del puerto B.
port_b_pullups(TRUE);
//-------- Espera a que se activen.
delay_us(5);
//-------- Inicializa las variables usadas por la rutina de interrupción
//-------- antes de activar las interrupciones
interrupt_count = 0;
got_interrupt = FALSE;
status_b7 = 0;
//-------- Desde que se activó el modo PULLUPS del puerto B, el estado
//-------- normal del pin B0 es ALTO. La gestión de la interrupción externa
//-------- se gestiona cuando se produce un cambio de nivel ALTO a BAJO.
ext_int_edge(H_TO_L);
//-------- Asegurarse de que el el bit de flag de la interrupción externa
//-------- es borrado antes de activar la gestión de dicha interrupción
//-------- externa.
INTF_BIT = 0;
enable_interrupts(INT_EXT);
enable_interrupts(GLOBAL);
//-------- Bucle principal.
//-------- Chequear si se produce alguna interrupción (got_interrupt). Si es así, contar, borrar
//-------- el flag y esperar 50 ms, reactivando la gestión de las interrupciones
while(1)
{
//-------- Chequear si se produce alguna interrupción (got_interrupt).
if(got_interrupt == TRUE)
{
//-------- Borrar el flag global que se inicio en la rutina de servicio
//-------- de interrupciones externas.
got_interrupt = FALSE;
//-------- Esperar 50 ms para evitar rebotes en los contactos de las teclas.
//delay_ms(50);
//-------- Borrar cualquier interrupción producida durante el periodo de espera.
INTF_BIT = 0;
//-------- Reactivar interrupciones
enable_interrupts(INT_EXT);
} // --- End If ---
.
} // --- End While --} // --- End MAIN ---
//----------------------------------------------------------------------------// Funciones
//----------------------------------------------------------------------------//----------------------------------------------------------------------------// Inicialización de teclado.
//----------------------------------------------------------------------------void init_kb(void)
{
//-------- Longitud de la trama para cada pulsación y mensaje de bienvenida
bitcount = 11;
printf("\n\rPC AT Keyboard Interface Ver 1.0 by XP8100");
printf("\n\rDecoder for 16F877 connected ...\n\r\n\r");
}
//----------------------------------------------------------------------------// Decodificación de pulsaciones
//----------------------------------------------------------------------------void decode(unsigned char sc)
{
static unsigned char is_up=0, shift = 0, mode = 0;
unsigned char i;
//-------- El último dato recibido fue el identificador de Up-Key
if (!is_up)
{
switch (sc)
{
//-------- Identificador de Up-Key
case 0xF0 :
is_up = 1;
break;
//-------- SHIFT Izquierdo
case 0x12 :
shift = 1;
break;
//-------- SHIFT Derecho
case 0x59 :
shift = 1;
break;
//-------- ENTER
case 0x5A :
shift = 0;
printf("\n\r");
break;
//-------- Si no es ninguno de los identificadores especiales, procesar
//-------- pulsación, localizando caracter en tabla de caracteres.
default:
//-------- Pulsación normal
if(!shift)
{
for(i = 0; shifted[i][0]!=sc && shifted[i][0]; i++);
.
if (shifted[i][0] == sc)
{
printf("%c", shifted[i][1]);
}
}
else
//-------- Pulsación + SHIFT presionado
{
for(i = 0; shifted[i][0]!=sc && shifted[i][0]; i++);
if (shifted[i][0] == sc)
{
printf("%c", shifted[i][1]);
}
}
break;
} // --- End Switch
}
else
{
//-------- No se permiten 2 0xF0 en una fila
is_up = 0;
switch (sc)
{
//-------- SHIFT Izquierdo
case 0x12 :
shift = 0;
break;
//-------- SHIFT Derecho
case 0x59 :
shift = 0;
break;
} // --- End Switch
}
}
//----------------------------------------------------------------------------// Rutina de gestión de interrupciones
//----------------------------------------------------------------------------#int_ext
void int_ext_isr(void)
{
unsigned char data;
//-------- Los bit 3 a 10 se considerran datos. Paridad, start y stop
//-------- son ignorados
if(bitcount < 11 && bitcount > 2)
{
data = (data >> 1);
status_b7 = input(PIN_B7);
if((status_b7) == 1)
data = data | 0x80;
}
//-------- Todos los bits se han recibido
if(--bitcount == 0)
{
.
decode(data);
data = 0;
bitcount = 11;
got_interrupt = TRUE;
}
got_interrupt = TRUE;
interrupt_count++;
disable_interrupts(INT_EXT);
}
CÓDIGO DEL CONCENTRADOR
#include <16F628A.h>
#fuses NOWDT,HS, NOPUT, NOPROTECT, NOBROWNOUT, MCLR, NOLVP, NOCPD //
Opciones de configuración
#use delay(clock=20000000)
#use rs232(baud=57600,rcv=PIN_A0)
#use fast_io(A)
#use fast_io(B)
int dato=0;
#Locate dato=0x69
int dato1=0;
#Locate dato1=0x6A
int c=0;
#Locate c=0x6B
int i=0;
#Locate i=0x6C
#int_EXT
EXT_isr()
.
{
set_tris_b(0b00000001);
//SEDEMORA 15(iNS) PARA LLEGAR AL output_B(dato1);
delay_us(1);
delay_cycles(3);
if(i!=0){
output_B(dato1);
delay_us(70);
output_B(0);
i=0;
}
else{
output_B(0);
delay_us(70);
}
set_tris_b(0b11111111);
}
Void Main() {
enable_interrupts(INT_EXT);
enable_interrupts(GLOBAL);
set_tris_a(0b00000001);
set_tris_b(0b11111111);
output_A(0);
while(true){
dato=getc();
c=0;
switch (dato) //Identifica el dato de la entrada y lo relaciona con la
//variable matriz
{
case 'A':
c=1;
break;
case 'B':
c=2;
break;
case 'C':
c=3;
break;
case 'D':
c=4;
break;
case 'E':
c=5;
break;
case 'F':
c=6;
break;
case 'G':
c=7;
break;
case 'H':
.
c=8;
break;
case 'I':
c=9;
break;
case 'J':
c=10;
break;
case 'K':
c=11;
break;
case 'L':
c=12;
break;
case 'M':
c=13;
break;
case 'N':
c=14;
break;
case 'Ñ':
c=15;
break;
case 'O':
c=16;
break;
case 'P':
c=17;
break;
case 'Q':
c=18;
break;
case 'R':
c=19;
break;
case 'S':
c=20;
break;
case 'T':
c=21;
break;
case 'U':
c=22;
break;
case 'V':
c=23;
break;
case 'W':
c=24;
break;
case 'X':
c=25;
break;
case 'Y':
c=26;
break;
case 'Z':
c=27;
.
break;
case '0':
c=28;
break;
case '1':
c=29;
break;
case '2':
c=30;
break;
case '3':
c=31;
break;
case '4':
c=32;
break;
//*******************************************************
case ' ':
c=66;
break;
case '+':
c=67;
break;
case '-':
c=68;
break;
case '*':
c=69;
break;
case '/':
c=70;
break;
case '=':
c=71;
break;
case 9:
c=126;
break;
case 8:
c=127;
}//fin swith
if(c!=0){
i=1;
c=c<<1;
dato1=c;
}
}
}
.
CÓDIGO DEL VIDEO
Codigo de archivo .h
FUNCIONES.h
#DEFINE FSR0L 0xFE9
#DEFINE INDF0 0xFEF
#DEFINE FSR1L 0xFE1
#DEFINE INDF1 0xFE7
//*****************************************************************
//Variables para la Funcion Llenar Screen
int8 POS_LETRA_SCREEN=0; //Variable utilizada como auxiliar paralas fuciones
#Locate POS_LETRA_SCREEN =0x80
int8 POS_LETRA_MATRIX=0;//Variable utilizada para hallar la direccionen de la letra en la
matrix
#Locate POS_LETRA_MATRIX =0x81
int8 DIRi_SCREEN=1;//Variable
#Locate DIRi_SCREEN =0x82
int8 n_DIRi_SCREEN=1;//Variable
#Locate n_DIRi_SCREEN =0x83
int8 DIRi_MATRIX=10;//14 por apunta al banco de memoria 14
#Locate DIRi_MATRIX =0x84 //Variable declarada Banco de memoria 6
//TOMA SOLO VALORES DE
//***********************************************************************
//variables Para la funcion Draw Letras
int8 N_LineasVideo=48;
#Locate N_LineasVideo =0x85
.
//***********************************************************************
int8 DATO=0;//DATO QUE INGRESA DEL PUERTO C
#Locate DATO =0x86
int8 DATO1=0;//DATO QUE INGRESA DEL PUERTO C
#Locate DATO1 =0x87
int8 Bandera_N_Letra=1; //ocupa el registro 0x8A bandera que me indica para incrementar N_
#Locate Bandera_N_Letra =0x88//valores 0=Incrementa y 1=Nada
//*****************************************************************
int8 i1=40;//variable para controlar el numero de repeticones en la funcion Leer Dato
#Locate i1=0x89
//Variables que me controlan el la interupciones INT de cada 16F628
int8 U1=3;
#Locate U1=0x8A
int8 contador=0;
#Locate contador=0x8B
int8 CondisionPresentacion=1;
#Locate CondisionPresentacion=0x8C
//SOBRAN VARIABLES 8D 8E 8F
//Estas Variables son individuales para cada niño
//*****************Variables del niño 1*******************************
int8 Borrar1=1;//Bander para Borra el vector de nino 1
#Locate Borrar1=0x90//valores 1= falso y 0 = verdad
int8 BorrarScreen=1;//Me Borra el vector de nino
#Locate BorrarScreen=0x91//valores 1= falso y 0 = verdad
int8 N_Letra1=0;
#Locate N_Letra1 =0x92
int8 N_LINEA_TEXTO1=0;
#Locate N_LINEA_TEXTO1 =0x93
int8 TN_LINEA_TEXTO1=0;
#Locate TN_LINEA_TEXTO1=0x94
//*****************Variables del niño 2*******************************
int8 Borrar2=1;//Bander para Borra el vector de nino 1
#Locate Borrar2=0x95//valores 1= falso y 0 = verdad
int8 BorrarScreen2=1;//Me Borra el vector de nino
#Locate BorrarScreen2=0x96//valores 1= falso y 0 = verdad
int8 N_Letra2=0;
#Locate N_Letra2 =0x97
int8 N_LINEA_TEXTO2=0;
#Locate N_LINEA_TEXTO2=0x98
int8 TN_LINEA_TEXTO2=0;
#Locate TN_LINEA_TEXTO2=0x99
.
//*****************Variables del niño 3*******************************
int8 Borrar3=1;//Bander para Borra el vector de nino 1
#Locate Borrar3=0x9A//valores 1= falso y 0 = verdad
int8 BorrarScreen3=1;//Me Borra el vector de nino
#Locate BorrarScreen3=0x9B//valores 1= falso y 0 = verdad
int8 N_Letra3=0;
#Locate N_Letra3 =0x9C
int8 N_LINEA_TEXTO3=0;
#Locate N_LINEA_TEXTO3=0x9D
int8 TN_LINEA_TEXTO3=0;
#Locate TN_LINEA_TEXTO3=0x9E
//*****************Variables del niño 4*******************************
int8 Borrar4=1;//Bander para Borra el vector de nino 1
#Locate Borrar4=0x9F//valores 1= falso y 0 = verdad
int8 BorrarScreen4=1;//Me Borra el vector de nino
#Locate BorrarScreen4=0xA0//valores 1= falso y 0 = verdad
int8 N_Letra4=0;
#Locate N_Letra4 =0xA1
int8 N_LINEA_TEXTO4=0;
#Locate N_LINEA_TEXTO4=0xA2
int8 TN_LINEA_TEXTO4=0;
#Locate TN_LINEA_TEXTO4=0xA3
//********************************************************
int FSR0H=1;
#Locate FSR0H =0xFEA
int FSR1H=1;
#Locate FSR1H =0xFE2
int8 PORTA=0;
#Locate PORTA=0xF89
int8 PORTB=0;
#Locate PORTB=0xF81
int8 PORTC=0;
#Locate PORTC=0xF8B
int8 LATC=0;
#Locate LATC=0xF82
//_____________________________FUNCIONES___________________________________
____
.
void int LeerDato(){
//Sincronización Horizontal (4.4us)
output_low(pin_a0); //sincro
delay_us(4);
delay_cycles(2);
output_high(pin_a0); //negro
//lineas de imagen + black porch 58,6
i1=40;//40 valor 2(Inst)
PORTA=U1;//2
//delay_us(4);//quitar
#asm
Loop1:
MOVFF PORTB , DATO //2
DECFSZ i1,F
//1
BRA Loop1
//2
#endasm //Tiempo Total= 5(Instruccione)*0.2*i1(=40) + 0,4us(i1=40)
+0,4us(PORTA=U1)+0,4(PORTA=1) =41,2us
//41,2-0,4(Dato1=Dato;)=40,8-4(delay_us(4))=36,8us
PORTA=1;
Dato1=Dato;
//tiempo sobrante
delay_us(17);//58,6-36,8=21,8us//21
delay_cycles(3);///modificar 4
output_low(pin_a0); //sincro
//ya Terminado y corregido
}
//___________________________________________________________________________
___
void int ClasificarLetra(){
//VARIABLES
//Clasificamos..
//Las letras Mayusculas A a la Z
//y los signos de + , - , *, / , espacio blanco
//Las letras se Encuentran en el Banco 6
//Sincronización Horizontal (4.4us)-goto funcion leer Dato -goto(entra fun clasif)
//4,4-0,4-0,4 = 3,6us
delay_us(3);
delay_cycles(3);
output_high(pin_a0); //negro
//Clasificacion del dato
//LOS numeros 1 al 1f(32) son la codificacion 0 = A 1=B.....30=/ 31 = *
//Las letras A a la Z y Signos estan en Banco de memoria 6
//LOS numeros 0x20(32 d) al 0x29(41 ) son la codificacion 32 = 0 33=1.....40=8 41 = 9
//Las letras A a la Z y Signos estan en Banco de memoria 6
//********************************************************************
if(DATO >=0x01){
if(DATO <=0x20){
.
Bandera_N_Letra=0;
DIRi_MATRIX=13;
DATO=DATO-1;
POS_LETRA_MATRIX=8*DATO;
}
else{
//total=19(Istrucciones)-9(Instruccinoes)=10(Instrucciones)*0,2=2us
delay_us(2);
}
}
else{
//total=19(Istrucciones)-4(Instruccinoes)=15(Instrucciones)*0,2=3us
delay_us(3);
}//Total=19(Instrucciones)*0,2=3,8us
//********************************************************************
//Clasificamos..
//Los numeros 0 al 9 se entran en el Banco 7
if(DATO >=0x21){
if(DATO <=0x40){
Bandera_N_Letra=0;
DIRi_MATRIX=14;
DATO=DATO-33;//(33 = 0x21)
POS_LETRA_MATRIX=8*DATO;
}
else{
//total=19(Istrucciones)-9(Instruccinoes)=10(Instrucciones)*0,2=2us
delay_us(2);
}
}
else{
//total=19(Istrucciones)-4(Instruccinoes)=15(Instrucciones)*0,2=3us
delay_us(3);
}//Total=19(Instrucciones)*0,2=3,8us
//********************************************************************
//Clasificamos..
//Los caracteres + - * / = en el Banco 7
if(DATO >=0x41){
if(DATO <=0x47){
Bandera_N_Letra=0;
DIRi_MATRIX=15;
DATO=DATO-65;//(33 = 0x21)
POS_LETRA_MATRIX=8*DATO;
}
else{
//total=19(Istrucciones)-9(Instruccinoes)=10(Instrucciones)*0,2=2us
delay_us(2);
}
}
.
else{
//total=19(Istrucciones)-4(Instruccinoes)=15(Instrucciones)*0,2=3us
delay_us(3);
}//Total=19(Instrucciones)*0,2=3,8us
//tiempo sobrante
delay_us(47); //58,6 - 3,8 - 3,8 -3,8 = 47,2 us
delay_Cycles(1);
output_low(pin_a0); //sincro
//ya Terminado la modificacion
}
//________________________________NIÑO
1________________________________________
void int Tratar_Letra(){
//Sincronización Horizontal (4.4us)-goto funcion ClasificarLetra -goto(entra fun Tratar_Letra)
//4,4-0,4-0,4 = 3,6us
delay_us(3);
delay_cycles(3);
output_high(pin_a0); //negro
//_***********************************************************************************
//ESTA RUTINA SE ME DEMORA 17 INSTRUCIONES EN V O f tiempo total = 17*0,2=
3,4 us//
if(N_LINEA_TEXTO1==0){//en v 2(ins) f 3(Ins) //ojo cambie 0 por 1
if(N_Letra1==16){//en v 3(ins) f 4(Ins)
if(TN_LINEA_TEXTO1==2){//en v 3(ins) f 4(Ins)
N_Letra1=15;
Borrar1=0;//0
//Entra a los 3(Bra)=2(ins)*3(Bra)=6(ins)*0,2=1,2
}
else{
//17 - 13(Inst cuando el if(N_LINEA_TEXTO1==1) es F)=4(Inst)*0,2=0,8 us
delay_cycles(4);
}
}
else{
//17 - 8(Inst cuando el if(N_Letra1 ==16) es F)=9(Inst)*0,2=1,8 us
delay_us(1);
delay_cycles(4);
}
}
else{
//17-3=14*0,2=2,8us
delay_us(2);
delay_cycles(4);
}
//_*****************************************************************************************************
.
//ESTA RUTINA SE ME DEMORA 12 INSTRUCIONES EN V O f tiempo total = 12*0,2=
2,4 us//
if(N_Letra1==16){
if(N_LINEA_TEXTO1==1){
N_Letra1 = 0;
N_LINEA_TEXTO1=0;
TN_LINEA_TEXTO1++;
}
else{
//12 - 8(Inst cuando el if(N_LINEA_TEXTO1==1) es F)=4(Inst)*0,2=0,8 us
delay_cycles(4);
}
}
else{
//12 - 4(Inst cuando el if(N_Letra1 ==16) es F)=8(Inst)*0,2=1,6 us
delay_us(1);
delay_cycles(3);
}
//******************************************************************************************************
//esta rutina se demora 7 intruciones tiempo total = 7*0,2=
1,4 us//
if (N_Letra1 == 16){
N_Letra1 = 0;
N_LINEA_TEXTO1++;
}
else{
//7-4(Instr cuando el if(N_Letra1 ==16) es F)=3(Instru)*0,2= 0,6us
delay_cycles(3);
}
//******************************************************************************************************
//ESTA RUTINA SE ME DEMORA 14 INSTRUCIONES EN V O f tiempo total = 14*0,2=
2,8 us//
if(CondisionPresentacion==0){
if(Bandera_N_Letra==0){
POS_LETRA_SCREEN=N_LINEA_TEXTO1*128+N_Letra1 ;//ocupa 5(Instrucciones)*0,2 =1 us
N_Letra1++;
}
else{
delay_us(1);
delay_cycles(4); //14-5(Instr cuando if(Bandera_N_Letra==0) es F) = 9(Inst)*0,2=1,8 us
}
}
else{
POS_LETRA_MATRIX=0;// posicion del caracter en la memoria 15
DIRi_MATRIX=1;//15
delay_us(1);
delay_cycles(3); //14-3(Instr cuando if(Bandera_N_Letra==0) es F) = 11(Inst)*0,2=2,2 us
}
//*********************************************************************************************
if(DATO1==126){//13(INS)*0,2=
2,6us
if(CondisionPresentacion==1){
BorrarScreen=0;
.
BorrarScreen2=0;
BorrarScreen3=0;
BorrarScreen4=0;
}
else{
//13 - 6 = 7*0,2=1,4
delay_us(1);
delay_cycles(2);
}
}
else{
//13 -4 = 9*0,2=1,8
delay_us(1);
delay_cycles(4);
}
//******************************BORRA todo POR UNA LETRA**************************************
//Esta rutina se demora 11 instrucciones en v o f tiempo total = 11*0,2 =
2,2us//
if(DATO1==126){//3(Ins) cuando if(DATO==126) v
//4(Ins) cuando if(DATO==126) F
BorrarScreen=0;
N_Letra1=0;
POS_LETRA_SCREEN=0;
N_LINEA_TEXTO1=0;
TN_LINEA_TEXTO1=0;
CondisionPresentacion=0;
// delay_Cycles(1);
}
else{
//11(Ins)-4(Ins)=6(Ins)*0,2=1,4us
delay_us(1);
delay_cycles(2);
}
if( TN_LINEA_TEXTO1==2){//Ocupa 7 Ins en V
tiempo total = 7*0,2= 1,4 us
n_DIRi_SCREEN=3; //2(Inst)*0,2=0,4 us
}
else{
//7(Ins)-4(Ins)=3*0,2=0,6us
delay_cycles(3);
//tiempo total = 1,2+1,2+1,4= 3,8 us//
}
//*********************BORRARUNA LETRA*************************************************
//
esta funcion tiempo de duracion 24+17(ins)=41*0,2
8,2us//
if (DATO1 == 127){//cuando if (DATO == 127) V 3(Ins)
//cuando if (DATO == 127) F 4(Ins)
//********** esta codigo ocupa 17(ins) *******************
POS_LETRA_SCREEN=N_LINEA_TEXTO1*128+N_Letra1;
if(TN_LINEA_TEXTO1!=0){//3(Ins) en F
//2(ins) en verdad
if(N_LINEA_TEXTO1==0){//3(Ins) en F
//2(ins) en verdad
if(N_Letra1==0){//3(Ins) en F
.
//2(ins) en verdad
//6(ins) en verdad todo los if
N_Letra1=16;
N_LINEA_TEXTO1=1;
TN_LINEA_TEXTO1--;
}
else{
//17(Ins)-11(Ins)=6*0,2=1,2us
delay_us(1);
delay_cycles(1);
}
}
else{
//17(Ins)-7(Ins)=10*0,2=2us
delay_us(2);
}
}
else{
//17(Ins)-3(Ins)=14*0,2=2,8us
delay_us(1);
delay_cycles(4);
}
//************************************************************************
if (N_LINEA_TEXTO1==0){
if (N_Letra1==0){//14-8=6(Ins)*0,2)1,2
delay_us(1);
delay_cycles(1);
}
else if(N_Letra1!=0){
N_Letra1=N_Letra1-1;
POS_LETRA_MATRIX=8;
DIRi_MATRIX=15;
}
}
else if(N_Letra1==0){
N_LINEA_TEXTO1=N_LINEA_TEXTO1-1;
N_Letra1=15;
POS_LETRA_MATRIX=8;
DIRi_MATRIX=15;
}
else if(N_Letra1!=0){
N_Letra1=N_Letra1-1;
POS_LETRA_MATRIX=8;
DIRi_MATRIX=15;
delay_cycles(1);
}
//14+3+5+2(BRA else)=24
}
else{
//41-4=37*0,2=7,4
.
delay_us(7);
delay_cycles(2);
}
//********************************************************************************
//La variables DIRi_SCREEN se cambia a 4 ,7 o 10 para los demas personajes
DIRi_SCREEN=1;//0,4us
//tiempo sobrante
//58,6 - (2,6+4,8+ 2 + 2,4 + 1,4 + 3 )(total=16,6) = 42us-(1,8us)=40,6us-3,8=36,8-0,4us=36,4
//36,4-3,4=33us-0,2(sale 3,2(If para Borrar screen)-3)=32,8-0,2=32,6-3,4=29,2us
//29,2-0,8=28,4-0,2=28,2-0,8=27,4-2,6=24,8
delay_us(24);
delay_cycles(4);
output_low(pin_a0); //sincro
//revisar
//todo esta calculado solo falta probar
}
//___________________________________________________________________________
___
void int Borrar_Screen11(){
//Sincronización Horizontal (4.4us)-goto funcion Tratar_Letra -goto(entra fun Borrar_Screen)
//4,4-0,4-0,4 = 3,6us
delay_us(3);
delay_cycles(3);
output_high(pin_a0); //negro
//Inico del tiempo de la imagem
if( BorrarScreen==0){
//emplea 3(Ins) el if para entrar en V
//**************************************************************
int8 Ced[256]={0x0};
#Locate Ced=0x100 //Ocupamos todos los registros del Banco1
//tiempo total=257+3(inicio if)+2(Bra)=262*0,2us=52,4us
//BorrarScreen=1;
delay_cycles(1);
}
else{
//emplea 4(Ins) el if para entrar en F
delay_us(51); //262 - 4 = 258*0,2us=51,6us
delay_cycles(3);
}
//tiempo sobrante
delay_us(6); //58,6-52,4 = 6,2us
delay_cycles(1);
output_low(pin_a0); //sincro
//___________________________________________________________________________
___
}
void int Borrar_Screen12(){
//Sincronización Horizontal (4.4us)-goto funcion Tratar_Letra -goto(entra fun Borrar_Screen)
.
//4,4-0,4-0,4 = 3,6us
delay_us(3);
delay_cycles(3);
output_high(pin_a0); //negro
//Inico del tiempo de la imagem
if( BorrarScreen==0){
//emplea 3(Ins) el if para entrar en V
int8 Ce[256]={0x0};
#Locate Ce=0x200 //Ocupamos todos los registros del Banco1
//tiempo total=257+3(inicio if)+2(Bra)=262*0,2us=52,4us
//BorrarScreen=1;
delay_cycles(1);
}
else{
//emplea 4(Ins) el if para entrar en F
delay_us(51); //262 - 4 = 258*0,2us=51,6us
delay_cycles(3);
}
//tiempo sobrante
delay_us(6); //58,6-52,4 = 6,2us
delay_cycles(1);
output_low(pin_a0); //sincro
}
//___________________________________________________________________________
___
void int Borrar_Screen13(){
//Sincronización Horizontal (4.4us)-goto funcion Tratar_Letra -goto(entra fun Borrar_Screen)
//4,4-0,4-0,4 = 3,6us
delay_us(3);
delay_cycles(3);
output_high(pin_a0); //negro
//Inico del tiempo de la imagem
if( BorrarScreen==0){
//emplea 3(Ins) el if para entrar en V
int8 Ce[256]={0x0};
#Locate Ce=0x300 //Ocupamos todos los registros del Banco1
//tiempo total=257+3(inicio if)+2(Bra)=262*0,2us=52,4us
BorrarScreen=1;
//delay_cycles(1);
}
else{
//emplea 4(Ins) el if para entrar en F
delay_us(51); //262 - 4 = 258*0,2us=51,6us
delay_cycles(3);
}
//tiempo sobrante
delay_us(6); //58,6-52,4 = 6,2us
delay_cycles(1);
output_low(pin_a0); //sincro
}
_______________________________NIÑO
2________________________________________
.
void int Tratar_Letra2(){
//Sincronización Horizontal (4.4us)-goto funcion ClasificarLetra -goto(entra fun Tratar_Letra)
//4,4-0,4-0,4 = 3,6us
delay_us(3);
delay_cycles(3);
output_high(pin_a0); //negro
//_***********************************************************************************
//ESTA RUTINA SE ME DEMORA 17 INSTRUCIONES EN V O f tiempo total = 17*0,2= 3,4
us//
if(N_LINEA_TEXTO2==0){//en v 2(ins) f 3(Ins) //ojo cambie 0 por 1
if(N_Letra2==16){//en v 3(ins) f 4(Ins)
if(TN_LINEA_TEXTO2==2){//en v 3(ins) f 4(Ins)
N_Letra2=15;
Borrar2=0;
//Entra a los 3(Bra)=2(ins)*3(Bra)=6(ins)*0,2=1,2
}
else{
//17 - 13(Inst cuando el if(N_LINEA_TEXTO2==1) es F)=4(Inst)*0,2=0,8 us
delay_cycles(4);
}
}
else{
//17 - 8(Inst cuando el if(N_Letra2 ==16) es F)=9(Inst)*0,2=1,8 us
delay_us(1);
delay_cycles(4);
}
}
else{
//17-3=14*0,2=2,8us
delay_us(2);
delay_cycles(4);
}
//_*****************************************************************************************************
//ESTA RUTINA SE ME DEMORA 12 INSTRUCIONES EN V O f tiempo total = 12*0,2=
2,4
us//
if(N_Letra2==16){
if(N_LINEA_TEXTO2==1){
N_Letra2 = 0;
N_LINEA_TEXTO2=0;
TN_LINEA_TEXTO2++;
}
else{
//12 - 8(Inst cuando el if(N_LINEA_TEXTO2==1) es F)=4(Inst)*0,2=0,8 us
delay_cycles(4);
}
}
else{
//12 - 4(Inst cuando el if(N_Letra2 ==16) es F)=8(Inst)*0,2=1,6 us
delay_us(1);
delay_cycles(3);
}
.
//******************************************************************************************************
//esta rutina se demora 7 intruciones tiempo total = 7*0,2=
1,4 us//
if (N_Letra2 == 16){
N_Letra2 = 0;
N_LINEA_TEXTO2++;
}
else{
//7-4(Instr cuando el if(N_Letra2 ==16) es F)=3(Instru)*0,2= 0,6us
delay_cycles(3);
}
//********************************8******************************************************
//
esta funcion tiempo de duracion 17*0,2 =
//tiene 4(ifs en V)+9(inst)+4(2 BRA) en V=17(Ins)
//tiene 3(if en F)
if(CondisionPresentacion==0){
if(DATO1 == 0){
POS_LETRA_SCREEN=N_LINEA_TEXTO2*128+N_Letra2;
POS_LETRA_MATRIX=0;// posicion del caracter en la memoria 15
DIRi_MATRIX=15;//15
}
else{
//17-5=12*0,2 = 2,4us
delay_us(2);
delay_cycles(2);
}
}
else{
//17-3=14*0,2 = 2,8us
delay_us(2);
delay_cycles(4);
}
3,4us//
//******************************************************************************************************
//ESTA RUTINA SE ME DEMORA 14 INSTRUCIONES EN V O f tiempo total = 14*0,2= 2,8
us//
if(CondisionPresentacion==0){
if(Bandera_N_Letra==0){
POS_LETRA_SCREEN=N_LINEA_TEXTO2*128+N_Letra2 ;//ocupa 5(Instrucciones)*0,2 =1 us
N_Letra2++;
}
else{
delay_us(1);
delay_cycles(4); //14-5(Instr cuando if(Bandera_N_Letra==0) es F) = 9(Inst)*0,2=1,8 us
}
}
else{
delay_us(2);
delay_cycles(1); //14-3(Instr cuando if(Bandera_N_Letra==0) es F) = 11(Inst)*0,2=2,2 us
}
//*********************************************************************************************
if(DATO1==126){//13(INS)*0,2=
2,6us
if(CondisionPresentacion==1){
.
BorrarScreen=0;
BorrarScreen2=0;
BorrarScreen3=0;
BorrarScreen4=0;
}
else{
//13 - 6 = 7*0,2=1,4
delay_us(1);
delay_cycles(2);
}
}
else{
//13 -4 = 9*0,2=1,8
delay_us(1);
delay_cycles(4);
}
//******************************BORRA todo POR UNA LETRA**************************************
//Esta rutina se demora 11 instrucciones en v o f tiempo total = 11*0,2 =
2,2us//
if(DATO1==126){//3(Ins) cuando if(DATO==126) v
//4(Ins) cuando if(DATO==126) F
BorrarScreen2=0;
N_Letra2=0;
POS_LETRA_SCREEN=0;
N_LINEA_TEXTO2=0;
TN_LINEA_TEXTO2=0;
CondisionPresentacion=0;
}
else{
//11(Ins)-4(Ins)=6(Ins)*0,2=1,4us
delay_us(1);
delay_cycles(2);
}
//*************************If para Borrar screen ********************************************************
//Este rutina se demora 16(Inst)
//ESTA RUTINA SE ME DEMORA 16 INSTRUCIONES EN V O f tiempo total = 16*0,2=
3,2 us//
if(Borrar2==0){
if(Bandera_N_Letra==0){
//entrar los 2 if en v se demora 4(Inst)
//Borro vector
BorrarScreen2=0;
N_Letra2=0;
N_LINEA_TEXTO2=0;
TN_LINEA_TEXTO2=0; //_aumentado
POS_LETRA_SCREEN=0;
Bandera_N_Letra=1;
Borrar2=1;
}
else{
//entrar los 1 if en v y otro if en f se demora 5(Inst)+2(BRA)=7(Ins)
//16-7=9(Ins)*0,2=1,8
.
Bandera_N_Letra=1; //2(Ins)*0,2=0,4
delay_us(1);
delay_cycles(2);
}
}
else{
//entrar los primer if en f se demora 3(Inst)=3(Ins)
////16-3=13(Ins)*0,2=2,6
Bandera_N_Letra=1;
delay_us(2);
delay_cycles(1);
}
//*************************Selecion del banco de DIRi_SCREEN********************
if( TN_LINEA_TEXTO2==0){//Ocupa 6Inst en V
tiempo total = 6*0,2= 1,2 us
n_DIRi_SCREEN=4; //2(Inst)*0,2=0,4 us
}
else{
//6(Ins)-4(Ins)=2*0,2=0,4us
delay_cycles(2);
}
if( TN_LINEA_TEXTO2==1){//Ocupa 6 Ins en V
tiempo total = 6*0,2= 1,2 us
n_DIRi_SCREEN=5; //2(Inst)*0,2=0,4 us
}
else{
//6(Ins)-4(Ins)=2*0,2=0,4us
delay_cycles(2);
}
if( TN_LINEA_TEXTO2==2){//Ocupa 7 Ins en V
tiempo total = 7*0,2= 1,4 us
n_DIRi_SCREEN=6; //2(Inst)*0,2=0,4 us
}
else{
//7(Ins)-4(Ins)=3*0,2=0,6us
delay_cycles(3);
//tiempo total = 1,2+1,2+1,4= 3,8 us//
}
//*********************BORRARUNA LETRA*************************************************
//
esta funcion tiempo de duracion 24+17(ins)=41*0,2
8,2us//
if (DATO1 == 127){//cuando if (DATO == 127) V 3(Ins)
//cuando if (DATO == 127) F 4(Ins)
//********** esta codigo ocupa 17(ins) *******************
POS_LETRA_SCREEN=N_LINEA_TEXTO2*128+N_Letra2;
if(TN_LINEA_TEXTO2!=0){//3(Ins) en F
//2(ins) en verdad
if(N_LINEA_TEXTO2==0){//3(Ins) en F
//2(ins) en verdad
if(N_Letra2==0){//3(Ins) en F
//2(ins) en verdad
//6(ins) en verdad todo los if
N_Letra2=16;
N_LINEA_TEXTO2=1;
TN_LINEA_TEXTO2--;
}
else{
//17(Ins)-11(Ins)=6*0,2=1,2us
.
delay_us(1);
delay_cycles(1);
}
}
else{
//17(Ins)-7(Ins)=10*0,2=2us
delay_us(2);
}
}
else{
//17(Ins)-3(Ins)=14*0,2=2,8us
delay_us(1);
delay_cycles(4);
}
//************************************************************************
if (N_LINEA_TEXTO2==0){
if (N_Letra2==0){//14-8=6(Ins)*0,2)1,2
delay_us(1);
delay_cycles(1);
}
else if(N_Letra2!=0){
N_Letra2=N_Letra2-1;
POS_LETRA_MATRIX=8;
DIRi_MATRIX=15;
}
}
else if(N_Letra2==0){
N_LINEA_TEXTO2=N_LINEA_TEXTO2-1;
N_Letra2=15;
POS_LETRA_MATRIX=8;
DIRi_MATRIX=15;
}
else if(N_Letra2!=0){
N_Letra2=N_Letra2-1;
POS_LETRA_MATRIX=8;
DIRi_MATRIX=15;
delay_cycles(1);
}
//14+3+5+2(BRA else)=24
}
else{
//41-4=37*0,2=7,4
delay_us(7);
delay_cycles(2);
}
//_****************************************************************************
//********************************************************************************
//La variables DIRi_SCREEN se cambia a 4 ,7 o 10 para los demas personajes
DIRi_SCREEN=4;//0,4us
//tiempo sobrante
.
//58,6 - (2,6+4,8+ 2 + 2,4 + 1,4 + 3 )(total=16,6) = 42us-(1,8us)=40,6us-3,8=36,8-0,4us=36,4
//36,4-3,4=33us-0,2(sale 3,2(If para Borrar screen)-3)=32,8-0,2=32,6-3,4=29,2us
//29,2-0,8=28,4-0,2=28,2-0,8=27,4-2,6=24,8
delay_us(24);
delay_cycles(4);
output_low(pin_a0); //sincro
//revisar
//todo esta calculado solo falta probar
}
}
void int Borrar_Screen22(){
//Sincronización Horizontal (4.4us)-goto funcion Tratar_Letra -goto(entra fun Borrar_Screen)
//4,4-0,4-0,4 = 3,6us
delay_us(3);
delay_cycles(3);
output_high(pin_a0); //negro
//Inico del tiempo de la imagem
if( BorrarScreen2==0){
//emplea 3(Ins) el if para entrar en V
int8 Ce[256]={0x0};
#Locate Ce=0x500 //Ocupamos todos los registros del Banco1
//tiempo total=257+3(inicio if)+2(Bra)=262*0,2us=52,4us
//BorrarScreen=1;
delay_cycles(1);
}
else{
//emplea 4(Ins) el if para entrar en F
delay_us(51); //262 - 4 = 258*0,2us=51,6us
delay_cycles(3);
}
//tiempo sobrante
delay_us(6); //58,6-52,4 = 6,2us
delay_cycles(1);
output_low(pin_a0); //sincro
}
//___________________________________________________________________________
___
void int Borrar_Screen23(){
//Sincronización Horizontal (4.4us)-goto funcion Tratar_Letra -goto(entra fun Borrar_Screen)
//4,4-0,4-0,4 = 3,6us
delay_us(3);
delay_cycles(3);
output_high(pin_a0); //negro
//Inico del tiempo de la imagem
if( BorrarScreen2==0){
//emplea 3(Ins) el if para entrar en V
int8 Ce[256]={0x0};
#Locate Ce=0x600 //Ocupamos todos los registros del Banco1
//tiempo total=257+3(inicio if)+2(Bra)=262*0,2us=52,4us
BorrarScreen2=1;
//delay_cycles(1);
.
}
else{
//emplea 4(Ins) el if para entrar en F
delay_us(51); //262 - 4 = 258*0,2us=51,6us
delay_cycles(3);
}
//tiempo sobrante
delay_us(6); //58,6-52,4 = 6,2us
delay_cycles(1);
output_low(pin_a0); //sincro
}
//________________________________NIÑO
3________________________________________
void int Tratar_Letra3(){
//Sincronización Horizontal (4.4us)-goto funcion ClasificarLetra -goto(entra fun Tratar_Letra)
//4,4-0,4-0,4 = 3,6us
delay_us(3);
delay_cycles(3);
output_high(pin_a0); //negro
//_***********************************************************************************
//ESTA RUTINA SE ME DEMORA 17 INSTRUCIONES EN V O f tiempo total = 17*0,2=
3,4 us//
if(N_LINEA_TEXTO3==0){//en v 2(ins) f 3(Ins) //ojo cambie 0 por 1
if(N_Letra3==16){//en v 3(ins) f 4(Ins)
if(TN_LINEA_TEXTO3==2){//en v 3(ins) f 4(Ins)
N_Letra3=15;
Borrar3=0;
//Entra a los 3(Bra)=2(ins)*3(Bra)=6(ins)*0,2=1,2
}
else{
//17 - 13(Inst cuando el if(N_LINEA_TEXTO3==1) es F)=4(Inst)*0,2=0,8 us
delay_cycles(4);
}
}
else{
//17 - 8(Inst cuando el if(N_Letra3 ==16) es F)=9(Inst)*0,2=1,8 us
delay_us(1);
delay_cycles(4);
}
}
else{
//17-3=14*0,2=2,8us
delay_us(2);
delay_cycles(4);
}
//_*****************************************************************************************************
//ESTA RUTINA SE ME DEMORA 12 INSTRUCIONES EN V O f tiempo total = 12*0,2=
2,4 us//
.
if(N_Letra3==16){
if(N_LINEA_TEXTO3==1){
N_Letra3 = 0;
N_LINEA_TEXTO3=0;
TN_LINEA_TEXTO3++;
}
else{
//12 - 8(Inst cuando el if(N_LINEA_TEXTO3==1) es F)=4(Inst)*0,2=0,8 us
delay_cycles(4);
}
}
else{
//12 - 4(Inst cuando el if(N_Letra3 ==16) es F)=8(Inst)*0,2=1,6 us
delay_us(1);
delay_cycles(3);
}
//******************************************************************************************************
//esta rutina se demora 7 intruciones tiempo total = 7*0,2=
1,4 us//
if (N_Letra3 == 16){
N_Letra3 = 0;
N_LINEA_TEXTO3++;
}
else{
//7-4(Instr cuando el if(N_Letra3 ==16) es F)=3(Instru)*0,2= 0,6us
delay_cycles(3);
}
//******************************************************************************************************
//ESTA RUTINA SE ME DEMORA 14 INSTRUCIONES EN V O f tiempo total = 14*0,2=
2,8 us//
if(CondisionPresentacion==0){
if(Bandera_N_Letra==0){
POS_LETRA_SCREEN=N_LINEA_TEXTO3*128+N_Letra3 ;//ocupa 5(Instrucciones)*0,2 =1 us
N_Letra3++;
}
else{
delay_us(1);
delay_cycles(4); //14-5(Instr cuando if(Bandera_N_Letra==0) es F) = 9(Inst)*0,2=1,8 us
}
}
else{
delay_us(2);
delay_cycles(1); //14-3(Instr cuando if(Bandera_N_Letra==0) es F) = 11(Inst)*0,2=2,2 us
}
//*********************************************************************************************
if(DATO1==126){//13(INS)*0,2=
2,6us
if(CondisionPresentacion==1){
BorrarScreen=0;
BorrarScreen2=0;
BorrarScreen3=0;
BorrarScreen4=0;
}
.
else{
//13 - 6 = 7*0,2=1,4
delay_us(1);
delay_cycles(2);
}
}
else{
//13 -4 = 9*0,2=1,8
delay_us(1);
delay_cycles(4);
}
//******************************BORRA todo POR UNA LETRA**************************************
//Esta rutina se demora 11 instrucciones en v o f tiempo total = 11*0,2 =
2,2us//
if(DATO1==126){//3(Ins) cuando if(DATO==126) v
//4(Ins) cuando if(DATO==126) F
BorrarScreen3=0;
N_Letra3=0;
POS_LETRA_SCREEN=0;
N_LINEA_TEXTO3=0;
TN_LINEA_TEXTO3=0;
CondisionPresentacion=0;
}
else{
//11(Ins)-4(Ins)=6(Ins)*0,2=1,4us
delay_us(1);
delay_cycles(2);
}
//*************************If para Borrar screen ********************************************************
//Este rutina se demora 16(Inst)
//ESTA RUTINA SE ME DEMORA 16 INSTRUCIONES EN V O f tiempo total = 16*0,2=
3,2 us//
if(Borrar3==0){
if(Bandera_N_Letra==0){
//entrar los 2 if en v se demora 4(Inst)
//Borro vector
BorrarScreen3=0;
N_Letra3=0;
N_LINEA_TEXTO3=0;
TN_LINEA_TEXTO3=0; //_aumentado
POS_LETRA_SCREEN=0;
Bandera_N_Letra=1;
Borrar3=1;
}
else{
//entrar los 1 if en v y otro if en f se demora 5(Inst)+2(BRA)=7(Ins)
//16-7=9(Ins)*0,2=1,8
Bandera_N_Letra=1; //2(Ins)*0,2=0,4
delay_us(1);
delay_cycles(2);
}
.
}
else{
//entrar los primer if en f se demora 3(Inst)=3(Ins)
////16-3=13(Ins)*0,2=2,6
Bandera_N_Letra=1;
delay_us(2);
delay_cycles(1);
}
//*************************Selecion del banco de DIRi_SCREEN********************
if( TN_LINEA_TEXTO3==0){//Ocupa 6Inst en V
tiempo total = 6*0,2= 1,2 us
n_DIRi_SCREEN=7; //2(Inst)*0,2=0,4 us
}
else{
//6(Ins)-4(Ins)=2*0,2=0,4us
delay_cycles(2);
}
if( TN_LINEA_TEXTO3==1){//Ocupa 6 Ins en V
tiempo total = 6*0,2= 1,2 us
n_DIRi_SCREEN=8; //2(Inst)*0,2=0,4 us
}
else{
//6(Ins)-4(Ins)=2*0,2=0,4us
delay_cycles(2);
}
if( TN_LINEA_TEXTO3==2){//Ocupa 7 Ins en V
tiempo total = 7*0,2= 1,4 us
n_DIRi_SCREEN=9; //2(Inst)*0,2=0,4 us
}
else{
//7(Ins)-4(Ins)=3*0,2=0,6us
delay_cycles(3);
//tiempo total = 1,2+1,2+1,4= 3,8 us//
}
//*********************BORRARUNA LETRA*************************************************
//
esta funcion tiempo de duracion 24+17(ins)=41*0,2
8,2us//
if (DATO1 == 127){//cuando if (DATO == 127) V 3(Ins)
//cuando if (DATO == 127) F 4(Ins)
//********** esta codigo ocupa 17(ins) *******************
POS_LETRA_SCREEN=N_LINEA_TEXTO3*128+N_Letra3;
if(TN_LINEA_TEXTO3!=0){//3(Ins) en F
//2(ins) en verdad
if(N_LINEA_TEXTO3==0){//3(Ins) en F
//2(ins) en verdad
if(N_Letra3==0){//3(Ins) en F
//2(ins) en verdad
//6(ins) en verdad todo los if
N_Letra3=16;
N_LINEA_TEXTO3=1;
TN_LINEA_TEXTO3--;
}
else{
//17(Ins)-11(Ins)=6*0,2=1,2us
delay_us(1);
delay_cycles(1);
}
}
.
else{
//17(Ins)-7(Ins)=10*0,2=2us
delay_us(2);
}
}
else{
//17(Ins)-3(Ins)=14*0,2=2,8us
delay_us(1);
delay_cycles(4);
}
//************************************************************************
if (N_LINEA_TEXTO3==0){
if (N_Letra3==0){//14-8=6(Ins)*0,2)1,2
delay_us(1);
delay_cycles(1);
}
else if(N_Letra3!=0){
N_Letra3=N_Letra3-1;
POS_LETRA_MATRIX=8;
DIRi_MATRIX=15;
}
}
else if(N_Letra3==0){
N_LINEA_TEXTO3=N_LINEA_TEXTO3-1;
N_Letra3=15;
POS_LETRA_MATRIX=8;
DIRi_MATRIX=15;
}
else if(N_Letra3!=0){
N_Letra3=N_Letra3-1;
POS_LETRA_MATRIX=8;
DIRi_MATRIX=15;
delay_cycles(1);
}
//14+3+5+2(BRA else)=24
}
else{
//41-4=37*0,2=7,4
delay_us(7);
delay_cycles(2);
}
//_****************************************************************************
//********************************************************************************
//La variables DIRi_SCREEN se cambia a 4 ,7 o 10 para los demas personajes
DIRi_SCREEN=7;//0,4us
//tiempo sobrante
//58,6 - (2,6+4,8+ 2 + 2,4 + 1,4 + 3 )(total=16,6) = 42us-(1,8us)=40,6us-3,8=36,8-0,4us=36,4
//36,4-3,4=33us-0,2(sale 3,2(If para Borrar screen)-3)=32,8-0,2=32,6-3,4=29,2us
//29,2-0,8=28,4-0,2=28,2-0,8=27,4-2,6=24,8
delay_us(24);
delay_cycles(4);
.
output_low(pin_a0); //sincro
//revisar
//todo esta calculado solo falta probar
}
//___________________________________________________________________________
___
void int Borrar_Screen31(){
//Sincronización Horizontal (4.4us)-goto funcion Tratar_Letra -goto(entra fun Borrar_Screen)
//4,4-0,4-0,4 = 3,6us
delay_us(3);
delay_cycles(3);
output_high(pin_a0); //negro
//Inico del tiempo de la imagem
if( BorrarScreen3==0){
//emplea 3(Ins) el if para entrar en V
int8 Ce[256]={0x0};
#Locate Ce=0x700 //Ocupamos todos los registros del Banco1
//tiempo total=257+3(inicio if)+2(Bra)=262*0,2us=52,4us
//BorrarScreen=1;
delay_cycles(1);
}
else{
//emplea 4(Ins) el if para entrar en F
delay_us(51); //262 - 4 = 258*0,2us=51,6us
delay_cycles(3);
}
//tiempo sobrante
delay_us(6); //58,6-52,4 = 6,2us
delay_cycles(1);
output_low(pin_a0); //sincro
//___________________________________________________________________________
___
}
void int Borrar_Screen32(){
//Sincronización Horizontal (4.4us)-goto funcion Tratar_Letra -goto(entra fun Borrar_Screen)
//4,4-0,4-0,4 = 3,6us
delay_us(3);
delay_cycles(3);
output_high(pin_a0); //negro
//Inico del tiempo de la imagem
if( BorrarScreen3==0){
//emplea 3(Ins) el if para entrar en V
int8 Ce[256]={0x0};
#Locate Ce=0x800 //Ocupamos todos los registros del Banco1
//tiempo total=257+3(inicio if)+2(Bra)=262*0,2us=52,4us
//BorrarScreen=1;
delay_cycles(1);
}
else{
//emplea 4(Ins) el if para entrar en F
.
delay_us(51); //262 - 4 = 258*0,2us=51,6us
delay_cycles(3);
}
//tiempo sobrante
delay_us(6); //58,6-52,4 = 6,2us
delay_cycles(1);
output_low(pin_a0); //sincro
}
//___________________________________________________________________________
___
void int Borrar_Screen33(){
//Sincronización Horizontal (4.4us)-goto funcion Tratar_Letra -goto(entra fun Borrar_Screen)
//4,4-0,4-0,4 = 3,6us
delay_us(3);
delay_cycles(3);
output_high(pin_a0); //negro
//Inico del tiempo de la imagem
if( BorrarScreen3==0){
//emplea 3(Ins) el if para entrar en V
int8 Ce[256]={0x0};
#Locate Ce=0x900 //Ocupamos todos los registros del Banco1
//tiempo total=257+3(inicio if)+2(Bra)=262*0,2us=52,4us
BorrarScreen3=1;
//delay_cycles(1);
}
else{
//emplea 4(Ins) el if para entrar en F
delay_us(51); //262 - 4 = 258*0,2us=51,6us
delay_cycles(3);
}
//tiempo sobrante
delay_us(6); //58,6-52,4 = 6,2us
delay_cycles(1);
output_low(pin_a0); //sincro
}
//_*****************************************************************************************************
//ESTA RUTINA SE ME DEMORA 12 INSTRUCIONES EN V O f tiempo total = 12*0,2=
2,4 us//
if(N_Letra4==16){
if(N_LINEA_TEXTO4==1){
N_Letra4 = 0;
N_LINEA_TEXTO4=0;
TN_LINEA_TEXTO4++;
}
else{
//12 - 8(Inst cuando el if(N_LINEA_TEXTO4==1) es F)=4(Inst)*0,2=0,8 us
delay_cycles(4);
}
}
.
else{
//12 - 4(Inst cuando el if(N_Letra4 ==16) es F)=8(Inst)*0,2=1,6 us
delay_us(1);
delay_cycles(3);
}
//******************************************************************************************************
//esta rutina se demora 7 intruciones tiempo total = 7*0,2=
1,4 us//
if (N_Letra4 == 16){
N_Letra4 = 0;
N_LINEA_TEXTO4++;
}
else{
//7-4(Instr cuando el if(N_Letra4 ==16) es F)=3(Instru)*0,2= 0,6us
delay_cycles(3);
}
//********************************8******************************************************
//
esta funcion tiempo de duracion 17*0,2 =
//tiene 4(ifs en V)+9(inst)+4(2 BRA) en V=17(Ins)
//tiene 3(if en F)
if(CondisionPresentacion==0){
if(DATO1 == 0){
POS_LETRA_SCREEN=N_LINEA_TEXTO4*128+N_Letra4;
POS_LETRA_MATRIX=0;// posicion del caracter en la memoria 15
DIRi_MATRIX=15;//15
}
else{
//17-5=12*0,2 = 2,4us
delay_us(2);
delay_cycles(2);
}
}
else{
//17-3=14*0,2 = 2,8us
delay_us(2);
delay_cycles(4);
}
3,4us//
//******************************************************************************************************
//ESTA RUTINA SE ME DEMORA 14 INSTRUCIONES EN V O f tiempo total = 14*0,2=
2,8 us//
if(CondisionPresentacion==0){
if(Bandera_N_Letra==0){
POS_LETRA_SCREEN=N_LINEA_TEXTO4*128+N_Letra4 ;//ocupa 5(Instrucciones)*0,2 =1 us
N_Letra4++;
}
else{
delay_us(1);
delay_cycles(4); //14-5(Instr cuando if(Bandera_N_Letra==0) es F) = 9(Inst)*0,2=1,8 us
}
}
else{
POS_LETRA_MATRIX=0;// posicion del caracter en la memoria 15
DIRi_MATRIX=10;//15
.
delay_us(1);
delay_cycles(3); //14-3(Instr cuando if(Bandera_N_Letra==0) es F) = 11(Inst)*0,2=2,2 us
}
//*********************************************************************************************
if(DATO1==126){//13(INS)*0,2=
2,6us
if(CondisionPresentacion==1){
BorrarScreen=0;
BorrarScreen2=0;
BorrarScreen3=0;
BorrarScreen4=0;
}
else{
//13 - 6 = 7*0,2=1,4
delay_us(1);
delay_cycles(2);
}
}
else{
//13 -4 = 9*0,2=1,8
delay_us(1);
delay_cycles(4);
}
//******************************BORRAtodo POR UNA LETRA**************************************
//Esta rutina se demora 11 instrucciones en v o f tiempo total = 11*0,2 =
2,2us//
if(DATO1==126){//3(Ins) cuando if(DATO==126) v
//4(Ins) cuando if(DATO==126) F
BorrarScreen4=0;
N_Letra4=0;
POS_LETRA_SCREEN=0;
N_LINEA_TEXTO4=0;
TN_LINEA_TEXTO4=0;
CondisionPresentacion=0;
}
else{
//11(Ins)-4(Ins)=6(Ins)*0,2=1,4us
delay_us(1);
delay_cycles(2);
}
//*************************If para Borrar screen ********************************************************
//Este rutina se demora 16(Inst)
//ESTA RUTINA SE ME DEMORA 16 INSTRUCIONES EN V O f tiempo total = 16*0,2=
3,2 us//
if(Borrar4==0){
if(Bandera_N_Letra==0){
//entrar los 2 if en v se demora 4(Inst)
//Borro vector
BorrarScreen4=0;
N_Letra4=0;
N_LINEA_TEXTO4=0;
.
TN_LINEA_TEXTO4=0; //_aumentado
POS_LETRA_SCREEN=0;
Bandera_N_Letra=1;
Borrar4=1;
}
else{
//entrar los 1 if en v y otro if en f se demora 5(Inst)+2(BRA)=7(Ins)
//16-7=9(Ins)*0,2=1,8
Bandera_N_Letra=1; //2(Ins)*0,2=0,4
delay_us(1);
delay_cycles(2);
}
}
else{
//entrar los primer if en f se demora 3(Inst)=3(Ins)
////16-3=13(Ins)*0,2=2,6
Bandera_N_Letra=1;
delay_us(2);
delay_cycles(1);
}
//*************************Selecion del banco de DIRi_SCREEN********************
if( TN_LINEA_TEXTO4==0){//Ocupa 6Inst en V
tiempo total = 6*0,2= 1,2 us
n_DIRi_SCREEN=10; //2(Inst)*0,2=0,4 us
}
else{
//6(Ins)-4(Ins)=2*0,2=0,4us
delay_cycles(2);
}
if( TN_LINEA_TEXTO4==1){//Ocupa 6 Ins en V
tiempo total = 6*0,2= 1,2 us
n_DIRi_SCREEN=11; //2(Inst)*0,2=0,4 us
}
else{
//6(Ins)-4(Ins)=2*0,2=0,4us
delay_cycles(2);
}
if( TN_LINEA_TEXTO4==2){//Ocupa 7 Ins en V
tiempo total = 7*0,2= 1,4 us
n_DIRi_SCREEN=12; //2(Inst)*0,2=0,4 us
}
else{
//7(Ins)-4(Ins)=3*0,2=0,6us
delay_cycles(3);
//tiempo total = 1,2+1,2+1,4= 3,8 us//
}
//*********************BORRARUNALETRA*************************************************
//
esta funcion tiempo de duracion 24+17(ins)=41*0,2
8,2us//
if (DATO1 == 127){//cuando if (DATO == 127) V 3(Ins)
//cuando if (DATO == 127) F 4(Ins)
//********** esta codigo ocupa 17(ins) *******************
POS_LETRA_SCREEN=N_LINEA_TEXTO4*128+N_Letra4;
if(TN_LINEA_TEXTO4!=0){//3(Ins) en F
//2(ins) en verdad
if(N_LINEA_TEXTO4==0){//3(Ins) en F
//2(ins) en verdad
if(N_Letra4==0){//3(Ins) en F
.
//2(ins) en verdad
//6(ins) en verdad todo los if
N_Letra4=16;
N_LINEA_TEXTO4=1;
TN_LINEA_TEXTO4--;
}
else{
//17(Ins)-11(Ins)=6*0,2=1,2us
delay_us(1);
delay_cycles(1);
}
}
else{
//17(Ins)-7(Ins)=10*0,2=2us
delay_us(2);
}
}
else{
//17(Ins)-3(Ins)=14*0,2=2,8us
delay_us(1);
delay_cycles(4);
}
//************************************************************************
if (N_LINEA_TEXTO4==0){
if (N_Letra4==0){//14-8=6(Ins)*0,2)1,2
delay_us(1);
delay_cycles(1);
}
else if(N_Letra4!=0){
N_Letra4=N_Letra4-1;
POS_LETRA_MATRIX=8;
DIRi_MATRIX=15;
}
}
else if(N_Letra4==0){
N_LINEA_TEXTO4=N_LINEA_TEXTO4-1;
N_Letra4=15;
POS_LETRA_MATRIX=8;
DIRi_MATRIX=15;
}
else if(N_Letra4!=0){
N_Letra4=N_Letra4-1;
POS_LETRA_MATRIX=8;
DIRi_MATRIX=15;
delay_cycles(1);
}
//14+3+5+2(BRA else)=24
}
else{
//41-4=37*0,2=7,4
delay_us(7);
delay_cycles(2);
.
}
//_****************************************************************************
//********************************************************************************
//La variables DIRi_SCREEN se cambia a 4 ,7 o 10 para los demas personajes
DIRi_SCREEN=10;//0,4us
//tiempo sobrante
//58,6 - (2,6+4,8+ 2 + 2,4 + 1,4 + 3 )(total=16,6) = 42us-(1,8us)=40,6us-3,8=36,8-0,4us=36,4
//36,4-3,4=33us-0,2(sale 3,2(If para Borrar screen)-3)=32,8-0,2=32,6-3,4=29,2us
//29,2-0,8=28,4-0,2=28,2-0,8=27,4-2,6=24,8
delay_us(24);
delay_cycles(4);
output_low(pin_a0); //sincro
//revisar
//todo esta calculado solo falta probar
}
//___________________________________________________________________________
___
void int Borrar_Screen41(){
//Sincronización Horizontal (4.4us)-goto funcion Tratar_Letra -goto(entra fun Borrar_Screen)
//4,4-0,4-0,4 = 3,6us
delay_us(3);
delay_cycles(3);
output_high(pin_a0); //negro
//Inico del tiempo de la imagem
if( BorrarScreen4==0){
//emplea 3(Ins) el if para entrar en V
int8 Ce[256]={0x0};
#Locate Ce=0xA00 //Ocupamos todos los registros del Banco1
//tiempo total=257+3(inicio if)+2(Bra)=262*0,2us=52,4us
//BorrarScreen=1;
delay_cycles(1);
}
else{
//emplea 4(Ins) el if para entrar en F
delay_us(51); //262 - 4 = 258*0,2us=51,6us
delay_cycles(3);
}
//tiempo sobrante
delay_us(6); //58,6-52,4 = 6,2us
delay_cycles(1);
output_low(pin_a0); //sincro
//___________________________________________________________________________
___
}
void int Borrar_Screen42(){
//Sincronización Horizontal (4.4us)-goto funcion Tratar_Letra -goto(entra fun Borrar_Screen)
//4,4-0,4-0,4 = 3,6us
delay_us(3);
delay_cycles(3);
.
output_high(pin_a0); //negro
//Inico del tiempo de la imagem
if( BorrarScreen4==0){
//emplea 3(Ins) el if para entrar en V
int8 Ce[256]={0x0};
#Locate Ce=0xB00 //Ocupamos todos los registros del Banco1
//tiempo total=257+3(inicio if)+2(Bra)=262*0,2us=52,4us
//BorrarScreen=1;
delay_cycles(1);
}
else{
//emplea 4(Ins) el if para entrar en F
delay_us(51); //262 - 4 = 258*0,2us=51,6us
delay_cycles(3);
}
//tiempo sobrante
delay_us(6); //58,6-52,4 = 6,2us
delay_cycles(1);
output_low(pin_a0); //sincro
}
//___________________________________________________________________________
___
void int Borrar_Screen43(){
//Sincronización Horizontal (4.4us)-goto funcion Tratar_Letra -goto(entra fun Borrar_Screen)
//4,4-0,4-0,4 = 3,6us
delay_us(3);
delay_cycles(3);
output_high(pin_a0); //negro
//Inico del tiempo de la imagem
if( BorrarScreen4==0){
//emplea 3(Ins) el if para entrar en V
int8 Ce[256]={0x0};
#Locate Ce=0xC00 //Ocupamos todos los registros del Banco1
//tiempo total=257+3(inicio if)+2(Bra)=262*0,2us=52,4us
BorrarScreen4=1;
}
else{
//emplea 4(Ins) el if para entrar en F
delay_us(51); //262 - 4 = 258*0,2us=51,6us
delay_cycles(3);
}
//tiempo sobrante
delay_us(6); //58,6-52,4 = 6,2us
delay_cycles(1);
output_low(pin_a0); //sincro
}
//___________________________________________________________________________
___
//
FIN
.
//___________________________________________________________________________
___
Void LlenarScreen(){
//Sincronización Horizontal (4.4us)-goto funcion ClasificarLetra -goto(entra fun Tratar_Letra)
//4,4-0,4-0,4-0,4 = 3,6us
delay_us(3);
delay_cycles(3);
output_high(pin_a0); //negro
/*
Duracion de la funcion es:
17(Instruciones) al inicar la funcion
(7*6(Inst))=42(Istrucciones) de repeticiones
9(Instrucciones) de terminado la funcion
Tiempo total=68(Ins)*0,2=13,6 us
Variables a ingresar a la funcion
DIR_MATRIX = Controla la posicion de inicio del banco donde se encuentra guardadas las
letras o numeros
Valores a tomar (Matrix Letras Mayusculas = 600 -- 6D7
Matrix Numeros 0 4=6D8--- 6FF
MAtrix Letras Minusculas = )
n_DIR_SCREEN = Controla la posicion de inicio de los vectores screen
Valores a tomar (Screen1=100h
Screen2=200h
Screen3=300h
Screen4=400h )
POS_LETRA_SCREEN = de acuedo a la formula 128*(Numero de Texto)+Numero de Letras
digitadas
Valores atomar (Numero de Letras digitadas=0....15
Numero de Lineas de Texto = 0 y 1 )
POS_LETRA_MATRIX = Indica la direccion donde comienza la letra en la matrix
Codigos de POS_LETRA_MATRIX
A
0X6 00
B
0X6 08
C
0X6 10
D
0X6 18
E
0X6 20
F
0X6 28
G
0X6 30
H
0X6 38
I
0X6 40
J
0X6 48
K
0X6 50
L
0X6 58
M
0X6 60
N
0X6 68
Ñ
0X6 70
O
0X6 78
.
P
0X6 80
Q
0X6 88
R
0X6 90
S
0X6 98
T
0X6 A0
U
0X6 A8
V
0X6 B0
W
0X6 B8
X
0X6 C0
Y
0X6 C8
Z
0X6 D0
FSR0 usamos para manipular las direcciones del vector
FSR1 usamos para manipular las direcciones del la Matrix
*/
#ASM
CLRF
CLRF
CLRF
CLRF
FSR0H
FSR0L
FSR1H
FSR1L
//Cargamos a los registros los numeros base 0=banco 0 --1=banco1....15=banco 15
//PARA SELECCIONAR EL BANCO SCREEN
MOVLB 0
MOVF DIRi_MATRIX,w //movemos 1 al registro W
MOVWF FSR1H //movemos el registro W a FSR1H
//PARA SELECCIONAR EL BANCO LETRAS y NUMEROS
CLRF W
MOVF n_DIRi_SCREEN ,W //movemos EL CONTENIDO DE DIRECCION DEL BANCO al
registro W
MOVWF FSR0H //movemos w al registro FSR0H
//*******************************0****************************************
//INGRESO direccion del VECTOR screen a FSR0
MOVLW 0 //Cargamos el registro w con el valor de 16(ver vector screen)
ADDWF POS_LETRA_SCREEN,W //sumamos W+J
MOVWF FSR0L//movemos el valor de W a FSR0L
//INGRESO la direccion de la matrix a FSR1
MOVF POS_LETRA_MATRIX,W //Movemos el valor de POS _LETRA a W
MOVWF FSR1L //Movemos W a FSR1L
MOVFF INDF1,INDF0
//*******************************1*****************************************
//INGRESO direccion del VECTOR screen a FSR0
MOVLW 16 //Cargamos el registro w con el valor de 16(ver vector screen)
ADDWF POS_LETRA_SCREEN,W //sumamos W+J
MOVWF FSR0L//movemos el valor de W a FSR0L
//INGRESO la direccion de la matrix a FSR1
INCF FSR1L,F
MOVFF INDF1,INDF0
.
//********************************2****************************************
//INGRESO direccion del VECTOR screen a FSR0
MOVLW 32 //Cargamos el registro w con el valor de 32 (ver vector screen)
ADDWF POS_LETRA_SCREEN,W //sumamos W+J
MOVWF FSR0L//movemos el valor de W a FSR0L
//INGRESO la direccion de la matrix a FSR1
INCF FSR1L,F
MOVFF INDF1,INDF0
//********************************3****************************************
//INGRESO direccion del VECTOR screen a FSR0
MOVLW 48 //Cargamos el registro w con el valor de 48(ver vector screen)
ADDWF POS_LETRA_SCREEN,W //sumamos W+J
MOVWF FSR0L//movemos el valor de W a FSR0L
//INGRESO la direccion de la matrix a FSR1
INCF FSR1L,F
MOVFF INDF1,INDF0
//********************************4****************************************
//INGRESO direccion del VECTOR screen a FSR0
MOVLW 64 //Cargamos el registro w con el valor de 16(ver vector screen)
ADDWF POS_LETRA_SCREEN,W //sumamos W+J
MOVWF FSR0L//movemos el valor de W a FSR0L
//INGRESO la direccion de la matrix a FSR1
INCF FSR1L,F
MOVFF INDF1,INDF0
//********************************5****************************************
//INGRESO direccion del VECTOR screen a FSR0
MOVLW 80 //Cargamos el registro w con el valor de 16(ver vector screen)
ADDWF POS_LETRA_SCREEN,W //sumamos W+J
MOVWF FSR0L//movemos el valor de W a FSR0L
//INGRESO la direccion de la matrix a FSR1
INCF FSR1L,F
MOVFF INDF1,INDF0
//********************************6****************************************
//INGRESO direccion del VECTOR screen a FSR0
MOVLW 96 //Cargamos el registro w con el valor de 16(ver vector screen)
ADDWF POS_LETRA_SCREEN,W //sumamos W+J
MOVWF FSR0L//movemos el valor de W a FSR0L
//INGRESO la direccion de la matrix a FSR1
INCF FSR1L,F
MOVFF INDF1,INDF0
//********************************7****************************************
//INGRESO direccion del VECTOR screen a FSR0
MOVLW 112 //Cargamos el registro w con el valor de 16(ver vector screen)
ADDWF POS_LETRA_SCREEN,W //sumamos W+J
MOVWF FSR0L//movemos el valor de W a FSR0L
.
//INGRESO la direccion de la matrix a FSR1
INCF FSR1L,F
MOVFF INDF1,INDF0
//7 por el tamano de la letra es de 8 pixeles
//********************************FIN****************************************
CLRF FSR0H
CLRF FSR0L
CLRF FSR1H
CLRF FSR1L
CLRF INDF0
CLRF INDF1
CLRF POS_LETRA_MATRIX
CLRW
CLRF POS_LETRA_SCREEN
#ENDASM
//tiempo sobrante
delay_us(45); //58,6 - 13,6us = 45 us
output_low(pin_a0); //sincro
//ya Terminado
}
//___________________________________________________________________________
___
Void Draw_Letras(){ //x=numero de lineas a repetir
/*
DIRi_SCREEN =
*/
#asm
CLRF FSR0H
CLRF FSR0L
CLRF PORTC
CLRF W
MOVF DIRi_SCREEN ,W //movemos EL CONTENIDO DE DIRECCION DEL BANCO al
registro W
MOVWF FSR0H //movemos w al registro FSR0H
MOVLW 0 //movemos EL CONTENIDO DE DIRECCION DEL BANCO al registro W
MOVWF FSR0L //movemos w al registro FSR0H
//total = 8(instrucciones de ingreso)
//*************************** INICIO DEL BUCLE *********************************
Loop:
#endasm
//Sincronización Horizontal (4.4us)+0,2(output)=4,6us
output_low(pin_a0); //sincronismo
delay_us(4);
.
delay_cycles(2);
//Back porch =4,8us +0,2(output)=5us
output_high(pin_a0); //negro
delay_us(4);
delay_cycles(4);
//63,4-4,4-4,8-0,4-2,2=51,6us
//******************IMAGEN********** Tiempo disponible = 51,6
delay_us(7);
#asm
//Letra 1
MOVFF INDF0,PORTC //2 ciclos
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
INCF FSR0L,F //total 11(Instrucciones)=
//Letra 2
MOVFF INDF0,PORTC //2 ciclos
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
INCF FSR0L,F //total 11(Instrucciones)=
//Letra 3
MOVFF INDF0,PORTC //2 ciclos
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
INCF FSR0L,F //total 11(Instrucciones)=
//Letra 4
MOVFF INDF0,PORTC //2 ciclos
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
.
INCF FSR0L,F //total 11(Instrucciones)=
//Letra 5
MOVFF INDF0,PORTC //2 ciclos
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
INCF FSR0L,F //total 11(Instrucciones)=
//Letra 6
MOVFF INDF0,PORTC //2 ciclos
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
INCF FSR0L,F //total 11(Instrucciones)=
//Letra 7
MOVFF INDF0,PORTC //2 ciclos
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
INCF FSR0L,F //total 11(Instrucciones)=
//Letra 8
MOVFF INDF0,PORTC //2 ciclos
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
INCF FSR0L,F //total 11(Instrucciones)=
//Letra 9
MOVFF INDF0,PORTC //2 ciclos
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
.
rrcf PORTC,F
rrcf PORTC,F
INCF FSR0L,F //total 11(Instrucciones)=
//Letra 10
MOVFF INDF0,PORTC //2 ciclos
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
rrcf PORTC,F
INCF FSR0L,F //total 11(Instrucciones)=
// Total = 11(instrucciones)*16= (176+1(clrf PORTC))=177*0,2=35,4
//tiempo disponible =51,6-35,4=16,2us
//16,2-7=9,2
nop
#endasm
//Front Porch + 0,2(Output)= 2,2us
//9,2+1,4(Front Porch)=10,6us
output_high(pin_a0); //negro
delay_us(10);// tiempo sobrante o disponible + 1 del //Front Porch
delay_cycles(3);//2us-0,6(Decfsz y Goto)=1,4us
#asm
DECFSZ N_LineasVideo,F
GOTO Loop
BCF 0xF89.0 // enceramos pin_a0 sincronismo
CLRF FSR0H
CLRF FSR0L
#endasm
DIRi_SCREEN++;
//Tiempo de Salid 7(Instrucciones)=7*0,2=1,4 us
}
CARGAR_DATOS.H
//Declaracion dela Matrix Direccion D00H
int8 Matrix_Mayusculas[27][8]={
//A
0x0,0x1C,0x22,0x41,0x7F,0x41,0x41,0x41
//B
0x00,0x3F,0x63,0x63,0x3F,0x63,0x63,0x3F,
//C
0x00,0x7E,0x7F,0x3,0x3,0x3,0x7F,0x7E,
//D
.
0x00,0x3F,0x43,0x43,0x43,0x43,0x43,0x3F
//E
0x00,0x7F,0x3,0x3,0x3F,0x3,0x3,0x7F,
//F
0x00,0x7F,0x3,0x3,0x3F,0x3,0x3,0x3,
//G
0x00,0x7E,0x43,0x3,0x7B,0x5B,0x43,0x7E,
//H
0x00,0x3,0x63,0x63,0x7F,0x63,0x63,0x63,
//I
0x00,0x7F,0x8,0x8,0x8,0x8,0x8,0x7F,
//J
0x00,0x7E,0x18,0x18,0x18,0x1B,0x1B,0x1E,
//K
0x00,0x63,0x33,0x1F,0xF,0x1F,0x33,0x63,
//L
0x00,0x3,0x3,0x3,0x3,0x3,0x3,0x7F,
//M
0x00,0x63,0x77,0x7F,0x6B,0x63,0x63,0x63,
//N
0x00,0x63,0x67,0x6F,0x7B,0x73,0x63,0x63,
//Ñ
0x00,0x18,0x63,0x67,0x6F,0x7B,0x73,0x63,
//O
0x00,0x3E,0x63,0x63,0x63,0x63,0x63,0x3E,
//P
0x00,0x3F,0x63,0x63,0x3F,0x3,0x3,0x3,
//Q
0x00,0x1E,0x21,0x21,0x21,0x29,0x31,0x5E
//R
0x00,0x3F,0x43,0x43,0x3F,0x1B,0x33,0x63
//S
0x00,0x3E,0x63,0x3,0x3E,0x60,0x63,0x3E,
//T
0x00,0x7F,0x8,0x8,0x8,0x8,0x8,0x8,
//U
0x00,0x63,0x63,0x63,0x63,0x63,0x7F,0x3E,
//V
0x00,0x63,0x63,0x63,0x63,0x63,0x3E,0x1C,
//W
0x00,0x63,0x63,0x6B,0x6B,0x77,0x77,0x63,
//X
0x00,0x41,0x22,0x14,0x8,0x14,0x22,0x41,
//Y
0x00,0x41,0x22,0x1C,0x8,0x8,0x8,0x8,
//Z
0x00,0x7F,0x21,0x10,0x8,0x4,0x42,0x7F,
//27 Letras OCUPA MEMORIA DE D00 HASTA DD7
//OCUPA HASTA LA DIRECCION DD7
//SOBRAN 40 espacios de memoria
};
#Locate Matrix_Mayusculas=0xD00
/////////////////Matrix Numeros59/////////////////
int8 Matrix_Numeros04[5][8]={
.
//0
0x00,0x3E,0x71,0x59,0x4D,0x45,0x47,0x3E
//1
0X00,0X38,0X3C,0X36,0X30,0X30,0X30,0X30,
//2
0X00,0X3E,0X63,0X63,0X30,0XC,0X6,0X7F,
//3
0X00,0X3E,0X63,0X60,0X7C,0X60,0X63,0X3E,
//4
0x00,0x33,0x33,0x33,0x7E,0x60,0x60,0x60,
};
#Locate Matrix_Numeros04=0xDD8 //OCUPA MEMORIA DE DD8 -- DFF
int8 Matrix_Numeros59[5][8]={
//5
0X00,0X7F,0X3,0X3,0X3E,0X00,0X63,0X3E,
//6
0X00,0X7C,0X6,0X3,0X3F,0X63,0X63,0X3E,
//7
0X00,0X7E,0X60,0X60,0XFC,0X60,0X60,0X60,
//8
0x00,0x3E,0x63,0x63,0x3E,0x63,0x63,0x3E,
//9
0x00,0x3E,0x63,0x63,0x7E,0x60,0x63,0x3E,
};
#Locate Matrix_Numeros59=0xED8 //OCUPA MEMORIA DE ED8 -- EFF
/////////////////Matrix Caracteres especiales/////////////////
int8 Matrix_Caracteres[7][8]={
//"Guion "
0x00,0x00,0x00,0x00,0x00,0x7F,0x7F,0x7F,
//" "
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
// +
0x00,0x18,0x18,0x7E,0x7E,0x18,0x18,0x00
// 0x00,0x00,0x00,0x7E,0x7E,0x00,0x00,0x00
// *
0x00,0x49,0x2A,0x1C,0x1C,0x1C,0x2A,0x49
// /
0x00,0x60,0x70,0x38,0x1C,0x0E,0x07,0x03
// =
0x00,0x00,0x7F,0x7F,0x00,0x7F,0x7F,0x00
};
#Locate Matrix_Caracteres=0xF00 //OCUPA MEMORIA DE F00 en adelante
.
SINCRONISMOV1.H
#use delay(clock=20000000)
#use fast_io(A)
#use fast_io(B)
int8 i,p;
int8 Campo=0;//valor inicial es 0 recu
void Pulsos_Campo_I(){
/* Ingresar al for ocupa =5(Inst) =1 us
Ciclo intermedio
=6(Inst)=1,2 us
Salir del for ocupa =7(Inst)=1,4 us
Los output ocupan = 0,2 us
*/
//6 post-sync
/* pulso bajo = 2,2
pulso alto = 29,2
*/
if(campo==1){
//if(campo==1) V ocupa 2(Ins) para entrar
//if(campo==1) F ocupa 3(Ins) para saltar
//2,6 sale de tiempo em el if(campo==1)(7 Instrucciones) F+entrara al for(5 Intrucciones )
delay_us(2); //necesito 2,6us para formar el pulso de la linea 262
delay_cycles(1);
output_low(pin_a0); //Sincro //2,6-0,4(2Inst)=2,2 us
//Aqui formamos el primer pulso de sicronismo vertical ver grafico
delay_us(4); //4,4 genera tiempo para sincro
delay_cycles(2);
output_high(pin_a0); //Negro
delay_us(25);//27,2 - 0,6(3 Instr de la variable p y campo )-0,4(Goto else) - 1(entrada al for)-=
25,2
delay_cycles(1);//27,2=tiempo de la linea de video(63,6)/2 y restado tiempo de sincro h y resta
0,2 output
p=4;//p=4 para dibujar 4 pulsos cunado es el campo 2
campo=0;//campo =0 para activar el campo
}
else{
p=5; //p=5 para dibujar 5 pulsos cunado es el campo 1
campo=1;//campo = 1 para activar el campo
}
for(i=1;i<=6;i++){//6
output_low(pin_a0); //Sincro
delay_us(2); //2,2us para sincro
delay_cycles(1);
output_high(pin_a0); //Negro
delay_us(28);//29,2 - 1,2(Ciclo Intermedio del For)= 28
}
//6 sincros verticales
/* pulso bajo = 26,8
pulso alto = 4,6
*/
.
output_low(pin_a0); //sincro
delay_us(26);
delay_cycles(4);
output_high(pin_a0); //negro
delay_us(3);
delay_cycles(3); //4,6-1(Ciclo Entrada al For)= 3,6
for(i=1;i<=5;i++){ //5
output_low(pin_a0); //sincro
delay_us(26);
delay_cycles(4);
output_high(pin_a0); //negro
delay_us(3);
delay_cycles(2); //4,6-1,2(Ciclo Intermedio del For)=3,4
}
//6 post-sync para los campos
/* pulso alto = 2,2
pulso bajo = 29,2
*/
output_low(pin_a0); //sincro
delay_us(2);
delay_cycles(1);
output_high(pin_a0); //negro
delay_us(28); //29,2-1(Ciclo Entrada al For)=28,2
delay_cycles(1);
for(i=1;i<=p;i++){
output_low(pin_a0); //sincro
delay_us(2);
delay_cycles(1);
output_high(pin_a0); //negro
delay_us(28); //29,2 - 1,2(Ciclo Intermedio del For)= 28
}
output_low(pin_a0); //sincro
if(campo==0){
delay_us(1); //2,2 -0,4(0,2*2(instruciones entrar if(campo==0) en condicion V)) =1,8
delay_cycles(4);
//Aqui formamos completamente la linea de video 9
output_high(pin_a0); //negro
delay_us(60); //60,8
delay_cycles(4);
output_low(pin_a0); //sincro
//Este delay_cycles(3) uso para completar el tiempo de sincronizacion horizontal para linea 10
delay_cycles(3);//Compenso los 3(Instruc) que usa el if(campo==0) en falso
}
}//Goto 0,4 us
//esto ya esta terminado
VIDEO.H
#use delay(clock=20000000)
#use fast_io(A)
#use fast_io(B)
.
int8 i,p;
int8 Campo=0;//valor inicial es 0 recu
void Pulsos_Campo_I(){
/* Ingresar al for ocupa =5(Inst) =1 us
Ciclo intermedio
=6(Inst)=1,2 us
Salir del for ocupa =7(Inst)=1,4 us
Los output ocupan = 0,2 us
*/
//6 post-sync
/* pulso bajo = 2,2
pulso alto = 29,2
*/
if(campo==1){
//if(campo==1) V ocupa 2(Ins) para entrar
//if(campo==1) F ocupa 3(Ins) para saltar
//2,6 sale de tiempo em el if(campo==1)(7 Instrucciones) F+entrara al for(5 Intrucciones )
delay_us(2); //necesito 2,6us para formar el pulso de la linea 262
delay_cycles(1);
output_low(pin_a0); //Sincro //2,6-0,4(2Inst)=2,2 us
//Aqui formamos el primer pulso de sicronismo vertical ver grafico
delay_us(4); //4,4 genera tiempo para sincro
delay_cycles(2);
output_high(pin_a0); //Negro
delay_us(25);//27,2 - 0,6(3 Instr de la variable p y campo )-0,4(Goto else) - 1(entrada al for)-=
25,2
delay_cycles(1);//27,2=tiempo de la linea de video(63,6)/2 y restado tiempo de sincro h y resta
0,2 output
p=4;//p=4 para dibujar 4 pulsos cunado es el campo 2
campo=0;//campo =0 para activar el campo
}
else{
p=5; //p=5 para dibujar 5 pulsos cunado es el campo 1
campo=1;//campo = 1 para activar el campo
}
for(i=1;i<=6;i++){//6
output_low(pin_a0); //Sincro
delay_us(2); //2,2us para sincro
delay_cycles(1);
output_high(pin_a0); //Negro
delay_us(28);//29,2 - 1,2(Ciclo Intermedio del For)= 28
}
//6 sincros verticales
/* pulso bajo = 26,8
pulso alto = 4,6
*/
for(i=1;i<=5;i++){ //5
output_low(pin_a0); //sincro
delay_us(26);
delay_cycles(4);
output_high(pin_a0); //negro
.
delay_us(3);
delay_cycles(2); //4,6-1,2(Ciclo Intermedio del For)=3,4
}
//6 post-sync para los campos
/* pulso alto = 2,2
pulso bajo = 29,2
*/
output_low(pin_a0); //sincro
delay_us(2);
delay_cycles(1);
output_high(pin_a0); //negro
delay_us(28); //29,2-1(Ciclo Entrada al For)=28,2
delay_cycles(1);
for(i=1;i<=p;i++){
output_low(pin_a0); //sincro
delay_us(2);
delay_cycles(1);
output_high(pin_a0); //negro
delay_us(28); //29,2 - 1,2(Ciclo Intermedio del For)= 28
}
output_low(pin_a0); //sincro
if(campo==0){
delay_us(1); //2,2 -0,4(0,2*2(instruciones entrar if(campo==0) en condicion V)) =1,8
delay_cycles(4);
//Aqui formamos completamente la linea de video 9
output_high(pin_a0); //negro
delay_us(60); //60,8
delay_cycles(4);
output_low(pin_a0); //sincro
//Este delay_cycles(3) uso para completar el tiempo de sincronizacion horizontal para linea 10
delay_cycles(3);//Compenso los 3(Instruc) que usa el if(campo==0) en falso
}
}//Goto 0,4 us
//esto ya esta terminado
#use delay(clock=20000000)
#use fast_io(A)
#use fast_io(B)
int n1;
Void LineasNegras(int x){
For(n1=1;n1<=x;++n1){
//Sincronización Horizontal (4.4us)
output_low(pin_a0); //sincro
delay_us(4);
delay_cycles(2);
//lineas de imagen + black porch 58,6-1,2(Ciclo Intermedio for)=57,4 us
output_high(pin_a0); //negro
delay_us(57);
.
delay_cycles(2);
}
output_low(pin_a0); //sincro
}
//_________________________LineasBlancas______________________________________
__
Void LineasBlancas(int x){
for(n1=1;n1<=x;++n1){
//Sincronización Horizontal (4.4us)
output_low(pin_a0); //sincro
delay_us(4);
delay_cycles(2);
//Back porch =4,8us +0,2(output)=5us
output_high(pin_a0); //negro
delay_us(4);
delay_cycles(4);
//Imagen = 63,4-4,4-4,8-0,4-2,2=51,6us
output_high(pin_a0); //negro
delay_us(51);
delay_cycles(3);
output_high(pin_a0); //negro
delay_cycles(4);// tiempo sobrante o disponible + 1 del //Front Porch
//2-1,2
}
output_low(pin_a0); //sincro
}
//_________________________LineasBlancas______________________________________
__
Void LineasBlancasNegras(int x){
for(n1=1;n1<=x;++n1){
//Sincronización Horizontal (4.4us)
output_low(pin_a0); //sincro
delay_us(4);
delay_cycles(2);
//Back porch =4,8us +0,2(output)=5us
output_high(pin_a0); //negro
delay_us(4);
delay_cycles(4);
//Imagen = 63,4-4,4-4,8-0,4-2,2=51,6us
output_high(pin_a0); //negro
delay_us(51);
delay_cycles(3);
.
output_high(pin_a0); //negro
delay_cycles(4);// tiempo sobrante o disponible + 1 del //Front Porch
//2-1,2
}
output_low(pin_a0); //sincro
}
VIDEO_PRINCIPAL_TERMINADO18F2525V116.C
#include <Sincronismov1.h>
#include <Video.h>
#include <Funciones.h>
//******************** PROGRAMA PRINCIPAL ***********************************
Void Main() {
set_tris_A (0b00000000);
set_tris_C (0b00000000);
set_tris_B (0b11111111);
output_A(0);
output_B(0);
delay_us(200);
.
While(TRUE){
//4,4 para sincro horizontal
//58,6 para imagen incluido fron o porch y blak porch
//_________________________________VIDEO____________________________________
__
//Linea 1 - 9
Pulsos_Campo_I();//Goto usa 0,4 us entrar
//Goto usa 0,4 us salir
//******************************* VIDEO ********************
//LINEA 10
delay_us(3); //4,4 -0,6(0,2*3(Intruciones del IF(campo==0) en falso)) -GotoSalir(0,4) =3,4
delay_cycles(2);
output_high(pin_a0); //negro
delay_us(56); //58,6 -entrar funcionLineasBoN(0,8)-entradao for(1) = 56,8
delay_cycles(4);//4
//LINEA 11 - 25
LineasNegras(15);//usa 0,8 /15
//**********************************Impresion del 1
niño********************************************************
//Linea 26
delay_us(4); //4,4 - GotoSalir(0,4) =4
output_high(pin_a0); //negro
delay_us(57); //58,6 -(0,4)goto funcion LerrDato-0,4(U1=3)=57,8us
delay_cycles(2);//2
U1=3; //esta variable controla las INT 3=PIC1 , 5=PIC2 , 9==PIC3 ,17=PIC4
//Cada funcion es una linea
//Linea 27 a 33
LeerDato();
ClasificarLetra();
Tratar_Letra();
Borrar_Screen11();
Borrar_Screen12();
Borrar_Screen13();
LlenarScreen();
//Linea 34
delay_us(4); //4,4 - GotoSalir(0,4) =4
output_high(pin_a0); //negro
delay_us(56); //58,6 -((0,4)goto funcion Draw_Letras+0,2*8(Inst de inicio de la funcion Draw
Letras))=56,6us
delay_cycles(2);
N_LineasVideo=16;
//Linea 35 a la 50
Draw_Letras();//forma 16 lineas
//Linea 51
delay_us(2); //4,4 - GotoSalir(0,4)-1,4(Salir de la funcion Draw_Letras() ) =2,6 us
delay_cycles(3);//3
output_high(pin_a0); //negro
delay_us(56); //58,6 -((0,4)goto funcion Draw_Letras+0,2*8(Inst de inicio de la funcion Draw
Letras))=56,6us
.
delay_cycles(1);//5
N_LineasVideo=16;
//Linea 52 a la 67
Draw_Letras();//forma 16 lineas
//Linea 69 a la 76
Draw_Letras();//forma 8 lineas
//77
delay_us(2); //4,4 - GotoSalir(0,4)-1,4(Salir de la funcion Draw_Letras() ) =2,6 us
delay_cycles(3);
output_high(pin_a0); //negro
delay_us(56); //58,6 -entrar funcionLineasBoN(0,8)-entradao for(1) = 56,8
delay_cycles(4);
//Linea 78 - 82
LineasNegras(5);//
//************************************NIÑO2*******************************************
//Linea 83
delay_us(4); //4,4 - GotoSalir(0,4) =4
output_high(pin_a0); //negro
delay_us(57); //58,6 -(0,4)goto funcion LerrDato-0,4(U1=3)=57,8us
delay_cycles(2);//2
U1=5; //esta variable controla las INT 3=PIC1 , 5=PIC2 , 9==PIC3 ,17=PIC4
//Cada funcion es una linea
//Linea 84 a 90
LeerDato();
ClasificarLetra();
Tratar_Letra();
Borrar_Screen11();
Borrar_Screen12();
Borrar_Screen13();
LlenarScreen();
//Linea 91
delay_us(4); //4,4 - GotoSalir(0,4) =4
output_high(pin_a0); //negro
delay_us(56); //58,6 -((0,4)goto funcion Draw_Letras+0,2*8(Inst de inicio de la funcion Draw
Letras))=56,6us
delay_cycles(2);
N_LineasVideo=16;
//107
Draw_Letras();//forma 16 lineas
//108
delay_us(2); //4,4 - GotoSalir(0,4)-1,4(Salir de la funcion Draw_Letras() ) =2,6 us
delay_cycles(3);//3
output_high(pin_a0); //negro
delay_us(56); //58,6 -((0,4)goto funcion Draw_Letras+0,2*8(Inst de inicio de la funcion Draw
Letras))=56,6us
delay_cycles(1);//5
N_LineasVideo=16;
.
//124
Draw_Letras();//forma 16 lineas
//125
delay_us(2); //4,4 - GotoSalir(0,4)-1,4(Salir de la funcion Draw_Letras() ) =2,6 us
delay_cycles(3);
output_high(pin_a0); //negro
delay_us(56); //58,6 -((0,4)goto funcion Draw_Letras+0,2*8(Inst de inicio de la funcion Draw
Letras))=56,6us
delay_cycles(1);
N_LineasVideo=8;
//133
Draw_Letras();//forma 8 lineas
//134
delay_us(2); //4,4 - GotoSalir(0,4)-1,4(Salir de la funcion Draw_Letras() ) =2,6 us
delay_cycles(3);
output_high(pin_a0); //negro
delay_us(56); //58,6 -entrar funcionLineasBoN(0,8)-entradao for(1) = 56,8
delay_cycles(4);
//135
LineasNegras(6);
//*************************************************************************************************
//************************************NIÑO 3*******************************************
//140
delay_us(4); //4,4 - GotoSalir(0,4) =4
output_high(pin_a0); //negro
delay_us(57); //58,6 -(0,4)goto funcion LerrDato-0,4(U1=3)=57,8us
delay_cycles(2);//2
U1=9; //esta variable controla las INT 3=PIC1 , 5=PIC2 , 9==PIC3 ,17=PIC4
//Cada funcion es una linea
//Linea 141 a 147
LeerDato();
ClasificarLetra();
Tratar_Letra();
Borrar_Screen11();
Borrar_Screen12();
Borrar_Screen13();
LlenarScreen();
//Linea 148
delay_us(4); //4,4 - GotoSalir(0,4) =4
output_high(pin_a0); //negro
delay_us(56); //58,6 -((0,4)goto funcion Draw_Letras+0,2*8(Inst de inicio de la funcion Draw
Letras))=56,6us
delay_cycles(2);
N_LineasVideo=16;
Draw_Letras();//forma 16 lineas
delay_us(2); //4,4 - GotoSalir(0,4)-1,4(Salir de la funcion Draw_Letras() ) =2,6 us
delay_cycles(3);//3
.
output_high(pin_a0); //negro
delay_us(56); //58,6 -((0,4)goto funcion Draw_Letras+0,2*8(Inst de inicio de la funcion Draw
Letras))=56,6us
delay_cycles(1);//5
N_LineasVideo=16;
Draw_Letras();//forma 16 lineas
delay_us(2); //4,4 - GotoSalir(0,4)-1,4(Salir de la funcion Draw_Letras() ) =2,6 us
delay_cycles(3);
output_high(pin_a0); //negro
delay_us(56); //58,6 -((0,4)goto funcion Draw_Letras+0,2*8(Inst de inicio de la funcion Draw
Letras))=56,6us
delay_cycles(1);
N_LineasVideo=8;
Draw_Letras();//forma 8 lineas
delay_us(2); //4,4 - GotoSalir(0,4)-1,4(Salir de la funcion Draw_Letras() ) =2,6 us
delay_cycles(3);
output_high(pin_a0); //negro
delay_us(56); //58,6 -entrar funcionLineasBoN(0,8)-entradao for(1) = 56,8
delay_cycles(4);
//192
LineasNegras(6);//usa 0,8 176
//*************************************************************************************************
//Linea 205
delay_us(4); //4,4 - GotoSalir(0,4) =4
output_high(pin_a0); //negro
delay_us(56); //58,6 -((0,4)goto funcion Draw_Letras+0,2*8(Inst de inicio de la funcion Draw
Letras))=56,6us
delay_cycles(2);
N_LineasVideo=16;
Draw_Letras();//forma 16 lineas
delay_us(2); //4,4 - GotoSalir(0,4)-1,4(Salir de la funcion Draw_Letras() ) =2,6 us
delay_cycles(3);//3
output_high(pin_a0); //negro
delay_us(56); //58,6 -((0,4)goto funcion Draw_Letras+0,2*8(Inst de inicio de la funcion Draw
Letras))=56,6us
delay_cycles(1);//5
N_LineasVideo=16;
Draw_Letras();//forma 16 lineas
delay_us(2); //4,4 - GotoSalir(0,4)-1,4(Salir de la funcion Draw_Letras() ) =2,6 us
delay_cycles(3);
.
output_high(pin_a0); //negro
delay_us(56); //58,6 -((0,4)goto funcion Draw_Letras+0,2*8(Inst de inicio de la funcion Draw
Letras))=56,6us
delay_cycles(1);
N_LineasVideo=8;
Draw_Letras();//forma 8 lineas
//248
delay_us(2); //4,4 - GotoSalir(0,4)-1,4(Salir de la funcion Draw_Letras() ) =2,6 us
delay_cycles(3);
output_high(pin_a0); //negro
delay_us(56); //58,6 -entrar funcionLineasBoN(0,8)-entradao for(1) = 56,8
delay_cycles(4);
//249
LineasNegras(14);//
//*************************************************************************************************
//Linea 262
delay_us(4); //4,4 - GotoSalir(0,4) =4
output_high(pin_a0); //negro
delay_us(55); //58,6 -0,4(goto while)-0,4(goto funcion Pulsos)-1,4(7inst if(campo==1)con F) 1(entradao for funcion Pulso) = 55,4
delay_cycles(2);//=55,2*/
}
}
.