lectura y gestión de códigos de barras con...

Lectura y gestión de códigos de barras con microcontrolador

AUTOR: Francisco Pelegrí Santamaría DIRECTOR: Jose Luis Ramírez Falo

FECHA: Enero / 2007.

2

ÍNDICE CONTENIDOS 3 FIGURAS 6 TABLAS 7 ÍNDICE DE CONTENIDOS 1 MEMORIA DESCRIPTIVA __________________________________________7

1.1 ANTECEDENTES __________________________________________________ 8

1.2 OBJETIVOS DEL PROYECTO _______________________________________ 8

1.3 RESUMEN ________________________________________________________ 9

1.4 TITULAR _________________________________________________________ 9

1.5 CÓDIGOS DE BARRAS ____________________________________________ 10 1.5.1 Introducción___________________________________________________________ 10 1.5.2 Tipos de simbología _____________________________________________________ 10 1.5.3 Código EAN/UPC ______________________________________________________ 13

1.5.3.1 Prefijo del País ____________________________________________________ 14 1.5.3.2 Número de Fabricante y Número de Articulo______________________________ 15 1.5.3.3 Digito Verificador __________________________________________________ 15 1.5.3.4 Especificaciones ___________________________________________________ 16 1.5.3.5 Tabla de Codificación de cada Digito____________________________________ 17 1.5.3.6 Zonas Mudas______________________________________________________ 18 1.5.3.7 Separadores_______________________________________________________ 18 1.5.3.8 Magnificación _____________________________________________________ 18

1.5.4 Conclusiones __________________________________________________________ 19

1.6 POSIBLES SOLUCIONES Y SOLUCIÓN ADOPTADA __________________ 19 1.6.1 Entorno ______________________________________________________________ 19 1.6.2 Lenguaje de programación ________________________________________________ 20 1.6.3 Interfaz PC – dispositivo__________________________________________________ 20 1.6.4 Tipo de lector __________________________________________________________ 21 1.6.5 Procesamiento de la información ___________________________________________ 22 1.6.6 Microcontroladores______________________________________________________ 23

1.7 DESCRIPCIÓN GENERAL _________________________________________ 24 1.7.1 Esquema global ________________________________________________________ 24 1.7.2 Composición del sistema _________________________________________________ 25

1.7.2.1 Circuito sensor ____________________________________________________ 25 1.7.2.1.1 Descripción ____________________________________________________ 25 1.7.2.1.2 Características __________________________________________________ 26 1.7.2.1.3 Descripción de funcionamiento ______________________________________ 26

1.7.2.2 Circuito del microcontrolador PIC ______________________________________ 28 1.7.2.3 Comunicación entre lector y PC________________________________________ 28 1.7.2.4 Entorno del PC ____________________________________________________ 29

1.8 ESPECIFICACIONES TÉCNICAS ___________________________________ 29 1.8.1 Entorno ______________________________________________________________ 29 1.8.2 Interfaz_______________________________________________________________ 29 1.8.3 Suministro eléctrico _____________________________________________________ 30 1.8.4 Microcontrolador _______________________________________________________ 31 1.8.5 Sensor _______________________________________________________________ 31 1.8.6 Códigos de barras _______________________________________________________ 32

3

1.9 ENTORNO DE TRABAJO __________________________________________ 32 1.9.1 Compilador ___________________________________________________________ 32 1.9.2 Software de grabación ___________________________________________________ 35 1.9.3 Hardware de grabación___________________________________________________ 38

2 MEMORIA DE CÁLCULO __________________________________________40

2.1 SUMINISTRO NECESARIO ________________________________________ 41

2.2 REGULACIÓN DEL SENSOR CNY70 ________________________________ 42 2.2.1 Calculo de resistencias de polarización del CNY70 ______________________________ 42 2.2.2 Sistema nuevo de lectura para la distinción de barras y espacios ____________________ 44

2.2.2.1 Calculo experimental de las resistencias en el nuevo sistema de lectura __________ 45

2.3 REGULACIÓN DE LA LECTURA DE CÓDIGOS DE BARRAS ___________ 51 2.3.1 Características de los códigos de barras_______________________________________ 51 2.3.2 Muestreo _____________________________________________________________ 51 2.3.3 Precisión del sensor y anchura de las barras ___________________________________ 51 2.3.4 Tamaño de los códigos de barras____________________________________________ 53 2.3.5 Reflectancia del material y los códigos de barras________________________________ 53 2.3.6 Conclusiones finales sobre la lectura de códigos de barras_________________________ 54

2.4 CORRIENTE POR LOS DIODOS LED SEÑALIZADORES _______________ 54

2.5 CALCULO TEORICO EL CONSUMO DE CORRIENTE DEL DISPOSITIVO 56 2.5.1 Consumo de los diferentes elementos del dispositivo_____________________________ 56 2.5.2 Consumo de corriente máximo del dispositivo _________________________________ 57 2.5.3 Consumo de corriente medio del dispositivo ___________________________________ 57 2.5.4 Duración de la pila ______________________________________________________ 58 2.5.5 Calculo del número de lecturas que el dispositivo es capaz de realizar con una pila ______ 59

3 DESARROLLO DEL SISTEMA FÍSICO _______________________________61

3.1 ALIMENTACIÓN EXTERNA _______________________________________ 62 3.1.1 Aplicación y propósito de la conexión de pilas en paralelo en el proyecto _____________ 62 3.1.2 Montaje de las pilas en el lector ____________________________________________ 62 3.1.3 Conexión de la doble alimentación __________________________________________ 63

3.2 SENSOR _________________________________________________________ 64 3.2.1 Conexionado del sensor con la placa PCB_____________________________________ 64 3.2.2 Conexión del sensor con las resistencias de polarización y el microcontrolador_________ 66 3.2.3 Motivos de diseño del conexionado con la placa PCB ____________________________ 67 3.2.4 Modo de empleo del sensor en las lecturas ____________________________________ 68

3.3 ENTORNO DEL MICROCONTROLADOR ____________________________ 70 3.3.1 Cristal oscilador de cuarzo ________________________________________________ 71 3.3.2 Pulsadores e interruptores_________________________________________________ 72

3.4 COMUNICACIÓN MICROCONTROLADOR-PC _______________________ 73 3.5 DISEÑO PCB _____________________________________________________ 74

3.5.1 Diseño del circuito impreso _______________________________________________ 75 3.5.2 Fabricación y montaje del PCB_____________________________________________ 78

4 DESARROLLO DEL SISTEMA INFORMÁTICO ________________________79

4.1 ESQUEMA Y DIAGRAMAS DEL SISTEMA ___________________________ 80 4.1.1 Flujograma general______________________________________________________ 80 4.1.2 Flujograma de la adquisición de datos del PIC a través del sensor ___________________ 81 4.1.3 Detección del inicio y final del código de barras ________________________________ 82 4.1.4 Decodificación de los datos obtenidos para obtener los números EAN________________ 84

4.1.4.1 Explicación general de la decodificación _________________________________ 84 4.1.4.2 Obtención de los máximos y mínimos valores _____________________________ 85 4.1.4.3 Clasificación de los máximos y mínimos en grupos _________________________ 86 4.1.4.4 Asociación de cada par de números a números del estándar EAN _______________ 90

4

4.1.4.5 Detección y corrección de errores ______________________________________ 91 4.1.5 Transferencia de datos del PIC al PC ________________________________________ 93

4.2 PROGRAMACIÓN DE LA APLICACIÓN EN EL PIC ___________________ 94 4.2.1 El compilador y las librerías _______________________________________________ 94 4.2.2 Funciones utilizadas para la lectura y comunicación USB _________________________ 94 4.2.3 Funciones utilizadas para la comunicación USB ________________________________ 96

4.3 PROGRAMACIÓN DE LA APLICACIÓN EN EL PC ___________________ 101 4.3.1 El compilador utilizado y las librerías ______________________________________ 101 4.3.2 Funciones importantes del programa para la gestión y comunicación USB____________ 101 4.3.3 Proceso de instalación del programa y drivers necesarios ________________________ 105 4.3.4 Estética del programa ___________________________________________________ 107

5 PRESUPUESTO _________________________________________________108

5.1 Introducción _____________________________________________________ 109 5.2 Coste de recursos hardware _________________________________________ 109

5.3 Coste de recursos software__________________________________________ 110

5.4 Coste de componentes y fabricación del PCB ___________________________ 110 5.5 Coste de recursos humanos _________________________________________ 112

5.6 Coste total del proyecto ____________________________________________ 113

5.7 Estudio del coste del dispositivo en el mercado __________________________ 113

6 CONCLUSIONES Y TRABAJO FUTURO _____________________________116

6.1 Conclusiones_____________________________________________________ 117

6.2 Trabajo futuro ___________________________________________________ 118

7 ANEXOS _______________________________________________________119

7.1 CÓDIGO FUENTE _______________________________________________ 120 7.1.1 Código del microcontrolador _____________________________________________ 120 7.1.2 Fichero .INF__________________________________________________________ 140 7.1.3 Código de la aplicación en el PC___________________________________________ 142

7.2 MANUAL DE USUARIO___________________________________________ 155 7.2.1 Instalación del dispositivo________________________________________________ 155 7.2.2 Utilización del dispositivo _______________________________________________ 156 7.2.3 Instalación de la aplicación_______________________________________________ 157 7.2.4 Utilización de la aplicación_______________________________________________ 157

7.3 BIBLIOGRAFÍA _________________________________________________ 160 7.3.1 Libros_______________________________________________________________ 160 7.3.2 Páginas web __________________________________________________________ 161 7.3.3 Datasheet’s___________________________________________________________ 162

5

ÍNDICE DE FIGURAS Figura 1.1. Código UPC normal..........................................................................................................................10 Figura 1.2. Código EAN-13...................................................................................................................................11 Figura 1.3. Código 39 ............................................................................................................................................11 Figura 1.4. Código Codabar..................................................................................................................................11 Figura 1.5. Código ITF 2 de 5...............................................................................................................................11 Figura 1.6. Código ISBN (Internacional Standard Book Number).....................................................................11 Figura 1.7. Código Pharmacode...........................................................................................................................11 Figura 1.8. Código Postnet....................................................................................................................................11 Figura 1.9. Código de segunda dimensión Maxicode..........................................................................................12 Figura 1.10. Código de segunda dimensión Datamatrix.....................................................................................12 Figura 1.11. Código de segunda dimensión PDF 417.........................................................................................12 Figura 1.12. Código EAN13 donde se separan los diferentes elementos para su comprensión.......................16 Figura 1.13. Separadores en códigos EAN/UPC................................................................................................18 Figura 1.14. Gráfico comparativo de microcontroladores de diferentes marcas.............................................23 Figura 1.15. Esquema global del conexionado entre dispositivos......................................................................24 Figura 1.16. Vista axonométrica del sensor CNY70............................................................................................25 Figura 1.17. Vista en planta del censor CNY70...................................................................................................26 Figura 1.18. Esquema del perfil del sensor CNY70.............................................................................................26 Figura 1.19. Esquema electrónico básico del sensor con una superficie reflectante........................................27 Figura 1.20 Esquema eléctrico del circuito del lector.........................................................................................28 Figura 1.21. Vista principal del compilador PCWH ...........................................................................................33 Figura 1.22. Editor de código................................................................................................................................34 Figura 1.23. Editor de código con la ventana de compilación ...........................................................................34 Figura 1.24. Vista del programa Winpic800........................................................................................................35 Figura 1.25. Vista de Winpic800 con la selección del modelo microcontrolador.............................................36 Figura 1.26. Selección del Hardware de grabación en el Winpic800................................................................36 Figura 1.27. Vista del programa PIC en datos hexadecimales...........................................................................37 Figura 1.28. Vista del programa grabado con éxito en el PIC...........................................................................37 Figura 1.29. Hardware de grabación GTP-USB+...............................................................................................38 Figura 1.30. Conexión del GTP-USB+, a través del ICSP, con los pines del PIC 18F2550............................39 Figura 2.1. Esquema eléctrico del circuito de doble alimentación.....................................................................41 Figura 2.2. Esquema eléctrico del circuito con el sensor CNY70.......................................................................42 Figura 2.3 Esquema eléctrico del sensor con el microcontrolador y el transistor de conmutación................44 Figura 2.4 Gráficas de resultados medios de la tabla 2.1...................................................................................46 Figura 2.5 Gráficas de resultados medios de la tabla 2.2...................................................................................47 Figura 2.6 Gráficas de resultados medios de la tabla 2.3...................................................................................48 Figura 2.7 Gráfica de diferencias entre grosores de barras...............................................................................49 Figura 2.8 Gráfica de diferencias entre grosores deespacios.............................................................................49 Figura 2.9. Ejemplo del paso del los infrarrojos del sensor sobre una línea negra..........................................52 Figura 2.10. Relación entre la corriente del CNY70 y el ángulo en que la radiación infrarroja es emitida. .52 Figura 2.11. Relación entre la corriente del CNY70 y la distancia a la que se encuentra de una superficie. 53 Figura 2.12. Colores de los códigos de barras....................................................................................................54 Figura 2.13. Carácterísticas de físicas y circuitales de un LED.........................................................................54 Figura 3.1. Foto de conector para pila de 9V ......................................................................................................62 Figura 3.2. Circuito eléctrico de la conexión de la doble alimentación y el PIC 18F2550..............................63 Figura 3.3. Ejemplo de conexión de los cables del CNY70 con la placa PCB ..................................................64 Figura 3.4. Esquema eléctrico de la conexión del CNY con el conector de la placa PCB...............................65 Figura 3.5. Foto del conexionado real del CNY70 con un conector..................................................................65 Figura 3.6. Esquema electrico de la conexión entre el sensor y el PIC.............................................................66 Figura 3.7. Diseño hipotético de la carcasa del lector........................................................................................67 Figura 3.8. Diseño hipotético del lector incorporado en un guante...................................................................67 Figura 3.9. Posiciones del lector al realizar una lectura de un código de barras............................................68 Figura 3.10. Distancia de conmutación del CNY70.............................................................................................69 Figura 3.11. Grafico de la relación que tiene el CNY70 con el Switching distance/Distance A......................69 Figura 3.12. Distancia de conmutación dependiendo de la posición del sensor respecto a una línea negra .70 Figura 3.13. Esquema eléctrico de la conexión del cristal de cuarzo con los condensadores y el PIC ..........71 Figura 3.14. Conexión de los condensadores al PIC 18F2550...........................................................................72 Figura 3.15. Pulsadores.........................................................................................................................................72

6

Figura 3.16. Esquema del tipo de cable USB utilizado.......................................................................................73 Figura 3.17. Conectores tipo A (izquierda) y tipo B (derecha) del cable USB..................................................73 Figura 3.18. Vista alzada y frontal del conector macho USB de los dos tipos..................................................74 Figura 3.19. Vista frontal de los conectores USB macho y hembra de los dos tipos........................................74 Figura 3.20. Diseño PCB con las pistas y los componentes................................................................................76 Figura 3.21. Diseño PCB con solo las pistas en las dos capas...........................................................................77 Figura 3.22. Diseño PCB con las pistas y el plano de masa...............................................................................78 Figura 3.23. Diseño del fotolito final que va a la insoladora .............................................................................78 Figura 4.1. Ejemplo gráfico de la diferenciación entre distintos grosores de barras.......................................86 Figura 4.2. Ejemplo gráfico de la corrección de picos máximos y mínimos con “Window moving”..............88 Figura 4.3. Ejemplo gráfico de la corrección de ciertos errores de lectura......................................................92 Figura 4.4. Flujo de comunicaciones entre un dispositivo USB y el host ..........................................................96 Figura 4.5. Jerarquía de descriptores...................................................................................................................97 Figura 4.6. Flujo de comunicaciones entre un dispositivo USB y el host a través de los endpoints................98 Figura 4.7. Configuración eléctrica para el USB connection sense pin ............................................................99 Figura 4.8. Conexión de los pines del puerto USB con los pines del PIC 18F2550 .......................................100 Figura 4.9. Vista del “Administrador de tareas” con el dispositivo USB reconocido y funcionando...........106 Figura 4.10. Vista del programa que guarda y gestiona los datos recibidos del dispositivo USB.................107 Figura 7.1 Ventana de administrador de dispositivos con el lector Codematic reconocido por el sistema..155 Figura 7.2 Ventana principal de la aplicación CODEMATIC..........................................................................158 ÍNDICE DE TABLAS Tabla 1.1. Estructura de un código de barras EAN/UPC....................................................................................13 Tabla 1.2. Prefijos de países Asignados por la Organizacion EAN internacional............................................14 Tabla 1.3. Ejemplo de calculo del digito verificador para un código EAN/UPC..............................................15 Tabla 1.4. Asignación de los juegos de codificación para los dígitos de acuerdo al valor del décimo tercer digito........................................................................................................................................................................17 Tabla 1.5. Juegos de codificación para cada digito de acuerdo a las combinaciones determinadas por el decimotercer digito del código. En el caso del UPC el decimotercer digito es cero.........................................17 Tabla 1.6. Parámetros operativos del puerto USB 2.0 ........................................................................................29 Tabla 1.7. Parámetros operativos del 74L05 .......................................................................................................30 Tabla 1.8. Parámetros de la pila de 9V de la marca CEGASA...........................................................................30 Tabla 1.9. Parámetros eléctricos del puerto USB................................................................................................30 Tabla 1.10. Parámetros operativos del microcontrolador..................................................................................31 Tabla 1.11. Parámetros operativos del sensor CNY70.......................................................................................31 Tabla 1.12. Parámetros de un código de barras en el estándar EAN ................................................................32 Tabla 2.1. Tabla de resultados con diferentes resistencias de polarización del fototransistor y R1=82Ω ....46 Tabla 2.2. Tabla de resultados con diferentes resistencias de polarización del fototransistor y R1=330Ω ..47 Tabla 2.3. Tabla de resultados con diferentes resistencias de polarización del fototransistor y R1=180Ω ..48 Tabla 2.4. Consumo de corriente de los distintos modos de funcionamiento del PIC 18F2550.......................56 Tabla 2.5. Consumo teórico de los diferentes elementos del circuito.................................................................56 Tabla 3.1. Relación entre la frecuencia del cristal y el valor de los condensadores.........................................72 Tabla 3.2. Características dimensionales de la placa PCB ................................................................................76 Tabla 5.1. Coste de recursos hardware ..............................................................................................................109 Tabla 5.2. Coste de recursos software ................................................................................................................110 Tabla 5.3. Coste de los componentes y el PCB ..................................................................................................111 Tabla 5.4. Presupuesto del coste de tareas del ingeniero..................................................................................112 Tabla 5.5. Presupuesto del coste de tareas del técnico......................................................................................112 Tabla 5.6. Coste total de los recursos humanos.................................................................................................112 Tabla 5.7. Coste total del proyecto......................................................................................................................113 Tabla 5.8. Coste material del lector según las unidades producidas...............................................................114 Tabla 5.9. Tabla de ingresos según unidades vendidas.....................................................................................114

7

1 MEMORIA DESCRIPTIVA

1.1 ANTECEDENTES 1.2 OBJETIVOS DEL PROYECTO 1.3 RESUMEN 1.4 TITULAR 1.5 CÓDIGOS DE BARRAS 1.6 POSIBLES SOLUCIONES Y SOLUCIÓN ADOPTADA 1.7 DESCRIPCIÓN GENERAL 1.8 PRESCRIPCIONES TÉCNICAS 1.9 ENTORNO DE TRABAJO 1.10 RESUMEN DE PRESUPUESTO

8

1.1 ANTECEDENTES

El microcontrolador es uno de los logros más sobresalientes del siglo XX, año tras año, estos dispositivos se acercan más a nuestras vidas, haciéndose un sitio en el centro de cada máquina, de cada equipo electrónico. Dada su alta versatilidad, su facilidad de programación y su alto grado de integración, es posible dotar a casi cualquier objeto de cierta “inteligencia”, de sensorización y reacción con el entorno. El bajo coste de estos dispositivos hace surgir la idea de realizar un diseño de un objeto microcontrolado, al alcance de cualquiera con conocimientos. Esto provoca que el producto final tenga un precio muy reducido. Este proyecto requeriría aplicar muchos de los conceptos estudiados a lo largo de la carrera de ingeniería técnica electrónica, así como el estudio y aplicación de otros no abarcados por ella. Se ha aplicado conceptos de electrónica básica con conceptos de programación de microcontroladores, gestión de comunicaciones USB y la utilización de varios programas de software informático. La motivación de este proyecto es realizar un lector de códigos de barras de bajo coste capaz de leer con suficiente precisión uno de los tipos de códigos de barras más comerciales, el EAN/UPC. Y luego gestionar dicha información con el software del PC.

1.2 OBJETIVOS DEL PROYECTO

El objetivo del proyecto es diseñar y construir un dispositivo eficaz, práctico y económico que sea capaz de leer códigos de barras y gestionar la información por software de PC. La información será leída mediante un sensor de bajo coste el cual irá conectado a un microcontrolador.

Los elementos básicos de los que puede constar este dispositivo son un sensor que

capte las barras, un microcontrolador que gestione toda la información recibida de la señal del sensor y un ordenador que disponga de puerto USB por el cual se transmitirá la información leída por el lector y se muestre dicha información por pantalla.

A parte del ordenador, en la selección de los elementos se buscará una buena relación

calidad/precio, utilizando elementos de bajo coste como son el sensor y el microcontrolador.

9

1.3 RESUMEN

El desarrollo del trabajo se ha dividido en los siguientes apartados:

1 - MEMORIA DESCRIPTIVA

Se exponen los motivos y objetivos del proyecto, así como una visión global de las diferentes partes del proyecto.

2 - MEMORIA DE CÁLCULO Se muestran los cálculos previos antes de realizar el montaje, así como los rangos de funcionamiento ideales, etc.

3 - DESARROLLO DEL SISTEMA FÍSICO Se presenta y explica el funcionamiento del prototipo el cual consta de tres partes, la parte sensadora, la de alimentación, y la microcontrolada.

4 - DESARROLLO DEL CÓDIGO FUENTE Se explican los algoritmos realizados para el control del sistema y se muestra el código desarrollado y las librerías utilizadas para tal propósito.

5 - PRESUPUESTO Se muestra el coste total del proyecto, tanto por el precio del material utilizado, por el tiempo de trabajo en la realización del prototipo y el precio que tendría en el mercado.

6 - CONCLUSIONES Y TRABAJO FUTURO Se sacan conclusiones sobre el proyecto realizado y se proponen ideas para futuras mejoras o variantes que puede o podría tener el proyecto.

7 - ANEXOS

1.4 TITULAR

El titular del presente proyecto es: - Nombre: CodeMatic S.A. (Nombre de empresa inventado) - CIF: 98364457 H - Dirección: Pol. Ind. Francolí. Calle 5, Nav23. - Representante legal: Francisco Pelegrí Santamaría - Teléfono: (+34) 977 222 322

10

1.5 CÓDIGOS DE BARRAS

1.5.1 Introducción

El Código de Barras es una disposición en paralelo de barras y espacios que codifican la información contenida.

Los códigos de barras representan un método simple y fácil para codificación de información que puede ser leída por dispositivos ópticos, y luego traducida dicha información para nuestro entendimiento mediante el software del ordenador.

1.5.2 Tipos de simbología

Podría decirse que los códigos de barras vienen en muchas formas o presentaciones. Muchos nos son familiares porque los hemos visto en las tiendas, pero existen algunos otros que son estándares en varias industrias. La industria de la salud, manufacturas, almacenes, etc. tienen terminologías únicas para su industria y que no son intercambiables.

La existencia de varios tipos de códigos de barras, se debe a que las simbologías están diseñadas para resolver problemas específicos. De acuerdo al tipo de necesidad de identificación interna del negocio, de acuerdo con los requisitos que se deben cumplir para poder comerciar según las normas del mercado, se debe optar por el sistema de codificación mas adecuado. Es decir, existen diferentes simbologías para las diferentes aplicaciones, y cada una de ellas tiene características propias.

La selección de la simbología dependerá del tipo de aplicación donde va a emplearse el código de barras. El tipo de carácter, numérico o alfanumérico, la longitud de los caracteres, el espacio que debe ocupar el código o la seguridad, son algunos de los factores que determinarán la simbología a emplear. En la actualidad existen varios tipos de códigos de barras como el EAN/UPC, que es uno de los más populares comercialmente hablando. Los siguientes no son tan comerciales, pero se utilizan mucho: CÓDIGO 39, CODIGO 93, CÓDIGO 128, ENTRELAZASO 2 de 5, CODABAR, POSNET, etc. Para más información sobre ellos mirar en el apartado 7.3.2 del anexo.

Figura 1.1. Código UPC normal

11

Figura 1.2. Código EAN-13.

Figura 1.3. Código 39

Figura 1.4. Código Codabar

Figura 1.5. Código ITF 2 de 5

Figura 1.6. Código ISBN (Internacional Standard Book Number)

Figura 1.7. Código Pharmacode

Figura 1.8. Código Postnet

12

También existen tipos de simbologías llamadas códigos de barras de dos dimensiones o bidimensionales, los cuales son más seguros y pueden albergar mucha más información que los códigos de barras de una dimensión o unidimensionales. Los tipos de códigos de barras bidimensionales que existen son el PDF 417, MAXICODE, DATAMATRIX, etc.

Figura 1.9. Código de segunda dimensión Maxicode

Figura 1.10. Código de segunda dimensión Datamatrix

Figura 1.11. Código de segunda dimensión PDF 417

Para más información mirar en el apartado 7.3.2 del anexo, o visitar las siguientes paginas web: http://www.metrologicmexico.com/contenido/archivos/000054.shtml http://ciberhabitat.gob.mx/comercio/textos/texto_codbarras.htm http://www.monografias.com/trabajos11/yantucod/yantucod.shtml http://www.azalea.com/Spanish/UPC.html

El proyecto se centra en un tipo de código de barras, que pertenece a los de una dimensión, es el EAN/UPC. Nos centramos en este tipo de código por su popularidad y comercialización. De aquí en adelante nos centraremos en el código de barras EAN/UPC, para conocer su estructuración y sus partes más influyentes para poder tratarlo.

13

1.5.3 Código EAN/UPC

La simbología EAN/UPC es la mas usada en el mundo debido a que se utiliza en toda la mercancía que se vende al comercio. Este código fue adoptado por la industria de comercio detallista en 1973 y se ha extendido a alimentos, ropa, artículos de oficina, software, herramientas, productos farmacéuticos, productos eléctricos, libros, revistas y otros.

Originalmente el código se llamaba UPC (Universal Product Code) administrado por la UCC (Uniform Code Council). El código tiene 12 dígitos impresos, compuesto por un digito de sistema, 5 dígitos de número de fabricante, 5 dígitos para el número de producto y un digito verificador. Los números de fabricante los asigna directamente UCC.

Para satisfacer la demanda de códigos, la Organización EAN (European Article Numbering) realizó una modificación a la estructura para incluir un decimotercer digito. Esto se logra utilizando un juego adicional de codificación y combinando las tablas. Se ha mantenido una correspondencia entre las dos simbologías, donde la estructura de los códigos UPC son un subgrupo dentro de la numeración EAN. Con el paso del tiempo y debido a la limitada cantidad de números de fabricante que podía asignar la UCC, se unieron las dos organizaciones para tener un sistema único de codificación.

Debido a que la estructura de los códigos UPC y EAN siguen las mismas reglas solo trataremos el caso más general que es el código EAN.

Por definición un símbolo está compuesto por barras de color oscuro y espacios claros de diferentes anchos a los ojos del lector. Es importante mencionar que lo oscuro y lo claro es función del lector, ya que este necesita cierto contraste para poder decodificarlo.

En su forma general, un código de barras contiene cuatro campos principales, Prefijo de país, Número de fabricante, Número de artículo y Digito Verificador. El prefijo del País es asignado por la Organización EAN internacional. Después cada país determina la estructura particular a implementar para el número de fabricante y el número de artículo. Debido a que cada país asigna la longitud de campo para los fabricantes y artículos disponibles le recomendamos que consulte a la Autoridad encargada de la emisión de códigos de su país. Hay que recordar que el dueño de la marca es quien asigna el número que deberá llevar el producto.

En el siguiente ejemplo se usa el número 9701234567895 solo para fines

ilustrativos, en la realidad este número, de acuerdo a la tabla EAN de prefijos, no corresponde a ningún país.

Tabla 1.1. Estructura de un código de barras EAN/UPC.

Prefijo del Pais Número de Fabricante Número de Articulo Digito Verificador 970 12345 6789 5

14

1.5.3.1 Prefijo del País

Eholn la estructura EAN, dentro del código de barras se encuentra un prefijo que determina el país origen de las mercancías. Este prefijo lo asigna la organización EAN internacional. La tabla siguiente presenta una lista de los prefijos de países asignados y estará sujeta a cambio conforme se sumen más a la lista. A parte de los países, también están los prefijos utilizados para revistas, libros y cupones.

PREFIJO PAIS PREFIJO PAIS 00-09 USA 750 Mexico 10-19 RESERVADO 759 Venezuela 20-29 Uso interno 76 Suiza 30-37 Francia 770 Colombia 380 Bulgaria 773 Uruguay

40-44 Alemania 775 Peru 460-469 USSR 779 Argentina

471 Taiwan 780 Chile 489 HongKong 789 Brasil 49 Japon 80-83 Italia 50 Reino unido 84 España 520 Grecia 850 Cuba 529 Chipre 859 Checoslovaquia

54 Belgica y Luxemburgo

860 Yugoslavia

560 Portugal 869 Turkia 569 Islandia 87 Holanda 57 Dinamarca 880 Corea del sur 590 Polonia 885 Tailandia 599 Hungria 888 Singapur

600-601 Sudafica 90-91 Austria 611 Marruecos 93 Australia 619 Tunez 94 Nueva Zelanda 64 Finlandia 955 Malasia

70 Noruega 959 Papua, Nueva Guinea

729 Israel 977 Revistas 73 Suecia 978-979 Libros

740-745 Guatemala, Salvador, Honduras, Nicaragua, Costa Rica, Panama

98-99 Cupones

Tabla 1.2. Prefijos de países Asignados por la Organizacion EAN internacional.

15

1.5.3.2 Número de Fabricante y Número de Articulo

El número de fabricante lo asigna la Autoridad Reguladora del sistema de código de barras en cada país. El Número de Articulo lo asigna el fabricante de los productos. Las reglas que determinan la cantidad de dígitos a utilizar las proporciona la Autoridad Reguladora de cada país. En el ejemplo anterior el número de fabricante estará compuesto de 5 dígitos y el número de artículos por cuatro dígitos. Esto permite tener un máximo de 99,999 fabricantes con 9,999 artículos a codificar por cada fabricante.

En la realidad se encuentra que son muy pocos los fabricantes que requieren esta

gran cantidad de números. Por lo general la gran mayoría de empresas tienen menos de 1,000 productos en toda su existencia. Sin embargo hay ciertos giros industriales que requieren una cantidad muy grande de números. Entre ellos se encuentran los fabricantes de ropa donde se puede llegar a codificar por modelo, estilo, color y talla. Esta numeración ha determinado que las Autoridades Reguladoras hayan determinado diferentes esquemas de asignación de números para atender a una mayor cantidad de requerimientos.

1.5.3.3 Digito Verificador

El último digito es un digito verificador que garantiza que la lectura realizada en el código sea correcta. Este digito verificador se calcula con el algoritmo que se puede entender mejor con el siguiente ejemplo:

- Se suman los dígitos en posiciones pares y se multiplica por tres. - Se suman los dígitos de posiciones impares - Se suman las cifras anteriores y se restan de la decena superior - Dígito verificador es el resultado

Tabla 1.3. Ejemplo de calculo del digito verificador para un código EAN/UPC

Posición 13 12 11 10 9 8 7 6 5 4 3 2 1

Código sin V 9 7 0 1 2 3 4 5 6 7 8 9 V

Posiciones pares

7 + 1 + 3 + 5 + 7 + 9 =(7+1+3+5+7+9)*3=96

Posición non 9 + 0 + 2 + 4 + 6 + 8 =(9+0+2+4+6+8)*1=29

Suma =(96+29) = 125

Resta decena superior

V = 130 - 125 = 5

Código Final 9 7 0 1 2 3 4 5 6 7 8 9 5

16

1.5.3.4 Especificaciones

En esta sección se explica como esta estructurado un código de barras para la simbología EAN13 y UPCA. La estructura es sencilla de entender sabiendo que un código de barras solo contiene la identificación del número codificado. Usaremos durante toda la explicación el mismo ejemplo para el número 9701234567895. A continuación se presenta un código EAN13 con mucha magnificación y donde se han separado los diferentes números para un mejor entendimiento. El símbolo del código de barras EAN13 esta construido de 7 secciones:

- Zona Muda Izquierda - que consta de 13 módulos. - Separador Izquierdo - que consta de 3 módulos, negro, blanco, negro - Dígitos 12 al 6 - codificados según la tabla de combinaciones marcada por el

treceavo digito. - Separador central - que consta de 5 módulos, blanco, negro, blanco, negro,

blanco. - Dígitos 5 a 1 - Codificados con el juego de codificación C - Separador Derecho - que consta de 3 módulos, negro, blanco, negro - Zona Muda Derecha - que consta de 7 módulos.

Figura 1.12. Código EAN13 donde se separan los diferentes elementos para su comprensión

17

Los juegos de codificación usados están determinados por el decimotercer dígito del código según se encuentra en la tabla siguiente. Para nuestro ejemplo 9701234567895, el decimotercer dígito es 9 por lo que la codificación de cada dígito del lado izquierdo del código sea con los juegos de codificación ABBABACCCCCC.

JUEGOS DE CODIFICACIÓN PARA EL CÓDIGO EAN/UPC 13 Digito 12 11 10 9 8 7 6 5 4 3 2 1

0 A A A A A A 1 A A B A B B 2 A A B B A B 3 A A B B B A 4 A B A A B B 5 A B B A A B 6 A B B B A A 7 A B A B A B 8 A B A B B A 9 A B B A B A

C

Tabla 1.4. Asignación de los juegos de codificación para los dígitos de acuerdo al valor del décimo tercer digito.

1.5.3.5 Tabla de Codificación de cada Digito

Individualmente los dígitos se representan de acuerdo al juego de codificación usado en cada parte del código de barras. Un digito esta compuesto por 7 módulos en los cuales se asignan barras negras o blancas de acuerdo a la paridad que se requiera dar. La paridad es par si la cantidad de módulos negros es par. Existen tres juegos de códigos presentados en la Tabla 1.5 de acuerdo de donde se colocaran en el símbolo y están dados por el resultado de la Tabla 1.4.

Tabla 1.5. Juegos de codificación para cada digito de acuerdo a las combinaciones determinadas por el decimotercer digito del código. En el caso del UPC el decimotercer digito es cero.

Carácter Juego A (impar) Juego B (Par) Juego C (Par) 0

1

2

3

4

5

6

7

8

9

18

En el ejemplo de la figura 13 se pueden identificar todos los números con las tablas de codificación. Se ha amplificado un símbolo normal para poder identificarlo más fácilmente.

1.5.3.6 Zonas Mudas

Las zonas mudas son áreas en blanco que se deben dejar en ambos lados del código como mínimo. Estas áreas permiten que un lector de código de barras pueda determinar sin lugar a dudas donde empieza y donde termina un código. Es importante respetar estas áreas cuando se pone un código de barras en un objeto, sea un libro, una caja, etc. El código EAN/UPC define que debe de haber 11 módulos como mínimo del lado izquierdo del código de barras y 7 módulos mínimo del lado derecho del código de barras.

1.5.3.7 Separadores

Los separadores se usan para delimitar el código de la información. Estos separadores le proporcionan información a los lectores para saber de que tipo de código de barras están decodificando. En el caso del Código EAN / UPC se tiene un separador intermedio que es único en las simbologías de código de barras. A continuación se muestran los separadores.

Figura 1.13. Separadores en códigos EAN/UPC

1.5.3.8 Magnificación

En varias situaciones es necesario amplificar o reducir las dimensiones de un código de barras EAN/ UPC. La norma marca que las dimensiones nominales entre señales de encuadre son de 37.29mm de ancho por 20.26 mm de altura. Estas señales de encuadre se usan para delimitar el código de barras y que se evite invadir las zonas mudas. Desde la primera barra a la última barra el código debe medir 31.35mm x 22.85 mm.

Sobre estas dimensiones nominales se recomienda hacer códigos de barra con factores de magnificación que van del 80% al 200%. Cuanto más grande sea el código, mayor tolerancia tendrá en su impresión.

El ancho de la barra mas delgada en un código al 100% es de 0.33 mm es decir de 13 mils (milésimos de pulgada).

Datos Datos

19

1.5.4 Conclusiones

Como se ha podido ver, en el mercado existen muchos tipos de códigos de barras, con un uso específico para cada uno, aunque el más común y conocido es el EAN/UPC.

Por ejemplo, el CÓDIGO 39, CÓDIGO 93 y CÓDIGO 128 es usado para inventarios

y aplicaciones industriales. El ENTRELAZADO 2 de 5 para la industria de los envíos, el CODABAR es aplicado mayormente en los bancos de sangre. El POSTNET solo es usado para el servicio postal de EEUU. El PHARMACODE es utilizado en la industria farmacéutica.

En este proyecto solo nos centraremos en este tipo de código de barras, por ser el

más extendido comercialmente.

1.6 POSIBLES SOLUCIONES Y SOLUCIÓN ADOPTADA

1.6.1 Entorno

Para el entorno con el que tendría que interactuar el usuario se podría haber optado por uno de los siguientes:

1) LINUX 2) UNIX 3) MS-DOS 4) Microsoft WINDOWS

Se podría haber optado por utilizar un entorno en LINUX o UNIX pero dado que su

tasa de implantación en el mercado aun no esta consolidada no se podría llegar a la mayoría de la población.

MS-DOS es un entorno conocido por mucha gente pero está condenado a la desaparición, los inconvenientes que plantea, además de su desaparición, el costo en horas de programación que supone programar un entorno amigable para el usuario final en este sistema operativo, además del costo a la hora de programar comunicaciones con dispositivos externos mediante el puerto serie.

Por lo tanto, la solución adoptada es la de usar Microsoft Windows, un entorno conocido por gran parte del usuario medio. Entorno bastante extendido y que cuenta con buenas herramientas de programación.

20

1.6.2 Lenguaje de programación

Se ha optado por utilizar Microsoft Visual Basic, dado que el realizar entornos amigables para el usuario es una tarea bastante sencilla, con lo que se gana tiempo de programación para implementar las tareas realmente necesarias. Además gestionan eficientemente las comunicaciones con dispositivos externos mediante el puerto serie.

1.6.3 Interfaz PC – dispositivo

1) Puerto paralelo 2) Puerto PS/2 3) Puerto serie 4) Puerto Fire Wire 5) IrDA 6) Puerto USB

Se podría haber usado como interfaz entre el PC y el dispositivo actuador el puerto

paralelo del PC, pero este es un recurso bastante limitado y que normalmente esta ocupado por impresoras o scanners.

Se podría haber usado un puerto PS/2, pero habitualmente están ocupados por teclado y

ratón, por lo que resultaría bastante complicada su implantación en un sistema doméstico normal.

Usar puerto serie sería la opción más idónea que nos vendría primero a la mente, ya que es un puerto muy extendido en las comunicaciones entre dispositivos, pero poco a poco ha ido cediendo terreno al novedoso y ahora extendido puerto USB, que proporciona mejores prestaciones.

El puerto Fire Wire es un puerto creado por Apple y Sony, que comúnmente se utiliza para dispositivos digitales como videocámaras, cámaras de fotos digitales, etc. Es un puerto más rápido que el USB y proporciona más energía a los dispositivos conectados a él, hasta 45W, aunque el número de dispositivos que se pueden conectar es un total de 63, menos que el USB que se pueden conectar hasta 127. Hoy por hoy es un puerto no tan conocido que el USB, pero ofrece mejores prestaciones.

El puerto IrDA es un puerto que está experimentando un auge dada la amplia gama de

dispositivos portátiles que disponen de la posibilidad de comunicar mediante infrarrojos, pero de todos modos aun no cuenta con una implantación elevada y la interfaz de la adaptación a los PC’s convencionales es sustancialmente más cara que otras posibles soluciones.

Por lo tanto, la solución adoptada es utilizar puerto USB, por que es un puerto muy

extendido y hace que la practica con el ordenador sea muy fácil para el usuario. Solo tienes que conectar el dispositivo y el sistema operativo (si es Windows XP) reconocerá el dispositivo. Esto es una buena idea para nuestro lector, ya que dará más facilidad de utilización. Además, ahora con la aparición de USB2.0 se ha convertido en un puerto de comunicación muy rápido, y no presenta problema de compatibilidad con el

21

microcontrolador, ya que existe una familia de microcontroladores PIC que soportan este tipo de conexión serie, una compatibilidad que no he encontrado con el FireWire.

1.6.4 Tipo de lector

Para leer los códigos de barras hay diferentes sistemas. Todos se basan básicamente en la diferencia de reflexión de luz que incide sobre el blanco y el negro. Los tipos de lectores son los siguientes:

1) Tipo pluma 2) De ranura 3) Tipo rastrillo o CCD 4) CCD de proximidad 5) Láser de proximidad 6) Láser tipo pistola 7) Láser fijos 8) Láser omnidireccionales

El lector de tipo pluma o lápiz tiene la ventaja que tiene un tamaño reducido y bajo

coste, pero requieren una cierta habilidad por parte del usuario, a veces se requiere hacer más de una lectura hasta llegar a leer el código. Van bien en códigos impresos de gran calidad. Los sensores utilizados en los de tipo pluma podrían ser los utilizados en los robots rastreadores que siguen una línea negra o blanca por ejemplo. El lector de ranura es el mismo sistema que el de pluma, pero la parte móvil es el código de barras, tiene más probabilidad de leer el código que con el de pluma, pero es menos práctico.

Los lectores de tipo rastrillo o CCD son lectores de contacto que emplean un fotodetector CCD (Dispositivo de Carga Acoplada) formado por una fila de LED’s que emite múltiples fuentes de luz y forma un dispositivo similar al encontrado en las cámaras de video. En los lectores CCD de proximidad el escaneo es completamente electrónico, como si se tomase una fotografía al código. No se requiere hacer contacto físico con el código pero debe hacerse a corta distancia. Tiene problemas de lectura en superficies curvas o irregulares. A diferencia de los tipo pluma no hay movimiento que degrade la imagen al escanearla.

Los lectores láser de proximidad requieren poca distancia del lector al objeto pero tienen mejor “performance” que los CCD debido a su potente luz láser. Estos dispositivos láser tienen mejores resultados en superficies curvas o irregulares.

Los lectores láser tipo pistola usan un mecanismo activador el escáner para prevenir la lectura accidental de otros códigos dentro de su distancia de trabajo. Un espejo rotatorio u oscilatorio dentro del equipo mueve el haz de un lado a otro a través del código de barras, de modo que no se requiere movimiento por parte del operador, éste solo debe apuntar y disparar. Por lo general pueden leer códigos estropeados o mal impresos, en superficies irregulares o de difícil acceso, como el interior de una caja. Más resistentes y aptos para ambientes más hostiles. El lector puede estar alejado de 2 a 20 cm del código,

22

pero existen algunos lectores especiales que pueden leer a una distancia de hasta 30 cm, 1,5 metros y hasta 5 metros.

Los lectores láser fijos son básicamente lo mismo que el tipo anterior, pero montados en una base. La ventana de lectura se coloca frente al código a leer (generalmente se orientan hacia abajo) y la lectura se dispara al pasar el artículo que contiene el código frente al lector y activarse un censor especial.. Esta configuración se encuentra frecuentemente en bibliotecas ya que libera las manos del operador para que pueda pasar el libro frente al lector. También se utiliza en sistemas automáticos de fábricas y almacenes, donde el lector se coloca sobre una banda transportadora y lee el código de los artículos que pasan frente a él.

Los lectores láser fijos omnidireccionales se encuentran normalmente en las cajas de supermercados. El haz de láser se hace pasar por un conjunto de espejos que generan un patrón ominidireccional, otorgando así la posibilidad de pasar el código en cualquier dirección. Los productos a leer se deben poder manipular y pasar a mano frente al lector. Recomendados cuando se requiere una alta tasa de lectura.

La solución adoptada en este caso es el lector de tipo pluma, debido a su reducido coste y practicidad, puesto que los lectores de tipo láser son relativamente caros si comparamos con el objetivo del proyecto que es construir un lector económico, practico, eficaz y eficiente. Eso lo conseguiremos con un sensor de reflexión de infrarrojos famoso en la robotica, el CNY70. Los sensores CCD podrían haber sido una buena solución, pero al montar el aparato habría que construirlo en las dimensiones de los códigos de barras que vayan a leer, esto reduce el rango de variedad de códigos de barras a leer, y también habría que tener en cuenta que se debe utilizar un sensor de imagen y tratar la imagen capturada, que conlleva mucho software de tratamiento de imagen.

1.6.5 Procesamiento de la información

1) Microprocesador 2) Microcontrolador con juego reducido de instrucciones

Se podría haber optado por utilizar un microprocesador, pero dado el tipo de

instrucciones a implementar sería sobredimensionar el circuito, además estos dispositivos son mucho más caros y requieren que se dispongan varios elementos externos, como pueden ser memoria de programa e interfaz entrada/salida.

Por lo tanto se ha optado por utilizar un microcontrolador con arquitectura de juego reducido de instrucciones dado que el juego de instrucciones de que dispone es más que suficiente para las operaciones que se van a realizar. Además su coste es relativamente bajo y tiene la memoria de programa y el interfaz I/O integrados.

23

1.6.6 Microcontroladores

Hoy en día hay una enorme cantidad de productos que funcionan en base de un microcontrolador o varios. La variedad de microcontroladores es grande, y debemos elegir bien el nuestro para nuestro dispositivo. Esta es una muestra de las marcas que fabrican microcontroladores:

1) MICROCHIP 2) NATIONAL SEMICONDUCTOR 3) MOTOROLA 4) ZILOG 5) INTEL 6) THOMSON

Un estudio comparativo entre microcontroladores de estas marcas nos muestra las

diferencias entre microcontroladores de mismas características pero de diferentes marcas. Esto nos ayudará a ir descartando posibilidades. El estudio consiste en hacerles pasar una serie de pruebas una de las cuales es el tamaño promedio que ocupa el código de los programas de prueba, que son los siguientes:

- Empaquetamiento de dos dígitos BCD. - Control de un bucle que decrementa un contador hasta cero. - Transmisión síncrona por desplazamiento en serie de 8 bits. - Temporizador software de 10 ms. - Exploración de un bit y salto si vale 1.

Figura 1.14. Gráfico comparativo de microcontroladores de diferentes marcas

Esta gráfica hace decantarme por los microcontroladores de MICROCHIP como

primera opción.

Una vez echado un vistazo a los microcontroladores MICROCHIP y las posibilidades que ofrece obtengo las siguientes conclusiones. Tengo más acceso a las herramientas de programación y grabación de microcontroladores de MICROCHIP que de

MICROCHIP NATIONAL MOTOROLA ZILOG INTEL THOMSON

TAMAÑO DE MEMORIA OCUPADA RELATIVA

VELOCIDAD DE EJECUCIÓN RELATIVA

24

otro tipo de microcontroladores. Además, puedo programarlos en un lenguaje que domino, como es el C.

Por último, MICROCHIP ha sacado una nueva gamma de microcontroladores PIC

capaces de trabajar con la comunicación USB, y con sus respectivos drivers. Adquirir los drivers es totalmente gratuito, y esta gamma de microcontroladores se puede adquirir a modo de SAMPLE, es decir, gratuito también, pidiendo un máximo de 4 a MICROCHIP. Aunque no fuesen gratuitos, el precio de estos oscila sobre los 5 €, es un precio bastante asequible.

Por lo tanto, la solución adoptada es la de usar microcontroladores PIC de la marca MICROCHIP.

1.7 DESCRIPCIÓN GENERAL

1.7.1 Esquema global

Este proyecto se basa en la transferencia de los datos de un código impreso a un PC convencional a través de unos pocos dispositivos de bajo coste. Para tal fin el montaje debe seguir el esquema mostrado por la figura siguiente.

Figura 1.15. Esquema global del conexionado entre dispositivos.

CÓDIGO DE BARRAS

LECTOR TIPO PLUMA CON EL MICROCONTROLADOR

CABLE DE CONEXIÓN USB ORDENADOR DONDE SE

GESTIONA LA INFORMACIÓN LEÍDA POR EL LECTOR

PC

25

1.7.2 Composición del sistema

1.7.2.1 Circuito sensor

1.7.2.1.1 Descripción

Esta es la primera etapa de todo el conjunto, y de las partes más importantes, por que serán nuestros ojos, y tenemos que cerciorarnos de que no nos engañe lo que ve, hay que calibrarlo bien.

Para la lectura de los códigos de barras utilizamos el sensor de reflexión CNY70,

dispositivo famoso en el mundo de la robótica móvil, ya que es utilizado para distinguir entre el blanco y el negro. Tiene una calidad y resolución elevada para lo económico que sale la compra de una unidad.

En esta etapa se trata de percibir, con la mayor apreciación posible, la anchura de

las barras blancas y negras. Gracias al sensor de reflexión recibiremos más o menos señal dependiendo de la zona reflectada: si es una zona negra se refleja menos infrarrojos que si fuese una zona blanca, ya que el negro absorbe más energía que el blanco. Pues ajustando bien el foco de emisión y recepción de infrarrojos, y con una programación adecuada en la adquisición de los datos, podremos saber con exactitud el ancho de las barras y poder realizar una lectura correcta y fiable.

El CNY70 tiene una construcción compacta y de tamaño reducido dónde el emisor de luz y el receptor se colocan en la misma dirección para detectar la presencia de un objeto utilizando la reflexión del infrarrojo sobre el objeto. El emisor consiste en un fotodiodo y el detector consiste en un fototransistor. La longitud de onda de trabajo es 950nm.

Figura 1.16. Vista axonométrica del sensor CNY70

26

1.7.2.1.2 Características

El sensor tiene una construcción compacta. Sus dimensiones son de 5 mm x 7 mm x 7 mm. La distancia entre el centro del emisor y el centro del receptor es de 0,25 mm. No necesita ningún ambiente especial, el coeficiente de temperatura es bajo, el detector esta provisto de un filtro óptico y el ratio de corriente de transferencia (CTR) típico es del 5%.

Figura 1.17. Vista en planta del censor CNY70

1.7.2.1.3 Descripción de funcionamiento

El fotodiodo emite una cantidad de infrarrojos dependiendo de la corriente que circule por ella, si se encuentra con alguna superficie lo suficientemente cercano a él, la señal de infrarrojos se refleja (dependiendo del material donde incide reflejara más o menos señal) e incide en el fototransistor cuya misión es recibir los infrarrojos y amplificar esa señal.

Figura 1.18. Esquema del perfil del sensor CNY70.

El CNY70 esta conectado por dos pines a la tensión de alimentación y los otros dos

a resistencias de polarización. Para calibrar el sensor nos ayudamos de estas dos

27

resistencias de polarización, una (R1) conectada entre el cátodo del fotodiodo y tierra, y otro (R2) entre el colector del fototransistor y tierra tal como muestra la figura siguiente:

Figura 1.19. Esquema electrónico básico del sensor con una superficie reflectante

Con R1 regulamos la corriente que atraviesa el fotodiodo, y en consecuencia regularemos el flujo de infrarrojos emitidos. Con R2 ajustamos la sensibilidad del sensor, proporcionando más o menos tensión a la salida dependiendo de la aplicación que se quiera dar. Darle mucha sensibilidad significaría dar más acceso al ruido que provocaría la luz ambiente y en consecuencia más problemas a la hora de interpretar una lectura, por eso hay que darle una sensibilidad adecuada.

GND

R1 R2

VCC

28

1.7.2.2 Circuito del microcontrolador PIC

Este es el esquema del circuito del lector de código de barras, hecho con EAGLE Layout Editor 4.15.

Figura 1.20 Esquema eléctrico del circuito del lector

Usando las librerías que tiene EAGLE y añadiendo la que contiene el PIC 18F2550

con el encapsulado ISP, se ha hecho el conexionado de los diferentes elementos que compone el circuito general.

1.7.2.3 Comunicación entre lector y PC

Los datos una vez procesados y descodificados por el microcontrolador, se transfieren al PC para poder visualizar los resultados en un entorno amigable y también para poder crear una base de datos. Para transferir estos datos lo haremos por el bus serie USB 2.0, que además de proporcionar una alta velocidad de transferencia, es compatible con USB 1.x.

29

1.7.2.4 Entorno del PC

El programa utilizado para mostrar los datos por pantalla esta creado en Visual C# de Microsoft Visual Studio 2005. Visual C# es un lenguaje de programación orientado a objetos. Posee una sintaxis que se asemeja a C++ y ofrece la posibilidad de desarrollar aplicaciones para tu propio uso. Además, otra cosa importante, es que se pueden usar las funciones de los drivers subministrados por MICROCHIP y ofrece un aspecto visual más bonito y como de usar. El aspecto visual del programa pretende ser lo más simplificado posible y bien estructurado para que el usuario no tenga ningún tipo de problema a la hora de usar la aplicación. Su función será la de guardar y gestionar los datos leídos por el lector. En el apartado 7.2 del anexo está el manual de usuario.

1.8 ESPECIFICACIONES TÉCNICAS

1.8.1 Entorno

El entorno en el cual se va a ejecutar y programar la aplicación de comunicación con el dispositivo tiene las siguientes características.

- La primera es que el sistema operativo sobre el que funciona y se programa la aplicación debe ser Microsoft Windows XP, por que el compilador utilizado (Visual C#) trabaja sobre este sistema operativo.

- La segunda es que disponga de las librerías estándar utilizadas por Visual Basic C# para ejecutar la aplicación. Por eso se incluyen las librerías de Visual Basic C# necesarias para que, en caso de que sea necesario, se habilite la ejecución de rutinas no contenidas en el sistema operativo y que permitan la ejecución normal del programa.

1.8.2 Interfaz

El puerto USB utilizado para la comunicación entre el microcontrolador y el PC tiene las siguientes características:

PARÁMETROS USB 2.0

Número máximo de dispositivos 127 Cambio en caliente Sí Longitud máxima de cable entre dispositivos 5 metros

Velocidad de transferencia de datos 480 Mbps (High-speed) 12 Mbps (Full-speed)

1,5 Mbps (Low-speed) Tensión de alimentación 5 V Corriente que suministra a los periféricos 500 mA

Tabla 1.6. Parámetros operativos del puerto USB 2.0

30

El dispositivo electrónico utilizado para adaptar la señal de 9 voltios provinente de la

pila para ajustarla y regularla a 5 V es el regulador de tensión 78L05.

PARÁMETROS 78L05 Voltaje de entrada 7V < VIN < 20V Voltaje de salida 4,8V < VIN < 5,2V

Corriente de salida 0 mA < IO < 70 mA (tipicamente 40 mA)

Temperatura de operatividad -20 ºC < T < 80 ºC Tipo de carcasa o encapsulado TO-92

Tabla 1.7. Parámetros operativos del 74L05

1.8.3 Suministro eléctrico

El suministro eléctrico provendrá de la pila de 9V y/o del puerto USB. Un pequeño ajuste en el circuito de alimentación hará que la pila no se consuma mientras el puerto USB este conectado al dispositivo. De esta forma garantizamos una mayor autonomía de la pila. Tanto la pila como el USB suministran la suficiente corriente y tensión como para hacer funcionar el lector, tal y como se comprueba en la memoria de calculo.

Los 9V de la pila no llegan al microcontrolador ni a los diferentes componentes del

circuito, sino, que su tensión es regulada por el 78L05 a 5V.

PARÁMETROS PILA 9V Designación CEI /IEC (Normas de ensayo según la Comisión Electrotécnica Internacional) 6LF22

Sistema Alcalino Tensión nominal 9 V Capacidad nominal 560 mAh Máxima intensidad 100mA Dimensiones 26,3 x 17,3 x 48,2 mm Peso aproximado 50 g. Conservación en condiciones normales de almacenamiento (según CEI/IEC – 60086-1) 4 años

Tabla 1.8. Parámetros de la pila de 9V de la marca CEGASA

A continuación, las características eléctricas del puerto USB:

PARÁMETROS PUERTO USB Tensión de alimentación 4,75 < VUSB < 5,25 V Corriente de suministro para dispositivos de alta potencia 500 mA Corriente de suministro para dispositivos de baja potencia 100 mA Potencia suministrada 2,5 W

Tabla 1.9. Parámetros eléctricos del puerto USB

31

1.8.4 Microcontrolador

El microcontrolador elegido para este proyecto es el de la empresa Microchip y pertenece a la familia PIC de la serie 18. Es un dispositivo de bajo consumo y de altas prestaciones que cuenta con la posibilidad de comunicarse vía USB.

PARÁMETROS PIC 18F2550

Tensión de alimentación 5 V Corriente máxima de entrada 250 mA Corriente máxima de salida por todos los pines 200 mA Corriente máxima de entrada en un pin I/O 25 mA Corriente máxima de salida en un pin I/O 25 mA Temperatura ambiente “Under bias” -40 ºC < T < +85 ºC Temperatura de almacenamiento -65 ºC < T < +150 ºC Potencia disipada total 1.0 W Memoria FLASH 32 kbytes Memoria SRAM 2048 bytes Memoria EEPROM 256 bytes Dimensiones 10,34 x 17,87 x 2,50 mm Tipo de encapsulado PDIP

Tabla 1.10. Parámetros operativos del microcontrolador

El microcontrolador se ha configurado para detectar y traducir las lecturas del sensor, y además para comunicarse con el ordenador por el puerto USB.

1.8.5 Sensor

El sensor utilizado para detectar y leer los códigos de barras es el CNY70, conocido por su aplicación en robots rastreadores o sigue líneas. Lo hemos elegido por su buena relación calidad/precio. Cuando hablamos de calidad nos referimos a su precisión.

PARÁMETROS CNY70 Tensión de alimentación 5 V Rango de temperatura operativa ambiente -55 ºC < T < +100 ºC Dimensiones 7 x 7 x 6 mm Potencia máxima disipada 200 mW Distancia de resolución optima 0,2 mm Distancia optima de trabajo De 0,2 mm a 3 mm Factor de acoplamiento* 5%

Tabla 1.11. Parámetros operativos del sensor CNY70

*El factor de acoplamiento es la relación entre la corriente del colector del fototransistor y la corriente del fotodiodo (IC/IF).

32

1.8.6 Códigos de barras

Según el estándar de EAN, las dimensiones que debe tener un código de barras son las siguientes:

PARÁMETROS Código de barras

Anchura nominal mínima de barras (100%) 0,33 mm Separación nominal mínima entre barras (100%) 0,33 mm Dimensiones nominales (100%) 31.35 x 22.85 mm. Dimensión mínima (80%) 25,08 x 18,28 mm Dimensión máxima (200%) 62,70 x 45,70 mm

Tabla 1.12. Parámetros de un código de barras en el estándar EAN

1.9 ENTORNO DE TRABAJO

Una vez determinados los componentes que forman el sistema, se debe programar el microcontrolador para que cumpla las condiciones para las que está previsto el sistema. Para ello es necesario utilizar varias herramientas tanto de software como de hardware para generar el archivo que será grabado en el microcontrolador.

1.9.1 Compilador

Los lenguajes más extendidos son el ASM, Basic y C, aunque también se pueden encontrar para lenguajes de programación basados en objetos, como son C++ y java, aunque estos compiladores no están lo suficientemente desarrollados y optimizados como para que puedan ser considerados como opción valida para el desarrollo de una aplicación de este tipo.

El lenguaje de programación elegido para este proyecto ha sido el C. Se ha elegido

por su facilidad para la realización de tareas complejas, a diferencia de lo que ocurre en ASM, por lo compacto del código generado y lo comprensible que resulta. Cada vez los compiladores de C están más optimizados, llegando en ocasiones a generar códigos tanto o más compactos que los desarrollados puramente en ASM.

Una vez determinado el lenguaje de programación con el que se va a trabajar, en este

caso el C, el siguiente paso es seleccionar el compilador. Podemos encontrar una amplia gama de compiladores, unos gratuitos como puede ser el C18, realizado por la empresa Microchip y otros de pago, como PICC de la empresa Hi-Tech ó CSCC de la empresa CCS.

El compilador elegido es el de la empresa CCS, en concreto el PCWH. Soporta a

toda la familia de PIC’s y próximamente también a los DsPIC. Ha sido elegido por su gran compactación del código generado y por su alta difusión en el mundo de la enseñanza. Se puede adquirir una versión de prueba gratuita, con ciertas limitaciones con respecto a la versión completa.

33

A continuación se hará una breve explicación de los procedimientos realizados para crear el programa y compilarlo. Para empezar se ejecuta el programa compilador PCWH y se elige la familia de PIC que se va a compilar, o del cual se va a escribir el código (Microchip PIC18, Microchip de 12 bits o Microchip de 14 bits). El compilador tiene una lista de microcontroladores PIC que son compatibles con el compilador. La lista es bastante extensa y recoge los últimos microcontroladores PIC que han salido en el mercado, como por ejemplo el que utilizo en el proyecto, el PIC 18F2550. El aspecto que tiene el programa nada más ejecutarlo es el siguiente:

Figura 1.21. Vista principal del compilador PCWH

Una vez ejecutado, se crea un nuevo fichero o se abré uno ya creado. Como ya

hemos comentado, es un compilador de C y, por lo tanto, la extensión de dichos archivos es *.c .

34

Figura 1.22. Editor de código

Una vez escrito el código hay que compilarlo para crear el archivo .HEX que se necesita para grabar el programa en el PIC. Además, el compilador crea otros archivos como el ERR, SYM, LST, COF, PJT, TRE y STA, destinados a otros usos.

Para compilar el código se ha de pulsar el icono , o pulsar F9. Cuando ha finalizado la compilación y no ha habido ningún error en el código, el entorno presenta el siguiente aspecto:

Figura 1.23. Editor de código con la ventana de compilación

35

Para escribir el código, a parte de tener conocimientos de programación, hay un manual de CCS se adjunta en el anexo, apartado 7.3.3. Una vez hechos todos estos pasos pasaremos al software de grabación.

1.9.2 Software de grabación

Una vez se ha compilado el programa de aplicación para el PIC, haciéndose uso del compilador de la empresa CCS, se obtiene un archivo hexadecimal (.hex) que se debe grabar en la memoria Flash del PIC. Para realizar esta labor se pueden encontrar multitud de programas tanto comerciales, como con licencia freeware. Pueden encontrarse tanto para plataformas UNIX como Windows. Entre esta variedad de software cabe destacar uno, tanto por sus características, como o su facilidad de uso, así como la gran cantidad de PIC’s y Hardware para grabación que soporta, el WinPIC800.

WinPIC800 es un software de grabación destinado a grabar la memoria ROM del

PIC con la aplicación previamente desarrollada. Soporta multitud de programadores, entre ellos, el desarrollado en este proyecto, el GTP-USB+, cuyos detalles se explican más adelante. El software, en constante evolución, puede ser descargado desde la página web personal de Sisco (http://perso.wanadoo.es/siscobf/), y presenta el aspecto siguiente:

Figura 1.24. Vista del programa Winpic800

36

Para grabar un programa en el microcontrolador primero hay que elegir el tipo de microcontrolador en el que se va a grabar el programa:

Figura 1.25. Vista de Winpic800 con la selección del modelo microcontrolador

A continuación se configura el hardware de grabación, escogiendo el que se va a

utilizar en la lista que hay:

Figura 1.26. Selección del Hardware de grabación en el Winpic800

37

Después se abre el archivo .HEX compilado y se mostraran todos los datos en hexadecimal por pantalla:

Figura 1.27. Vista del programa PIC en datos hexadecimales

Por último se pulsa el botón de grabar y si todo sale bien, se grabara en pocos segundos el programa en el microcontrolador:

Figura 1.28. Vista del programa grabado con éxito en el PIC

38

1.9.3 Hardware de grabación

Una vez compilado la aplicación y creado el archivo hexadecimal (.hex), el siguiente paso será pasar ese programa del PC al PIC, y para ello se requiere el soporte de un hardware que facilitará la tarea de pasar la información a los pins, dirigido desde el software de grabación WinPIC800. El hardware de grabación elegido es el GTP-USB+, el cual se conecta por el puerto USB y no necesita alimentación externa, que es una gran ventaja para un uso doméstico, y es creado por el mismo creador del WinPIC800, por lo que le da mucha compatibilidad.

Figura 1.29. Hardware de grabación GTP-USB+

Los esquemas y demás detalles del grabador GTP-USB+ se encuentran en los

anexos, apartado 7.3.3. Para llevar a cabo la grabación hay que tener en cuenta una serie de aspectos del

WinPIC800. Para grabar el PIC podemos hacerlo de dos maneras, por el ZIF SOCKET, que es un zocalo específicamente montado para poder grabar cualquier tipo de PIC, solo has de conectar correctamente el PIC según el numero de pines que tenga en el zócalo y conectarlo a la salida del grabador que poner ZIF SOCKET. La otra manera, que es la que he utilizado en el proyecto es por la salida ICSP (In Circuit Serial Programming), donde se conectan 5 pines de esta salida a los correspondientes pines del PIC.

39

La siguiente figura muestra un esquema de cómo se conectan los pines del ICSP a los pines del microcontrolador PIC de 28 pines, es un montaje muy sencillo.

Figura 1.30. Conexión del GTP-USB+, a través del ICSP, con los pines del PIC 18F2550

PIC18F2550

I C S P

VSS

VSS VDD

MCLR/VPP Clock

Data

GTP-USB+

1

15

28

14

Data Clock

VPP

VSS

VDD

40

2 MEMORIA DE CÁLCULO

2.1 SUMINISTRO NECESARIO 2.2 CÁCULO DE ELEMENTOS ELECTRÓNICOS

41

2.1 SUMINISTRO NECESARIO

Un dispositivo electrónico para que funcione necesita tensión y corriente para poder funcionar, necesita una fuente que le suministre la energía para llevar a cabo su función. El dispositivo se alimenta de una tensión de 5 V. Esta caída de tensión se obtiene del puerto USB (de dos de sus pines). Esto limita el alcance del dispositivo para realizar lecturas de códigos de barras. Por ese motivo, se dota al dispositivo de una alimentación externa que obtenemos de una pila de 9 V, que gracias a un estabilizador de tensión, conseguimos reducir estos 9 V a 5 V. Otra solución hubiera sido varias pilas de 1,5 V conectadas en serie, pero por motivos de espacio y autonomía del dispositivo se ha elegido una pila de 9 V.

Ahora tenemos que el dispositivo se puede alimentar por dos fuentes., la del USB y de la pila. Con intención de ahorrar el máximo el consumo de la pila se ha creado un sistema que mientras el dispositivo este conectado al puerto USB para gestionar los datos con el PC, la pila deje de consumirse

El circuito que realice este sistema consta de dos diodos y un transistor MOSFET negado, que es el siguiente:

Figura 2.1. Esquema eléctrico del circuito de doble alimentación

PILA 9V

REGULADOR DE TENSIÓN

VCC

VUSB

OUT

78L05

IN GND

+

-

42

El funcionamiento de este circuito es bastante sencillo, basta con poner dos diodos polarizados directamente con las fuentes de tensión, y en paralelo entre ellos, para que sus cátodos se unan en un mismo nodo, nodo que será el de la alimentación general del circuito del dispositivo, es decir, microcontrolador y todos los demás componentes que lo constituyan. Con esto conseguimos que la corriente de una fuente no afecte a la otra dañándola. El elemento que va seguido de la pila es un estabilizador de tensión que regulará la tensión de la pila a 5 V, que es la tensión a la que queremos alimentar el dispositivo. Luego, el elemento más importante, es el transistor MOSFET (con la entrada del GATE negada), cuya función es la siguiente: Cuando se conecte el dispositivo al USB, la fuente del USB alimentará al circuito, y hará que se corte el camino entre el drenador y surtidor del MOSFET, consiguiendo así desconectar la pila de 9 V del circuito. La entrada GATE del MOSFET ha de estar negada, para que cuando no haya tensión del USB, haga que se establezca un camino por el que la pila pueda alimentar al circuito.

2.2 REGULACIÓN DEL SENSOR CNY70

2.2.1 Calculo de resistencias de polarización del CNY70

Para ajustar el sensor a nuestras necesidades, en este caso lectura de barras blancas y negras, habrá que calcular los valores idóneos de las resistencias R1 y R2.

Figura 2.2. Esquema eléctrico del circuito con el sensor CNY70

La tensión de alimentación VCC es de 5V.

Para empezar, ajustaremos el nivel de radiación infrarroja que debe emitir el

fotodiodo. Para eso colocaremos una resistencia conectarla entre el cátodo del fotodiodo y tierra, como se indica en la figura anterior R1. Según las especificaciones técnicas del

VCC

GND

R1 R2

IF IC

43

sensor, la corriente máxima que puede pasar por el fotodiodo es de 50 mA y la tensión típica en el fotodiodo es de 1,25 V. Entonces, para obtener la resistencia mínima a colocar, se realiza el siguiente cálculo:

Ω=−

= 7550

25,151 mA

VVR MIN (1)

Luego comprobamos la potencia que se disipa en la resistencia:

WmAVVIVP FMAXR 19,050)25,15(1 =⋅−=⋅∆= (2)

Con esto sabemos que con una resistencia de 0,25 W no va haber problema.

Típicamente, el funcionamiento normal de este sensor ronda los 20 mA, por lo que la resistencia será de:

Ω=−

= 5,18720

25,151 mA

VVR TIP (3)

El valor comercial que más se le aproxima es de 180 Ω . Este valor supone una

corriente de 20,83 mA, como se muestra a continuación:

mAVV

I F 83,20180

25,15=

Ω−

= (4)

Por otra parte, hay que polarizar el fototransistor con la resistencia R2, para que trabaje en la zona de trabajo idonea. Esta resistencia es la que nos dará la sensibilidad del sensor hacia la raciadión recibida. Sabemos que la tensión colector-emisor del fototransistor cuando se encuentre en el estado de saturación será de 0,3 V, es decir en el caso de máxima transferencia de señal entre el emisor y el receptor. Y también pasará por ella una corriente de colector de 0,1 mA, por lo que el valor de la resistencia R2 una vez se saben estos valores será el siguiente:

Ω=−

= kmA

VVR SAT 47

1,03,05

2 (5)

Este es el valor máximo de resistencia, por el que se obtiene la saturación del

fototransistor. Para hacerlo trabajar en una zona más lineal hay que disminuir dicho valor. Para esta resistencia no hay problema con la potencia ya que la corriente que atraviesa el fototransistor no es mayor de 1 mA y las resistencias tienen un valor bastante grande.

44

Una vez realizado pruebas con diferentes resistencias se ha llegado a un

compromiso con las resistencias de polarización del fotodiodo y del fototransistor. Dicho compromiso consistía en llegar a diferenciar con la máxima claridad posible los diferentes grosores de barras, ya que según el grosor de la barra se refleja más o menos radiación y se podía apreciar. Los valores son los siguientes:

R1 = 180 Ω R2 = 33 kΩ

Estos son valores de resistencias comerciales, y los que mejor resultado dan, pero la

distinción de las barras blancas entre dos grosores concretos no se hacía muy patente, por lo que se ha razonado otra idea.

2.2.2 Sistema nuevo de lectura para la distinción de barras y espacios Se trata de usar un valor de resistencia cuando lee una barra y usar otro valor de

resistencia cuando se lee un espacio. El objetivo es tener la máxima claridad en diferenciar los distintos grosores de barras y los distintos grosores de espacios. Usando una R2 grande, supone más sensibilidad y más claridad a la hora de leer barras negras. En cambio, para los espacios en blanco, conviene usar una R2 más pequeña hasta el punto de llevar al fototransistor a trabajar en la zona lineal, ya que el reflejo del color blanco tiende a saturar el fototransistor frecuentemente. Para cumplir ese objetivo se ha diseñado un sistema que permita conmutar entre una resistencia y otra a la hora de la lectura.

Figura 2.3 Esquema eléctrico del sensor con el microcontrolador y el transistor de conmutación

GND

R1 R2

CNY70

VCC

2

PIC 18F2550

28

24

1

15 14

R3

GND

PIN 2 à ENTRADA A/D (AN1) PIN 24 à E/S (RB3)

2N7000

45

Cuando el lector ha leído una barra, el microcontrolador pone a nivel alto el pin 24, que es un pin de entrada/salida, y deja en cortocircuito el transistor. Esto provoca que la resistencia R2 y R3 se configuren en paralelo y el valor total de la resistencia disminuya haciendo que el fototransistor del CNY70 trabaje en la zona lineal y diferencie bien los grosores de los espacios en blanco del código de barras.

Y cuando el lector ha detectado un espacio en blanco, el microcontrolador pone a

nivel bajo el pin 24 y deja en circuito abierto el transistor, haciendo que solo actúe la resistencia R2 en la lectura del fototransistor. Como la resistencia R2 es grande, diferenciará bien los diferentes grosores de las barras del código de barras.

Este sistema se ha basado en el caso real del ojo humano. La pupila se autorregula para controlar la entrada de luz en la retina. Cuando hay mucha luz la pupila se estrecha y cuando hay poca luz la pupila se ensancha para captar más luz y poder ver mejor el entorno. Pues eso es parecido al sistema anterior, por que cuando se refleja un blanco, quiere decir que el fototransistor recibe mucha luz, para eso hay que disminuir la resistencia de polarización, es decir, la sensibilidad para que pueda percibir mejor la señal sin saturarse, es como si se estrechase la pupila, y viceversa en el caso de una barra negra.

2.2.2.1 Calculo experimental de las resistencias en el nuevo sistema de lectura

Para adecuar las resistencias al sistema anterior, hay que realizar un experimento que se trata de realizar muchas lecturas y comprobar su comportamiento. En este experimento se intenta buscar una buena relación entre la sensibilidad del fototransistor y la radiación emitida por el fotodiodo.

Para empezar hay que evitar que el fototransistor de sature con facilidad, por lo que la emisión de infrarrojos por parte del fotodiodo debería ser moderada para que el fototransistor no se sature frecuentemente. Para el experimento se han escogido varias resistencias para poder escoger la más adecuada.

Luego hay que contrastar la radiación que emitirá el fotodiodo con la sensibilidad del receptor. Para eso hay que elegir las dos resistencias adecuadas que polarizan el fototransistor. Primero sabemos que R2, que ajusta la sensibilidad para las barras negras es de 47k Ω , porque con este valor hace que el fototransistor se sature con gran cantidad de luz, es decir, es más sensible a captar las barras negras, ya que cuando detecta un espacio blanco rápidamente se satura.

Por otro lado, para captar los espacios en blanco hay que experimentar con la otra resistencia, inferior a la de antes, para que no se sature fácilmente y obtener buena diferenciación entre grosores de diferentes espacios en blanco. Para ello se ha probado siempre con la resistencia R2 de 47k Ω , y variando la resistencia R3 mirando los resultados del conversor A/D obtenidos de la salida del sensor al leer los diferentes grosores de barras. Los grosores se clasifican numéricamente del 1 al 4, siendo el 1 el más fino, y el 4 el más grueso. Dichos grosores son proporcionales entre si, siendo el 4 cuatro veces más grande que el 1, dos veces más grande que el 2 y el 3 tres veces más grande que el 1.

46

Para cada caso, el sensor capta un nivel de tensión diferente, que viene representado en la tabla 2.1 de a continuación, con números del 0 al 1023, ya que divide la tensión de 5 V con un conversor A/D de 10 bits.

Primero probamos con mucha radiación del emisor, es decir, con una R1 = 82Ω , que nos polariza la corriente en el fotodiodo a 45,73 mA, cerca del valor máximo, y los resultados son los siguientes:

R1 = 82 Ω (45,73 mA)

47k Ω // 100k Ω

47k Ω // 56k Ω

47k Ω // 47k Ω

47k Ω // 22k Ω

47k Ω // 15k Ω

GROSOR BARRAS 1 950 ~ 996 944 ~ 989 672 ~ 856 468 ~ 632 397 ~ 521 2 535 ~ 653 502 ~ 632 455 ~ 675 367 ~ 439 214 ~ 261 3 403 ~ 440 391 ~ 451 343 ~ 398 208 ~ 262 150 ~ 181 4 329 ~ 457 295 ~ 321 286 ~ 331 167 ~ 211 127 ~ 148

GROSOR ESPACIOS 1 986 ~ 989 886 ~ 940 531 ~ 757 490 ~ 560 455 ~ 610 2 989 ~ 997 935 ~ 960 915 ~ 973 887 ~ 910 835 ~ 894 3 990 ~ 996 981 ~ 990 978 ~ 987 955 ~ 970 915 ~ 963 4 991 ~ 998 988 ~ 992 979 ~ 986 962 ~ 974 957 ~ 969

Tabla 2.1. Tabla de resultados con diferentes resistencias de polarización del fototransistor y R1=82Ω

Las gráficas siguientes son el resultado de la media de los resultados de la tabla anterior. La gráfica de la izquierda simboliza la de los grosores de barras y la de la derecha la de los grosores de espacios.

Figura 2.4 Gráficas de resultados medios de la tabla 2.1

47k Ω // 100k Ω

47k Ω // 56kΩ 47k Ω // 47kΩ

47k Ω // 22kΩ

47k Ω // 15kΩ

cuentasADC bits 102421010 ==

cuentaVcuentaVcuentasV

solución /88,4/8828125,41024

5Re ≅==

VALOR ADC VALOR ADC

GROSOR BARRAS GROSOR ESPACIOS

47

Lo que nos revela los resultados anteriores es que el fototransistor se satura con facilidad con los espacios en blanco, aunque se puedan apreciar los grosores de las barras, no es una de las mejores opciones. Además, con facilidad se pueden solapar los valores del ADC entre los distintos grosores, es decir, se pueden confundir con facilidad los diferentes grosores de barras y espacios en la lectura. Hay demasiada radiación. Ahora probamos con poca luz, es decir, con R1 = 330 Ω , que hace circular 11,36 mA por el fotodiodo. Los resultados son los siguientes:

R1 = 330 Ω (11,36 mA)

47k Ω // 100k Ω

47k Ω // 56k Ω

47k Ω // 47k Ω

47k Ω // 22k Ω

47k Ω // 15k Ω

GROSOR BARRAS 1 335 ~ 392 324 ~ 375 338 ~ 381 324 ~ 385 325 ~ 383 2 189 ~ 360 185 ~ 363 179 ~ 345 178 ~ 328 169 ~ 318 3 128 ~ 155 135 ~ 156 125 ~ 151 119 ~ 154 120 ~ 147 4 128 ~ 161 121 ~ 163 94 ~ 119 78 ~ 104 53 ~ 89

GROSOR ESPACIOS 1 258 ~ 348 267 ~ 329 185 ~ 253 146 ~ 201 127 ~ 189 2 359 ~ 651 321 ~ 674 250 ~ 451 185 ~ 236 168 ~ 198 3 313 ~ 696 318~ 658 281 ~ 564 297 ~ 359 290 ~ 320 4 708 ~ 784 685 ~ 740 555 ~ 632 364 ~ 391 315 ~ 327



En este caso, hay demasiada poca luz, lo que hace que los resultados que da el conversor A/D sean bajos en el caso de los grosores de barras y grosores de espacios, y también tiende a solaparse los diferentes grosores de barras y hace difícil la lectura.

47k Ω // 100k Ω

47k Ω // 56kΩ 47k Ω // 47kΩ

47k Ω // 22kΩ

47k Ω // 15kΩ

GROSOR BARRAS GROSOR ESPACIOS

VALOR ADC VALOR ADC

48

En este otro caso, probamos un caso intermedio entre lo valores anteriores, es decir, R1 = 180Ω , lo que ajusta la corriente que pasa por el fotodiodo a 20,83 mA, un valor cercano al mostrado en los ejemplos del “datasheet” del CNY70 (apartado 7.3.3 del anexo) Los resultados son los siguientes:

R1 = 180 Ω (20,83 mA)

47k Ω // 100k Ω

47k Ω // 56k Ω

47k Ω // 47k Ω

47k Ω // 22k Ω

47k Ω // 15k Ω

GROSOR BARRAS 1 799 ~ 953 454 ~ 614 394 ~ 541 324 ~ 424 205 ~ 275 2 415 ~ 811 222 ~ 278 225 ~ 256 151 ~ 212 121 ~ 151 3 287 ~ 326 176 ~ 202 156 ~ 175 123 ~ 146 120 ~ 155 4 247 ~ 265 127 ~ 159 120 ~ 131 120 ~ 127 120 ~ 135

GROSOR ESPACIOS 1 975 ~ 987 524 ~ 732 434 ~ 602 395 ~ 555 247 ~ 340 2 985 ~ 991 911 ~ 983 780 ~ 864 670 ~ 736 394 ~ 471 3 982 ~ 994 976~ 984 925 ~ 954 762 ~ 831 460 ~ 512 4 991 ~ 998 980 ~ 985 965 ~ 996 818 ~ 845 503 ~ 511



Ahora hacemos otra comprobación comparando las diferencias entre los valores

medios de los grosores de las barras y espacios. Para ver eso con claridad se ha creado un gráfico de barras para todos los casos y así comparar cual tiene mejor comportamiento:

47k Ω // 100k Ω

47k Ω // 56kΩ 47k Ω // 47kΩ

47k Ω // 22kΩ

47k Ω // 15kΩ

GROSOR ESPACIOS GROSOR BARRAS

VALOR ADC VALOR ADC

49

Figura 2.7 Gráfica de diferencias entre grosores de barras

Figura 2.8 Gráfica de diferencias entre grosores de espacios

47k Ω // 100k Ω

47k Ω // 56k Ω 47k Ω // 47k Ω

47k Ω // 22kΩ

47k Ω // 15k Ω

VALOR ADC

VALOR ADC

DIFERENCIAS DE GROSORES DE BARRAS

DIFERENCIAS DE GROSORES DE ESPACIOS

1-2 2-3 3-4 2-3 2-3 1-2 3-4 3-4 1-2

82 Ω 180 Ω 330 Ω

1-2 2-3 3-4 2-3 2-3 1-2 3-4 3-4 1-2

82 Ω 180 Ω 330 Ω

50

Por lo que se puede comprobar, la barra roja que corresponde a la configuración de R1=180Ω , R2 = 47k Ω y R3 = 47kΩ , tiene buena respuesta en las diferencias de barras y de espacios, aunque en el caso de R1=180Ω , R2 = 47kΩ y R3 = 100k Ω , tiene buena diferenciación de barras en cuanto a diferencia de valores medios, pero tienden a solaparse los valores ADC, por lo que ya no es tan bueno.

La gráfica de color rojo que corresponde al caso de R2 = 47kΩ y R3 = 47kΩ tiene

una recta bastante regular, tiene una buena diferenciación entre valores medios de grosores de barras y espacios y no se solapan los valores con los diferentes grosores. Es el mejor caso de los tres vistos. Como conclusión a los datos experimentales, la resistencia R3 que mejor resultado da en cuanto a la diferenciación de los distintos grosores de barras y espacios es la de 47k Ω . Entonces, como resultado final, las resistencias que polarizan el fototransistor serán:

R2 = 47 k Ω R3 = 47 k Ω

Cuando actúa la resistencia R3, la configuración en paralelo de las dos resistencias

hace que el valor de la resistencia en conjunto sea el siguiente:

Ω=Ω+ΩΩ⋅Ω

=

Ω+

Ω

= kkkkk

kk

RR 5,2347474747

471

471

13||2 (6)

Mediante un programa monitor se puede comprobar los resultados de la conversión

A/D numéricamente y gráficamente. Se pueden consultar detalles sobre este programa monitor en los anexos, apartado 7.3.3.

Y por lo que se ha podido comprobar, donde más rango de diferenciación entre

diferentes grosores de barras y espacios se encuentra cuando las resistencias son:

R1 = 180 Ω R2 = 47 k Ω R3 = 47 k Ω

Por último, para elegir un transistor de conmutación había que basarse en el tiempo

de subida y bajada de la conmutación del transistor. Trabajando con un tiempo de muestreo de 3 ms no en la lectura, hay muchos transistores a elegir. En este caso se ha elegido el transistor MOSFET NPN 2N7000 (apartado 7.3.3 del anexo) por su bajo coste y su reducido tiempo de conmutación, que es muy inferior al tiempo de muestreo en la lectura.

51

2.3 REGULACIÓN DE LA LECTURA DE CÓDIGOS DE BARRAS

En este apartado se pretende hallar las características que tienen los códigos de barras para un cálculo posterior de muestreos, frecuencia de muestreo que deberá realizar el sensor y la anchura mínima que deberá tener las barras del código de barras para una buena lectura.

2.3.1 Características de los códigos de barras Para empezar, analizamos un código de barras EAN-13 por su número de barras y

contamos a simple vista que contiene 30 barras negras y 29 barras blancas. Luego, sabiendo que cada numero esta traducido en dos barras negras (se puede comprobar en el apartado 1.5.3.5), sabemos que 24 de las 30 barras corresponderán a los 12 números que contiene el código EAN-13 y las 6 barras restantes corresponden entonces a los separadores.

2.3.2 Muestreo

Para conocer el número de muestreos, hemos tenido que saber el número de barras que hay que leer. Tenemos que como mínimo se deberán de hacer 59 muestreos (30 barras + 29 espacios), pero es muy difícil que se haga una lectura del sensor en el punto central de cada barra, además la velocidad a la que pase el sensor no es constante, sino ligeramente variable porque las lecturas se realizan con la mano. Entonces se tendrá que hacer más muestreos para saber que nivel de tensión da en cada momento y a partir de ahí detectar las barras según las variaciones de tensión.

2.3.3 Precisión del sensor y anchura de las barras Por otra parte, la precisión del sensor es un aspecto a considerar. Según las

especificaciones técnicas, el sensor es capaz de detectar líneas negras de un grosor inferior a 0,5 mm cuando el sensor se encuentra a una distancia inferior de 0,5 mm. Este grado de precisión es apreciable al tener que detectar barras 0,3 mm de grosor. Entonces, para tener una buena apreciación de las líneas que se leen, la cantidad de lecturas del conversor A/D tiene que ser bastante grande, es decir, el numero de muestras que habrá que sacar de la lectura.

Para hacernos una idea de lo explicado, la figura siguiente muestra el paso del foco

del sensor por una línea negra de un código de barras.

1 2 3

52

Figura 2.9. Ejemplo del paso del los infrarrojos del sensor sobre una línea negra

Cuando el foco del sensor detecta solo el color blanco, el nivel de señal reflejada es

máximo, dependiendo de la reflexión del material. Pero en el punto 2, una parte del foco del sensor se encuentra encima de la línea negra, por lo que la señal total reflejada será inferior a la señal reflejada del paso 1, y por lo tanto, podemos empezar a percatarnos de que estamos empezando a detectar una línea. En el punto 4 es cuando obtenemos la mínima señal reflejada, por lo que nos encontramos justo en el centro de la línea. Otra cosa a tener en cuenta es que la señal reflejada en un extremo del foco no es la misma que en el centro del foco aunque este reflejando la misma área. En el centro del foco es donde la proporción de señal emitida y recibida es máxima, es decir, el 100%. En cambio, a un ángulo de 50º, la proporción es del 30%.

Figura 2.10. Relación entre la corriente del CNY70 y el ángulo en que la radiación infrarroja es emitida.

Entonces, el número de muestras a realizar deberá ser como mínimo de 5 por cada barra como mínimo. En total un mínimo de 295 muestras ( 30 barras + 29 espacios por 5 muestras por cada barra hacen 295 muestras en total ) y cuantas más muestras mejor.

Tal y como se muestra en la gráfica siguiente, la precisión máxima del sensor es de aproximadamente 0,3mm, es decir, donde hay mejor relación entre la corriente de colector es cuando el sensor se encuentra a 0,3 mm de distancia con la superficie.

4 5 6 7

CNY70

50º

53

La distancia “A” de la gráfica corresponde a la distancia del sensor con la superficie. Por lo tanto, las lecturas se realizarán con el sensor en contacto con la superficie.

Figura 2.11. Relación entre la corriente del CNY70 y la distancia a la que se encuentra de una superficie.

2.3.4 Tamaño de los códigos de barras

El tamaño influye en la calidad de la lectura, cuanto más pequeño sea el código de barras, más finas serán las barras y mas estrecha será la separación entre barras, en conclusión, los niveles de reflexión entre barras negras y blancas serán más próximos entre si y será más difícil la distinción entre dichas barras, entonces la lectura final es más probable que sea errónea. Por lo que se ha decidido usar el máximo tamaño permitido por el estándar EAN, el 200 % del tamaño, cuyas medidas se especifican en el apartado 1.8.6.

2.3.5 Reflectancia del material y los códigos de barras Por último, hay que tener en cuenta la reflectancia de la superficie donde se encuentra impreso el código de barras y la reflectancia de las barras del mismo código de barras. Esta reflectancia depende del color de la superficie básicamente y del tipo de material de la superficie. Un folio normal de 80 g. satinado tiene una reflectancia del 90% (mirar los porcentajes de reflectancia en el “dataste” del CNY70, apartado 7.3.3 del anexo) , es decir, refleja la señal infrarroja casi en su totalidad. Y una línea negra sobre este tipo de papel se refleja de un 4% a un 7%, por lo que la diferenciación entre la señal reflejada en un espacio en blanco y una barra negra se hace más notoria. Por eso se ha optado por experimentar y usar el lector en códigos de barras impresos con tinta negra de impresora sobre una hoja de papel normal, de 80 g. satinado. No se ha encontrado otra posibilidad mejor que esta, ya que las demás posibilidades hacían que la diferencia entre el blanco y el negro fuera más pequeña y por lo tanto, el reconocimiento de los diferentes grosores de barras sobre los diferentes grosores de espacios se hacen más difíciles de reconocer, incluso imposible. El color también es importante, ya que los diferentes colores reflejan una cantidad diferente de radiación infrarroja. Se ha optado por las barras negras sobre papel blanco por

54

que son los colores que más difieren en cuanto reflejo de infrarrojos, ya que como teoría, el color negro es el color que absorbe más energía y el blanco el que menos.

Figura 2.12. Colores de los códigos de barras

2.3.6 Conclusiones finales sobre la lectura de códigos de barras Como conclusión a todo esto tenemos que:

- El foco del sensor es más grande que una línea fina del código de barras. - El numero de muestras deberá de ser igual o mayor que 295. - La lectura del código de barras se realizará con el sensor pegado a la superficie. - Los códigos de barras deberán ser impresos en papel normal y con tinta negra. - Los códigos de barras serán del máximo tamaño posible, siendo del 200% del

tamaño 100% del estándar.

2.4 CORRIENTE POR LOS DIODOS LED SEÑALIZADORES Tiene suma importancia la corriente que pase por los LED’s que nos indicaran los estados del dispositivo, ya que una parte del consumo se irá por ellos, y por lo tanto la autonomia del producto, y además tener en cuenta que el HUB del USB administra un máximo de 500mA. Para empezar elegiremos el tipo de LED, que por motivos de espacio y consumo será el estándar de 3mm de diámetro de encapsulado.

Figura 2.13. Carácterísticas de físicas y circuitales de un LED

55

Las características de este diodo nos indica que la corriente máxima que debe pasar por él para un funcionamiento normal es de 10mA, puestos que el microcontrolador esta alimentado a 5V y el diodo consume 0,7 V aproximadamente, según la ley de Ohm, para conseguir ese paso de corriente necesitaríamos una resistencia de:

RVV

mA)7,05(

10−

= (7)

mAV

R10

3,4= (8)

Ω= 430R (9)

Puesto a que comercialmente no existe una resistencia de dicho valor, el valor más próximo sin que sobrepase los 10mA de corriente seria una resistencia de 470Ω . Entonces la corriente que pasaría sería de:

mAV

I 15,9470

3,4=

Ω= (10)

Lo que resulta un consumo menor de corriente y una iluminación del LED más que aceptable. Pero aún podemos ir más lejos, por que utilizando resistencias de 1kΩ también obtenemos una iluminación aceptable y casi ahorramos el doble de corriente, aproximadamente el la corriente consumida será la siguiente:

mAV

I 3,41000

3,4=

Ω= (11)

Esto nos permite ahorrar casi el doble de corriente, aproximadamente la siguiente:

%99,4610015,93,4

(%) =⋅=mAmA

I AHORRO (12)

Aproximadamente nos ahorramos un 47 % de la corriente, eso nos permitirá una mayor autonomía, disipación de menos potencia y una buena iluminación del LED.

56

2.5 CALCULO TEORICO EL CONSUMO DE CORRIENTE DEL DISPOSITIVO En este apartado haremos un cálculo aproximado del consumo de máximo que puede llegar a tener nuestro dispositivo, así podremos elegir el tipo de batería más conveniente para el prototipo final.

2.5.1 Consumo de los diferentes elementos del dispositivo

Para empezar miraremos en el “dataste” del microcontrolador PIC 18F2550 (mirar apartado 7.3.3 de los anexos), para averiguar el consumo de corriente que tiene este chip en cada uno de sus modos de funcionamiento:

VALOR TÍPICO VALOR MÁXIMO Ud.

MODO NORMAL (RUN) 20 ~ 25 40 ~ 50 mA MODO ESPERA (IDLE) 8,0 ~ 10,5 18 ~ 21 mA

MODO SLEEP 0,1 ~ 0,4 1,9 ~ 15 * µ A

Tabla 2.4. Consumo de corriente de los distintos modos de funcionamiento del PIC 18F2550

* En el modo sleep a +25º el consumo máximo de corriente es de 2 µ A, y el de 15 µ A es a +85º, sabiendo que las unidades son en µ A no supone una diferencia considerable para la aplicación que esta realizando el PIC Los dos valores que se muestran son la diferencia que hay entre una alimentación de 4,2 V y 5 V. La alimentación de nuestro circuito es la que proporciona el USB, que es de 5V, pero experimentalmente ese no es exactamente el voltaje que proporciona, sino que es de 4,84 V, por eso he puesto esos dos valores en la tabla.

A continuación, mostraremos la tabla de consumo de corriente de los diferentes elementos que compondrán nuestro prototipo final, los cálculos teoricos de estos:

VALOR Ud. LED (3mm) 4,3 mA FOTODIODO (CNY 70) 20,83 mA FOTOTRANSISTOR (CNY 70) 0,3 ~ 1,0 mA BOTON RESET (al pulsarlo) 0,5 mA

Tabla 2.5. Consumo teórico de los diferentes elementos del circuito

57

2.5.2 Consumo de corriente máximo del dispositivo En el peor de los casos, es decir, el caso en el que hay un máximo consumo de corriente, el dispositivo tiene 2 LED’s encendidos simultáneamente, el CNY 70 funcionando en el mayor consumo de corriente y el PIC esta en modo de funcionamiento normal (considerando el máximo valor de corriente), el consumo máximo de corriente del prototipo seria de:

( ) mAmAmAmAMÁXIMOCONSUMO 183,2023,450 ++⋅+= (13)

2.5.3 Consumo de corriente medio del dispositivo

Para el cálculo del consumo medio de corriente hay que tener en cuenta una serie de cosas:

- El botón de RESET no estará siempre pulsado, y el tiempo que permanece pulsado es despreciable, sin embargo tendremos en cuenta al menos consideraremos un 20% para poder hacer un calculo medio aproximado, por si alguna vez se pulsa.

mAmAI RESET 1,010020

5,0 =⋅= (14)

- Los tres LED’s no estarán siempre encendidos a la vez, solo un LED permanecerá encendido mientras el dispositivo este funcionando, y solo por un corto periodo de tiempo, van a estar dos LED’s encendidos a la vez. Considero, en un hipotético peor caso, que el hay dos LED’s encendidos a la vez el 50% del tiempo, aunque no llega a ser así.

mAmAmAI SLED 6,810050

3,423,4' =⋅⋅+= (15)

- El fotodiodo y el fototransistor del sensor CNY70 consumen suficiente corriente como para considerarlo. La suma de corriente del emisor y receptor es la siguiente:

mAmAmAICNY 83,21183,2070 =+= (16)

mAMÁXIMOCONSUMO 83,71=

58

- El PIC no estará siempre en modo RUN, variará según este leyendo un código de barras o no. Entonces oscilará entre el modo normal y el modo espera. Planteándonos el peor de los casos, que será el de ir leyendo muy seguidamente códigos de barras, considero que 2/3 del tiempo esta en modo normal y 1/3 está en modo espera, por que es el tiempo que pasa entre que se lee un código de barras a otro.

mAmAmAI PIC 16,205,367,165,1031

2532

=+=⋅+⋅= (17)

El consumo de corriente medio total será:

70' CNYRESETSLEDPIC IIIIMEDIOTEÓRICOCONSUMO +++= (18)

mAmAmAmAMEDIOTEÓRICOCONSUMO 83,211,06,816,20 +++= (19)

2.5.4 Duración de la pila

Para el proyecto, uno de los objetivos es tener la mayor autonomía posible. La pila utilizada para alimentar el circuito sin estar conectado por USB es una pila de 9V, cuya capacidad de corriente es de 560mAh.

Basándonos en el peor de los casos, cuando el dispositivo consume el máximo de corriente todo el tiempo, es decir, 71,83 mA (véase el apartado 2.2.4), el dispositivo es capaz de mantenerse operativo el siguiente espacio de tiempo:

horasmA

mAhT TEÓRICOMAX 81,7

83,71560

== (20)

Esto se traduce en 7 horas, 48 minutos y 36 segundos.

Ahora, en el caso práctico del consumo de corriente medio, el número de horas de funcionamiento es el siguiente:

horasmA

mAhT TEÓRICOMEDIO 05,11

69,50560

== (21)

Y esto se traduce en 11 horas y 3 minutos aproximadamente.

mAMEDIOTEÓRICOCONSUMO 69,50=

59

Esto nos muestra nos muestra que el dispositivo es capaz de funcionar, con una sola pila de 9V, durante una jornada laboral de 8 horas de trabajo en el peor de los casos, y 3 horas y media más en el caso de consumo medio.

También existe la posibilidad de mejorar este dato, conectando dos pilas de las mismas características en paralelo. Lo más importante es que tengan el mismo voltaje (9V en nuestro caso).

Conectando dos pilas como la anterior en paralelo conseguiremos doblar la capacidad de corriente total, y eso nos proporciona el doble de tiempo de operatividad del dispositivo (véase apartado 3.1).

En el caso de no usarse el lector, el consumo se reduciría a 12,3 mA (8 mA del PIC y 4,3 mA del LED que avisa que el dispositivo esta alimentado), la duración de la pila en reposo sería de:

horasmA

mAhT TEÓRICOREPOSO 53,45

30,12560

== (22)

Y esto se traduce en 1 dia, 21 horas, 31 minutos y 48 segundos aproximadamente.

2.5.5 Calculo del número de lecturas que el dispositivo es capaz de realizar con una pila

Para saber el número de lecturas que es capaz de realizar el dispositivo nos basaremos en la autonomía del dispositivo y la duración aproximada de cada lectura. Para ello consideraremos el peor de los casos y lo contrastamos con el consumo medio teórico de corriente. Consideramos en ambos casos que la lectura de un código de barras 0,8 segundos de media aproximadamente.

Considerando el peor de los casos en el que la autonomía del producto es de 7 horas, 48 minutos y 36 segundos, el número de lecturas que se pueden realizar será:

lecturass

sssLECTURASN 35145

8,036288025200

º =++

= (23)

Y en el caso del consumo medio de corriente, en el que su autonomía es de 11 y 3 minutos, el número de lecturas sería el siguiente:

lecturass

ssLECTURASN 49725

8,018039600

º =+

= (24)

60

Como conclusión a esto tenemos que el número de códigos de barras que se pueden leer con este dispositivo es muy grande. Si contamos que cada producto tiene un código de barras propio, este lector es capaz de leer un número de productos de almacenes bastante grandes.

61

3 DESARROLLO DEL SISTEMA FÍSICO

3.1 ALIMENTACIÓN EXTERNA 3.2 SENSOR 3.3 ENTORNO DEL MICROCONTROLADOR 3.4 COMUNICACIÓN MICROCONTROLADOR-PC 3.5 ENTORNO DEL PC 3.6 DISEÑO PCB

62

En este capítulo se explican los procedimientos realizados para la creación de cada

una de las partes del dispositivo, tanto como los elementos escogidos para dicho montaje y las razones por las cuales se ha decidido diseñarlo de esta manera y no de otra, como también la elección de ciertos elementos y no otros.

3.1 ALIMENTACIÓN EXTERNA

3.1.1 Aplicación y propósito de la conexión de pilas en paralelo en el proyecto

Para el proyecto, el propósito de esto es aumentar la autonomía del lector, conectando dos pilas de 9V en paralelo. Por ejemplo, el lector usa una pila de 9V con una capacidad de corriente de 560mAh, si conectamos dos pilas de estas mismas características en paralelo conseguiremos doblar la corriente de suministro en 1120mAh, doblando así la autonomía del lector.

Anteriormente, en el apartado 2.2.4 se ha calculado la corriente teórica que consumía

el lector, que es de 71.83 mA, entonces, con un suministro de corriente de 1120 mAh, el lector se mantendría operativo durante 15 horas, 35 minutos y 32 segundos aproximadamente.

3.1.2 Montaje de las pilas en el lector

La pila de 9 V se conecta externamente a la placa PCB con la ayuda de un cable conector para pilas de 9 V.

Figura 3.1. Foto de conector para pila de 9V

En el caso de conectar dos pilas en paralelo, se requerirán dos porta pilas de 9V para

cada una de las pilas, y se conectarán en paralelo en la placa PCB. La pila o las pilas irán colocadas según se especifique en el diseño de la carcasa.

63

3.1.3 Conexión de la doble alimentación

Como se ha explicado anteriormente en el apartado 2.1, se ha diseñado un sistema para la interacción y protección de las dos fuentes externas de tensión que se conectan al dispositivo. Se trata de que la pila no se consuma mientras el dispositivo se conecta al puerto USB, además proteger dichas fuentes por diodos.

El esquema eléctrico del diseño es el siguiente:

Figura 3.2. Circuito eléctrico de la conexión de la doble alimentación y el PIC 18F2550

El diodo protege la fuente del puerto USB y el diodo que hay en el transistor BS250 protege a la pila de 9 V.

64

3.2 SENSOR

Una de las partes más importantes del desarrollo de este lector es el sensor que percibe la variación entre las líneas negras y blancas cuyo funcionamiento se explica en el apartado 1.7.2.1.

3.2.1 Conexionado del sensor con la placa PCB El sensor tiene 4 pines, dos de los cuales se conectan entre si, exactamente los dos

pines que van a la alimentación. Al sensor se sueldan 3 cables que irán a los pads que le correspondan de la placa PCB. A continuación se muestra una figura que representa dicha conexión entre el sensor CNY70 a la placa PCB mediante tres cables.

Figura 3.3. Ejemplo de conexión de los cables del CNY70 con la placa PCB

El 1 corresponde a la conexión entre el emisor del fototransistor y las resistencias de 47k Ω que esta en la placa PCB, la conexión 2 corresponde al que une el colector del fototransistor, el ánodo del fotodiodo y la alimentación. Y por último la conexión 3 corresponde a la unión entre el cátodo del fotodiodo y la resistencia de 180 Ω que esta soldada en la placa PC.

CNY 70

PCB

1

2

3

65

Figura 3.4. Esquema eléctrico de la conexión del CNY con el conector de la placa PCB

Como el sensor se encuentra conectada a la placa PCB mediante cables, en el esquema circuital del PCB solo viene representado el conector de tres cables. Un ejemplo real de la conexión de estos cables a un conector como se ha explicado:

Figura 3.5. Foto del conexionado real del CNY70 con un conector

66

3.2.2 Conexión del sensor con las resistencias de polarización y el microcontrolador

El sensor debe conectarse a una de los pines del microcontrolador que se use para la conversión A/D de la señal sensada. Este pin se le llama entrada analógica y tal y como se ha diseñado en este proyecto, el pin al que debe conectarse es el pin numero 3, que corresponde a la entrada analógica 1 (AN1) del PIC 18F2550. La figura siguiente muestra la conexión mencionada.

Figura 3.6. Esquema electrico de la conexión entre el sensor y el PIC

A parte de la conexión a la entrada analógica, el sensor también va conectado al sistema que polariza y controla la lectura del sensor, como son las resistencias de polarización y el transistor de conmutación. Este último va conectado al pin 24 que corresponde a un pin de entrada/salida, el cual esta configurado para generar una salida en los momentos requeridos que anteriormente se ha explicado en el apartado 2.2.2. Por último, el sensor también va conectado a la alimentación externa, que a la vez va conectado al pin de alimentación del PIC, el pin 20.

67

3.2.3 Motivos de diseño del conexionado con la placa PCB La aplicación de cables en vez de conectar el sensor directamente a la placa PCB es por motivos de diseño, utilizando los cables podremos adaptar el sensor a un específico tipo y estilo de carcasa en el cual contendrá el lector. El diseño de dicha carcasa no va incluido en este proyecto, pero a continuación se muestra un ejemplo esquemático de lo que podría ser.

Figura 3.7. Diseño hipotético de la carcasa del lector

La intención del diseño sería una carcasa ergonómica lo más pequeña posible y que el sensor se encuentre en una zona de la carcasa que fuera cómoda para realizar eficazmente las lecturas. Otra posibilidad de diseño sería el dispositivo implementado en un guante. Este guante cubriría la mano y la muñeca. En la muñeca se encontraría la placa PCB con el circuito y la batería. Y en el dedo se encontraría el sensor, con el fin de realizar las lecturas con la punta del dedo, como si la lectura del código de barras se realizase con el dedo.

Figura 3.8. Diseño hipotético del lector incorporado en un guante

PCB

CNY 70

9V

USB

18 F

25 50

PCB

CNY70

68

3.2.4 Modo de empleo del sensor en las lecturas

Para realizar las lecturas con el sensor, la manera correcta de hacerlo con un

movimiento lateral de izquierda a derecha de una manera uniforme, con el sensor pegado al papel y lo más importante es que la posición de las ventanitas del fotodiodo y fototransistor respecto las líneas del código de barras tienen que quedar en perpendicular como muestra la siguiente figura:

Figura 3.9. Posiciones del lector al realizar una lectura de un código de barras

Para un buen funcionamiento del lector es recomendable hacer la lectura de una manera correcta, en la posición 1, en caso contrario, sería difícil de distinguir entre distintos grosores de barras. Antes de explicar el porque es mejor realizar la lectura de una manera que de otra, hay que explicar un concepto relacionado con las características del sensor. Se trata de la distancia de conmutación (“Switching distance”). La distancia de conmutación es la distancia que recorre el sensor desde que la corriente del colector del fototransistor pasa del 90% al 10% o viceversa. En nuestro caso la distancia que recorre desde que pasa del nivel más alto de negro y llega al nivel más alto de blanco o viceversa. La siguiente figura explica este fenómeno:

CORRECTO

(MÁS PRECISO)

INCORRECTO

(MENOS PRECISO)

POSICIÓN 1

POSICIÓN 2

69

Figura 3.10. Distancia de conmutación del CNY70

Si miramos en el documento técnico del sensor CNY70 (apartado 7.3.3 de los anexos), podemos ver la siguiente gráfica. Esta gráfica corresponde a la relación entre la distancia del sensor con la superficie (“Distance A”) y la distancia de conmutación (“Switching distance”).

Figura 3.11. Grafico de la relación que tiene el CNY70 con el Switching distance/Distance A

Como se puede observar, existe una notoria diferencia entre una posición y la otra,

una diferencia importante pensando que al leer códigos de barras nos movemos en valores que rondan 1 milímetro y menos. Y la siguiente y última figura muestra la diferencia que existe entre una posición y otra al pasar por una línea. La primera gráfica muestra el ancho de la línea, la segunda y la tercera son el comportamiento de la corriente de colector al pasar el sensor por encima de la línea en una posición o en la otra. Y como resultado, la gráfica que más se ciñe al ancho de la barra es la de arriba, es decir, cuando el sensor esta e la posición 1.

70

Figura 3.12. Distancia de conmutación dependiendo de la posición del sensor respecto a una línea negra

Se puede comprobar que en la posición 1, el sensor tiene menor distancia de conmutación (“switching distance”), lo que hace más preciso a la hora de reconocer líneas finas. Según especificaciones técnicas del sensor, puede llegar a reconocer hasta líneas más finas de 0,5mm a una distancia inferior de 0,5mm de la superficie (véase dataste del CNY70, en el apartado 7.3.3 del anexo).

3.3 ENTORNO DEL MICROCONTROLADOR A la hora de adquirir el microcontrolador, una vez sabiendo el modelo que queríamos y necesitábamos, procedí a buscar lugares de venta, pero dada la novedosa salida de este tipo de PIC’s, la pagina de MICROCHIP© (www.microchip.com), proporcionaba a sus clientes

unos PIC’s de prueba de una forma totalmente gratuita, para que pudiésemos probarlo y experimentar con él. Eso es lo que hice, pedir el PIC 18F2550 (se pueden pedir un máximo de 4 en el envío). Me registré en la página y los pedí, me tenían que llegar de Tailandia. Por mail me iban informando los pasos que iba siguiendo mi envío hasta que lo embarcaban en el avión. Al cabo de 2 semanas me llegaba el paquete con mis cuatro PIC’s, sin tener que pagar gastos de envío ni nada.

LÍNEA

POSICIÓN 1

POSICIÓN 2

POSICIÓN 1

POSICIÓN 2

71

Una vez abierto el paquete, me encontraba con la factura, detalles del proveedor, en este caso, “MICROCHIPDirect” y mis PIC’s iban dentro de una bolsa antiestática y además dentro de un tubo de plástico antiestático, para más protección

A continuación damos paso a explicar brevemente los componentes que irán conectados al microcontrolador PIC.

3.3.1 Cristal oscilador de cuarzo

Un elemento indispensable para el funcionamiento de un microcontrolador es el cristal de cuarzo. Este genera la base de tiempo que necesita el microcontrolador para ejecutar el programa.

En nuestro diseño hemos escogido un cristal de cuarzo cuya frecuencia generada es

de 20MHz. Además, para estabilizar la frecuencia de dicho cristal, se colocan dos condensadores cerámicos, uno en cada para del encapsulado del cristal de cuarzo y a tierra, tal como muestra la figura siguiente:

Figura 3.13. Esquema eléctrico de la conexión del cristal de cuarzo con los condensadores y el PIC

Los pines OSC1 y OSC del PIC18F2550 son el 9 y el 10 respectivamente.

72

Para saber que valores deben tener los condensadores, se mira en la hoja de especificaciones t la relación entre la frecuencia y el valor de capacidad de los condensadores, tal como muestra la siguiente tabla:

Tabla 3.1. Relación entre la frecuencia del cristal y el valor de los condensadores.

Como podemos comprobar, el valor de dichos condensadores debe ser de 15 pF.

También se conectan otros elementos al microcontrolador, como un condensador cerámico de 100 nF entre alimentación y masa para eliminar el rizado de la señal de alimentación.

Además, también se conecta un condensador electrolítico en el pin 14 del PIC 18F2550, cuya función es regular la tensión de USB a 3,3 V. Este condensador debe tener un valor de 47 µ F. Este valor, viene en especificaciones técnicas del PIC. La siguiente figura muestra la conexión de dichos condensadores.

Figura 3.14. Conexión de los condensadores al PIC 18F2550

3.3.2 Pulsadores e interruptores

El último elemento externo esencial es el pulsador, elemento esencial para la interacción del usuario con el microcontrolador. Se utilizan dos pulsadores, uno más pequeño (6mm x 6mm) para el “RESET”, y otro más grande (12mm x 12mm) para generar la interrupción que hará que el lector empiece a leer. Y también hay que incorporar un interruptor que abra y cierre el circuito de la alimentación.

Figura 3.15. Pulsadores

73

3.4 COMUNICACIÓN MICROCONTROLADOR-PC

Para la comunicación del microcontrolador PIC con el PC hace falta un medio de conexión. Este medio de conexión no es nada más ni nada menos que un cable de 4 hilos, de los cuales, dos son para transmitir datos y los otros dos para transmitir potencia.

Figura 3.16. Esquema del tipo de cable USB utilizado

Los datos se transmiten de forma balanceada a velocidades entre 1,5 Mbps y 12 Mbps. La señal se transmite codificada en un código autoreloj de no retorno a cero invertido (NRZI) para poder incluir junto con los datos información de sincronización. Las líneas de alimentación (Vbus y GND) evitan la necesidad de utilizar fuentes de alimentación externas. Tiene una tensión de 5 V y la corriente se limita a un máximo de 500mA por razones de seguridad, siendo el consumo y la configuración eléctrica totalmente transparente al usuario. La distancia entre dos periféricos conectados al mismo cable no debe ser superior a 5 metros para evitar problemas de caídas de tensión.

Al comienzo se detectan los dispositivos conectados midiendo los niveles de voltaje de las líneas. Si un dispositivo está conectado, entonces el dispositivo envía información sobre el tipo o la clase a la que pertenece, qué modo de transferencia utilizará y cuáles son sus necesidades de ancho de banda.

El aspecto real de los cables USB es el siguiente, siendo el conector de la izquierda del tipo A y el de la derecha del tipo B.

Figura 3.17. Conectores tipo A (izquierda) y tipo B (derecha) del cable USB

74

Y este es el esquema del cabezal de los dos tipos de conectores USB, del tipo A a la izquierda y del tipo B a la derecha:

Figura 3.18. Vista alzada y frontal del conector macho USB de los dos tipos

Y por último la vista frontal de los conectores USB macho (a la izquierda) y de los conectores USB hembra (a la derecha):

Figura 3.19. Vista frontal de los conectores USB macho y hembra de los dos tipos

Los conectores macho suelen ir en los dispositivos portátiles que vayan a conectarse al hardware del ordenador, y el que está en el ordenador es el conector hembra. El dispositivo del proyecto lleva incorporado un conector hembra de tipo B en la placa. El motivo de ser hembra es porque no venden conectores macho que se suelden a placa. Y el motivo por el que es de tipo B es porque ocupa menos espacio superficial en el PCB que el tipo A, y es más robusto y se engancha mejor en la placa.

3.5 DISEÑO PCB

La implementación del circuito en una placa PCB es la manera óptima para crear un circuito abarcando el mínimo espacio posible, con la ventaja de poder dar forma a esta placa.

Antes de proceder al diseño del circuito impreso final, antes se crea un circuito de

prueba sobre una placa de topos, para comprobar que la selección de los componentes y el diseño del esquema eléctrico son correctos. Una vez probada esta placa que sirve de prototipo, y viendo que funciona correctamente, procedemos al diseño del PCB.

La tarea de la creación del PCB se puede dividir en dos fases:

- Diseño del circuito impreso - Fabricación y montaje del PCB

75

3.5.1 Diseño del circuito impreso Para empezar, el programa utilizado para crear dicha PCB ha sido el EAGLE 4.15

Layout Editor de la empresa Cadsoft, escogiendo este programa porque creo que es el más sencillo de usar y me da más posibilidades y rapidez que otros.

Antes que nada, hay que crear el circuito en el editor de esquemáticos del EAGLE.

Se van eligiendo los componentes requeridos en el diseño de una extensa lista de componentes que tienen las librerías del EAGLE por defecto. A la vez que eliges el símbolo del componente, a un lado se muestra el diseño en alzado del encapsulado junto a sus dimensiones para una posterior creación del layout.

Para introducir el PIC 18F2550 en el esquema circuital hay que descargar una

librería de Internet, en la página oficial de EAGLE (http://www.cadsoft.de). La librería en cuestión se llama “PIC18Fxx5x.lbr” y contiene todos los PIC’s de la familia 18Fxx5x junto a los diferentes encapsulados de cada uno. El que hay que elegir para este diseño es el 18F2550 en encapsulado ISP.

Una vez realizado las conexiones convenientes entre los componentes, ya esta listo

para que el programa me vuelque los componentes en el “Layout”, es decir, en la pantalla donde tendré que organizar los componentes sobre la superficie de la placa PCB a la que daré forma y tamaño. La forma que le he dado ha sido cuadrada, por la sencillez y por tener menos trabajo a la hora de recortar la placa después.

Tanto la colocación de los componentes como el ruteado de las pistas se realizarán

de forma que se puedan conseguir los siguientes objetivos:

- Minimizar la longitud de las pistas. - Minimizar el número de pistas. - Facilitar el soldado de los componentes - Facilitar el acceso a los interruptores y al conector USB

El elemento central del diseño es el microcontrolador, el emplazamiento del resto de los componentes dependerá de él, haciéndose en función de la conexión de cada uno de estos elementos con el microcontrolador y poniendo especial atención a los interruptores y al conector USB, de forma que se pueda acceder a ellos con facilidad. Para la implementación del circuito se utilizarán dos caras de trazado de pistas, la Top y la Bottom. En la cara Top es donde van los componentes, y en la cara Bottom es donde esta hecho el plano de masa. La anchura de las pistas y la separación entre pistas viene impuesta por la máquina de fabricación de los PCB’s, en este caso será de 0,8 mm. La separación entre las pistas y el plano de masa será de 1 mm aproximadamente, para asegurar que no haya problema de cortocircuito ni derivación de corriente a masa en alguna parte del circuito que sea problemático. El ruteado de las pistas se hará de forma automática por el programa EAGLE.

76

Las dimensiones y características dimensionales del circuito PCB vienen descritas en la siguiente tabla:

CARACTERÍSTICAS

Dimensiones de la placa 8,64x7,36 mm (3,40x2,9 mils) Capas de ruteado 2 (top y bottom) Anchura de las pistas 0,8001 mm (31,5 mils) Separación entre pistas 0,8001 mm (31,5 mils) Separación entre las pistas y el cobre del plano de masas 1,016 mm (40 mils)

Tabla 3.2. Características dimensionales de la placa PCB

Una vez hecho el ruteado y con los componentes en su sitio, el resultado es el

siguiente:

Figura 3.20. Diseño PCB con las pistas y los componentes

77

Y la imagen siguiente es sin los componentes:

Figura 3.21. Diseño PCB con solo las pistas en las dos capas

Una vez ruteado y puesto el nombre en nuestra placa, se crea un plano de masa, para que haya una buena referencia a tierra en todo el circuito. Esto evitará que haya diferentes caídas de tensión en diferentes puntos del circuito cuando debería haber la misma tensión. Además, en caso de cortocircuito se derive la corriente a masa sin dañar el resto del circuito. Mejor sería esta referencia si engancháramos esta placa a una carcasa, por eso se han puesto unas marcas para poder poner los tornillos y así poder enganchar a alguna carcasa.

78

Figura 3.22. Diseño PCB con las pistas y el plano de masa

3.5.2 Fabricación y montaje del PCB

En la fabricación del PCB, se necesita el fotolito de la placa diseñada anteriormente. Este fotolito se imprime en una hoja transparente preparada para impresoras de tinta de inyección. El objetivo es que la parte transparente sea lo más transparente posible y la parte de las pistas sea lo más negro y opaco posible, tan opaco que no pase la luz. Es el requisito que se demanda para fabricar el PCB. Este fotolito se envía a fabricar. Una vez creada el PCB se procede a una inspección visual para detectar posibles defectos de fabricación y se comprobarán mediante un multímetro las conexiones. El soldado de los componentes se realiza de forma manual mediante un soldador de montaje superficial. Terminada la soldadura de los componentes, se realiza una inspección de las conexiones mediante un multímetro para comprobar que no existen cortocircuitos entre las señales y que cada pata de los componentes está correctamente soldada.

Figura 3.23. Diseño del fotolito final que va a la insoladora

79

4 DESARROLLO DEL SISTEMA INFORMÁTICO

4.1 FLUJOGRAMAS DEL SISTEMA 4.2 PROGRAMACIÓN DE LA APLICACIÓN EN EL PIC 4.3 PROGRAMACIÓN DE LA APLICACIÓN EN EL PIC

80

4.1 ESQUEMA Y DIAGRAMAS DEL SISTEMA

En este apartado va a ser descrito el funcionamiento de las rutinas de los programas utilizados para llevar a cabo las funciones del lector, tanto de lectura de los códigos de barras como los procesos que realiza el programa del PC. Todo ello va a explicarse con flujogramas o diagramas de bloques para su fácil y rápida comprensión.

4.1.1 Flujograma general Para empezar, se explica el funcionamiento general del conjunto:

Este es el funcionamiento básico general de todo el proyecto. Desglosaremos cada parte en sucesivos flujogramas para más especificación. Más adelante detallamos cada apartado esencial que hay que comprender para leer el código fuente.

LEER CÓDIGO DE BARRAS

GUARDAR EN MEMORIA DEL PIC

PASAR DATOS AL PC?

ENVIAR DATOS AL PC

GESTION DE DATOS Y MOSTRAR POR PANTALLA

SI

NO

INICIO

81

4.1.2 Flujograma de la adquisición de datos del PIC a través del sensor

El siguiente flujograma explica los pasos que sigue el programa del PIC para obtener los resultados percibidos por el sensor en forma de datos.

La tabla es de 400 valores, aunque limitado por la memoria del PIC, son suficientes valores para poder hacer un buen tratamiento de la señal obtenida. Este valor esta muy por encima del valor calculado en el apartado 2.3 de la memoria de cálculo. Este número de muestras implica que el tiempo máximo total de lectura es de 1 segundo como mínimo aproximadamente, y puede ser más tiempo dependiendo del número de muestras que se repitan. Sabiendo que cada muestra tarda entorno unos 3 ms.

INICIO

ENVIAR ORDEN POR INTERRUPCIÓN EXTERNA PARA

ACTIVAR EL ADC

OBTENER DATO DEL CONVERSOR A/D

¿El dato obtenido es igual que el dato anteriormente

guardado en la tabla?

GUARDAR DATO EN UNA TABLA

( tabla[i]=DATO )

NO

SI

¿Esta la tabla de datos completa? ó

¿Fin de la lectura ADC?

NO

i++

FIN DE LA LECTURA

SI

82

4.1.3 Detección del inicio y final del código de barras

El hecho de detectar el inicio y final del código de barras nos ahorrará mucha faena a la hora de decodificar la información obtenida para traducirlo en el número EAN final. Para detectar el inicio del código de barras se comparan los valores obtenidos en el conversor A/D. Primero hasta que no toca el sensor con la superficie, y luego hasta que el sensor no pasa por encima de una barra que hará variar el nivel de A/D y por lo tanto podremos detectar la primera barra. Dicha detección de inicio del código de barras se explica por pasos en el siguiente flujograma.

INICIO

ENVIAR ORDEN POR INTERRUPCIÓN EXTERNA PARA ACTIVAR EL ADC


¿El dato obtenido es igual o mayor que el dato que equivale

al sensor en contacto con el papel?

GUARDAR DATO EN UNA TABLA

( tabla[i]=DATO )

SI

NO

INICIO DE LA LECTURA

SI


¿El dato obtenido equivale o es menor al valor de una

barra negra?

NO

83

Para la detección del final del código de barras lo que se hace es detectar los

máximos y cuando se hayan contado 30 máximos, es decir, 30 barras, la lectura se dará por finalizada. Este proceso se hace a la vez que se está leyendo el código de barras. La detección de máximos y mínimos se explica en el apartado 4.1.4.2.

INICIO DE LA LECTURA


¿Valor máximo?

SI

NO

FIN DE LA LECTURA

SI

CUENTA_BARRAS + 1

¿CUENTA_BARRAS = 30 ? NO

84

4.1.4 Decodificación de los datos obtenidos para obtener los números EAN

Está es una de las partes más importantes de todo el proyecto, por que es la parte que se encarga de traducir los valores obtenidos por el sensor en números del estándar EAN, es decir, el número del código de barras leído.

Para explicar esta parte primero haremos una explicación básica y general de todo el

proceso, que posteriormente se desglosa para explicar con más detalle cada punto de la decodificación.

4.1.4.1 Explicación general de la decodificación El inicio parte del momento que se obtiene la tabla de valores obtenidos de la

conversión A/D anterior.

El dispositivo es capaz de almacenar hasta un total de 50 códigos de barras. Es lo máximo que permite la memoria del microcontrolador PIC 18F2550.

INICIO

OBTENER LOS MÁXIMOS Y MINIMOS COMPARANDO CADA DATO DE LA TABLA

CON EL DATO ANTERIOR Y POSTERIOR

CLASIFICAR DICHOS MÁXIMOS Y MÍNIMOS EN 4 GRUPOS

ASOCIAR CADA PAR DE NÚMEROS EN NÚMEROS DEL ESTÁNDAR EAN

GUARDAR DICHOS NÚMEROS EN UNA TABLA

PREPARADO PARA ENVIAR LOS NUMEROS EAN DE LA

TABLA AL PC

85

4.1.4.2 Obtención de los máximos y mínimos valores

La intención de obtener dichos valores máximos y mínimos es para obtener los puntos donde se ha detectado una línea negra o una línea blanca.

INICIO

INICIALIZACIÓN DEL ÍNDICE DE LA TABLA DE DATOS DEL

CONVERSOR A/D A CERO.

LEER DATO DE LA TABLA ( tabla[i] )

¿El dato de la tabla es mayor que el dato anterior

y mayor que el dato posterior de la tabla?

GUARDAR MÁXIMO

SI

NO

SI

SI

NO

¿El dato de la tabla es menor que el dato anterior

y menor que el dato posterior de la tabla?

GUARDAR MÍNIMO

i++

NO

¿Fin de la tabla de datos

ADC?

FIN DE OBTENCIÓN DE MÁXIMOS Y MÍNIMOS

86

4.1.4.3 Clasificación de los máximos y mínimos en grupos

El siguiente paso de la descodificación será la de clasificar los máximos y mínimos obtenidos en la fase anterior en 4 grupos. La razón por la que clasificamos dichos valores en grupos es bien simple, y se basa en que las barras de los códigos de barras del estándar EAN tienen 4 tipos de grosores distintos, y partiendo de esto clasifico los máximos y mínimos según el nivel que tienen. Es decir, una barra del máximo grosor tendrá un nivel de pico máximo mayor que una barra de un grosor inferior, y lo mismo sucede con las barras blancas.

A continuación se muestra un ejemplo gráfico para clarificar este concepto de

clasificar los máximos y mínimos:

Figura 4.1. Ejemplo gráfico de la diferenciación entre distintos grosores de barras

Este gráfico de ejemplo muestra la clasificación de los grupos según el grosor de las líneas negras, también hay otro tipo de clasificación según las líneas blancas, que se miraría por los puntos mínimos de la grafica. Según el grupo al que pertenezca el máximo o mínimo se le asignará un valor del 1 al 4 el cual se guardará en su respectiva tabla para después ser tratado.

A continuación se muestra el flujograma para la clasificación de los valores máximos y mínimos:

1

2

3

4

GRUPOS

LECTURA ADC

87

INICIO

LEER MÁXIMO DE LA TABLA DE MÁXIMOS

ASIGNAR UN VALOR DEL 1 AL 4 SEGÚN EL NIVEL DEL VALOR MÁXIMO

GUARDAR EL VALOR DEL 1 AL 4 EN UNA TABLA DE VALORES MÁXIMOS

¿Fin de la tabla de máximos?

i++

i++

NO

SI

NO

SI

LEER MÍNIMO DE LA TABLA DE MÍNIMOS

ASIGNAR UN VALOR DEL 1 AL 4 SEGÚN EL NIVEL DEL VALOR MÍNIMO

GUARDAR EL VALOR DEL 1 AL 4 EN UNA TABLA DE VALORES MÍNIMOS

¿Fin de la tabla de mínimos?

FIN DE CLASIFICACIÓN DE MÁXIMOS Y MÍNIMOS

88

Esto sería la teoría básica de la clasificación de los grosores de barras, pero aún es un algoritmo susceptible de tener algún que otro error a causa de la poca diferencia un espacio y otro. El problema es que los niveles de los picos máximos y mínimos puede que entren en el mismo grupo por poca diferencia. Estudiando bien las gráficas que salen como resultado de las lecturas, se puede apreciar que las barras más anchas tienen puntos más cercanos al pico que en barras más estrechas. Como solución a esto se ha pensado en aplicar la teoría del llamado “Window moving”, o ventana móvil. Se trata de hacer la media de proporcional entre varias muestras para obtener una y así suavizar la señal eliminando picos producidos por ruido o alteraciones de la señal. En nuestro caso, aplicamos lo de la media proporcional a cada pico máximo o mínimo, por tal de diferenciar los picos en los grupos de grosores de barras. Tomamos como ejemplo la figura siguiente, donde hay dos picos con distinta curvatura, cuyo pico máximo es el mismo. Pero si realizamos la media entre el pico máximo, el valor anterior y el valor posterior, tenemos otro valor de pico. Resulta que el gráfico de la izquierda tiene los valores anterior y posterior más cercanos del pico máximo que en el gráfico de la derecha, por lo que la media será más alta, y por lo tanto, diferenciamos mejor los grosores de las barras.

Figura 4.2. Ejemplo gráfico de la corrección de picos máximos y mínimos con “Window moving”

Para precisar más, podemos considerar un valor más que los otros a la hora de hacer

la media. En el ejemplo anterior, hemos considerado para la media entre los tres que el pico máximo valía ½ y los valores anterior y posterior ¼, por lo que el valor de la media se aproxima más al pico máximo que si contasen los 3 valores 1/3. Esto depende de la necesidad del diseñador. En este proyecto, después de muchas pruebas, se ha llegado a la conclusión de que estas proporciones deben ser las siguientes:

Para los picos máximos: 1/3 - 1/3 - 1/3 Para los picos mínimos: 1/6 - 4/6 - 1/6

¼ ¼ ½ ¼ ¼ ½

Nº de muestra

Valor A/D

89

A continuación el flujograma que muestra el procedimiento de obtención de

máximos y mínimos con el método de la ventana móvil:

INICIO

LEER MÁXIMO DE LA TABLA DE MÁXIMOS, EL VALOR ANTERIOR Y EL POSTERIOR A ESTE MÁXIMO

ASIGNAR UN VALOR DEL 1 AL 4 SEGÚN EL NIVEL DEL VALOR MÁXIMO MEDIO OBTENIDO

GUARDAR EL VALOR DEL 1 AL 4 EN UNA TABLA DE VALORES MÁXIMOS

¿Fin de la tabla de máximos?

i++

i++

NO

SI

NO

SI

LEER MÍNIMO DE LA TABLA DE MÍNIMOS, EL VALOR ANTERIOR Y

EL POSTERIOR A ESTE MÍNIMO

FIN DE CLASIFICACIÓN DE MÁXIMOS Y MÍNIMOS

HACER LA MEDIA DE LOS TRES VALORES

(1/3 - 1/3 - 1/3)

(1/6 - 4/6 - 1/6)

HACER LA MEDIA DE LOS TRES VALORES

ASIGNAR UN VALOR DEL 1 AL 4 SEGÚN EL NIVEL DEL VALOR MÍNIMO MEDIO OBTENIDO

GUARDAR EL VALOR DEL 1 AL 4 EN UNA TABLA DE VALORES MÍNIMOS

¿Fin de la tabla de mínimos?

90

4.1.4.4 Asociación de cada par de números a números del estándar EAN

Si no ha habido ningún error deben haber 30 valores máximos asignados del 1 al 4 y

29 valores mínimos asignados del 1 al 4 también, por que son el número de barras que tiene el código de barras.

Ahora nos basaremos en que cada número del código de barras esta compuesto de 2

barras negras y dos barras blancas de diferentes grosores y de diferentes combinaciones. Con este hecho lo que haremos es asociar cada par de barras a un número del estándar EAN que en el apartado 1.5.3.5 viene detallado. Entonces recorreremos ambas tablas de valores máximos y mínimos al mismo tiempo, y recogiendo el valor de las dos barras negras y el valor la barra blanca que las separa, asignaremos a esta combinación un número EAN.

A continuación el flujograma que muestra los pasos que sigue el programa de una

forma esquemática y ordenada:

INICIO

LEER DATO DE LA TABLA DE VALORES MÁXIMOS Y GUARDAR EN UNA VARIABLE

LEER DATO DE LA TABLA DE VALORES MÍNIMOS Y GUARDAR EN UNA VARIABLE

índice_valores_máximos + 1

LEER DATO DE LA TABLA DE VALORES MÁXIMOS Y GUARDAR EN UNA VARIABLE

SEGÚN EL VALOR DE DICHAS VARIABLES ASIGNAR UN NÚMERO DEL ESTÁNDAR EAN Y GUADARLO EN LA TABLA DE NÚMEROS EAN.

91

4.1.4.5 Detección y corrección de errores

Durante el proceso de obtención del número del código de barras se pueden producir varios errores a causa de una mala lectura, consecuencia de un incorrecto uso del lector a la hora de intentar proceder a la lectura de un código de barras. El sistema tiene una serie de algoritmos y pautas que evitan ciertos errores hasta el punto de corregirlos, en otro caso se avisa por la señal luminosa del LED que la lectura es incorrecta, y por lo tanto, no es válida. Según la secuencia del parpadeo del LED nos advertirá de que tipo de error puede haberse tratado. La asignación de dichas secuencias están descritas en el manual de usuario, apartado 7.2.2 del anexo.

A continuación describimos todos los posibles errores que pueden producirse en una

lectura:

- No haber leído todas las barras. - Haber interpretado grosores de barras negras o blancas que no correspondan

con la realidad.

Ahora las soluciones adoptadas para corregir ciertos errores, o bien, avisar al usuario

de que se ha producido un error. La diferencia entre corregir y avisar radica en que hay errores que no se pueden corregir por falta de información proporcionada por el sensor, por ese motivo un indicador luminoso LED nos advierte que la lectura realizada no es correcta y por lo tanto no será guardada.

¿Fin de la tabla de valores máximos?

índice_valores_máximos + 1

SI

NO

NÚMERO EAN OBTENIDO Y GUARDADO EN LA TABLA DE NÚMEROS EAN

índice_valores_mínimos + 2

92

Por otra parte, hay errores de lectura que si se pueden corregir y otros que se pueden evitar. Para los que se pueden corregir, se trata de arreglar la gráfica obtenida de los valores del conversor A/D, donde se pueden haber producido picos que pueden confundir al algoritmo de obtención de máximos y mínimos. Los casos que se pueden dar son los siguientes:

Figura 4.3. Ejemplo gráfico de la corrección de ciertos errores de lectura

Para corregir esto, se vuelve a recorrer la tabla de los valores del ADC y se corrige

cambiando ciertos valores que pueden producir error, como por ejemplo, hacer la media entre los valores adyacentes al pico que se quiere arreglar, así como resultado el pico desaparece y se queda alineada con los valores adyacentes. O por ejemplo, en el pico máximo, se produzcan dos picos máximos pero que en realidad es un solo pico máximo, entonces, detectando esos dos picos, se cambia el valor del central y se pone por encima de los anteriores. Así finalmente conseguimos arreglar la gráfica para que luego detecte los verdaderos máximos y mínimos.

A la hora de evitar errores, nos basamos en la probabilidad de obtener unos grosores de barras u otros. Dependiendo de los grosores de las dos barras leídas, podemos evitar que como resultado obtengamos un grosor de espacio que es imposible que pueda producirse. Para eso se ha mirado la tabla 1.5 del apartado 1.5.3.5 y se han buscado todos los posibles casos. Por ejemplo, si detectamos una barra de grosor máximo (grosor 4) y una barra de grosor mínimo (grosor 1), podemos intuir, que entre estas barras no puede haber un espacio de grosor mayor que 1.

RECTA CON ERROR

CORRECCIÓN

93

4.1.5 Transferencia de datos del PIC al PC

En este apartado se explica la manera en que interactúan el PIC y el PC a la hora de comunicarse para transferir datos. En este caso en concreto, se trata de enviar los números EAN obtenidos de todas las lecturas al PC para poder ser visualizado en pantalla y almacenar los datos.

El HOST es físicamente el HUB, que es el concentrador USB que se encarga de la comunicación USB, si hay un dato en el buffer del HUB y es de entrada, significa que va del fuera al PC y si es de salida significa que va del PC a fuera, en nuestro caso al PIC.

INICIO

El PIC coloca el dato en el buffer de entrada del HOST*

( PIC à PC )

¿Hay dato en el buffer de entrada

del HOST? ( PIC à PC )

ENVIAR DATO AL PC DESDE EL PIC

GUARDAR DATO EN UNA TABLA ( tabla[i] = DATO )

¿Hay otro dato a recibir?

i++

NO

SI

NO

SI

FIN DE LA TRANSMISIÓN

94

4.2 PROGRAMACIÓN DE LA APLICACIÓN EN EL PIC

Este apartado hace referencia al programa hecho para el PIC, explicando el compilador utilizado, librerías utilizadas y funciones para la lectura de los códigos de barras y para la comunicación USB.

4.2.1 El compilador y las librerías

El compilador utilizado para crear el programa en el PIC es el PCWH de la empresa CCS, como anteriormente en esta memoria se ha comentado.

En este apartado nos centramos en las librerías utilizadas para la correcta creación

del programa. El código detallado de cada librería se encuentra en los anexos (apartado 7.3.3) de esta memoria.

Las librerías del programa del PIC son las siguientes: 18F2550.h : Librería con las direcciones de los pines del PIC 18F2550 y la definición de constantes esenciales para programar este microcontrolador. pic18_usb.h : Librería que incluye las funciones y constantes necesarias para la comunicación USB con los microcontroladores de la familia 18Fxx5x. PakoUSB.h : Librería con la configuración del dispositivo USB y sus descriptores que dan identidad personal al producto. Es el responsable de que salga el nombre del producto por pantalla una vez conectado el lector al puerto USB. usb.c : Otra librería con más funciones generales sobre la comunicación USB, esta librería además contiene la librería usb.h.

4.2.2 Funciones utilizadas para la lectura y comunicación USB

En este apartado se comentan las funciones utilizadas para la creación del código, y se describe la función que desempeñan en el conjunto del lector.

Para la lectura de los códigos de barras disponemos de un sensor conectado al conversor analógico/digital del PIC. Partiendo de esto tendremos que obtener los valores de tensión dados en el sensor en forma de números que podamos interpretar y tratar.

Para empezar, el ADC (conversor analogico/digital) tiene una resolución de 10 bits, esto supone tener 1024 posibles valores de tensión. Una manera de decírselo al compilador es la siguiente:

#device ADC = 10

95

Después hay que configurar el ADC para que funcione de la manera que queramos, y al compilador hay que decirselo de la siguiente manera: setup_port_a(ALL_ANALOG | VSS_VDD); //todas las entradas analogicas, y las tensiones de referencia son las que le entran al PIC por el pin VSS y VDD. setup_adc(ADC_CLOCK_INTERNAL); //que use el reloj interno del PIC set_adc_channel(1); //por último decirle que el canal donde tiene que estar listo para recibir informacion a convertir set_tris_A(0b00000010); //esto último es para configurar el pin 1 RA1 como entrada y los demas como salida, aunque el resto nos va a dar igual Una vez configurado el ADC, pasaremos a la lectura, es decir, a obtener los datos y guardarlos en una tabla para poder ser tratados luego. Para hacer esto echaremos mano de la siguiente función:

read_adc();

Y usado de la siguiente manera almacenamos el valor sacado del conversor en una variable, cuyo nombre es “resultado_adc” y es un entero:

resultado_adc=read_adc(); Esta función se le llama periódicamente, con una frecuencia constante, almacenando los datos leídos en una tabla de “x” posiciones.

96

4.2.3 Funciones utilizadas para la comunicación USB

Ahora detallamos las funciones necesarias para la comunicación USB entre el PIC y el PC. Pero antes de nada, habrá que hacer una breve descripción del funcionamiento de comunicación del USB para entender el porqué de dichas funciones y los parámetros que le acompañan.

En la siguiente figura se puede ver la arquitectura del sistema y el flujo de comunicaciones entre los distintos niveles.

Figura 4.4. Flujo de comunicaciones entre un dispositivo USB y el host

El flujo de datos del bus USB desde un punto de vista lógico hay que entenderlo como una serie de puntos finales (endpoints), que se agrupan en conjuntos que dan lugar a interfaces, las cuales permiten controlar la función del dispositivo. La arquitectura se puede dividir en tres niveles o capas. En el nivel mas bajo el controlador de host USB se comunica con la interfaz del bus utilizando el cable USB, mientras que en un nivel superior el software USB del sistema se comunica con el dispositivo lógico utilizando el canal (pipe) de control por defecto. En lo que al nivel de función se refiere, el software cliente establece la comunicación con las interfaces de la función a través de canales asociados a puntos finales. Cada dispositivo USB está compuesto por unos puntos finales independientes y una dirección única asignada por el sistema en tiempo de conexión, de forma dinámica. A su vez, cada punto final dispone de un identificador único dentro del

97

dispositivo (número de endpoint) que viene asignado de fábrica, además de una determinada orientación del flujo de datos. Cada punto final es por si solo una conexión simple, que soporta un flujo de datos de entrada o de salida. Un canal USB es una conexión lógica entre un punto final del periférico y el software del host, que permite intercambiar datos entre ellos. El canal que esta formado por el punto final 0 se denomina canal de control por defecto. Este canal está siempre disponible una vez se ha conectado el dispositivo y ha recibido un reset del bus. El resto de canales aparecen después de que se configure el dispositivo. El canal de control por defecto es utilizado por el software USB del sistema para obtener la identificación y para configurar al periférico. Todos los dispositivos USB tienen una jerarquía de descriptores:

Figura 4.5. Jerarquía de descriptores

• Descriptor de dispositivo: Es único. Incluye la versión de USB, el identificador de vendedor y producto (que identifican el driver) y el número de configuraciones que el dispositivo tiene.

• Descriptor de configuración: Especifica la potencia requerida y si el dispositivo

tiene alimentación propia o no. Puede haber varias configuraciones (diferentes combinaciones de interfaces y endpoints) y el host puede seleccionar una. Sólo puede haber una activa.

• Descriptor de interface: Es una unión de puntos finales en un grupo funcional que

realizan una tarea única. Ejemplo: impresora, scanner y fax, cada uno es un interface.

• Descriptor de punto final: Especifica el tipo de transferencias usadas, la dirección

de los datos y el tamaño máximo del paquete de datos para cada endpoint. El punto final 0 siempre es de control por defecto y no tiene descriptor. La dirección de los datos es desde el punto de vista del host (IN: del periférico al host, OUT: del host al periférico).

98

La siguiente figura muestra la arquitectura de comunicación entre dos dispositivos USB y el host mediante los puntos finales (endpoints):

Figura 4.6. Flujo de comunicaciones entre un dispositivo USB y el host a través de los endpoints

De los diferentes endpoints que hay para establecer la comunicación, se utiliza

siempre el endpoint0 (EP0) porque es el de control. Y para la transferencia de datos entre el dispositivo y el host usaremos el endpoint 1, que es bidireccional y tiene tres modos de comunicación, el “bulk”, por interrupción o isócrona. En nuestro caso, el modo de comunicación más conveniente es el “bulk”, que nos permite hacer transferencias de paquetes de datos de diferentes tamaños. También es la manera más rapida de enviar y/o recibir grandes cantidades de información. #define USB_HID_DEVICE FALSE //deshabilitamos el uso de las directivas HID #define USB_EP1_TX_ENABLE USB_ENABLE_BULK //activa el EP1(EndPoint1) para transferencias de entrada (IN) bulk/interrupt #define USB_EP1_RX_ENABLE USB_ENABLE_BULK //activa el EP1(EndPoint1) para transferencias de salida (OUT) bulk/interrupt #define USB_EP1_TX_SIZE 1 //tamaño de informacion para reservar en el buffer de envio de datos del endpoint 1(1 byte) #define USB_EP1_RX_SIZE 3 //tamaño de informacion para reservar en el buffer de recibir datos del endpoint 1 (3 bytes)

99

Las funciones para la inicialización del dispositivo USB con el PC son las siguientes:

usb_init(); Inicializa el stack USB, la periferia del USB y conecta la unidad al bus USB. También habilita las interrupciones, en general, inicializa el USB.

usb_task(); Se encargar de mirar el estado de la conexión, para ver si se ha conectado, o si se conecta o desconecta el dispositivo al bus USB.

usb_wait_for_enumeration(); Se mantiene en un bucle infinito hasta que el dispositivo es enumerado.

usb_enumerated(); Esta función devuelve TRUE si el dispositivo ha sido enumerado (configurado) por el HOST, y FALSE si no ha sido así. Se recomienda no hacer uso de las funciones del USB hasta que no se haya enumerado y configurado el dispositivo.

usb_kbhit(1); Devuelve TRUE si la salida (OUT) del endpoint contiene datos del HOST, el 1 significa que se refiere al endpoint 1 (EP1). Por el funcionamiento portátil del dispositivo, se ha tenido que programar el PIC de una manera que mientras no estuviese conectado al puerto USB del PC el lector pudiese hacer su función de lector, y para ello habría que separar las funciones cuando el dispositivo esta conectado o no. Para ello se ha tenido que hacer un pequeño truco que se trata de conectar el pin 1 del USB (el pin de alimentación de 5 V) a un pin de entrada y salida del PIC, para crear una interrupción cuando este pin detecte un nivel alto, diese la información necesaria al PIC y empezase la tarea de enumeración y configuración del dispositivo USB con HOST del PC. En nuestro caso hemos utilizado uno de las entradas libres en el puerto B del PIC, por ejemplo el RB2. Para declarar que el pin que corresponde a la entrada RB2 se hace con la siguiente línea de código al principio del programa.

#define USB_CON_SENSE_PIN PIN_B2

Figura 4.7. Configuración eléctrica para el USB connection sense pin

VUSB (5V)

I/O PIN en el PIC

GND

4k7 Ω

100

La figura siguiente ejemplifica y clarifica esta explicación:

Figura 4.8. Conexión de los pines del puerto USB con los pines del PIC 18F2550

Por último quedan las funciones para recibir datos del PC y enviar datos del al PC. El de recibir datos (usb_get_packet) se usa en este caso para recibir ordenes del PC para que el PIC realice alguna tarea, como por ejemplo la de que envie los datos contenidos en el PIC al PC. En el caso de enviar datos al PC (usb_put_packet) es para lo que se ha mencionado anteriormente, enviar los datos guardados de las conversiones ADC.

usb_get_packet(1, recibe, 3); //cojemos el paquete de tamaño 3bytes del EP1 y almacenamos los datos para un uso //específico, en este caso en una variable llamada “recibe”

usb_put_packet(1, envia, 1, USB_DTS_TOGGLE); //enviamos el paquete de tamaño 1byte del EP1 al PC, usando la variable” envia” que es la que contiene el byte a enviar. La razón de “put_packet” es poner el paquete de bytes en el buffer para que el PC lo //recoja Referente a la comunicación USB, se puede consultar toda la información necesaria de la bibliografía, páginas web y documentos que hay en los anexos (apartado 7.3) de la memoria.

5V D - D+ GND

1

4

20 8

PIC 18F2550

28

19

23

1

PIN 8 à VSS PIN 15 à D – PIN 16 à D + PIN 19 à VSS PIN 20 à VDD PIN 23 à RB2

15 16

“SENSE PIN” (PIN QUE DETECTA LA

CONEXIÓN USB)

14

101

4.3 PROGRAMACIÓN DE LA APLICACIÓN EN EL PC

En este apartado se muestra el programa realizado en el PC, detallando el compilador utilizado, la función que tiene en todo el conjunto, las cosas que se han necesitado para la comunicación USB, las funciones más importantes que componen el programa y por último la estética que tiene el programa de cara al usuario.

4.3.1 El compilador utilizado y las librerías

En este caso, el compilador utilizado para crear el programa en el PC es el Visual C#, como se ha comentado en un apartado anterior.

Las librerías utilizadas han sido las propias del compilador, aunque para programar

la comunicación USB, se han hecho servir funciones proporcionadas por MICROCHIP© que vienen en el archivo “mpusbapi.dll”. Las funciones utilizadas en el programa del PC se pueden ver en el siguiente apartado, y el resto de las funciones y contenido de este archivo se puede ver en los anexos, apartado 7.3.3.

4.3.2 Funciones importantes del programa para la gestión y comunicación USB

Esta es la parte de la programación de más relevancia en la comunicación por bus

USB, ya que sin estos primeros pasos, y sin tener conocimientos básicos previos no se podría llevar a cabo el propósito de la comunicación USB.

Para empezar, este codigo corresponde a la parte de programa del proyecto en Visual

C#, es decir, el llamado por defecto “Program.cs”. Hay que definir el VID (Vendor Identification) y el PID (Product Identification). Y

se hace de la siguiente manera.

#region Definición de los Strings: EndPoint y VID_PID string vid_pid_norm = "vid_04d8&pid_0011";

Hay proporcionados una serie de numeros para uso personal y para probar proyectos, pero en un caso real, la propia casa de USB te proporciona unos números únicos para tu producto, si tu producto ha pasado una serie de pruebas para garantizar el correcto funcionamiento del dispositivo USB, y así tu producto poder llevar el logo USB que garantice al consumidor que el producto ha sido probado por “USB-IF Inc” (“USB Implementers Forum Inc.”). Para conseguirlo has de rellenar una solicitud para que tu producto pase las pruebas técnicas para que sea merecedor del logo. Además, se ha de pagar una fianza de 2000$ americanos. Si eres miembro de “USB-IF Inc.”, a parte de los beneficios que supone, has de pagar una fianza de 4000$ americanos anuales.

Para má información visitar ” http://www.usb.org/developers/vendor/ ”, en esta

dirección se pueden descargar las solicitudes y mirar los detalles sobre el pago y obtención del VID.

102

El periférico que se va a desarrollar no pertenece a ninguna clase genérica, así que habrá que indicar el driver que se le quiere asignar. El driver que se utilizará será un driver USB de propósito general para Windows suministrado por Microchip (mchpusb.sys). Así mismo, Microchip proporciona un identificador de vendedor (0x04D8) que puede ser utilizado en productos desarrollados con microcontroladores PIC.

Para más información, consultar la siguiente URL:

http://www.usb.org/developers/logo_license.html

Y a continuación definir el endpoint por el que van a pasar los datos, que en este caso sera el endpoint 1 (EP1): string out_pipe = "\\MCHP_EP1"; //de salida ( PC à PIC ) string in_pipe = "\\MCHP_EP1"; //de entrada ( PIC à PC ) #endregion Una vez definido la ruta de paso de datos e identificado el producto, habra que importar las funciones que necesitaremos para el proyecto. Dichas funciones, como ya hemos comentado anteriormente, se importan del archivo “mpusbapi.dll”, y se hace de la siguiente manera: #region Funciones importadas de la DLL: mpusbapi.dll [DllImport("mpusbapi.dll")] private static extern DWORD _MPUSBGetDLLVersion(); [DllImport("mpusbapi.dll")] private static extern DWORD _MPUSBGetDeviceCount(string pVID_PID); [DllImport("mpusbapi.dll")] private static extern void* _MPUSBOpen(DWORD instance, string pVID_PID, string pEP, DWORD dwDir, DWORD dwReserved); [DllImport("mpusbapi.dll")] private static extern DWORD _MPUSBRead(void* handle, void* pData, DWORD dwLen, DWORD* pLength, DWORD dwMilliseconds); [DllImport("mpusbapi.dll")] private static extern DWORD _MPUSBWrite(void* handle, void* pData, DWORD dwLen, DWORD* pLength, DWORD dwMilliseconds); [DllImport("mpusbapi.dll")] private static extern DWORD _MPUSBReadInt(void* handle, DWORD* pData, DWORD dwLen, DWORD* pLength, DWORD dwMilliseconds); [DllImport("mpusbapi.dll")] private static extern bool _MPUSBClose(void* handle); #endregion

103

Las funciones importadas del “mpusbapi.dll” son las que se usarán luego en el programa para crear la comunicación USB entre el PC y el microcontrolador. Dichas funciones, exactamente sirven para abrir o cerrar los canales de entrada o salida, y para enviar o recibir paquetes de datos. Dichas funciones son las siguientes: void* myOutPipe; void* myInPipe; public void OpenPipes() DWORD selection = 0; myOutPipe = _MPUSBOpen(selection, vid_pid_norm, out_pipe, 0, 0); myInPipe = _MPUSBOpen(selection, vid_pid_norm, in_pipe, 1, 0); public void ClosePipes() _MPUSBClose(myOutPipe); _MPUSBClose(myInPipe); private void SendPacket(byte* SendData, DWORD SendLength) uint SendDelay = 1000; DWORD SentDataLength; OpenPipes(); _MPUSBWrite(myOutPipe, (void*)SendData, SendLength, &SentDataLength, SendDelay); ClosePipes(); private void ReceivePacket(byte* ReceiveData, DWORD* ReceiveLength) uint ReceiveDelay = 1000; DWORD ExpectedReceiveLength = *ReceiveLength; OpenPipes(); _MPUSBRead(myInPipe, (void*)ReceiveData, ExpectedReceiveLength, ReceiveLength, ReceiveDelay); ClosePipes();

También hay otra funcion “_MPUSBGetDeviceCount” que la utilizamos para detectar si un dispositivo específico esta conectado al puerto USB. Digo específico por que lo que hace la función es comparar la PID y la VID, y como són únicas en cada dispositivo, podemos concretar si el dispositivo al que va relacionado el programa esta conectado al puerto USB.

104

Una vez escritas las funciones anteriores, ya podemos hacer uso de ellas para nuestros objetivos personales. En este proyecto, lo más importante es el envio y recepción de datos, por lo que muestro dos ejemplos a continuación: Aquí enviamos 2 bytes, que colocamos en “send_buf” y con la funcion “SendPacket()” lo llegamos a enviar.

public void enviar_datos(uint dato)

byte* send_buf = stackalloc byte[2]; send_buf[0] = 0x01; send_buf[1] = (byte)dato; SendPacket(send_buf, 2);

En esta recibimos los datos, primero enviamos 1 byte informando de que el PC quiere obtener los datos que tiene el PIC, y una vez hecho esto, el PIC empezara a enviar paquetes de 2 bytes que se almacenan en “receive_buf”, y esto se almacena en una variable del programa que luego es tratado para mostrar en pantalla de la manera que queramos.

public int obtener_datos(int index)

byte* receive_buf = stackalloc byte[2]; byte* send_buf = stackalloc byte[1]; DWORD RecvLength = 2; int result,result1,result2; tabla = new int[128]; send_buf[0] = 0x00; SendPacket(send_buf, 1); ReceivePacket(receive_buf, &RecvLength); result1 = receive_buf[0]; result2 = receive_buf[1]; result2 = result2 << 8; result = result1 + result2; tabla[index] = result; return result;

105

4.3.3 Proceso de instalación del programa y drivers necesarios

Cuando el sistema operativo detecta un nuevo periférico USB, intenta determinar que driver debe utilizar para comunicarse con el dispositivo y una vez determinado, cargar el driver seleccionado. Esto lo lleva a cabo el Administrador de Dispositivos, que utiliza instaladores de clase y dispositivo y archivos INF para encontrar el driver adecuado para cada dispositivo. El Administrador de Dispositivos además de ser el responsable de instalar, configurar y desinstalar dispositivos, también se encarga de añadir información sobre cada dispositivo en el registro del sistema, el cual contiene información sobre el hardware y el software instalados en el sistema.

Los instaladores de clase y dispositivo son DLL’s. Windows tiene una serie de instaladores por defecto que el Administrador de Dispositivos utiliza para localizar y cargar los drivers para dispositivos pertenecientes a clases soportadas por el sistema operativo. El archivo INF es un fichero de texto que contiene información que ayuda a Windows a identificar el dispositivo. Este archivo indica al sistema operativo que drivers debe utilizar y que información debe almacenar en el registro.

El dispositivo desarrollado no pertenece a una de las clases USB por defecto que

soporta el sistema operativo así que tanto el instalador de clase como el archivo INF habrá que crearlos.

Cuando se conecta el dispositivo al ordenador, Windows muestra el mensaje Nuevo

Hardware Encontrado. Si el periférico nunca ha sido enumerado en el sistema, el sistema operativo necesita localizar un driver para él. Al ser la primera vez que se conecta el dispositivo y no ser de una clase genérica, Windows no encontrará un archivo INF que pueda utilizar para asignarle un driver y lanzará el Asistente para Agregar Nuevo Hardware donde se puede indicar la localización del archivo INF necesario para la instalación del periférico. Una vez localizado, se carga el driver indicado, se añade el periférico en el Administrador de Dispositivos y se indica al usuario que la instalación del dispositivo ha finalizado de forma correcta. En el Administrador de Dispositivos se puede ver también la descripción del dispositivo y el fabricante, obtenidos del archivo INF. Además, durante esta operación, se ha copiado el fichero INF (picusb.inf) en el directorio \windows\inf, el driver (mchpusb.sys) en \windows\system32\drivers y el instalador de clase (mpusbci.dll) en \windows\system32, de forma que la próxima vez que se conecte el dispositivo, el ordenador lo reconocerá sin necesidad de indicar ningún dato.

La información en un archivo INF está dividida en secciones. Cada sección puede

ser identificada porque su nombre está entre corchetes. Las principales secciones son:

• Version: Especifica el sistema operativo para el que está destinado el fichero INF. En esta sección se indica también el nombre de la clase de los dispositivos instalados con este fichero así como un identificador de clase que es utilizado por el registro del sistema para identificar a los dispositivos pertenecientes a esta clase.

• ClassInstall: En esta sección se indica si se ha de instalar una nueva clase. El

Administrador de Dispositivos únicamente procesa la sección si una clase de dispositivo aún no está instalada en el sistema. Aquí será donde indicaremos el icono, el nombre y la descripción de la clase así como el nombre del archivo DLL (mpusbci.dll) que instalará la nueva clase en el Administrador de Dispositivos.

106

• Manufacturer: Contiene el identificador de vendedor y producto (USB\VID_04D8&PID_0011). Cuando el Administrador de Dispositivo encuentra una coincidencia entre estos valores y los identificadores obtenidos del dispositivo durante la enumeración, sabe que ha encontrado el archivo INF correcto.

• DestinationDirs: Indica el directorio o directorios donde se copiarán los ficheros.

• Strings: Define las cadenas referenciadas en las otras secciones. El fichero INF

creado (picusb.inf) puede verse en el apartado 7.1.2 del anexo.

A continuación se muestra la información del dispositivo conectado al PC mediante

la ventana de Administrador de dispositivos:

Figura 4.9. Vista del “Administrador de tareas” con el dispositivo USB reconocido y funcionando

107

4.3.4 Estética del programa

Se ha pensado en un diseño sencillo, bonito y de fácil manejo para el usuario. El programa consta de una sola ventana donde están todos los controles necesarios para la comunicación entre el PIC y el PC. Aparte hay un cuadro de texto para visualizar los números de los códigos de barras leídos y una pequeña línea de texto de color negro donde informa al usuario del estado en cada momento.

Figura 4.10. Vista del programa que guarda y gestiona los datos recibidos del dispositivo USB

108

5 PRESUPUESTO

5.1 INTRODUCCIÓN 5.2 COSTE DE RECURSOS HARDWARE 5.3 COSTE DE RECURSOS SOFTWARE 5.4 COSTE DE COMPONENTES Y FABRICACIÓN DEL PCB 5.5 COSTE DE RECURSOS HUMANOS 5.6 COSTE TOTAL DEL PROYECTO 5.7 COSTE DEL DISPOSITIVO EN EL MERCADO

109

5.1 Introducción

Para realizar una estimación del coste económico del proyecto, se han dividido los gastos asociados al desarrollo del mismo en varios grupos:

• Recursos hardware: Hardware necesario para la realización del proyecto

pero que no forma parte de él. • Recursos software: Software necesario para llevar a cabo la realización del

proyecto pero que no forma parte constituyente de él.

• Componentes y fabricación del PCB: Coste de los componentes del circuito impreso y coste de la fabricación del mismo

• Recursos humanos: Mano de obra necesaria para realizar el proyecto

El coste total es la suma de todos los costes anteriores. Además, se añade al final el coste del producto una vez puesto en el mercado.

5.2 Coste de recursos hardware

El hardware de desarrollo del sistema consta de un ordenador personal de sobremesa de las siguientes características:

- Procesador AMD Duron a 902MHz - Memoria RAM de 1Gb - Disco duro de 40 Gb - Monitor LG de 17”

A parte del ordenador se ha necesitado el hardware grabador del PIC, el GTP-

USB+ , un soldador y estaño para el montaje de la placa PCB, un multímetro digital y un cable USB para la comunicación entre el dispositivo y el PC

CONCEPTO PRECIO PC AMD Duron a 902MHz 81,25€ * Grabador de PIC’s GTP-USB+ 60,00 € Soldador de precisión 30,00 € Multímetro digital 15,00 €

TOTAL 186,25 € Tabla 5.1. Coste de recursos hardware

* El PC cuesta 1200,00 € que se amortizan en 4 años (48 meses), haciendo uso de él 8 horas diarias. Esto supone 25 horas al mes, considerando que al mes se usa el PC 160 horas y en total se ha usado 520 horas para el trabajo del ingeniero el total es de:

(25 € / 160 h) x 520 h = 81,25 €

110

5.3 Coste de recursos software

El software utilizado en el desarrollo del proyecto consta del sistema operativo, la herramienta utilizada en el diseño de la placa PCB, el compilador de C CCS para el software del PIC, el programa para grabar los programas en el PIC Winpic800, y por último el Visual C# para el desarrollo de la aplicación en el entorno de Windows.

El sistema operativo utilizado ha sido el Microsoft Windows XP Profesional, con la

ampliación del service pack 2, sin el cual no habría sido posible la creación de la aplicación en Visual C# 2005 Express Edition. El Visual C# ha sido utilizado para el desarrollo del programa monitor y para la aplicación del proyecto.

La herramienta para el diseño de la placa PCB es el EAGLE Layout Editor 4.15 y el

programa para la grabación de los programas al PIC ha sido el Winpic800 v3.60. Por último el compilador de C ha sido el PCWH 3.227 de la casa CCS.

CONCEPTO PRECIO Microsoft Windows XP Profesional 131,52 €

EAGLE Layout Editor 4.15 200,00 € Compilador CCS v3.227 331,86 € Visual C# 2005 Express Edition 0,00 €

Winpic800 v3.60 0,00 € TOTAL 663,38 €

Tabla 5.2. Coste de recursos software

5.4 Coste de componentes y fabricación del PCB La siguiente tabla muestra la cantidad y coste de los diferentes componentes utilizados para el montaje del dispositivo:

CONCEPTO REFERENCIA PRECIO UNIDAD

UNIDADES PRECIO TOTAL

Resistencia ¼ W 1k Ω R1 0,03 3 0,09 Resistencia ¼ W 180Ω R2 0,03 2 0,06 Resistencia ¼ W 47kΩ R3 0,08 2 0,16 Resistencia ¼ W 10kΩ R4 0,04 1 0,04 Resistencia ¼ W 4k7Ω R5 0,04 2 0,08 Condesador electrolítico 47microF 25V

C1 0,18 1 0,18

Condensador cerámico 15nanoF 500V

C2 0,03 2 0,06

Condensador cerámico 100nF C3 0,11 1 0,11

111

Cristal oscilador de cuarzo 20MHz

Q1 0,87 1 0,87

Diodo LED 3mm diámetro Rojo(10mA)

D1 0,10 1 0,10

Diodo LED 3mm diámetro Amarillo(10mA)

D2 0,10 1 0,10

Diodo LED 3mm diámetro Verde(10mA)

D3 0,10 1 0,10

Pulsador CI vert. 6x6 mm CC-PUSH

BTN1 0,26 1 0,26

Pulsador CI vert. 12x12 mm CC-PUSH

BTN2 0,34 1 0,34

Mini-interruptor de alimentación

BTN3 0,76 1 0,76

Transistor MOSFET de canal N 2N7000 Encapsulado TO-92

T1 0,24 1 0,24

Transistor MOSFET de canal P BS250 Encapsulado TO-92

T2 0,46 1 0,46

Estabilizador de tensión a 5 V y 100mA 78L05 Encapsulado TO-92

T3 0,19 1 0,19

Zocalo 28 pines ZCL1 0,27 1 0,27 USB tipo B hembra para chasis USB1 1,25 1 1,25 Placa fotosensible fibra de vidrio 2 caras 80x120 mm 1,2mm

PCB1 3,20 1 3,20

Microcontrolador PIC 18F2550 CH1 4,62 1 4,62

CNY70 (Sensor óptico de reflexión de Vishay)

S1 1,12 1 1,12

Cable de conexión para el sensor de 1,5 m

Cbl1 0,21 1 0,21

Cable USB de 1,5 m con conectores TIPO A macho y TIPO B macho.

Cbl2 1,95 1 1,95

TOTAL 16,82 €

Tabla 5.3. Coste de los componentes y el PCB

112

5.5 Coste de recursos humanos

Los recursos humanos en el proyecto corren a cargo del proyectista al que se le aplicará un sueldo de Ingeniero hipotético de 21.000 €/año. El proyecto se ha dividido en tareas cada una con un coste estimado en horas/hombre. No todas estas tareas necesitan de un ingeniero, algunas pueden ser realizadas por un técnico oficial de 2ª, en cuyo caso el proyectista tomará su papel. El salario hipotético del técnico será de 12.000 €/año. Considerando que un año tiene 1700 horas hábiles, se obtienen los siguientes salarios por hora:

• Ingeniero: 12,35 €/hora • Técnico: 7,05 €/hora

Las tareas realizadas por el ingeniero son el análisis de requisitos, diseño, implementación y experimentación, mientras que el técnico se encargará únicamente del montaje y testeo de la placa de prueba y del PCB. A continuación pueden verse las horas dedicadas a cada tarea así como el coste resultante.

TAREA HORAS COSTE Análisis de requisitos 60 741,00€ Diseño 180 2223,00€ Implementación 200 2470,00€ Experimentación 80 988,00€

TOTAL 520 6422,00€ Tabla 5.4. Presupuesto del coste de tareas del ingeniero

TAREA HORAS COSTE Montaje 3 21,15€ Testeo 5 35,25€

TOTAL 8 56,40€ Tabla 5.5. Presupuesto del coste de tareas del técnico

TAREA HORAS COSTE Ingeniero 520 6422,00€ Técnico 8 56,40€

TOTAL 528 6478,40€ Tabla 5.6. Coste total de los recursos humanos

113

5.6 Coste total del proyecto

Aquí se detalla el coste total del proyecto, desglosado en todas las partes en las que ha consistido. Hay que mencionar que todos los precios antes mencionados son con IVA incluido.

CONCEPTO COSTE

Coste de recursos hardware 192,25 € Coste de recursos software 663,38 € Coste de componentes y fabricación del PCB 16,82 € Coste de recursos humanos 6478,40 €

TOTAL 7350,85 €

Tabla 5.7. Coste total del proyecto

El presupuesto total del proyecto del lector de códigos de barras asciende a la cantidad de siete mil trescientos cincuenta euros con ochenta y cinco céntimos .

5.7 Estudio del coste del dispositivo en el mercado

Aquí se hace una estimación del posible precio de venta del lector en el mercado, para ello hay que estudiar el impacto que puede tener el producto en el mercado y estudiar la relación entre costes y ingresos según el número de unidades vendidas.

Este producto va dirigido a almacenes de industrias, empresas y supermercados. Para

empezar, se venderá a nivel estatal, con vistas a abrirse al mercado internacional si este tiene éxito.

Para calcular el coste de cada unidad vendida hemos de saber los siguientes

parámetros:

- Costes fijos (CF): Son los costes de recursos humanos, los costes de hardware y los costes de software. Son costes independientes del número de unidades vendidas.

- Costes variables (CV): Son los costes de producción y material de cada unidad. Son costes proporcionales al número de unidades.

- Costes totales (CT): Es la suma de los costes fijos y los costes variables.

( )UNIDADESNCVCFCTCVCFCT UNIDAD º⋅+=⇒+= (25)

- Ingresos totales (IT): Son los ingresos obtenidos de haber vendido una cierta cantidad unidades. Es proporcional al número de unidades producidas y vendidas.

CTUNIDADESNPRECIOIT UNIDAD −+= º (26)

114

En este caso, los parámetros anteriores son los siguientes:

€03,7334€40,6478€38,663€25,192 =++=CF (27)

UNIDADESNMATERIALCOSTECV º+= (28)

El coste material (o coste variable) del lector disminuye a causa de la cantidad de componentes comprados, como el microcontrolador PIC, transistores, etc. La siguiente tabla refleja el coste material del lector según el número de unidades producidas.

UNIDADES Coste Material 1-25 16,74 € 26-99 16,48 €

100-999 16,21 € 1000-4999 16,08 € 5000-9999 15,85 €

10000+ 15,34 € Tabla 5.8. Coste material del lector según las unidades producidas

Una vez conocidos estos parámetros, hay que llegar a un compromiso con el precio de cada lector de código de barras. Un precio razonable sería de 30 € por unidad, un precio muy por debajo de los lectores de códigos de barras en el mercado. La estrategia es la de obtener beneficios pronto, aunque el precio de cada unidad disminuye dependiendo del número de unidades vendidas.

A continuación una tabla con de ingresos totales según las unidades vendidas. Según las unidades vendidas, el precio de cada unidad sufre una rebaja para incentivar más la venta y obtener más beneficios. Vienen todos los parámetros para calcularlo con las ecuaciones anteriores.

UNIDADES CF CM CV CT PRECIO UD IT

1-9 7334,03 € 16,74 € 16,74 € 7350,77 € 30 € - 7.320,77 € 10-49 7334,03 € 16,74 € 167,4 € 7501,43 € 30 € - 7.201,43 € 50-99 7334,03 € 16,48 € 824 € 8175,03 € 30 € - 6.675,03 €

100-199 7334,03 € 16,21 € 1.621 € 8.955,03 € 29 € - 6.055,03 € 200-499 7334,03 € 16,21 € 3.242 € 10.576,03 € 29 € - 4.776,03 € 500-999 7334,03 € 16,21 € 8.105 € 15.439,03 € 29 € - 939,03 €

1.000-4.999 7334,03 € 16,08 € 16.080 € 23.414,03 € 28 € 4.585,97 € 5.000-9.999 7334,03 € 15,85 € 79.250 € 86.584,03 € 27 € 48.415,97 €

10.000-99.999 7334,03 € 15,34 € 153.400 € 160.734,03 € 25 € 89.265,97 € 100.000-999.999 7334,03 € 15,34 € 1.534.000 € 1.541.334,03 € 25 € 95.8665,97 €

1.000.000+ 7334,03 € 15,34 € 15.340.000 € 15.347.334,03 € 25 € 9.652.665,97 €

Tabla 5.9. Tabla de ingresos según unidades vendidas

El sector al que va destinado este producto es al de empresas que utilicen un almacén

organizado con productos marcados por un código de barras, como son los supermercados

115

y almacenes industriales, etc. España consta de alrededor de 3.000.000 de empresas, 250.000 de estas se ubican en la industria, y 800.000 en el comercio. Suponiendo que vendemos una unidad del producto al 50 % de estas empresas, el número de lectores vendidos sería de 550.000, entonces el beneficio obtenido sería el siguiente:

( ) ( )[ ]€03,334.7/€82,16000.550000.550/€30 +⋅−⋅= ududududIT (29)

€97,665.241.7€03,334.258.9€000.500.16 =−=IT (30) Por último, calcularemos el mínimo de ventas para no obtener perdidas, lo que se conoce también como Punto Muerto (PM). Para calcular el punto muerto, consideramos el precio de la unidad a 29 € en el precio y el coste material de 16,21 € ya que viendo la tabla 5.9 podemos intuir que el número de unidades que se han de vender para no tener perdidas está entre 500 y 1000 unidades.

( ) ( )[ ] 0ºº =+⋅−⋅ CFUNIDADESNCVUNIDADESNPRECIOUNIDAD (31)

0€03,7334º€21,16º€29 =−⋅−⋅ UNIDADESNUNIDADESN (32)

unidadesud

UNIDADESN 42,573/€79,12

€03,7334º == (33)

Para no tener perdidas, se deberían vender al menos 574 unidades. Se debería

encarecer el precio del producto para obtener beneficios vendiendo menos unidades, pero también hay que tener en cuenta que si el cliente lo considera caro no se venderán suficientes.

116

6 CONCLUSIONES Y TRABAJO FUTURO

6.1 CONCLUSIONES 6.2 TRABAJO FUTURO

117

6.1 Conclusiones

Después de haber realizado pruebas y haber examinado los resultados obtenidos, se pueden extraer conclusiones sobre el proyecto. Tanto el dispositivo como la aplicación software del PC desarrollados satisfacen todos los objetivos marcados inicialmente. El resultado del proyecto ha sido la obtención de un circuito impreso con un microcontrolador PIC que realiza la conversión A/D de los datos adquiridos por un sensor óptico de reflexión a la vez que controla la comunicación con el host y el envío de estos datos a través del bus USB. Estos datos pueden ser visualizados mediante una aplicación que permite realizar un tratamiento de datos. Con la elección de USB como medio de comunicación entre el dispositivo y el PC se consiguen algunos requisitos especificados:

- Alimentación por el bus: El estándar USB permite la alimentación de dispositivos que consumen un máximo de 2,5 W.

- Fácil instalación: Cuando el usuario conecta el periférico al ordenador, Windows automáticamente lo detecta y carga el driver apropiado. La primera vez que se conecte, Windows pedirá al usuario que indique la ubicación del driver, pero a continuación, la instalación será automática. No es necesario ejecutar ningún programa de instalación ni reinicia el sistema.

- Fácil y rápida comunicación de datos: Aunque no es relevante, es importante si se envía una gran cantidad de datos.

La elección del bus USB y el microcontrolador PIC 18F2550 ha influido tanto en el

tamaño del periférico como en su coste. USB dispone de conectores muy sencillos, de tamaño reducido y bastante económico. Al tener todos los componentes necesarios para la comunicación USB y la conversión A/D integrados en el microcontrolador, disminuye el número de componentes necesarios de la placa y, por lo tanto, el tamaño y coste de la misma.

Respecto a la aplicación software, se puede decir que lleva a cabo todas las

funciones para las que fue diseñada, presentando un interfaz de usuario intuitivo y fácil de utilizar. Se puede concluir que los ordenadores actuales utilizan una gama muy amplia de componentes. La interconexión de dichos dispositivos cumple un rol trascendental, donde aquellos más simples en su instalación y versátiles en su operación invaden rápidamente el mercado. Un mercado marcado por los dispositivos “Plug & Play”, siendo el medio más utilizado el estándar USB, el cual provee una interfaz única, práctica y fácil de usar para la gran mayoría de periféricos que puede utilizar el ordenador, además de extender notoriamente la cantidad de dichos dispositivos que se pueden utilizar de forma simultánea.

Una de las desventajas de USB, desde el punto de vista del desarrollador, es la complejidad del protocolo, aunque, gracias a que su uso está muy extendido, se ha podido comprobar que existen gran cantidad de herramientas que facilitan el desarrollo de periféricos que utilizan éste estándar, pudiendo decir que la única limitación en el diseño de estos dispositivos sería la imaginación de los diseñadores.

118

Por último, el bajo coste económico del dispositivo, que está muy por debajo del resto de lectores de códigos de barras que están a la venta en el mercado. Dichos lectores rondan los 100 € incluso más, mientras que el lector diseñado en este proyecto es de 30 € o menos, dependiendo del estudio de mercado realizado. Este hecho hace que las expectativas creadas al principio del proyecto se cumplan con creces.

6.2 Trabajo futuro

Aunque se han cumplido los objetivos del proyecto, es posible mejorarlo en ciertos aspectos y dotarlo de nuevos elementos y características:

• Conectar el lector de códigos de barras a una PDA. Esto dotaría al lector de

una alimentación externa sin necesidad de utilizar una pila. Esto además permitiría descargar directamente la información del código de barras a la PDA pudiendo visualizar al instante el resultado de la lectura. Además, gracias a la memoria de la PDA se podrían almacenar muchos más códigos de barras que en el microcontrolador.

• Utilizar una batería recargable de litio en vez de una pila de 9V. Además,

poder recargar dicha batería vía USB automáticamente cuando este se conecte al puerto USB. Esto dotaría de mayor autonomía al lector, además de mayor comodidad al no tener que ir cambiando de pila cuando esta se consuma.

• Incorporar una pantalla LCD en el dispositivo. Así se podrá visualizar el

estado del dispositivo, es decir, si esta leyendo, enviando datos, recibiendo datos, borrando datos, si ha tenido un error, etc. Además, se podrá visualizar el resultado de cada lectura al momento de haber leído. Aunque esto encarecería el dispositivo, sería una buena herramienta.

• Hacer la placa PCB con elementos SMD para disminuir el tamaño de la placa

notablemente. Esto disminuiría el volumen del dispositivo, haciéndolo más portátil y incorporarlo en carcasas mucho más pequeñas. Además abarataría el coste de material al haber menos cantidad de silicio y otros elementos.

• Crear una base de datos con los resultados obtenidos de las lecturas de

códigos de barras y clasificar los resultados según el prefijo, el número del elemento y tener la posibilidad de dotar a cada código de barras de una descripción.

• Aumentar el número de tipos de códigos de barras a poder leer con el lector

de código de barras.

• Añadir más memoria al dispositivo para poder almacenar más códigos de barras mediante un chip de memoria conectado al microcontrolador.

119

7 ANEXOS

7.1 CODIGO FUENTE 7.2 MANUAL DE USUARIO 7.3 BIBLIOGRAFÍA

120

7.1 CÓDIGO FUENTE

7.1.1 Código del microcontrolador ///////////////////////////////////////////////////////////////////////// //// CODEMATIC.c //// //// //// //// Realizado con el compilador CCS PCWH 3.227 //// ///////////////////////////////////////////////////////////////////////// #include <18F2550.h> #device ADC=10 #fuses HSPLL,NOWDT,NOPROTECT,NOLVP,NODEBUG,USBDIV,PLL5,CPUDIV1,VREGEN #use delay(clock=48000000) ///////////////////////////////////////////////////////////////////////////// // // CCS Library dynamic defines. For dynamic configuration of the CCS //Library // for your application several defines need to be made. See the //comments // at usb.h for more information // ///////////////////////////////////////////////////////////////////////////// #define USB_HID_DEVICE FALSE //deshabilitamos el uso de las directivas HID #define USB_EP1_TX_ENABLE USB_ENABLE_BULK //turn on EP1(EndPoint1) for IN bulk/interrupt transfers #define USB_EP1_RX_ENABLE USB_ENABLE_BULK //turn on EP1(EndPoint1) for OUT bulk/interrupt transfers #define USB_EP1_TX_SIZE 1 //size to allocate for the tx endpoint 1 buffer #define USB_EP1_RX_SIZE 3 //size to allocate for the rx endpoint 1 buffer ///////////////////////////////////////////////////////////////////////////// // // Include the CCS USB Libraries. See the comments at the top of these // files for more information // ///////////////////////////////////////////////////////////////////////// #include <pic18_usb.h> //Microchip PIC18Fxx5x Hardware layer for CCS's PIC USB driver #include <PakoUSB.h> //Configuración del USB y los descriptores para este dispositivo #include <usb.c> //handles usb setup tokens and get descriptor reports

121

#define LEDV PIN_B7 #define LEDR PIN_B5 #define LEDA PIN_B6 #define LED_ON output_high #define LED_OFF output_low #define modo recibe[0] #define param1 recibe[1] #define param2 recibe[2] #define resultado envia[0] long int tabla[400]; int tabla_num_EAN[650]; //50x13=650 50 numeros EAN-13 long int index; int cuenta_espacios,fin_codigo,cuenta_barras; int num_EAN[15]; //TABLAS PARA EL OBTENER EL NUMERO EAN int tabla_valores_filtro[30]; int tabla_valores_filtro_min[60]; int new_button_pressed=0; int old_button_pressed=0; int usb_conectado_old=0; int usb_conectado_new=0; int funcion=0; #INT_EXT void EXT0_isr() funcion=2; //MODO LECTURA #INT_EXT1 void EXT1_isr() if(usb_conectado_old==0) // if button action and was not pressed ext_int_edge(1,H_TO_L); // change so interrupts on release usb_conectado_new=1; funcion=1; // the button is now down else if(usb_conectado_old==1) // if button action and was pressed ext_int_edge(1,L_TO_H); // change so interrupts on press usb_conectado_new=0;

122

funcion=0; // the button is now up usb_conectado_old=usb_conectado_new; void main(void) int8 recibe[3]; //declaramos variables int8 envia[1]; index=0; funcion=0; //INICIALIZA EL DISPOSITIVO EN MODO ESPERA //CONFIGURACION DEL ADC setup_port_a(ALL_ANALOG | VSS_VDD); setup_adc(ADC_CLOCK_INTERNAL); set_adc_channel(1); set_tris_A(0b00000010); //RA1 como entrada set_tris_b(0b11111000); //RB3-RB7 como entrada //CONFIGURACIÓN DE INTERRUPCIONES ext_int_edge(1,L_TO_H); //HABILITA INTERRUPCIONES DE FLANCO ASCENDENTE EN EL EXT1 enable_interrupts(INT_EXT1); enable_interrupts(INT_EXT); enable_interrupts(GLOBAL); LED_OFF(LEDV); LED_OFF(LEDA); LED_OFF(LEDR); while(TRUE) if(funcion==0) //MODO ESPERA delay_ms(1000); LED_ON(LEDV); Delay_ms(1000); //espera de 1 segundo para que el LED verde parpadee LED_OFF(LEDV); if(funcion==1) //MODO USB LED_OFF(LEDV); //encendemos led rojo LED_ON(LEDR); usb_init(); //inicializamos el USB

123

usb_task(); //habilita periferico usb e interrupciones usb_wait_for_enumeration(); //esperamos hasta que el PicUSB sea configurado por el host LED_OFF(LEDR); LED_ON(LEDV); //encendemos led verde if(usb_enumerated()) //si el PicUSB está configurado if (usb_kbhit(1)) //si el endpoint de salida contiene datos del host usb_get_packet(1, recibe, 3); //cojemos el paquete de tamaño 3bytes del EP1 y almacenamos en recibe if (modo == 0) // Modo enviar datos al PC envia[0] = tabla_num_EAN[index]; //ASIGNAMOS UN VALOR DE LA TABLA A LA VARIABLE QUE NOS ENVIARA EL DATO POR EL CABLE USB usb_put_packet(1, envia, 1, USB_DTS_TOGGLE); //enviamos el paquete de tamaño 1byte del EP1 al PC index++; if(index==650) index=0; if (modo == 1) // Modo_borrar_datos_PIC for(index=0;index<650;index++) tabla_num_EAN[index]=0; //incializamos todos los valores de la tabla de numeros EAN envia[0]=1; usb_put_packet(1, envia, 1, USB_DTS_TOGGLE); //enviamos confirmacion de haber borrado los datos if(funcion==2) //MODO LECTURA int valor_filtro = 0, index_valores = 0, index_valores_min = 0; int num1 = 0, num2 = 0, num_final = 0, index_EAN = 0; int valor_max_anterior = 0, valor_max_posterior = 0, valor_minimo = 0; int valor_min_anterior = 0, valor_min_posterior = 0; int guardar_valor_min = 0;

124

int valor_min = 0; int valor_min_window = 0; int window_parcial1 = 0, window_parcial2 = 0, resto_parcial1 = 0, resto_parcial2 = 0; int valor_max_window = 0; int dc_parcial1=0, dc_parcial2=0, dc_parcial3 = 0, dc_resto = 0, digito_control = 0; int num_barras=0,num_espacios=0, num_total_barras=0; long int resultado_adc=0,resultado_adc_old=0; long int cuenta_aux_ant=0,cuenta_aux_pos=0; int cuenta_aux_barras=0; long int i=0,aux=0; int start_detected=0,fin_lectura=0; cuenta_barras=0; cuenta_espacios=0; /*****DETECCION DE INICIO DEL CODIGO DE BARRAS*****/ while(resultado_adc<=980) //hasta que no llegue al papel a una zona blanca no empieza a funcionar resultado_adc=read_adc(); while(resultado_adc>=940) //hasta que no llegue al papel a una zona blanca no empieza a leer el lector resultado_adc=read_adc(); /**************************************************/ tabla[0]=1001; LED_ON(LEDA); //ENCIENDE EL LED AMARILLO SIMBOLIZANDO EL INICIO DE LECTURA /**********INICIO DE LECTURA************/ for(i=1;i<400;i++) //BUCLE DE LECTURA resultado_adc=read_adc(); delay_ms(1); tabla[i]=resultado_adc; if (tabla[i]<120) i--; //EVITA RUIDO DEBIDO A MALOS CONTACTOS if(tabla[i]==tabla[i-1]) i--; else if ((tabla[i]==tabla[i-1]-1)||(tabla[i]==tabla[i-1]+1)) i--; else if ((tabla[i]==tabla[i-1]-2)||(tabla[i]==tabla[i-1]+2)) i--; else if ((tabla[i-1] < tabla[i-2]) && (tabla[i-1] < tabla[i]) && (tabla[i-1] >= 950))

125

tabla[i-1]=tabla[i-2]-1; //PARA ELIMINAR PICOS BAJOS PROVOCADOS POR EL RUIDO AMBIENTAL tabla[i]=tabla[i-1]; i--; else if((tabla[i-1] < tabla[i-2]) && (tabla[i-1] < tabla[i]))//PICO MAXIMO if(cuenta_aux_barras==1) cuenta_aux_pos=i; cuenta_aux_barras=0; if(cuenta_aux_pos-cuenta_aux_ant<4) cuenta_barras--; else if(cuenta_aux_barras=0) cuenta_aux_ant=i; cuenta_aux_barras=1; if(tabla[i-1]<=800) cuenta_barras++; if(cuenta_barras==30) aux=i; i=400; delay_ms(1); /*****FIN DE LECTURA******/ LED_OFF(LEDA); //APAGA EL LED AMARILLO SIMBOLIZANDO EL FIN DE LA LECTURA if(cuenta_barras<30) //AVISO DE ERROR LED_ON(PIN_B6);delay_ms(100); LED_OFF(PIN_B6);delay_ms(100); LED_ON(PIN_B6);delay_ms(100); LED_OFF(PIN_B6);delay_ms(100); LED_ON(PIN_B6);delay_ms(100); LED_OFF(PIN_B6);

126

/****RETOCAR LA GRAFICA****/ for(i=1;i<400;i++) if((tabla[i-1]>tabla[i])&&(tabla[i+1]>tabla[i])) //PICO MAXIMO

if((tabla[i-2]<tabla[i-1])&&(tabla[i+2]<tabla[i+1])) tabla[i]=(tabla[i-1]+tabla[i+1])/2;

if(tabla[i]<1000) if((tabla[i-2]<tabla[i-1]) && (tabla[i+2]>tabla[i+1])) tabla[i]=(tabla[i-1]+tabla[i+1])/2; //CASO 1 else if((tabla[i-2]>tabla[i-1]) && (tabla[i+2]<tabla[i+1])) tabla[i]=(tabla[i-1]+tabla[i+1])/2; //CASO 2 else if((tabla[i-1]<tabla[i])&&(tabla[i+1]<tabla[i])) //PICO MINIMO if(tabla[i]<650) //PROMEDIO del posterior con el anterior if(tabla[i-1]==tabla[i+1]) tabla[i-1]=tabla[i-1]-2; //si son dos valores iguales la media no servira, habra ke delimitar una diferencia de 2 tabla[i]=(tabla[i-1]+tabla[i+1])/2; if((tabla[i-1]==tabla[i]+1)&&(tabla[i+1]<tabla[i])) tabla[i-1]--; tabla[i]=(tabla[i-1]+tabla[i+1])/2; if((tabla[i-1]==tabla[i])&&(tabla[i+1]==tabla[i])&&(tabla[i]>=980)) tabla[i]=tabla[i-1]+1; cuenta_barras=0; for(i=1;i<400;i++) //CUENTA EL NUMERO DE BARRAS LEIDAS PARA EVITAR ERROR DE LECTURA if((tabla[i-1]>tabla[i])&&(tabla[i+1]>tabla[i])&&(tabla[i]<=978)) cuenta_barras++; if(cuenta_barras<30) //AVISO DE ERROR LED_ON(PIN_B6);delay_ms(100); LED_OFF(PIN_B6);delay_ms(100); LED_ON(PIN_B6);delay_ms(100); LED_OFF(PIN_B6);delay_ms(100); LED_ON(PIN_B6);delay_ms(100); LED_OFF(PIN_B6);

127

/****FIN DE RETOQUE DE LA LECTURA*******/ while(aux<400) //COMPLETARMOS EL RESTO DE LA TABLA CON EL VALOR 1000 tabla[aux]=1000; aux++; /*****INICIO DE OBTENCION DE MAXIMOS Y MINIMOS*****/ for (i = 1; i <= 398; i++) if ((tabla[i] < tabla[i - 1]) && (tabla[i] < tabla[i + 1])) //PICO MAXIMO if (tabla[i] <= 209) valor_filtro = 4; else if ((tabla[i] >= 210) & (tabla[i] <= 285)) valor_filtro = 3; else if ((tabla[i] >= 286) & (tabla[i] <= 549)) valor_filtro = 2; else if ((tabla[i] >= 550) & (tabla[i] <= 900)) valor_filtro = 1; else valor_filtro = 0; valor_max_window = ((tabla[i - 1] + tabla[i + 1] + tabla[i]) / 3); if (valor_max_window <= 143) valor_filtro = 4; else if ((valor_max_window >= 144) & (valor_max_window <= 180)) valor_filtro = 3; else if ((valor_max_window >= 181) & (valor_max_window <= 335)) valor_filtro = 2; else if ((valor_max_window >= 336) & (valor_max_window <= 700)) valor_filtro = 1; /******SEGUNDO FILTRO******/ if (valor_max_anterior != 0) valor_max_posterior = valor_filtro; else if (valor_max_anterior == 0) valor_max_anterior = valor_filtro; /**FIN DEL SEGUNDO FILTRO**/ if (valor_filtro != 0) tabla_valores_filtro[index_valores] = valor_filtro; index_valores++; if (index_valores == 30) index_valores = 0;

128

if ((valor_max_anterior != 0) && (valor_max_posterior != 0) && (valor_minimo != 0) && (index_valores <= 14) && (index_valores >= 0)) if ((valor_max_anterior == 1) && (valor_max_posterior == 1)) if (valor_min_window <= 680) valor_filtro = 1; else if ((valor_min_window >= 681) & (valor_min_window <= 843)) valor_filtro = 2; else if ((valor_min_window >= 844) & (valor_min_window <= 909)) valor_filtro = 3; else if ((valor_min_window >= 910) & (valor_min_window <= 1024)) valor_filtro = 4; else if ((valor_max_anterior == 1) && (valor_max_posterior == 2)) if (valor_min_window <= 680) valor_filtro = 1; else if ((valor_min_window >= 681) & (valor_min_window <= 843)) valor_filtro = 2; else if ((valor_min_window >= 844) & (valor_min_window <= 1024)) valor_filtro = 3; else if ((valor_max_anterior == 1) && (valor_max_posterior == 3)) if (valor_min_window <= 680) valor_filtro = 1; else if ((valor_min_window >= 681) & (valor_min_window <= 1024)) valor_filtro = 2; else if ((valor_max_anterior == 1) && (valor_max_posterior == 4)) valor_filtro = 1; //este es el algortimo bueno de antes if (valor_min_window <= 680) valor_filtro = 1; else if ((valor_min_window >= 681) & (valor_min_window <= 843)) valor_filtro = 2; else if ((valor_min_window >= 844) & (valor_min_window <= 1024)) valor_filtro = 3; else if ((valor_max_anterior == 2) && (valor_max_posterior == 1)) if (valor_min_window <= 680) valor_filtro = 1; else if ((valor_min_window >= 681) & (valor_min_window <= 843)) valor_filtro = 2;

129

else if ((valor_min_window >= 844) & (valor_min_window <= 1024)) valor_filtro = 3; else if ((valor_max_anterior == 2) && (valor_max_posterior == 2)) if (valor_min_window <= 680) valor_filtro = 1; else if ((valor_min_window >= 681) & (valor_min_window <= 843)) valor_filtro = 2; else if ((valor_min_window >= 844) & (valor_min_window <= 1024)) valor_filtro = 3; else if ((valor_max_anterior == 2) && (valor_max_posterior == 3)) if (valor_min_window <= 680) valor_filtro = 1; else if ((valor_min_window >= 681) & (valor_min_window <= 1024)) valor_filtro = 2; else if ((valor_max_anterior == 2) && (valor_max_posterior == 4)) valor_filtro = 1; if (valor_min_window <= 680) valor_filtro = 1; else if ((valor_min_window >= 681) & (valor_min_window <= 843)) valor_filtro = 2; else if ((valor_min_window >= 844) & (valor_min_window <= 1024)) valor_filtro = 3; else if ((valor_max_anterior == 3) && (valor_max_posterior == 1)) if (valor_min_window <= 680) valor_filtro = 1; else if ((valor_min_window >= 681) & (valor_min_window <= 1024)) valor_filtro = 2; else if ((valor_max_anterior == 3) && (valor_max_posterior == 2)) if (valor_min_window <= 680) valor_filtro = 1; else if ((valor_min_window >= 681) & (valor_min_window <= 1024)) valor_filtro = 2;

130

else if ((valor_max_anterior == 3) && (valor_max_posterior == 3)) if (valor_min_window <= 680) valor_filtro = 1; else if ((valor_min_window >= 681) & (valor_min_window <= 843)) valor_filtro = 2; else if ((valor_min_window >= 844) & (valor_min_window <= 920)) valor_filtro = 3; else if ((valor_min_window >= 920) & (valor_min_window <= 1024)) valor_filtro = 4; else if ((valor_max_anterior == 3) && (valor_max_posterior == 4)) if (valor_min_window <= 680) valor_filtro = 1; else if ((valor_min_window >= 681) & (valor_min_window <= 843)) valor_filtro = 2; else if ((valor_min_window >= 844) & (valor_min_window <= 920)) valor_filtro = 3; else if ((valor_min_window >= 920) & (valor_min_window <= 1024)) valor_filtro = 4; else if ((valor_max_anterior == 4) && (valor_max_posterior == 1)) if (valor_min_window <= 680) valor_filtro = 1; else if ((valor_min_window >= 681) & (valor_min_window <= 843)) valor_filtro = 2; else if ((valor_min_window >= 844) & (valor_min_window <= 920)) valor_filtro = 3; else if ((valor_min_window >= 920) & (valor_min_window <= 1024)) valor_filtro = 4; else if ((valor_max_anterior == 4) && (valor_max_posterior == 2)) if (valor_min_window <= 680) valor_filtro = 1; else if ((valor_min_window >= 681) & (valor_min_window <= 843)) valor_filtro = 2; else if ((valor_min_window >= 844) & (valor_min_window <= 920)) valor_filtro = 3; else if ((valor_min_window >= 920) & (valor_min_window <= 1024)) valor_filtro = 4; else valor_filtro = 0; else if ((valor_max_anterior == 4) && (valor_max_posterior == 3))

131

if (valor_min_window <= 680) valor_filtro = 1; else if ((valor_min_window >= 681) & (valor_min_window <= 843)) valor_filtro = 2; else if ((valor_min_window >= 844) & (valor_min_window <= 920)) valor_filtro = 3; else if ((valor_min_window >= 920) & (valor_min_window <= 1024)) valor_filtro = 4; else if ((valor_max_anterior == 4) && (valor_max_posterior == 4)) if (valor_min_window <= 680) valor_filtro = 1; else if ((valor_min_window >= 681) & (valor_min_window <= 843)) valor_filtro = 2; else if ((valor_min_window >= 844) & (valor_min_window <= 920)) valor_filtro = 3; else if ((valor_min_window >= 920) & (valor_min_window <= 1024)) valor_filtro = 4; guardar_valor_min = 1; valor_max_anterior = valor_max_posterior; valor_min_anterior = valor_min_posterior; //valor_max_anterior = 0; else if ((valor_max_anterior != 0) && (valor_max_posterior != 0) && (valor_minimo != 0) && (index_valores >= 15) && (index_valores <= 30)) if ((valor_max_anterior == 1) && (valor_max_posterior == 1)) if (valor_min_window <= 680) valor_filtro = 1; else if ((valor_min_window >= 681) & (valor_min_window <= 843)) valor_filtro = 2; else if ((valor_min_window >= 844) & (valor_min_window <= 920)) valor_filtro = 3; else if ((valor_min_window >= 920) & (valor_min_window <= 1024)) valor_filtro = 4; else if ((valor_max_anterior == 1) && (valor_max_posterior == 2)) if (valor_min_window <= 680) valor_filtro = 1;

132

else if ((valor_min_window >= 681) & (valor_min_window <= 843)) valor_filtro = 2; else if ((valor_min_window >= 844) & (valor_min_window <= 1024)) valor_filtro = 3; else if ((valor_max_anterior == 1) && (valor_max_posterior == 3)) if (valor_min_window <= 680) valor_filtro = 1; else if ((valor_min_window >= 681) & (valor_min_window <= 843)) valor_filtro = 2; else if ((valor_min_window >= 844) & (valor_min_window <= 920)) valor_filtro = 3; else if ((valor_min_window >= 920) & (valor_min_window <= 1024)) valor_filtro = 4; else if ((valor_max_anterior == 1) && (valor_max_posterior == 4)) valor_filtro = 1; if (valor_min_window <= 680) valor_filtro = 1; else if ((valor_min_window >= 681) & (valor_min_window <= 843)) valor_filtro = 2; else if ((valor_min_window >= 844) & (valor_min_window <= 909)) valor_filtro = 3; else if ((valor_min_window >= 910) & (valor_min_window <= 1024)) valor_filtro = 4; else if ((valor_max_anterior == 2) && (valor_max_posterior == 1)) if (valor_min_window <= 680) valor_filtro = 1; else if ((valor_min_window >= 681) & (valor_min_window <= 843)) valor_filtro = 2; else if ((valor_min_window >= 844) & (valor_min_window <= 1024)) valor_filtro = 3; else if ((valor_max_anterior == 2) && (valor_max_posterior == 2)) if (valor_min_window <= 680) valor_filtro = 1; else if ((valor_min_window >= 681) & (valor_min_window <= 843)) valor_filtro = 2; else if ((valor_min_window >= 844) & (valor_min_window <= 920)) valor_filtro = 3; else if ((valor_min_window >= 920) & (valor_min_window <= 1024)) valor_filtro = 4;

133

else if ((valor_max_anterior == 2) && (valor_max_posterior == 3)) if (valor_min_window <= 680) valor_filtro = 1; else if ((valor_min_window >= 681) & (valor_min_window <= 843)) valor_filtro = 2; else if ((valor_min_window >= 844) & (valor_min_window <= 920)) valor_filtro = 3; else if ((valor_min_window >= 920) & (valor_min_window <= 1024)) valor_filtro = 4; else if ((valor_max_anterior == 2) && (valor_max_posterior == 4)) if (valor_min_window <= 680) valor_filtro = 1; else if ((valor_min_window >= 681) & (valor_min_window <= 843)) valor_filtro = 2; else if ((valor_min_window >= 844) & (valor_min_window <= 920)) valor_filtro = 3; else if ((valor_min_window >= 920) & (valor_min_window <= 1024)) valor_filtro = 4; else if ((valor_max_anterior == 3) && (valor_max_posterior == 1)) if (valor_minimo <= 940) valor_filtro = 1; //este es el algortimo bueno de antes else if ((valor_minimo >= 941) & (valor_minimo <= 1024)) valor_filtro = 2; else valor_filtro = 0; if (valor_min_window <= 680) valor_filtro = 1; else if ((valor_min_window >= 681) & (valor_min_window <= 1024)) valor_filtro = 2; else if ((valor_max_anterior == 3) && (valor_max_posterior == 2)) if (valor_min_window <= 680) valor_filtro = 1; else if ((valor_min_window >= 681) & (valor_min_window <= 843)) valor_filtro = 2; else if ((valor_min_window >= 844) & (valor_min_window <= 1024)) valor_filtro = 3; else valor_filtro = 0; else if ((valor_max_anterior == 3) && (valor_max_posterior == 3))

134

if (valor_min_window <= 680) valor_filtro = 1; else if ((valor_min_window >= 681) & (valor_min_window <= 843)) valor_filtro = 2; else if ((valor_min_window >= 844) & (valor_min_window <= 920)) valor_filtro = 3; else if ((valor_min_window >= 920) & (valor_min_window <= 1024)) valor_filtro = 4; else if ((valor_max_anterior == 3) && (valor_max_posterior == 4)) if (valor_min_window <= 680) valor_filtro = 1; else if ((valor_min_window >= 681) & (valor_min_window <= 843)) valor_filtro = 2; else if ((valor_min_window >= 844) & (valor_min_window <= 920)) valor_filtro = 3; else if ((valor_min_window >= 920) & (valor_min_window <= 1024)) valor_filtro = 4; else if ((valor_max_anterior == 4) && (valor_max_posterior == 1)) if (valor_min_window <= 680) valor_filtro = 1; else if ((valor_min_window >= 681) & (valor_min_window <= 843)) valor_filtro = 2; else if ((valor_min_window >= 844) & (valor_min_window <= 920)) valor_filtro = 3; else if ((valor_min_window >= 920) & (valor_min_window <= 1024)) valor_filtro = 4; else valor_filtro = 0; else if ((valor_max_anterior == 4) && (valor_max_posterior == 2)) if (valor_min_window <= 680) valor_filtro = 1; else if ((valor_min_window >= 681) & (valor_min_window <= 843)) valor_filtro = 2; else if ((valor_min_window >= 844) & (valor_min_window <= 920)) valor_filtro = 3; else if ((valor_min_window >= 920) & (valor_min_window <= 1024)) valor_filtro = 4; else if ((valor_max_anterior == 4) && (valor_max_posterior == 3)) if (valor_min_window <= 680) valor_filtro = 1; else if ((valor_min_window >= 681) & (valor_min_window <= 843)) valor_filtro = 2; else if ((valor_min_window >= 844) & (valor_min_window <= 920)) valor_filtro = 3;

135

else if ((valor_min_window >= 920) & (valor_min_window <= 1024)) valor_filtro = 4; else if ((valor_max_anterior == 4) && (valor_max_posterior == 4)) if (valor_min_window <= 680) valor_filtro = 1; else if ((valor_min_window >= 681) & (valor_min_window <= 843)) valor_filtro = 2; else if ((valor_min_window >= 844) & (valor_min_window <= 920)) valor_filtro = 3; else if ((valor_min_window >= 920) & (valor_min_window <= 1024)) valor_filtro = 4; guardar_valor_min = 1; valor_max_anterior = valor_max_posterior; valor_min_anterior = valor_min_posterior; if ((valor_filtro != 0) && (guardar_valor_min == 1)) tabla_valores_filtro_min[index_valores_min] = valor_filtro; index_valores_min++; guardar_valor_min = 0; else if ((tabla[i] > tabla[i - 1]) && (tabla[i] > tabla[i + 1])) //PICOS MINIMOS valor_minimo = tabla[i]; valor_min = tabla[i]; /****ALGORITMO VENTANA MOBIL****/ window_parcial1 = ((tabla[i - 1] + tabla[i + 1]) / 6); resto_parcial1 = ((tabla[i - 1] + tabla[i + 1]) % 6); if (resto_parcial1 >= 3) window_parcial1++; window_parcial2 = ((tabla[i] * 4) / 6); resto_parcial2 = ((tabla[i] * 4) % 6); if (resto_parcial2 >= 3) window_parcial2++; valor_min_window = window_parcial1 + window_parcial2; /*******************************/ if (valor_min_anterior != 0) valor_min_posterior = valor_min; else if (valor_min_anterior == 0) valor_min_anterior = valor_min;

136

/*****FIN DE OBTENCION DE MAXIMOS Y MINIMOS*****/ if (index_valores != 0) LED_ON(PIN_B6);delay_ms(100); LED_OFF(PIN_B6);delay_ms(100); LED_ON(PIN_B6);delay_ms(100); LED_OFF(PIN_B6);delay_ms(100); LED_ON(PIN_B6);delay_ms(100); LED_OFF(PIN_B6); index_valores = 0; /*****OBTENICON DEL NUMERO EAN A PARTIR DE LOS MAXIMOS Y MINIMOS****/ index_valores_min = 0; while (index_valores < 30) num1 = tabla_valores_filtro[index_valores]; //grosor de la primera barra index_valores++; num2 = tabla_valores_filtro[index_valores]; //grosor de la barra siguiente //BARRAS ESPACIADORAS if (((num1 == 1) && (num2 == 1)) && ((index_valores == 1) || (index_valores == 15) || (index_valores == 29))) num_EAN[index_EAN] = 0; index_EAN++; else if ((index_valores >= 2) && (index_valores <= 13)) //JUEGO A (IMPAR) if ((num1 == 1) && (num2 == 2)) if (tabla_valores_filtro_min[index_valores_min] == 2) num_EAN[index_EAN] = 2; if (tabla_valores_filtro_min[index_valores_min] == 3) num_EAN[index_EAN] = 4; if (tabla_valores_filtro_min[index_valores_min] == 4) num_EAN[index_EAN] = 4; if (tabla_valores_filtro_min[index_valores_min] == 1) num_EAN[index_EAN] = 9; if ((num1 == 2) && (num2 == 1))

137

if (tabla_valores_filtro_min[index_valores_min] == 2) num_EAN[index_EAN] = 1; if (tabla_valores_filtro_min[index_valores_min] == 3) num_EAN[index_EAN] = 5; if (tabla_valores_filtro_min[index_valores_min] == 4) num_EAN[index_EAN] = 5; if (tabla_valores_filtro_min[index_valores_min] == 1) num_EAN[index_EAN] = 0; if ((num1 == 4) && (num2 == 1)) num_EAN[index_EAN] = 3; if ((num1 == 1) && (num2 == 4)) num_EAN[index_EAN] = 6; if ((num1 == 3) && (num2 == 2)) num_EAN[index_EAN] = 7; if ((num1 == 2) && (num2 == 3)) num_EAN[index_EAN] = 8; //JUEGO B(PAR) if ((num1 == 1) && (num2 == 1)) if (tabla_valores_filtro_min[index_valores_min] == 4) num_EAN[index_EAN] = 3; if (tabla_valores_filtro_min[index_valores_min] == 1) num_EAN[index_EAN] = 6; if (tabla_valores_filtro_min[index_valores_min] == 3) num_EAN[index_EAN] = 7; if (tabla_valores_filtro_min[index_valores_min] == 2) num_EAN[index_EAN] = 8; if ((num1 == 2) && (num2 == 2)) if (tabla_valores_filtro_min[index_valores_min] == 2) num_EAN[index_EAN] = 1; else if (tabla_valores_filtro_min[index_valores_min] == 3) num_EAN[index_EAN] = 1; else if (tabla_valores_filtro_min[index_valores_min] == 4) num_EAN[index_EAN] = 1; else if (tabla_valores_filtro_min[index_valores_min] == 1) num_EAN[index_EAN] = 2; if ((num1 == 3) && (num2 == 1)) if (tabla_valores_filtro_min[index_valores_min] == 1) num_EAN[index_EAN] = 4; else if (tabla_valores_filtro_min[index_valores_min] == 2) num_EAN[index_EAN] = 5; else if (tabla_valores_filtro_min[index_valores_min] == 3) num_EAN[index_EAN] = 5; else if (tabla_valores_filtro_min[index_valores_min] == 4) num_EAN[index_EAN] = 5;

138

if ((num1 == 1) && (num2 == 3)) if (tabla_valores_filtro_min[index_valores_min] == 1) num_EAN[index_EAN] = 9; else if (tabla_valores_filtro_min[index_valores_min] == 2) num_EAN[index_EAN] = 0; else if (tabla_valores_filtro_min[index_valores_min] == 3) num_EAN[index_EAN] = 0; else if (tabla_valores_filtro_min[index_valores_min] == 4) num_EAN[index_EAN] = 0; index_EAN++; else if ((index_valores >= 6) && (index_valores <= 27)) //JUEGO C(PAR) if ((num1 == 1) && (num2 == 1)) if (tabla_valores_filtro_min[index_valores_min] == 4) num_EAN[index_EAN] = 3; if (tabla_valores_filtro_min[index_valores_min] == 1) num_EAN[index_EAN] = 6; if (tabla_valores_filtro_min[index_valores_min] == 3) num_EAN[index_EAN] = 7; if (tabla_valores_filtro_min[index_valores_min] == 2) num_EAN[index_EAN] = 8; if ((num1 == 2) && (num2 == 2)) if (tabla_valores_filtro_min[index_valores_min] == 2) num_EAN[index_EAN] = 1; if (tabla_valores_filtro_min[index_valores_min] == 3) num_EAN[index_EAN] = 1; if (tabla_valores_filtro_min[index_valores_min] == 4) num_EAN[index_EAN] = 1; if (tabla_valores_filtro_min[index_valores_min] == 1) num_EAN[index_EAN] = 2; if ((num1 == 1) && (num2 == 3)) if (tabla_valores_filtro_min[index_valores_min] == 1) num_EAN[index_EAN] = 4; if (tabla_valores_filtro_min[index_valores_min] == 2) num_EAN[index_EAN] = 5; if (tabla_valores_filtro_min[index_valores_min] == 3) num_EAN[index_EAN] = 5; if (tabla_valores_filtro_min[index_valores_min] == 4) num_EAN[index_EAN] = 5; if ((num1 == 3) && (num2 == 1))

139

if (tabla_valores_filtro_min[index_valores_min] == 1) num_EAN[index_EAN] = 9; if (tabla_valores_filtro_min[index_valores_min] == 2) num_EAN[index_EAN] = 0; if (tabla_valores_filtro_min[index_valores_min] == 3) num_EAN[index_EAN] = 0; if (tabla_valores_filtro_min[index_valores_min] == 4) num_EAN[index_EAN] = 0; index_EAN++; index_valores++; index_valores_min++; index_valores_min++; /*******FIN DE OBTENCION DEL NUMERO EAN*******/ /**********DIGITO DE CONTROL************/ for (index_EAN = 1; index_EAN <= 6; index_EAN++) index_EAN++; dc_parcial1 = dc_parcial1 + num_EAN[index_EAN]; for (index_EAN = 8; index_EAN <= 13; index_EAN++) index_EAN++; dc_parcial1 = dc_parcial1 + num_EAN[index_EAN]; for (index_EAN = 1; index_EAN <= 6; index_EAN++) dc_parcial2 = dc_parcial2 + num_EAN[index_EAN]; index_EAN++; for (index_EAN = 8; index_EAN <= 13; index_EAN++) dc_parcial2 = dc_parcial2 + num_EAN[index_EAN]; index_EAN++; dc_parcial1 = dc_parcial1 * 3; dc_parcial3 = dc_parcial1 + dc_parcial2; dc_resto = dc_parcial3 % 10; digito_control = 10 - dc_resto; /***************************************/ funcion=0; //DEVUELVE EL DISPOSITIVO AL ESTADO DE ESPERA AL FINALIZAR LA LECTURA

140

7.1.2 Fichero .INF Signature="$WINDOWS NT$" Class=%ClassName% ClassGuid=4D36E911-E325-11CE-BFC1-08002BE10318 Provider=%MFGNAME% DriverVer=03/10/2005,1.0.0.0 CatalogFile=picusb.cat [DestinationDirs] DefaultDestDir = 12 PicUSB.ClassCopyFiles = 11 ;------------------------------------------------------------------------ ; Class installation sections ;------------------------------------------------------------------------ [ClassInstall32] AddReg=PicUSB.ClassReg CopyFiles=PicUSB.ClassCopyFiles [PicUSB.ClassReg] HKR,,,0,%ClassName% HKR,,Class,,%ClassDesc% HKR,,Icon,,11 HKR,,Installer32,,"picusbci.dll,PicUSBClassInstaller" [PicUSB.ClassCopyFiles] picusbci.dll ;------------------------------------------------------------------------ ; Device Install Section ;------------------------------------------------------------------------ [Manufacturer] %MFGNAME%=Standard [Standard] %DESCRIPTION%=DriverInstall, USB\VID_04D8&PID_0011 [SourceDisksNames] 1 = %INSTDISK%,,,"" [SourceDisksFiles] mchpusb.sys = 1,, wdmstub.sys = 1,, picusbci.dll = 1,, ;------------------------------------------------------------------------ ; Windows 2000/XP Sections ;------------------------------------------------------------------------ [DriverInstall.NT] CopyFiles=DriverCopyFiles [DriverCopyFiles] mchpusb.sys

141

[DriverInstall.NT.Services] AddService = PicUSB, 2, DriverService [DriverService] DisplayName = %SVCDESC% ServiceType = 1 ; SERVICE_KERNEL_DRIVER StartType = 3 ; SERVICE_DEMAND_START ErrorControl = 1 ; SERVICE_ERROR_NORMAL ServiceBinary = %12%\mchpusb.sys LoadOrderGroup = Extended Base ;------------------------------------------------------------------------ ; Windows 98/Me Sections ;------------------------------------------------------------------------ [DriverInstall] AddReg=DriverAddReg CopyFiles=DriverCopyFiles,StubCopyFiles DriverVer=09/26/2005,1.0.0.0 [DriverAddReg] HKR,,DevLoader,,*ntkern HKR,,NTMPDriver,,"wdmstub.sys,mchpusb.sys" [StubCopyFiles] wdmstub.sys ;------------------------------------------------------------------------ ; String Definitions ;------------------------------------------------------------------------ [Strings] MFGNAME="PakoJones USB" INSTDISK="PicUSB Device Driver Disc" DESCRIPTION="PakoUSB" SVCDESC="PicUSB Device Driver" ClassName="PIC 18Fxx5x USB Devices" ClassDesc="PakoUSB Sample Device"

142

7.1.3 Código de la aplicación en el PC

Form1.cs using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Text; using System.Windows.Forms; namespace WindowsApplication1 public partial class Form1 : Form Program codematic_api = new Program(); //declara un nombre a Program.cs para el uso en este código /**************VARIABLES GLOBALES***************/ int[] tabla; /***********************************************/ public Form1() InitializeComponent(); private void recibir_datos_Click(object sender, EventArgs e) int fin_transmision = 0; int index = 0,j=0; uint dispositivo_conectado = 0; tabla = new int[650]; //50x13, 50 números EAN pantalla_num_ean.Text = " "; pantalla_estado.Text = " "; pantalla_estado.Text = "Conectando..."; dispositivo_conectado = codematic_api.Conexion(); //mira si el dispositivo esta conectado por el puerto USB if (dispositivo_conectado == 1) pantalla_estado.Text = " "; pantalla_estado.Text = "Dispositivo conectado"; else if (dispositivo_conectado == 0) pantalla_estado.Text = " "; pantalla_estado.Text = "Dispositivo no conectado"; /*********************************/

if (dispositivo_conectado == 1) //si esta conectado entonces empieza la tranferencia de datos

143

pantalla_estado.Text = " "; pantalla_estado.Text = "Recibiendo datos... "; while (index<650) if (j <= 13) pantalla_num_ean.Text += codematic_api.Recibir_Datos(index).ToString() + " "; else pantalla_num_ean.Text += codematic_api.Recibir_Datos(index).ToString() + "\n"; j = 0; //tabla[index] = codematic_api.Guardar_datos(index);

//guarda los datos en una tabla index++; j++; if (fin_transmision == 0) pantalla_estado.Text = "ERROR al recibir datos del CODEMATIC"; else if (fin_transmision == 1) pantalla_estado.Text = "Fin de transmision con exito"; private void borrar_datos_pic_Click(object sender, EventArgs e) int datos_borrados = 0; uint dispositivo_conectado = 0; DialogResult respuesta; respuesta=MessageBox.Show("\t\n¿Esta seguro de querer borrar los datos del PIC?\t", "Seleccione una opción", MessageBoxButtons.YesNo, MessageBoxIcon.Warning); if (respuesta == DialogResult.Yes) pantalla_estado.Text = " "; pantalla_estado.Text = "Conectando..."; dispositivo_conectado = codematic_api.Conexion(); //mira si el dispositivo esta conectado al puerto USB if (dispositivo_conectado == 1) //si esta conectado entonces empieza la rutina de borrar los datos pantalla_estado.Text = " "; pantalla_estado.Text = "Dispositivo conectado"; pantalla_estado.Text = " "; pantalla_estado.Text = "Borrando datos... "; datos_borrados=codematic_api.Borrar_Datos(); else if (dispositivo_conectado == 0) pantalla_estado.Text = " "; pantalla_estado.Text = "Dispositivo no conectado"; /*********************************/

144

if (datos_borrados == 1) pantalla_estado.Text = " "; pantalla_estado.Text = "Datos borrados con éxito "; else if (datos_borrados == 0) pantalla_estado.Text = " "; pantalla_estado.Text = "ERROR al borrar los datos del CODEMATIC "; private void salir_Click(object sender, EventArgs e) DialogResult respuesta; respuesta = MessageBox.Show(" ¿Desea salir del programa? ", "Seleccione una opcion", MessageBoxButtons.YesNo, MessageBoxIcon.Question); if (respuesta == DialogResult.Yes) Close(); private void conexion_Click(object sender, EventArgs e) uint dispositivo_conectado = 0; pantalla_estado.Text = " "; pantalla_estado.Text = "Conectando..."; dispositivo_conectado=codematic_api.Conexion(); if (dispositivo_conectado == 1) pantalla_estado.Text = " "; pantalla_estado.Text = "Dispositivo conectado"; else if (dispositivo_conectado == 0) pantalla_estado.Text = " "; pantalla_estado.Text = "Dispositivo no conectado"; private void info_Click(object sender, EventArgs e) Form2 frm = new Form2(); frm.Show(); //hace aparecer otra ventana con la información del programa

145

Program.cs using System; using System.Collections.Generic; using System.Windows.Forms; using System.Runtime.InteropServices; // Clase para importar DLL using PVOID = System.IntPtr; using DWORD = System.UInt32; namespace WindowsApplication1 unsafe public class Program /// <summary> /// The main entry point for the application. /// </summary> [STAThread] static void Main() Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Application.Run(new Form1()); #region Definición de los Strings: EndPoint y VID_PID string vid_pid_norm = "vid_04d8&pid_0011"; string out_pipe = "\\MCHP_EP1"; string in_pipe = "\\MCHP_EP1"; #endregion #region Funciones importadas de la DLL: mpusbapi.dll [DllImport("mpusbapi.dll")] private static extern DWORD _MPUSBGetDLLVersion(); [DllImport("mpusbapi.dll")] private static extern DWORD _MPUSBGetDeviceCount(string pVID_PID); [DllImport("mpusbapi.dll")] private static extern void* _MPUSBOpen(DWORD instance, string pVID_PID, string pEP, DWORD dwDir, DWORD dwReserved); [DllImport("mpusbapi.dll")] private static extern DWORD _MPUSBRead(void* handle, void* pData, DWORD dwLen, DWORD* pLength, DWORD dwMilliseconds); [DllImport("mpusbapi.dll")] private static extern DWORD _MPUSBWrite(void* handle, void* pData, DWORD dwLen, DWORD* pLength, DWORD dwMilliseconds); [DllImport("mpusbapi.dll")] private static extern DWORD _MPUSBReadInt(void* handle, DWORD* pData, DWORD dwLen, DWORD* pLength, DWORD dwMilliseconds); [DllImport("mpusbapi.dll")] private static extern bool _MPUSBClose(void* handle); #endregion int[] tabla; //declaracion de la tabla como variable global //int[] vector_valores; void* myOutPipe; void* myInPipe;

146

public void OpenPipes() DWORD selection = 0; myOutPipe = _MPUSBOpen(selection, vid_pid_norm, out_pipe, 0, 0); myInPipe = _MPUSBOpen(selection, vid_pid_norm, in_pipe, 1, 0); public void ClosePipes() _MPUSBClose(myOutPipe); _MPUSBClose(myInPipe); private void SendPacket(byte* SendData, DWORD SendLength) uint SendDelay = 1000; DWORD SentDataLength; OpenPipes(); _MPUSBWrite(myOutPipe, (void*)SendData, SendLength, &SentDataLength, SendDelay); ClosePipes(); private void ReceivePacket(byte* ReceiveData, DWORD* ReceiveLength) uint ReceiveDelay = 1000; DWORD ExpectedReceiveLength = *ReceiveLength; OpenPipes(); _MPUSBRead(myInPipe, (void*)ReceiveData, ExpectedReceiveLength, ReceiveLength, ReceiveDelay); ClosePipes(); /******************************************************/ public int Recibir_Datos(int index) byte* receive_buf = stackalloc byte[1]; //asigna 1 byte en el buffer de entrada byte* send_buf = stackalloc byte[1]; //asigna 1 byte en el buffer de salida DWORD RecvLength = 2; int result; tabla = new int[650]; send_buf[0] = 0x01; //asigna un 1 en el byte de envio (de salida) para entrar en el modo de recibir datos del PIC SendPacket(send_buf, 1); //envia el 1 ReceivePacket(receive_buf, &RecvLength); //recoje los datos del HOST result = receive_buf[0]; //guarda el resultado en una variable

147

tabla[index] = result; //guarda el dato en la tabla return result; //devuelve el resultado a Form1.cs para que sea tratado public int Borrar_Datos() byte* receive_buf = stackalloc byte[1]; //asigna 1 byte en el buffer de entrada byte* send_buf = stackalloc byte[1]; //asigna 1 byte en el buffer de salida DWORD RecvLength = 2; int result; send_buf[0] = 0x02;//asigna un 2 en el byte de envio (de salida) para entrar en el modo de borrar datos en el PIC SendPacket(send_buf, 1); //envia el 2 ReceivePacket(receive_buf, &RecvLength); //Recibe el justificante de si result = receive_buf[0]; //los datos han sido borrados con exito return result; //devuelve el resultado a Form1.cs para que sea tratado public uint Conexion() uint usb_connection; usb_connection=_MPUSBGetDeviceCount(vid_pid_norm); // comprueba la conexión del lector al puerto USB return usb_connection; //devuelve el resultado a Form1.cs para que sea tratado

148

Form1.Designer.cs namespace WindowsApplication1 partial class Form1 /// <summary> /// Required designer variable. /// </summary> private System.ComponentModel.IContainer components = null; /// <summary> /// Clean up any resources being used. /// </summary> /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param> protected override void Dispose(bool disposing) if (disposing && (components != null)) components.Dispose(); base.Dispose(disposing); #region Windows Form Designer generated code /// <summary> /// Required method for Designer support - do not modify /// the contents of this method with the code editor. /// </summary> private void InitializeComponent() this.apartado_control = new System.Windows.Forms.GroupBox(); this.conexion = new System.Windows.Forms.Button(); this.info = new System.Windows.Forms.Button(); this.borrar_datos_pic = new System.Windows.Forms.Button(); this.recibir_datos = new System.Windows.Forms.Button(); this.apartado_num_ean = new System.Windows.Forms.GroupBox(); this.pantalla_num_ean = new System.Windows.Forms.RichTextBox(); this.apartado_estado = new System.Windows.Forms.GroupBox(); this.pantalla_estado = new System.Windows.Forms.TextBox(); this.salir = new System.Windows.Forms.Button(); this.imagen_titulo = new System.Windows.Forms.PictureBox(); this.apartado_control.SuspendLayout(); this.apartado_num_ean.SuspendLayout(); this.apartado_estado.SuspendLayout(); ((System.ComponentModel.ISupportInitialize)(this.imagen_titulo)).BeginInit(); this.SuspendLayout(); // // apartado_control // this.apartado_control.Controls.Add(this.conexion); this.apartado_control.Controls.Add(this.info); this.apartado_control.Controls.Add(this.borrar_datos_pic); this.apartado_control.Controls.Add(this.recibir_datos); this.apartado_control.Location = new System.Drawing.Point(135, 131); this.apartado_control.Name = "apartado_control"; this.apartado_control.Size = new System.Drawing.Size(174, 178);

149

this.apartado_control.TabIndex = 0; this.apartado_control.TabStop = false; this.apartado_control.Text = "CONTROL"; // // conexion // this.conexion.BackColor = System.Drawing.Color.Gold; this.conexion.Location = new System.Drawing.Point(14, 96); this.conexion.Name = "conexion"; this.conexion.Size = new System.Drawing.Size(151, 33); this.conexion.TabIndex = 3; this.conexion.Text = "CONEXIÓN DEL PIC"; this.conexion.UseVisualStyleBackColor = false; this.conexion.Click += new System.EventHandler(this.conexion_Click); // // info // this.info.Location = new System.Drawing.Point(14, 135); this.info.Name = "info"; this.info.Size = new System.Drawing.Size(151, 33); this.info.TabIndex = 2; this.info.Text = "Acerca de..."; this.info.UseVisualStyleBackColor = true; this.info.Click += new System.EventHandler(this.info_Click); // // borrar_datos_pic // this.borrar_datos_pic.BackColor = System.Drawing.Color.OrangeRed; this.borrar_datos_pic.Location = new System.Drawing.Point(14, 58); this.borrar_datos_pic.Name = "borrar_datos_pic"; this.borrar_datos_pic.Size = new System.Drawing.Size(151, 33); this.borrar_datos_pic.TabIndex = 1; this.borrar_datos_pic.Text = "BORRAR DATOS DEL PIC"; this.borrar_datos_pic.UseVisualStyleBackColor = false; this.borrar_datos_pic.Click += new System.EventHandler(this.borrar_datos_pic_Click); // // recibir_datos // this.recibir_datos.BackColor = System.Drawing.SystemColors.Desktop; this.recibir_datos.Location = new System.Drawing.Point(14, 19); this.recibir_datos.Name = "recibir_datos"; this.recibir_datos.Size = new System.Drawing.Size(151, 33); this.recibir_datos.TabIndex = 0; this.recibir_datos.Text = "RECIBIR DATOS"; this.recibir_datos.UseVisualStyleBackColor = false; this.recibir_datos.Click += new System.EventHandler(this.recibir_datos_Click); // // apartado_num_ean // this.apartado_num_ean.Controls.Add(this.pantalla_num_ean); this.apartado_num_ean.Location = new System.Drawing.Point(12, 131); this.apartado_num_ean.Name = "apartado_num_ean"; this.apartado_num_ean.Size = new System.Drawing.Size(117, 177); this.apartado_num_ean.TabIndex = 1; this.apartado_num_ean.TabStop = false; this.apartado_num_ean.Text = "NUMEROS EAN";

150

// // pantalla_num_ean // this.pantalla_num_ean.Location = new System.Drawing.Point(6, 19); this.pantalla_num_ean.Name = "pantalla_num_ean"; this.pantalla_num_ean.Size = new System.Drawing.Size(105, 149); this.pantalla_num_ean.TabIndex = 0; // // apartado_estado // this.apartado_estado.Controls.Add(this.pantalla_estado); this.apartado_estado.Location = new System.Drawing.Point(12, 315); this.apartado_estado.Name = "apartado_estado"; this.apartado_estado.Size = new System.Drawing.Size(297, 50); this.apartado_estado.TabIndex = 2; this.apartado_estado.TabStop = false; this.apartado_estado.Text = "ESTADO"; // // pantalla_estado // this.pantalla_estado.BackColor = System.Drawing.SystemColors.InfoText; this.pantalla_estado.Font = new System.Drawing.Font("Tahoma", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0))); this.pantalla_estado.ForeColor = System.Drawing.Color.LawnGreen; this.pantalla_estado.Location = new System.Drawing.Point(6, 19); this.pantalla_estado.Name = "pantalla_estado"; this.pantalla_estado.Size = new System.Drawing.Size(277, 23); this.pantalla_estado.TabIndex = 0; // // salir // this.salir.Location = new System.Drawing.Point(12, 371); this.salir.Name = "salir"; this.salir.Size = new System.Drawing.Size(297, 33); this.salir.TabIndex = 4; this.salir.Text = "SALIR"; this.salir.UseVisualStyleBackColor = true; this.salir.Click += new System.EventHandler(this.salir_Click); // // imagen_titulo // this.imagen_titulo.Image = global::WindowsApplication1.Properties.Resources.logo_codematic_titulo; this.imagen_titulo.Location = new System.Drawing.Point(22, 12); this.imagen_titulo.Name = "imagen_titulo"; this.imagen_titulo.Size = new System.Drawing.Size(278, 113); this.imagen_titulo.TabIndex = 5; this.imagen_titulo.TabStop = false; // // Form1 // this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; this.ClientSize = new System.Drawing.Size(321, 409); this.Controls.Add(this.imagen_titulo); this.Controls.Add(this.salir); this.Controls.Add(this.apartado_estado); this.Controls.Add(this.apartado_num_ean); this.Controls.Add(this.apartado_control);

151

this.Name = "Form1"; this.Text = "CODEMATIC (PFC - Codigos de barras)"; this.apartado_control.ResumeLayout(false); this.apartado_num_ean.ResumeLayout(false); this.apartado_estado.ResumeLayout(false); this.apartado_estado.PerformLayout(); ((System.ComponentModel.ISupportInitialize)(this.imagen_titulo)).EndInit(); this.ResumeLayout(false); #endregion private System.Windows.Forms.GroupBox apartado_control; private System.Windows.Forms.Button borrar_datos_pic; private System.Windows.Forms.Button recibir_datos; private System.Windows.Forms.Button info; private System.Windows.Forms.GroupBox apartado_num_ean; private System.Windows.Forms.RichTextBox pantalla_num_ean; private System.Windows.Forms.GroupBox apartado_estado; private System.Windows.Forms.TextBox pantalla_estado; private System.Windows.Forms.Button salir; private System.Windows.Forms.Button conexion; private System.Windows.Forms.PictureBox imagen_titulo; Form2.cs using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Text; using System.Windows.Forms; namespace WindowsApplication1 public partial class Form2 : Form public Form2() InitializeComponent(); private void button1_Click(object sender, EventArgs e) Close();

152

Form2.Designer.cs namespace WindowsApplication1 partial class Form2 /// <summary> /// Required designer variable. /// </summary> private System.ComponentModel.IContainer components = null; /// <summary> /// Clean up any resources being used. /// </summary> /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param> protected override void Dispose(bool disposing) if (disposing && (components != null)) components.Dispose(); base.Dispose(disposing); #region Windows Form Designer generated code /// <summary> /// Required method for Designer support - do not modify /// the contents of this method with the code editor. /// </summary> private void InitializeComponent() this.label1 = new System.Windows.Forms.Label(); this.label2 = new System.Windows.Forms.Label(); this.label3 = new System.Windows.Forms.Label(); this.pictureBox1 = new System.Windows.Forms.PictureBox(); this.label4 = new System.Windows.Forms.Label(); this.linkLabel1 = new System.Windows.Forms.LinkLabel(); this.cerrar = new System.Windows.Forms.Button(); ((System.ComponentModel.ISupportInitialize)(this.pictureBox1)).BeginInit(); this.SuspendLayout(); // // label1 // this.label1.AutoSize = true; this.label1.Font = new System.Drawing.Font("Futura Md BT", 12F, ((System.Drawing.FontStyle)((System.Drawing.FontStyle.Bold | System.Drawing.FontStyle.Underline))), System.Drawing.GraphicsUnit.Point, ((byte)(0))); this.label1.Location = new System.Drawing.Point(190, 9); this.label1.Name = "label1"; this.label1.Size = new System.Drawing.Size(155, 19); this.label1.TabIndex = 0; this.label1.Text = "CODEMATIC v1.0";

153

// // label2 // this.label2.AutoSize = true; this.label2.Location = new System.Drawing.Point(191, 41); this.label2.Name = "label2"; this.label2.Size = new System.Drawing.Size(182, 13); this.label2.TabIndex = 1; this.label2.Text = "Autor: Francisco Pelegrí Santamaría"; // // label3 // this.label3.AutoSize = true; this.label3.Location = new System.Drawing.Point(191, 66); this.label3.Name = "label3"; this.label3.Size = new System.Drawing.Size(205, 13); this.label3.TabIndex = 2; this.label3.Text = "Fecha de la versión: 9 de Enero del 2007"; // // pictureBox1 // this.pictureBox1.Image = global::WindowsApplication1.Properties.Resources.logo_acercade; this.pictureBox1.Location = new System.Drawing.Point(13, 9); this.pictureBox1.Name = "pictureBox1"; this.pictureBox1.Size = new System.Drawing.Size(171, 113); this.pictureBox1.TabIndex = 3; this.pictureBox1.TabStop = false; // // label4 // this.label4.AutoSize = true; this.label4.Location = new System.Drawing.Point(191, 92); this.label4.Name = "label4"; this.label4.Size = new System.Drawing.Size(35, 13); this.label4.TabIndex = 4; this.label4.Text = "WEB:"; // // linkLabel1 // this.linkLabel1.AutoSize = true; this.linkLabel1.Location = new System.Drawing.Point(239, 92); this.linkLabel1.Name = "linkLabel1"; this.linkLabel1.Size = new System.Drawing.Size(106, 13); this.linkLabel1.TabIndex = 5; this.linkLabel1.TabStop = true; this.linkLabel1.Text = "www.codematic.com"; // // cerrar // this.cerrar.Location = new System.Drawing.Point(340, 124); this.cerrar.Name = "cerrar"; this.cerrar.Size = new System.Drawing.Size(62, 21); this.cerrar.TabIndex = 6; this.cerrar.Text = "CERRAR"; this.cerrar.UseVisualStyleBackColor = true;

this.cerrar.Click += new System.EventHandler(this.button1_Click);

154

// // Form2 // this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; this.ClientSize = new System.Drawing.Size(412, 153); this.Controls.Add(this.cerrar); this.Controls.Add(this.linkLabel1); this.Controls.Add(this.label4); this.Controls.Add(this.pictureBox1); this.Controls.Add(this.label3); this.Controls.Add(this.label2); this.Controls.Add(this.label1); this.Name = "Form2"; this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen; this.Text = "Acerca de CODEMATIC"; ((System.ComponentModel.ISupportInitialize)(this.pictureBox1)).EndInit(); this.ResumeLayout(false); this.PerformLayout(); #endregion private System.Windows.Forms.Label label1; private System.Windows.Forms.Label label2; private System.Windows.Forms.Label label3; private System.Windows.Forms.PictureBox pictureBox1; private System.Windows.Forms.Label label4; private System.Windows.Forms.LinkLabel linkLabel1; private System.Windows.Forms.Button cerrar;

155

7.2 MANUAL DE USUARIO

7.2.1 Instalación del dispositivo

Al conectar el lector de códigos de barras por primera vez, aparecerá el asistente para la instalación de nuevo hardware. Se marca la opción “No” y se hace click sobre “Siguiente”. En la siguiente pantalla se marca la opción “Instalar desde una lista o ubicación específica”. Una vez hecho esto, se hace clic sobre “Siguiente” para pasar a la próxima pantalla, donde se marca la opción de “Buscar el controlador más adecuado en estas ubicaciones”. Se hace clic sobre “Incluir esta ubicación en la búsqueda” y a continuación sobre “Examinar”. Entonces se selecciona la carpeta donde se encuentran los drivers, en este caso, “Codematic_Driver”, y se hace clic a “Aceptar” y luego a “Siguiente”. En este momento, comenzarán a copiarse los archivos necesarios en el ordenador. Una vez se termine de copiar, aparecerá una pantalla indicando que la instalación del driver está terminada. El LED verde se encenderá, lo que indica que está listo para que se use el lector.

Si todo ha ido bien, en el Administrador de Dispositivos debe aparecer lo siguiente:

Figura 7.1 Ventana de administrador de dispositivos con el lector Codematic reconocido por el sistema

El resto de veces que se conecte el lector al ordenador, este será reconocido de forma

automática con lo que no será necesario indicar ningún tipo de información.

156

7.2.2 Utilización del dispositivo

El dispositivo contiene tres LED’s indicadores de los distintos estados del dispositivo y dos botones para poder interactuar con él directamente. Los tres LED’s indican lo siguiente:

- LED verde: Indica que el dispositivo esta alimentado. - LED amarillo: Indica que el sensor está leyendo un código de barras. - LED rojo: Indica de algún error según su secuencia de parpadeo.

También hay dos botones, uno grande para realizar las lecturas y el otro más pequeño

para resetear el sistema.

Para un uso correcto del dispositivo, hay que conocer una serie de aspectos respecto a la posición del sensor, velocidad, etc. Estos aspectos vienen descritos a continuación:

- Pulsar el botón de inicio de lectura. Este se puede reconocer por ser el botón

más grande de los dos botones en el dispositivo. - Colocar el sensor tocando la superficie, justo al lado del código de barras al que

se va a efectuar la lectura. El sensor debe estar en la posición que marca la figura siguiente:

- Desplazar el sensor por encima del código de barras de una manera recta e uniforme, manteniendo la posición respecto el código de barras, sin dejar de estar en contacto con la superficie y a una velocidad constante.

- El proceso de lectura se marca por el encendido del LED amarillo cuando detecta el principio del código de barras, y el apagado del mismo LED al detectar el final del código de barras.

- Si ha habido algún error, el LED rojo se parpadeara tres veces, en intervalos de medio segundo.

- Si no se ha encendido el LED rojo, significa que la lectura se ha realizado correctamente.

Para que una lectura se realice correctamente, el LED amarillo deberá encenderse al

inicio del código de barras y apagarse al final del código de barras, si se apaga antes o después no se habrá realizado una lectura correcta, y lo indicará el LED rojo. El tiempo para que de tiempo a realizar una lectura esta entre 1 segundo y 1,5 segundos aproximadamente. Todas las lecturas que se encuentren en ese tiempo y el LED amarillo se encienda y se apague en el inicio y final del código de barras, son validas.

CARA ESCRITA CON LA DESCRIPCIÓN DEL SENSOR

157

En caso de no encenderse el LED amarillo al intentar realizar una lectura, se deben comprobar las conexiones del sensor con la placa, resetear el dispositivo pulsando el botón más pequeño que hay en el dispositivo o comprobar que hay alimentación en el sistema observando que el LED verde esté encendido.

Para visualizar los resultados de las lecturas hay que conectar el dispositivo por el puerto USB, y se hace uso de la aplicación creada para su fin y que se comenta en los siguientes apartados. En caso de que el LED rojo se encienda, hay que conocer a que tipo de error corresponde cada secuencia de parpadeo.

- Tres veces seguidas en intervalos de medio segundo. Quiere decir que se ha realizado mal la lectura, es decir, no se tienen los datos necesarios para poder descodificar el código de barras.

- Encendido permanente. Quiere decir que ha habido algún problema con la

conexión USB, puede ser debido a un fallo al intentar enumerar el dispositivo.

7.2.3 Instalación de la aplicación

Antes de indicar cómo instalar el software que permite la comunicación con el dispositivo, se indicarán una serie de requisitos que debe cumplir el sistema para poder ejecutar la aplicación. Estos requisitos son:

- Sistema operativo Microsoft Windows 2000 o XP. - Tener instalado .NET Framework 2.0 (en caso de no tenerlo instalado, el

asistente de instalación puede instalarlo automáticamente).

Para instalar la aplicación hay que ejecutar el programa “Setup.exe”. Una vez ejecutado nos verificará si tenemos los requisitos necesarios. En el caso de que “.NET Framework 2.0” no esté instalado, el propio programa lo descargará de la red y lo instalará automáticamente. Una vez hecho todo esto, se creará un icono en el menú de “INICIO” donde se podrá ejecutar el programa “CODEMATIC”.

7.2.4 Utilización de la aplicación

La aplicación CODEMATIC tiene una ventana principal donde se muestra el titulo, los botones de control de la aplicación, la tabla donde se muestran los números del estándar EAN que se han leído con el lector, una línea de texto donde se muestran mensajes de estado y un último botón para cerrar la aplicación. El aspecto de dicha ventana principal es el siguiente:

158

Figura 7.2 Ventana principal de la aplicación CODEMATIC

Para interactuar con el dispositivo lector de códigos de barras, hay que usar los botones del apartado de CONTROL. En este apartado hay cuatro botones:

- Recibir Datos: Se recogen todos los números EAN guardados en el lector y a continuación se muestran en pantalla en el apartado de “Números EAN”. Cuando se pulsa este botón, primero comprueba que el dispositivo este conectado al ordenador, una vez hecho esto empieza la transferencia de datos. Una vez finalizada la transferencia muestra los datos en la tabla del apartado “Números EAN”.

159

- Borrar datos del PIC: Borra los números EAN que hayan guardados en el lector. Cuando se pulsa el botón sale una ventana de aviso donde pregunta si se esta seguro de borrarlos, es una medida de seguridad, por si se pulsa el botón por equivocación.

- Conexión USB: La función de este botón es comprobar la conexión del

dispositivo con el PC, mostrando el resultado en el apartado de “Estado”. - Acerca de…: Muestra información sobre el programa, como la versión del

programa, el creador del programa y la fecha en que ha estado creado. El aspecto de la ventana que se muestra es el siguiente:

Luego hay otro apartado donde se muestra el estado en que se encuentra la comunicación, es decir, si se están recibiendo o borrando los datos, si el dispositivo esta conectado o si ha habido algún error. Este apartado muestra el siguiente aspecto:

Los estados que puede mostrar son los siguientes:

- Dispositivo conectado - Conectando… - Dispositivo no conectado - Datos borrados con éxito - ERROR al borrar datos del CODEMATIC - Recibiendo datos… - ERROR al recibir datos del CODEMATIC - Fin de transmisión con éxito

160

Por último, el botón de “SALIR” que se encuentra en la parte inferior de la ventana principal del programa. Es usado para cerrar la aplicación. Cuando se pulsa sale otra ventana preguntando si se desea salir del programa, como medida de precaución, por si se ha pulsado el botón por equivocación.

7.3 BIBLIOGRAFÍA

7.3.1 Libros Andrés Cánovas López “MANUAL DE USUARIO DEL COMPILADOR PCW DE CCS”, 2006. Francisco Javier Ceballos. “ENCICLOPEDIA DE MICROSOFT VISUAL C#” Ed. Ra-Ma, 2006. Jan Alexson. “USB COMPLETE SECOND EDITION” Ed. Lakeview Research, 2001. José Antonio González Seco “MANUAL DE PROGRAMACIÓN C#”, 2006. José María Angulo Usategui, Eugenio Martín Cuenca, Ignacio Angulo Martínez. “MICROCONTROLADORES PIC, LA SOLUCIÓN EN UN CHIP” Ed. Thomson, 2000. José María Angulo Usategui, Eugenio Martín Cuenca, Ignacio Angulo Martínez. “MICROCONTROLADORES PIC, LA CLAVE DEL DISEÑO” Ed. Thomson, 2003 John Sharp. “MICROSOFT VISUAL C# 2005, STEP BY STEP” Ed. Microsoft Press, 2005. Xavier Fenard. “EL BUS USB, GUÍA DEL DESARROLLADOR”. Ed. Thomson, 2001.

161

7.3.2 Páginas web http://www.metrologicmexico.com/contenido/archivos/000054.shtml Distintos tipos de códigos de barras. (Enero 2007) http://www.azalea.com/FAQ/ Distintos tipos de códigos de barras(Inglés). (Enero 2007) http://www.monografias.com/trabajos11/yantucod/yantucod.shtml Explicación general sobre los códigos de barras y lectores de códigos de barras. (Enero 2007) http://www.wikihow.com/Read-12-Digit-UPC-Barcodes Como leer códigos de barras UPC-12 a simple vista. (Inglés) . (Enero 2007) http://www.mqp.com/ums_1.htm USB made simple. Web para entender la configuración del USB (Inglés). (Enero 2007) http://www.ipcitec.freeservers.com/Cap_04.html Resumen sobre la arquitectura USB en capítulos. (Enero 2007) http://www.lvr.com/usbc.htm USB CENTRAL Information, tools, and links to material about the Universal Serial Bus (USB) (Inglés) . (Enero 2007) http://www.usb.org USB Implementers Forum, Inc. (Enero 2007) http://www.zator.com/Hardware/H2_5_3.htm Puerto USB. (Enero 2007) http://www.microchip.com Página oficial de MICROCHIP. (Enero 2007) http://pic18fusb.online.fr/wiki/wikka.php?wakka=Links Links para el PIC18F2550 (Inglés). (Enero 2007) http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=2124&param=en022613&page=wwwFullSpeedUSB Drivers para el PIC18F2550 y la comunicación USB (Inglés). (Enero 2007) http://picmania.garcia-cuervo.com/USB_0_Desencadenado.htm Página de RedRaven hablando del pic18xx50 comunicado USB con el PC. (Enero 2007) http://www.ccsinfo.com Características del compilador de C CCS. (Enero 2007) http://www.microsoft.com/whdc/devtools/ddk/default.mspx Windows Driver Development Kit (DDK) . (Enero 2007) http://www.developer.com/net/csharp/ Articulos, cursos y foro sobre programación en Visual C# (Inglés). (Enero 2007) http://www.lawebdelprogramador.com Articulos, cursos y foro sobre programación Visual C#. (Enero 2007)

162

http://www.winpic800.com Web del creador del grabador GTP-USB+ y del programa de grabación WinPic800. (Enero 2007)

7.3.3 Datasheet’s

Los datasheet’s están contenidos en el CD del PFC. Los datasheet’s son los siguientes:

1. CNY70 2. 2N7000 3. BS250 4. Un paseo por USB 1.0 5. Un paseo por USB 2.0 6. 1N4148 7. PIC 2455/2550/4455/4550 8. Making sense of the USB Standard 9. USB Instrumentation by Eric Brown (Yale University) 10. USB Mass Storage Device Using a PIC(C) MCU (AN1003) 11. Power Management for PIC18 USB Microcontrollers with nanoWatt Technology

(AN950) 12. Pila eléctrica de 9V CEGASA (6LF22 Super Alcalina) 13. Verificación de códigos de barras para simbologías lineales. Aspectos generales

técnicos detallados para las Organizaciones Miembros de EAN (Julio 2003) 14. Librería 18F2550.h 15. Librería pic18_usb.h 16. Librería PakoUSB.h 17. Librería usb.c 18. Librería usb.h 19. Librería de funciones para Visual C#, picusbci.dll 20. Programa monitor para estudiar los resultados del lector 21. Archivo de instalación y esquemas del GTP-USB+

lectura y gestión de códigos de barras con...

Documents