proyecto integrado · 2019. 9. 10. · exposición del proyecto integrado. (se asiste a clase el...

Comprobador de componentes 1

TÉCNICO SUPERIOR EN MANTENIMIENTO

ELECTRÓNICO

Curso académico 2013-2015

PROYECTO INTEGRADO

Comprobador de componentes

Autor: Nefi Badillo Ruiz

Tutor: Antonio Perez Saavedra

Málaga, Junio de 2015


Índice 1 Memoria ................................................................................................................ 3

1.1 Descripción del producto ................................................................................ 3

1.2 Objetivos y especificaciones ........................................................................... 4

1.3 Planificación ................................................................................................... 5

1.4 Diseño ............................................................................................................ 6

1.4.1 Esquema eléctrico. Explicación del esquema .......................................... 7

1.4.2 Esquema PCB. Explicación del esquema. ............................................. 11

1.4.3 Circuito impreso ..................................................................................... 12

1.4.4 Preparación del circuito ......................................................................... 13

1.4.5 Soldadura de componentes ................................................................... 15

1.4.6 Conexión de la placa a arduino ............................................................. 17

1.4.7 Programa Arduino. Idea de funcionamiento ........................................... 19

1.4.8 Producto terminado. Fotografías. ........................................................... 26

1.5 Pruebas y resultados .................................................................................... 31

1.6 Manual de usuario ........................................................................................ 40

1.7 Manual de servicio ........................................................................................ 41

1.8 Bibliografía ................................................................................................... 42

1.9 Presupuesto ................................................................................................. 42

2 Planos ................................................................................................................. 43

2.1 Esquema completo ....................................................................................... 44

2.2 PCB bottom .................................................................................................. 45

Anexo I. Estudio y normas de seguridad ................................................................. 46

Anexo II. Página web .............................................................................................. 46


1 Memoria

1.1 Descripción del producto

El proyecto que he realizado en estos meses durante el periodo de FCT es un

comprobador de varios tipos de componentes.

Lo he basado sobre arduino, dado que es una plataforma de hardware libre y permite al

usuario modificarlo de la manera que vea más conveniente.

Arduino es una placa con un microcontrolador, en mi caso ese microcontrolador es el

Atmega328, y un entorno de desarrollo que facilita su uso gracias a la aplicación de

escritorio que tienen y al gran equipo de desarroladores que hay en todo el mundo,

porque al ser una plataforma libre, cualquiera puede hacer una programación para un

producto y subirlo a internet, asi se consigue que esta plataforma crezca dia a dia y siga

mejorando.

Pero con arduino solo no podría hacer el producto, asi que tambien tenemos una placa

fotosensible donde realizare mi circuito impreso, el cual detallare en páginas posteriores,

y una pantalla LCD.

Para el diseño del circuito impreso he usado el programa de diseño Eagle, que permite

al usuario no solo crear un esquema con los componentes necesarios si no tambien

exportar ese esquema para realizar el diseño de la placa final.

Necesitaremos el panel LCD para poder visualizar de una forma rápida los detalles de

los componentes que introduzcamos en nuestro producto final, este LCD está conectado

a la placa que a su vez está conectada con arduino, asi cuando se introduzca el

componente en la placa, arduino detectará que tipo de componente es y cuales son sus

características para posteriormente llevarlo al LCD para que podamos ver en detalle el

componente.

Para realizar la comprobación de un componente debemos ponerlo en los conectores

de 3 pines hembra situados en la placa fotosensible y darle al boton que también está

situado en esa placa e inmediatamente veremos sus valores reflejados en el panel LCD,

para medir otro componente solo debemos sacar el anterior, introducir el que queramos

medir ahora y darle al botón de nuevo y como en el caso anterior veremos sus valores

en el panel LCD.

A groso modo esa seria la descripción del producto y para lo que sirve, en posteriores

apartados iré entrando en detalle en cada uno de los componentes que forman el

producto final para entender mejor el proyecto y que no se quede nada sin explicar asi

como un manual de usuario para que quede todo lo mas claro posible.


1.2 Objetivos y especificaciones

El objetivo principal era el de tener un comprobador de varios componentes el cual nos

arrojase sus principales características de una manera facil y rapida, por eso recurrimos

a un proyecto basado en arduino para mejorarlo en varios aspectos, uno de ellos era

que carecia de pantalla, se necesitaba un ordenador y una aplicación para dicho

ordenador para poder visualizar las características de los componentes, ahora con este

diseño solo necesitaremos el ordenador para alimentar al arduino por usb o si no

disponemos de ordenador lo podemos hacer por la entrada de alimentación que tiene

conectandolo a la red eléctrica, dado que la visualización la haremos con el panel LCD

lo cual es más rápido tambien.

El proyecto inicial carecia del panel LCD ,eso el objetivo prioritario era mejorar el anterior

para seguir aportando ideas al proyecto y que vaya mejorando.

Teniamos que ir sumando buenas ideas al proyecto, por lo que nos pusimos como meta

el objetivo de hacer un producto mejor y más util.

A continuación expondre el listado de materiales con sus características para

posteriormente explicar las especificaciones finales del producto completo.

3 Resistencias de 680Ω

3 Resistencias de 470K Ω

1 Condensador de 100nF

1 Pulsador

1 Conector de 3 pines hembra

2 Conectores de 14 pines macho

1 Potenciómetro de 5K

1 Faja de 14 vias (16cm)

1 Panel LCD (2x16)

1 Placa fotosensible (7,5cm x 6cm)

1 Arduino UNO

Cable de conexión de arduino a PC (1m.)


1.3 Planificación

Día 20 de Marzo: El profesor explica en lo que consistirá el proyecto

Semana del 23 al 27 de Marzo: Estudio de la documentación. (En casa)

Semana del 6 al 10 de Abril: Montaje y prueba del prototipo. (Se asiste a clase

el día 9)

Semana del 13 al 17 de Abril: Pruebas con componentes varios. (En casa)

Semana del 20 al 24 de Abril. Diseño y fabricación del prototipo PCB. (Se asiste

a clase el día 23)

Semana del 27 de Abril al 1 de Mayo. Diseño y fabricación del prototipo PCB.

(En casa)

Semana del 4 al 8 de Mayo. Documentación escrita y web. (En casa)

Semana del 11 al 15 de Mayo. Documentación escrita y web. (Se asiste a clase

el día 14)

Semana del 18 al 22 de Mayo. Documentación escrita y web. (En casa)

Semana del 25 al 29 de Mayo. Documentación escrita y web. (Se asiste a clase

el día 28)

Semana del 1 al 5 de Junio. Puesta a punto de documentación. (Se asiste a

clase el día 4)

Semana del 8 al 12 de Junio. Preparación de exposición PowerPoint. (En casa)

Semana del 15 al 19 de Junio. Exposición del proyecto integrado. (Se asiste a

clase el 18)


1.4 Diseño

El diseño se realiza con el programa Eagle, en el cual podemos hacer primero un diseño

esquemático con todos los componentes necesarios y unirlos para crear así el diseño

completo.

Una vez realizado el esquemático con el mismo programa podemos irnos a un apartado

para realizar la PCB, alli reordenaremos los componentes con sus respectibas uniones

bien hechas para formar el diseño final el cual imprimiremos para crear nuestra placa

de circuito impreso.

En los siguientes apartados veremos los diseños mencionados anteriormente con su

respectiva explicación.


1.4.1 Esquema eléctrico. Explicación del esquema


En este fragmento obtenido del esquema de arriba, vemos etiquetas en todas las

entradas, las etiquetas sirven para unir los componentes y evitar el lio de lineas de

muchas veces se forman en estos diseños, los que ya sepan manejar este programa

sabran de lo que hablo, asi se ven mucho más claras las uniones.

También vemos una entrada de GND y de +5V para alimentar el arduino que es el

componente que vemos abajo.

Las entradas de D0 hasta D13 son las entradas digitales que tiene arduino.

La entrada de GND de arduino la conectamos como vemos a GND para proporcionar la

masa que necesita.

Donde vemos AREF en arduino tenemos que alimentarlo a 5V, como vemos en la

etiqueta de arriba.

El resto de uniones las iremos viendo mas abajo.


Como veiamos más arriba, las entradas digitales las pusimos con etiquetas para evitar

lios en el diseño.

Lo que vemos es el LCD y sus respectivas conexiones.

Las entradas 11,12,13 y 14 del LCD las conectamos a las entradas digitales 2,3,4 y 5

como podemos ver en las etiquetas.

Las entradas digitales 6 y 7 van a las entradas 4 y 6 del LCD.

A la entrada 5 del LCD conectaremos una masa que vemos representado con GND.

El componente R7 es un potenciómetro para regular el contraste del LCD, para ello

conectaremos la entrada 3 del LCD a la entrada central del potenciómetro, la cual esta

representada por la letra S.

La entrada 1 del LCD la conectamos a la entrada del potenciómetro de abajo que tiene

la letra A y a su vez a GND.

La entrada 2 del LCD va conectada a la entrada del potenciómetro de arriba que tiene

la letra E y a su vez a VCC.


La entrada de 5V de arduino la conectamos a la etiqueta de 5V, la cual estaba conectada

también a los 5V de la otra entrada de arduino.

La etiqueta VIN está conectada la entrada VIN de arduino, esa sera la entrada.

Como vemos hemos puenteado las dos entradas de GND de arduino a una entrada

externa de GND.

R1, R3 y R5 son resistencias de 680Ω.

R2, R4 y R6 son resistencias de 470KΩ.

C1 es el condensador de 100nF.

S1 es el pulsador de la placa que sirve para empezar a medir un componente y como

vemos en un extremo tenemos conectado el condensador y en el otro extremo está

conectado a la entrada A3 de arduino.


1.4.2 Esquema PCB. Explicación del esquema.

Ya realizado el esquemático, podemos hacer la PCB como vemos arriba, donde ya

tenemos todos los componentes ordenador de la forma más eficiente posible para

ocupar el mínimo espacio y poder conectarlo todo más fácil.

Una vez tengamos lista la distribución, procedemos a unir lineas, cambiar el tamaño de

linea para evitar fallos al revelar, aumentar el tamaño de los agujeros para evitar fallos

al taladrar.

Realizados los pasos anteriores solo nos queda crear el plano de masa e imprimirlo para

empezar a revelar la placa.


1.4.3 Circuito impreso

Con el diseño de PCB ya bien realizado, procedemos a guardarlo en formato de imagen

para imprimirlo, y nos saldrá una imagen como la que vemos en la parte superior.

Con la imagen de arriba ya impresa, solo nos quedará colocarla encima de una placa

fotosensible para insolarla en la insoladora.

Cuando pase el tiempo necesario para que se insole, sacaremos la placa con mucho

cuidado, porque al ser fotosensible si le incide la luz de forma continuada puede alterar

nuestro diseño, mejor mantener la placa con la imagen impresa arriba y taparlo con la

mano.

Ya con nuestra placa insolada debemos comenzar el proceso de revelado que se lleva

a cabo con un recipiente de sosa con agua, otro con acido y otro con agua sola para

aclarar.

Debemos tener mucho cuidado en ese proceso, dado que si nos pasamos de sosa

podemos partir pistas y nuestro circuito seria inutil y tocaria repetirlo, tampoco podemos

dejarlo mucho tiempo en el acido porque perderiamos la placa, asi que seria conveniente

llevar bien los tiempos de cada proceso.

Con la placa de circuito impreso ya lista, pasamos al siguiente apartado que nos irá

guiando durante el proceso para terminarla.


1.4.4 Preparación del circuito

Como vimos arriba, ya tenemos la placa impresa, ahora toca taladrarla con un taladro

de banco como vemos en la imagen inferior:

Aquí vemos la placa preparada en el taladro de banco para crearle los agujeros

necesarios para la implementación de todos los componentes necesarios para crear el

proyecto final.

Llevaremos a cabo estos agujeros con la punta de taladro más pequeña que tengamos,

en mi caso usé una de 0.7mm y no tuve ningun problema dado que como dije en el

apartado del diseño, agrande los pads para evitar que se rompieran en este proceso.


En las dos imágenes de arriba vemos la placa con el proceso de taladrado ya finalizado

y la podemos apreciar tanto por delante como por detrás.

Si se hacen bien los agujeros no nos llevarmos ningun pad y mucho menos una pista, y

como vemos en las imágenes yo no tuve ningun problema y me salió todo bien, en caso

de que un agujero pierda su pista de cobre no pasa nada, podrias remediarlo haciendo

algun tipo de puente pero el resultado final no quedaria tan vistoso aunque seguiria

siendo igual de funcional.


1.4.5 Soldadura de componentes

Cuando ya tengamos todos los agujeros listo será el momento de empezar a soldar

todos los componentes en su lugar.

Como vemos en la imagen superior tenemos todos los componentes ya soldados, tanto

arriba como abajo tenemos una fila de pines los cuales veremos en la imagen inferior y

que nos serviran para acoplarlo perfectamente a nuestro arduino.

A la izquierda vemos soldado el condensador que al no ser electrolítico da igual como

soldemos sus patillas.

Seguidamente del condensador apreciamos todo el grupo de resistencias soldadas

alternativamente con respecto a su valor como bien vimos en el diseño de paginas

anteriores.

A la derecha del conjunto de resistencias vemos un gran componente azul claro, ese es

el componente que hará de puente entre nuestro arduino y el panel LCD, por

consiguiente conectaremos la faja a ese componente macho.

Pegado al conector vemos un potenciometro, está pegado al conector para recordarnos

que calibra el contraste del panel LCD.


Más a la izquierda vemos un conector de 3 pines hembra con un número 1 abajo que

nos indica cual es la patilla 1 para la hora de la conexión de los componentes, en ese

conector de 3 pines conectaremos los componentes que vayamos a medir.

El componente que vemos a la derecha del conector de 3 pines de color amarillo es un

puente, el cual nos ayudó a tener mejor el diseño y evitar posibles cortos por pasar

líneas muy cerca de otras, pero si le ponemos un recubrimiento plástico como se ve en

la imagen no solo queda mejor que estando desnudo si no que queda bastante bien.

Por último vemos pegado al puente un pulsador, el cual servirá para iniciar la secuencia

de comprobación de los componentes que queramos medir.

Como decia más arriba, aquí vemos como a quedado la placa por debajo una vez

realizadas las respectivas soldaduras de los componentes que vimos en la imagen

superior.

Poco hay que comentar de esta imagen salvo que tenemos los pines de conexión al

arduino que no podiamos ver en la imagen superior y las soldaduras realizadas en los

componentes.


1.4.6 Conexión de la placa a arduino

Podriamos decir que esta es la prueba de fuego, dado que si los pines no estan bien

alineados o no estan bien soldados no se acoplaran bien a nuestro arduino y no haran

la conexión necesaria para su funcionamiento, pero como vemos en las imágenes

superior e inferior ponemos la placa con cuidado sobre el arduino para no doblar ningun

pin de la placa y que encaje perfectamente, y cuando ya estemos seguros de que hacen

buena conexión podremos apretarlo más para que se conecte como es debido y quede

mas compacto.


Como hemos visto arriba, primero debemos posarlo despacio para ver que se acoplarán

bien todos los pines y una vez lo tengamos procederemos a empujarlo para que se unan

del todo como bien vemos en las 2 imágenes de esta página.

Los pines y los conectores de arduino se acoplan a las mil maravilllas y asi lo podemos

ver en las fotos, no queda ningún sitio libre ni ningun pin doblado o sin meterse

totalmente, esta todo muy bien montado como veremos en el apartado de diseño final


1.4.7 Programa Arduino. Idea de funcionamiento

Idea de funcionamiento.

En todos los casos utilizamos las salidas digitales de los pines del arduino para,

establecer por medio de las resistencias de la placa intensidades conocidas en los

distintos pines donde se conectan los terminales del componente a comprobar.

Establecidas las corrientes necesarias se comprueban las tensiones que se leen en las

entradas analógicas.

Estableciendo la secuencia específica de corrientes y lectura de tensiones se determina

el componente de que se trata y alguna de sus características.

El código completo se encuentra en la web, donde como proyecto en constante

desarrollo se van incorporando procedimientos con más o menos exactitud para la

obtención de características de semiconductores y en menor grado componentes

pasivos.


Ejemplo 1. Código para comprobación de transitores MOSFET ( los más interesantes

desde el punto de vista de reparación de problemas de alimentación en equipos de

visualización )

byte FET_Type; //MOSFET type unsigned int U_R_c; //Voltage across collector resistor unsigned int U_R_b; //Voltage across base resistor unsigned int BJT_Level; //Voltage threshold for BJT unsigned int FET_Level; //Voltage threshold for FET unsigned int I_CE0; //Leakage current unsigned long hFE_C; //hFE (common collector) unsigned long hFE_E; //hFE (common emitter) //Init, set probes and measure if (BJT_Type == TYPE_NPN) //NPN / n-channel BJT_Level = 2557; //Voltage across base resistor (5.44µA) FET_Level = 3400; //Voltage across drain resistor (4.8mA) FET_Type = TYPE_N_CHANNEL; /* We assume - BJT: probe-1 = C / probe-2 = E / probe-3 = B - FET: probe-1 = D / probe-2 = S / probe-3 = G probes already set to: Gnd -- probe-2 / probe-1 -- Rl -- Vcc drive base/gate via Rh instead of Rl */ R_DDR = Probes.Rl_1 | Probes.Rh_3; //Enable Rl for probe-1 & Rh for probe-3 R_PORT = Probes.Rl_1 | Probes.Rh_3; //Pull up collector via Rl and base via Rh delay(50); //Wait to skip gate charging of a FET U_R_c = UREF_VCC - ReadU(Probes.Pin_1); //U_R_c = Vcc - U_c U_R_b = UREF_VCC - ReadU(Probes.Pin_3); //U_R_b = Vcc - U_b else //PNP / p-channel BJT_Level = 977; //Voltage across base resistor (2.1µA) FET_Level = 2000; //Voltage across drain resistor (2.8mA) FET_Type = TYPE_P_CHANNEL; /* We assume - BJT: probe-1 = E / probe-2 = C / probe-3 = B - FET: probe-1 = S / probe-2 = D / probe-3 = G probes already set to: Gnd -- Rl - probe-2 / probe-1 -- Vcc drive base/gate via Rh instead of Rl */ R_DDR = Probes.Rl_2 | Probes.Rh_3; //Pull down base via Rh U_R_c = ReadU_5ms(Probes.Pin_2); //U_R_c = U_c U_R_b = ReadU(Probes.Pin_3); //U_R_b = U_b //Distinguish BJT from depletion-mode MOSFET if (U_R_b > BJT_Level) //U_R_b exceeds minimum level of BJT /* A voltage drop across the base resistor Rh means that a current is flowing constantly. So this can't be a FET. Problem: A reversed collector and emitter also passes the tests, but with a low hFE. So we need to run two tests to be sure and select the test results with the higher hFE. */ //Two test runs needed at maximium to get right hFE & pins if (Check.Found == COMP_BJT) Check.Done = 1; Check.Found = COMP_BJT; Check.Type = BJT_Type; //Leakage current


I_CE0 = GetLeakageCurrent(); //Get leakage current (in µA) /* Calculate hFE via voltages and known resistors: - hFE = I_c / I_b = (U_R_c / R_c) / (U_R_b / R_b) = (U_R_c * R_b) / (U_R_b * R_c) - consider leakage current: I_c = I_c_conducting - I_c_leak = (U_R_c_conducting / R_c) - (U_R_c_leak / R_c) = (U_R_c_conducting - U_R_c_leak) / R_c -> U_R_c = U_R_c_conducting - U_R_c_leak = U_R_c_conducting - U_Rl */ if (U_R_c > U_Rl) U_R_c -= U_Rl; // - U_Rl (leakage) hFE_E = U_R_c * R_HIGH; //U_R_c * R_b hFE_E /= U_R_b; // / U_R_b hFE_E *= 10; //Upscale to 0.1 if (BJT_Type == TYPE_NPN) //NPN hFE_E /= (R_LOW * 10) + Config.RiH; // / R_c in 0.1 Ohm else //PNP hFE_E /= (R_LOW * 10) + Config.RiL; // / R_c in 0.1 Ohm //Get hFE for common collector circuit hFE_C = Get_hFE_C(BJT_Type); //Keep largest hFE if (hFE_C > hFE_E) hFE_E = hFE_C; //Only update data if hFE is larger than old one if (hFE_E > BJT.hFE) //Save data BJT.hFE = hFE_E; BJT.I_CE0 = I_CE0; BJT.B = Probes.Pin_3; if (BJT_Type == TYPE_NPN) //NPN BJT.C = Probes.Pin_1; BJT.E = Probes.Pin_2; else //PNP BJT.C = Probes.Pin_2; BJT.E = Probes.Pin_1; #if 0 /* Check for proper emitter and collector: - I_c is much lower for reversed emitter and collector. - So we reverse the probes and measure I_c (= U_R_c / R_c) again. - Since R_c is constant we may simply compare U_R_c. This is an alternative solution instead of running the check two times. */ SetADCHiz(); //Set ADC port to HiZ mode R_DDR = 0; //Set resistor port to HiZ mode if (BJT_Type == TYPE_NPN) //NPN //We assume: probe-1 = E / probe-2 = C / probe-3 = B, set probes: Gnd -- probe-1 / probe-2 -- Rl -- Vcc SetADCLow(); ADC_DDR = Probes.ADC_1; //Pull-down emitter directly R_PORT = Probes.Rl_2 | Probes.Rh_3; //Pull-up base via Rh R_DDR = Probes.Rl_2 | Probes.Rh_3; //Enable probe resistors U_R_b = UREF_VCC - ReadU_5ms(Probes.Pin_2);//U_R_c = Vcc - U_c else //PNP //We assume: probe-1 = C / probe-2 = E / probe-3 = B, set probes: Gnd -- Rl - probe-1 / probe-2 -- Vcc R_PORT = 0; R_DDR = Probes.Rl_1 | Probes.Rh_3; //Pull down base via Rh ADC_DDR = Probes.ADC_2; ADC_PORT = Probes.ADC_2; //Pull-up emitter directly


U_R_b = ReadU_5ms(Probes.Pin_1); //U_R_c = U_c //If not reversed, BJT is identified if (U_R_c > U_R_b) //I_c > I_c_reversed //Move other stuff here: save data & Comp= Check.Done = 1; #endif else if ((U_Rl < 97) && (U_R_c > FET_Level)) //No BJT /* If there's - just a small leakage current (< 0.1mA) in non-conducting mode - a large U_R_c (= large current) when conducting - a low U_R_b (= very low gate current) we got a FET or an IGBT. The drain source channel of a MOSFET is modeled as a resistor while an IGBT acts more like a diode. So we measure the voltage drop across the conducting path. A MOSFET got a low voltage drop based on it's R_DS_on and the current. An IGBT got a much higher voltage drop. */ I_CE0= ReadU(Probes.Pin_1) - ReadU(Probes.Pin_2); if (I_CE0 < 250) //MOSFET Check.Found = COMP_FET; Check.Type = FET_Type | TYPE_ENHANCEMENT | TYPE_MOSFET; else //IGBT Check.Found = COMP_IGBT; Check.Type = FET_Type | TYPE_ENHANCEMENT; Check.Done = 1; //Transistor found //Measure gate threshold voltage GetGateThreshold(FET_Type); //Save data FET.G = Probes.Pin_3; if (FET_Type == TYPE_N_CHANNEL) //n-channel FET.D = Probes.Pin_1; FET.S = Probes.Pin_2; else //p-channel FET.D = Probes.Pin_2; FET.S = Probes.Pin_1;


Ejemplo 2. Código para comprobación de diodos.

Diode_Type *Diode; //Pointer to diode unsigned int U1_Rl; //Vf #1 with Rl pull-up unsigned int U1_Rh; //Vf #1 with Rh pull-up unsigned int U1_Zero; //Vf #1 zero unsigned int U2_Rl; //Vf #2 with Rl pull-up unsigned int U2_Rh; //Vf #2 with Rh pull-up unsigned int U2_Zero; //Vf #2 zero wdt_reset(); //Reset watchdog DischargeProbes(); //Try to discharge probes if (Check.Found == COMP_ERROR) return; //Skip on error /* DUT could be: - simple diode - protection diode of a MOSFET or another device - intrinsic diode junction of a BJT - small resistor (< 3k) - capacitor (> around 22µF) Solution: - Vf of a diode rises with the current within some limits (about twice for Si and Schottky). Ge, Z-diodes and LEDs are hard to determine. So it might be better to filter out other components. - For a MOSFET pretection diode we have to make sure that the MOSFET in not conducting, to be able to get Vf of the protection diode. So we discharge the gate and run the measurements twice for p and n channel FETs. - Take care about the internal voltage drop of the µC at the cathode for high test currents (Rl). - Filter out resistors by the used voltage divider: k = Rl + Ri_H + Ri_L U_Rh = U_Rl / (k - (k - 1) U_Rl / 5V) U_Rl = k U_Rh / (1 + (k - 1) U_Rh / 5V) - Filter out caps by checking the voltage before and after measurement with Rh. In 15ms a 22µF cap would be charged from 0 to 7mV, a larger cap would have a lower voltage. We have to consider that caps also might be charged by EMI. Hints: - Rl drives a current of about 7mA. That's not the best current for measuring Vf. The current for Rh is about 10.6µA. Most DMMs use 1mA. Vf #1, supporting a possible p-channel MOSFET */ //We assume: probe-1 = A / probe2 = C, set probes: Gnd -- probe-2 / probe-1 -- Rl or Rh -- Vcc SetADCLow(); ADC_DDR = Probes.ADC_2; //Pull down cathode directly //R_DDR is set to HiZ by DischargeProbes(); U1_Zero = ReadU(Probes.Pin_1); //Get voltage at anode //Measure voltage across DUT (Vf) with Rh R_DDR = Probes.Rh_1; //Enable Rh for probe-1 R_PORT = Probes.Rh_1; //Pull up anode via Rh //Discharge gate PullProbe(Probes.Rl_3, FLAG_10MS | FLAG_PULLUP); U1_Rh = ReadU_5ms(Probes.Pin_1); //Get voltage at anode, neglect voltage at cathode //Measure voltage across DUT (Vf) with Rl R_DDR = Probes.Rl_1; //Enable Rl for probe-1 R_PORT = Probes.Rl_1; //Pull up anode via Rl //Discharge gate PullProbe(Probes.Rl_3, FLAG_10MS | FLAG_PULLUP); U1_Rl = ReadU_5ms(Probes.Pin_1); //Get voltage at anode U1_Rl -= ReadU(Probes.Pin_2); //Substract voltage at cathode DischargeProbes(); //Try to discharge probes if (Check.Found == COMP_ERROR) return; //Skip on error //Vf #2, supporting a possible n-channel MOSFET //We assume: probe-1 = A / probe2 = C, set probes: Gnd -- probe-2 / probe-1 -- Rl or Rh -- Vcc SetADCLow(); ADC_DDR = Probes.ADC_2; //Pull down cathode directly


U2_Zero = ReadU(Probes.Pin_1); //Get voltage at anode //Measure voltage across DUT (Vf) with Rh R_DDR = Probes.Rh_1; //Enable Rh for probe-1 R_PORT = Probes.Rh_1; //Pull up anode via Rh //Discharge gate PullProbe(Probes.Rl_3, FLAG_10MS | FLAG_PULLDOWN); U2_Rh = ReadU_5ms(Probes.Pin_1); //Get voltage at anode, neglect voltage at cathode //Measure voltage across DUT (Vf) with Rl R_DDR = Probes.Rl_1; //Enable Rl for probe-1 R_PORT = Probes.Rl_1; //Pull up anode via Rl //Discharge gate PullProbe(Probes.Rl_3, FLAG_10MS | FLAG_PULLDOWN); U2_Rl = ReadU_5ms(Probes.Pin_1); //Get voltage at anode U2_Rl -= ReadU(Probes.Pin_2); //Substract voltage at cathode R_PORT = 0; //Stop pulling up //Process results, choose between measurements of p and n channel setup if (U1_Rl > U2_Rl) //The higher voltage wins U2_Rl = U1_Rl; U2_Rh = U1_Rh; U2_Zero = U1_Zero; /* U_Rh < 10mV for - resistor < 1k Ohm - very large cap */ if (U2_Rh <= 10) return; //Small resistor or very large cap /* U_Zero <= 2 for resistor or diode U_Zero > 2 for cap or diode if U_Zero > 2 then U_Rh - U_Zero < 100 for cap Hints: If U_Zero > 10 and U_Rh is about U_Zero it's a large cap. As larger the cap as lower U_Rl (charging time 15ms). */ U1_Zero = U2_Rh - U2_Zero; //Voltage difference if ((U2_Zero > 2) && (U1_Zero < 100)) return; //Capacitor /* The voltages for a resistor will follow the equation: k = Rl + Ri_H + Ri_L Ul = k U_Rh / (1 + (k - 1) U_Rh / 5V) Allow a tolerance of 3%. For U_Rh > 40mV we don't need to check for a resistor. Hint: Actually we could change the thresshold above from 10 t0 40 and remove this test completely. The lowest U_Rh measured for a diode was 56mV for a AA118. */ if (U2_Rh < 40) //Resistor (< 3k) uint32_t a, b; //Calculate expected U_Rl based on measured U_Rh in mV, k factor b = (R_HIGH * 10) / ((R_LOW * 10) + Config.RiH + Config.RiL); a = b - 1; //k - 1 a /= 5; // / 5V a *= U2_Rh; // *U_Rh a += 1000; // +1 (1000 for mV) b *= 1000; //For mV b *= U2_Rh; // *U_Rh b /= a; //U_Rl in mV //Check if calculated U_Rl is within some % of measured value U1_Zero = (unsigned int)b; U1_Rl = U1_Zero; U1_Rh = U1_Zero; U1_Zero /= 50; //2% U1_Rh += U1_Zero; //102% U1_Zero = (unsigned int)b; U1_Zero /= 33; //3% U1_Rl -= U1_Zero; //97% (for resistors near 1k)


//Resistor if ((U2_Rl >= U1_Rl) && (U2_Rl <= U1_Rh)) return; //If U_Rl (Vf) is between 0.15V and 4.64V it's a diode if ((U2_Rl > 150) && (U2_Rl < 4640)) //If we haven't found any other component yet if ((Check.Found == COMP_NONE) || (Check.Found == COMP_RESISTOR)) Check.Found = COMP_DIODE; //Save data Diode = &Diodes[Check.Diodes]; Diode->A = Probes.Pin_1; Diode->C = Probes.Pin_2; Diode->V_f = U2_Rl; //Vf for high measurement current Diode->V_f2 = U2_Rh; //Vf for low measurement current Check.Diodes++;


1.4.8 Producto terminado. Fotografías.

Aquí vemos solo la parte de la placa de circuito impreso que diseñamos acoplada al

arduino, falta conectarle la otra parte del producto que seria el panel LCD.


En esta imagen ya vemos el proyecto al completo, la placa de circuito impreso junto al

arduino y ambas conectadas mediante un faja a un panel LCD.

A la derecha de la placa vemos un cable de alimentación, en este caso es de tipo USB

y lo tengo conectado al portatil para alimentar al arduino y poder ver en pantalla los

datos de los componentes que introduzcamos.

Nada más conectar el arduino al portatil vemos que en el panel aparece una frase, esa

frase nos indica el nombre del proyecto, en este caso Ardutester, y la versión en la cual

se encuentra el prooyecto, porque recordemos que esto sigue en proceso de pruebas y

mejoras.


Para ver si funciona el proyecto, aunque solo sea una leve prueba, le damos al boton

de la placa y si todo va bien deberia aparecer en pantalla lo que vemos en la imagen

que es la palabra “Probing” que significa probando el componente, pero como no

tenemos conectado ningun componente aparecera inmediatamente despues de ese

mensaje el mensaje que vemos en la imagen inferior.


Y como decia arriba al no tener un componente insertado deberiamos ver en el LCD el

mensaje de “No component found!” el cual nos dice en ingles que no ha encontrado

ningun componente para medir, como decia anteriormente, esto es una simple prueba

para ver que la placa esta bien hecha y hace una correcta conexión con todos los

componentes a los que va conectado, que en este caso son arduino y panel LCD.


Para una mejor presentación podeis ponerlo sobre un tablon de cartón-pluma como hice

para mi exposición y queda bastante mejor presentado.


1.5 Pruebas y resultados

Comenzamos las pruebas con un condensador polarizado de 100uF como podemos

observar en la imagen.

Para medirlo lo pusimos en las patillas 1 y 3 y le dimos al botón, al momento nos

presentó en la pantalla LCD que era un condensador como vemos en el dibujo superior

del panel, que estaba colocado en las patillas 1 y 3 del medidor y que nos arrojaba un

valor de 86.81 uF, que teniendo en cuenta el valor nominal que marca el condensador

obtenemos un error de solo un 13,19% lo cual no está nada mal, porque recordemos

que no los polímetros dan valores exactos, asi que en este caso tenemos un resultado

muy satisfactorio.


En este caso estamos midiendo un MOSFET, el IRF 540A para ser más exactos, y como

podemos ver nos muestra en pantalla que es un MOSFET, que sus patillas están

colocadas en GDS=321, lo cual significa que la patilla 3 (la que está más cerca de las

resistencias) es la Gate, la patilla 2 es la Drain y la patilla 1 la Source.

Como se puede apreciar, en la parte de la derecha del panel vemos un reloj de arena,

eso nos indica que hay más valores que nos puede representar pero que no caben

porque el panel es pequeño, asi que tenemos 2 segundos para ver el patillaje y luego

cambiará a la otra pantalla para dejarnos ver más características sobre éste

componente.

Las características que no caben las podemos ver en la imagen de abajo, donde también

explicaré un poco que tenemos.


Estos son los valores que se quedan fijos sobre el LCD con respecto al MOSFET.

Para ver estos valores, al igual que los anteriores, tendriamos que acudir a un datasheet,

pero con esto ya no es necesario, dado que te da los principales valores que usamos,

en este caso los valores son:

Vth=610mV

CGS=472pF


En esta prueba estamos midiendo un transistor NPN, el TIP 31C.

Cuando realizamos la medición vemos que nos dice de primeras muchas cosas:

Es un transistor NPN.

El emisor está en la patilla 3, la base en la patilla 1 y el colector en la patilla 2.

Tiene una ganancia en corriente de 688, es decir, esa es su beta.

Eso es lo primero que vemos, porque también tenemos un reloj de arena, y como en el

componente anterior, estos valores aparecen durante 2 segundos y despues salen otros

valores, los cuales veremos más abajo.


Aquí tenemos la continuación de la medida del transistor anterior, que como vemos

mantiene arriba los valores que salian antes, pero abajo nos da otros valores, que como

podemos ver es: V_BE=157mV.


Aquí tenemos otro transistor de tipo NPN, pero en este caso en de tipo, los de

“sombrero”, y como en los casos anteriores, nos marca varios valores, los cuales son:

Es del tipo NPN

Su Emisor está en la patilla 3, su Base en la patilla 2 y su Colector en la patilla

1.

Tiene una beta de 691.

Para ver más valores sobre este componentes nos vamos abajo para ver que sale

despuesde que se quite el reloj de arena.


Esto es lo que sale despues del reloj de arena en la medición del transistor anterior,

mantiene los resultados de la parte superior pero nos arroja otro valor: V_BE=177mV.


Ahora estamos midiendo otro transistor, pero en este caso es del tipo PNP y se trata del

transistor BC328.

Como en casos anteriores nos da una serie de valores, los cuales son:

Es del tipo PNP.

Su Emisor es la patilla 1, su Base es la patilla 2 y su Coelctor es la patilla 3.

Tiene una beta de 1311.


La última prueba realizada es la medida de un diodo, el ZY 200, y como vemos nos dice

el patillaje del diodo con su respectivo símbolo, diciendo que la patilla 1 es el lado que

no está marcado con una línea blanca, y la patilla 3 es la marcada con una línea blanca,

tambien tenemos una medida que es: Vf=174mV.


1.6 Manual de usuario

Para comenzar a utilizar el comprobador de componentes les recomiendo sigan estos

pasos:

1) Conectarle alimentación a arduino, ya sea por conexión USB o directamente a

la corriente.

2) Esperar que se encienda, no tarda más de 2 o 3 segundos.

3) Introducir el componente que vayamos a medir en la zona apropiada, la cual es

el conector de 3 pines hembra situado en la parte izquierda de la placa.

4) Darle al botón para iniciar la secuencia de detección del componente.

5) Ver en pantalla el valor arrojado por el comprobador.

Para medir otro componente sigan estos pasos:

1) Sacar el componente anterior.

2) Introducir el componente nuevo que vayamos a medir.

3) Darle al botón

4) Ver en pantalla el valor arrojado por el comprobador.

En caso de fallo en la comprobación del componente siga estos pasos:

1) Desconecte el cable de alimentación de arduino.

2) Vuelva a conectarlo y siga los pasos del primer procedimiento para la medición

de componentes.

3) Si no funcionase el paso anterior compruebe que el componente que intenta

medir está dentro de los rangos aceptados por el comprobador de compontes y

es un componente válido para este comprobador.


1.7 Manual de servicio

Tenga cuidado con el comprobador y siga atentamente estas indicaciones para que el

comprobador funcione correctamente:

1) Cuidado con la faja que conecta arduino con el LCD, es muy frágil y podria

dañarse alguna vía haciendo que el comprobador no funcionase correctamente.

2) No dejar el panel LCD expuesto al sol, dado que esto podría causar un fuerte

daño en el panel haciendo que no se vea bien o incluso que falle alguna parte.

3) No modificar ningún componente de la placa de circuito impreso.

4) No regular el potenciómetro a menos que sea necesario.

En caso de fallo reiterado en las comprobaciones siga estos pasos:

1) Asegurese de que está midiendo componentes válidos para este sistema de

medida.

2) Comprobar que el condensador no está roto midiendo continuidad en sus dos

patillas, si da continuidad se debe cambiar por otro de su misma medida.

3) Determinar si es fallo en la visualización o en la medición, si se ven valores

extraños en el LCD puede deberse a la faja, en ese caso cambiese.

4) Si el LCD y su faja están bien puede deberse a la programación de arduino,

recomendamos reintalarla por si hubiera algun fallo.

5) Si todos los pasos anteriores no consiguieron arreglar el fallo, por favor, pongase

en contacto con nosotros en la cuenta de correo que se encuentra en la web del

producto, la cual se encuentra en el anexo III.


1.8 Bibliografía

http://www.arduino.cc/en/Main/Software

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

http://www.mikrocontroller.net/articles/AVR-Transistortester

1.9 Presupuesto

Arduino UNO: 20€

Placa fotosensible: 7.5€

Resistencias (6): 0.66€

Condensador: 0.23€

Pulsador: 1.54€

Potenciómetro: 1.05€

Zócalo: 1€

Cable plano 14 vías: 5.97€

Zócalo para cable plano (2): 2.38

LCD: 12,97€

Total: 53.31€

http://www.arduino.cc/en/Main/Software

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

http://www.mikrocontroller.net/articles/AVR-Transistortester


2 Planos


2.1 Esquema completo


2.2 PCB bottom


ANEXOS

Anexo I. Estudio y normas de seguridad

Hechar la cantidad exacta de productos químicos a la hora del revelado.

No mezclar los productos del revelado, manter cada uno separado del otro.

Introducir los desechos de los vertidos del revelado cada uno por separa en

botellas de seguridad para posteriormente llevarlos a un punto limpio.

Gafas de protección a la hora de revelar y taladrar la placa.

Anexo II. Página web

Para saber más sobre el proyecto no dudeis en acceder a mi página web:

http://comprobadordecomponentes.weebly.com

http://comprobadordecomponentes.weebly.com/

proyecto integrado · 2019. 9. 10. · exposición del proyecto integrado. (se asiste a clase el...

Documents