UNIVERSIDAD POLITÉCNICA SALESIANA - …dspace.ups.edu.ec/.../123456789/4655/1/UPS-ST000363.pdf3.4.2...

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


1.1 INSUFICIENCIA MORIZ DE ORIGEN CEREBRAL (IMOC) .........................1

1.2 DESCRIPCIÓN DE LA IMOC.......................................................................2


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


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


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


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


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


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


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-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)


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

1

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,

2

• 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/


3

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.

4

• 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.

5

• 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, mueren por

complicaciones respiratorias y procesos infecciosos).

Corea: sistema extrapiramidal (putamen y caudado).

6

• 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.

7

• 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).

8

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.

9

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.

10

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.

11

• 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.

12

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).

13

• 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)

14

• 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).

15

• 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.

16

• 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

17

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.

18

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.

19

• 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..



20

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..



21

CAPÍTULO II Fundamentos

Teóricos

22

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).

23

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).

24

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

25

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.

26

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í:

27

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.

http://es.wikipedia.org/wiki/NTSC

28

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.

29

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 (Cross-

hatch 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.

30

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:

31

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,

32

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).

33

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.

34

• “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

35

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:

36

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”.

37

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

38

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


39

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.

40

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

41

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.

42

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.

43

Cuadro de pulsos

Figura 2.1.2-1 Diagrama de tiempos del sistema PAL 1

----------------------------------- 1.- Tutorial Pc y Pic http://conket.com/modules.php?name=Sections&op=viewarticle&artid=14


44

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.

45

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.

46

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.

47

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 ".

48

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

49

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.

50

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

51

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

52

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

53

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.

54

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

55

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)

56

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.

57

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.

58

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

59

• 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

60

• 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)

61

• 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

62

CAPITULO III

Teoría

63

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.

64

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) .

65

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

66

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.

67

Formato del teclado

TTeeccllaaddoo MMuullttiiffuunncciióónn ((110011 tteeccllaass)) óó PPSS//22

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:

68

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.

69

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).

70

* 01 Alt ESC * 35 Alt - 58 Shift F5 7F Alt 8 03 Ctrl 2, NUL 37 Alt -*- 59 Shift F6 80 Alt 9 * 0E Alt ß 3B r1 5A Shift F7 81 Alt 0 0F Shift Tab 3C r2 5B Shift F8 82 Alt ‘ 10 Alt Ω 3D r3 5C Shift F9 83 Alt ¡ 11 Alt W 3E r4 5D Shift F10 84 Ctrl PgUp 12 Alt E 3F r5 5E Ctrl F1 # 85 F11 13 Alt R 40 R6 5F Ctrl F2 # 86 F12 14 Alt T 41 R7 60 Ctrl F3 # 87 Shift F11 15 Alt Y 42 R8 61 Ctrl F4 # 88 Shift F12 16 Alt U 43 R9 62 Ctrl F5 # 89 Ctrl F11 17 Alt I 44 R10 63 Ctrl F6 # 8A Ctrl F12 18 Alt O 47 None 64 Ctrl F7 # 8B Alt F11 19 Alt F @ 47 “None” 65 Ctrl F8 # 8C Alt F12 * 1A Alt [ 48 ↑ 66 Ctrl F9 # 8D Ctrl “↑” * 1B Alt ] @ 48 “↑” 67 Ctrl F10 # 8E Ctrl “-” * 1C Alt Intro 49 PgUp 68 Alt F1 # 8F Ctrl “ذ” 1E Alt A @ 49 “PgUp” 69 Alt F2 # 90 Ctrl “↑” 1F Alt S * 4A Alt “-“ 6A Alt F3 # 91 Ctrl “↓” 20 Alt D 4B ß 6B Alt F4 # 92 Ctrl “Ins” 21 Alt r @ 4B “ß” 6C Alt F5 # 93 Ctrl “Del” 22 Alt G * 4C “5” 6D Alt F6 # 94 Ctrl Tab 23 Alt H 4D à 6E Alt F7 # 95 Ctrl “/” 24 Alt J @ 4D “à” 6F Alt F8 # 96 Ctrl “*” 25 Alt K * 4E Alt “+” 70 Alt F9 # 97 Ctrl “Home” 26 Alt L 4F End 71 Alt F10 # 98 Ctrl “ß” * 27 Alt Ñ @ 4F “End” 72 Ctrl Ptr # 99 Ctrl “à” * 28 Alt 50 ↓ 73 Ctrl ß # 9F Ctrl “End” * 29 Alt \ @ 50 “↓” 74 Ctrl à # A0 Ctrl “↓” * 2B Alt 51 PgDn 75 Ctrl End # A1 Ctrl “PgDn” 2C Alt z @ 51 “PgDn” 76 Ctrl PgDn # A2 Ctrl “Ins” 2E Alt x 52 Ins 77 Ctrl Home # A3 Ctrl “Del” 2F Alt c @ 52 “Ins” 78 Alt 1 # A4 Ctrl “/” 30 Alt v 53 Del 79 Alt 2 # A5 Ctrl Tab 31 Alt N @ 53 “Del” 7A Alt 3 # A6 Ctrl “Intro” 32 Alt M 54 Shift F1 7B Alt 4 * 33 Alt , 55 Shift F2 7C Alt 5 * 34 Alt . 56 Shift F3 7D Alt 6 57 Shift F4 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.

71

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:

72

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:

73

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

74

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,

75

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:

76

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:

77

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).

78

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:

79

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

80

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

81

• 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

82

• 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

83

• 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

84

• 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:

85

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)

86

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

87

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.

88

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.

89

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.

90

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.

91

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

92

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

93

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.

94

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

95

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.

96

Figura 3.3.7-3 Montaje de elementos impresos Figura 3.3.7-4 Visualización a contra luz

97

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.

98

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

99

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 Valor 4 R1-P1, R1-P2, R2-P1, R2-P2 330 10 Condensadores 1 C1-F 100uF

4 C1-MAX, C2-MAX, C3-MAX, C4-MAX 1uF

4 C1-P1, C1-P2, C2-P1, C2-P2 33pF 1 C2-F 10uF 19 Diferentes dispositivos 1 CI7805 7805

3 CONN-RJ11,CONN-TECLADO1, CONN-TECLADO2

CONN-H4

2 CONN-VDD-F, CONN-VDD-PIC CONN-H2

2 CRYSTAL-P1, CRYSTAL-P2 20Mhz

100

5 LED-F, LED1-P2, LED1_P1, LED2-P1, LED2-P2

DIODE-LED

1 MAX232 MAX232 2 PIC_1, PIC_2 PIC16F628A 2 R-MCLR_1, R-MCLR_2 1 RES_LED 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

101

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.

102

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

Entrada de señal Señal RS232 Señal TTL

Señal de habilitación

Módulo teclado MAX232 Concentrador PIC16F628A

Video Figura 3.4.2-2 Diagrama de bloque



103

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

104

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

105


PIC 16F628A

Salidas---------------------- RBO | RB7---------------------

Entrada----------------------RB0 (Control)

Video

RA0 + RC0

PIC18F2525

Entradas---------------------- RB0 | RB6 RB7 (GND)---------------------- Salidas---------------------- RA1 | RA4---------------------- RA0 + RC0

Receptor

Concentrador

RBO de cada pic

señales

control

Televisor


Elementos del módulo

Materiales para MODULOS VIDEO – FUENTE - RECIBIR DATO DE RED 8 Resistencias

Cantidad Referencia Valor 4 R1, R1-P1, R1-P2, R2 1k 1 R1-F 330 1 R1-V 910 1 R2-V 450 1 R3-V 78 20 Condensadores 8 C1, C1-M, C2, C2-M, C3, C3-M, C4, C4-M 1uF

10 C1-P1, C1-P2, C1-V, C2-P1, C2-P2, C2-V, C5-C8 33pF

1 C1_F 47uF 1 C2-F 100uF 2 Diodos

106

1 D2 1N4148 1 D2-F LED 30 Dispositivos diferentes 1 CI-7805 7805

9

CONECTOR_VIDEO,CONN-RA1-RA2, CONN-RS232, FUENTE, FUENTE_VIDEO, PIN-RA1-RA2, PIN-RA3-RA4, VOLTAJE VDD-F, VOLTA_12V

CONN-SIL2

1 CONN-12V CONN-SIL1

5 CONN-PUER-B, CONN-PUER-B1-CONN-PUER-B4

CONN-SIL7

5 CRYSTAL-PIC1, CRYSTAL-PIC2, CRYSTAL-V, X1, X2

20MHZ

1 DZ_5.1V 1N5357BRL 2 MAX232-2, MAX232_1 MAX232 1 MRCL-V 1k 4 PIC-1, PIC-2, PIC3, PIC4 PIC16F628A 1 VIDEO PIC18F2525

Esquema módulo recibir datos, video (vista componentes)

Figura 3.4.3-4 Disposición de elementos de video, red y fuente

107

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.

108

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

109

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

110

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


delay_us(26);

delay_cycles(4);


111

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

*/


delay_us(2);

delay_cycles(1);


delay_us(28); //29,2-1(Ciclo Entrada al For)=28,2

delay_cycles(1);

for(i=1;i<=p;i++)


delay_us(2);

delay_cycles(1);


delay_us(28); //29,2 - 1,2(Ciclo Intermedio del For)= 28


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


delay_us(60); //60,8

delay_cycles(4);


112

//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.


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


delay_us(4);

delay_cycles(4);

//Front Porch + 0,2(Output)= 2,2us


delay_us(10);// tiempo sobrante o disponible + 1 del //Front Porch

delay_cycles(3);//2us-0,6(Decfsz y Goto)=1,4us

113

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

Bits 765 43210

Valor

Hexadecimal

Ancho

1 0 00000000 0x00

1 00011000 0x1C A

2 00100010 0x22 L

114

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


//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,

115

//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.

116

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.

117

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 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

118

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

119

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


delay_us(4);

delay_cycles(4);

//63,4-4,4-4,8-0,4-2,2=51,6us

120

//******************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

121

#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(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;

122

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)

123

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.

124

• ß: 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


0x200


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);

125

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

126

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);

127

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);

128

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) *******************

129

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

130

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.

131

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




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 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>

132

//******************** 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);


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


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

133

LeerDato();

ClasificarLetra();

Tratar_Letra();

Borrar_Screen11();

Borrar_Screen12();

Borrar_Screen13();

LlenarScreen();

//Linea 34

delay_us(4); //4,4 - GotoSalir(0,4) =4


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

134

Diagrama de Actividades

Figura 3.4.4-4 Diagrama de actividades

135

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.

136

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

137

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

138

Diagrama de Actividades

Figura 3.4.4-7 Diagrama de actividades

Diagrama de secuencia

Figura 3.4.4-8 Diagrama de secuencias

139

CAPITULO IV

Software

140

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 un programador de PIC) un

microcontrolador de 6, 8, 18 ó 40 pines.

141

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.

142

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

143

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.

144

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

145

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

146

Los operadores aritméticos se usan para realizar operaciones matemáticas.

Se listan en la siguiente tabla:


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

147

• 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.

148


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:


Figura 4.1.3-7 Cuadro de desplazamiento de bit

• Expresiones

Figura 4.1.3-8 Cuadro de representación de formatos

149

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

150

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.

151

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:

152

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)

153

• #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

154

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

155

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');

);

156

• 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( " ---------- " );

157

• 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);

158

• 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(); // en la variable keypress se guardan los caracteres

if (!input(PIN_B2)) // 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)

159

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 ) // comprobamos si es '1' el MSB

output_low(pin_A0); // 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.

160

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.

161

Ejemplos:

#use delay (clock=4000000) // reloj de 4MHz

delay_ms( 2 ); // 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:


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 */

162

• 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 );

163

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.

164

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.

165

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.

166

CAPITULO V

Implementación y Resultados

167

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.

168

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

169

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.

DESCRIPCIÓN COSTO CANTIDAD

PRECIO

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

170

CAJAS TECLADO 4 2 8

CAJAS VIDEO 7 1 7

RESISTENCIAS 0,25 20 5

CONECTORES

PS/2 0,5 4 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 150

COSTOS DE MANO 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.

171

CAPITULO VI

Conclusión

172

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

173

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.

174

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


175

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


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


http://conket.com/modules.php?name=Downloads&d_op=viewdownload&cid=3

http://216.239.39.104/translate_c?hl=es&u=http://www.rickard.gunee.com/proje

176

Este sitio ofrece artículos sobre distintos proyectos con pic’s.

5.- Como es una señal de video

http://www.hardcore-

modding.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


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.

http://www.hardcore

http://es.wikipedia.org/wiki


177

ANEXOS

.

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) #use fixed_io(a_outputs=PIN_A0,PIN_A1,PIN_A2,PIN_A3) #use fixed_io(b_outputs=PIN_B5) #use rs232(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// //*********************BORRAR UNA 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 = 3,4us// //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); //****************************************************************************************************** //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// //*********************BORRAR UNA 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// //*********************BORRAR UNA 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 = 3,4us// //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); //****************************************************************************************************** //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); //******************************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 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// //*********************BORRAR UNA 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_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 FSR0H CLRF FSR0L CLRF FSR1H CLRF 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ÑO 2******************************************* //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*/

UNIVERSIDAD POLITÉCNICA SALESIANA - …dspace.ups.edu.ec/.../123456789/4655/1/UPS-ST000363.pdf3.4.2...

Documents

Transcript of UNIVERSIDAD POLITÉCNICA SALESIANA - …dspace.ups.edu.ec/.../123456789/4655/1/UPS-ST000363.pdf3.4.2...