Buscar este blog

miércoles, 23 de diciembre de 2015

[Electrónica][Arduino] Trasteando con un LM741

Hola, compañeros!

Hoy he estado trasteando un poco con un LM741.
Os pongo en situación, estoy haciendo una cosa (ya os contaré que tal) y para esto necesito que un LDR actué como interrupt [aqui más info sobre las interrupts], para ello no podía usarlo como se suele hacer, es decir, leer el valor que daba el ldr con el arduino e interpretar el valor en el código. Necesitaba que me enviara o HIGH  o LOW según la intensidad de la luz ambiente.

Amplificador operacional
Como no sabía muy bien como hacerlo, pregunté como por  la comunidad de aficionados a la electrónica y me recomendaron que mirara el LM741, junto a otros amplificadores operacionales (cogí el 741, porque era el que tenían en la tienda), a parte me pasaron otro circuito que funcionaba con un transistor, pero ahora mismo no tengo el transistor y la verdad es que el precio del transistor y el del LM741 son muy parecidos, por lo que he preferido usar el integrado.

Bueno, ahora vamos con un poco de teoría, el LM741 (y los demás circuitos del mismo tipo) son amplificadores operacionales, la wikipedia los define [aquí] como un circuito que tiene dos entradas y una salida. La salida es la diferencia de las dos entradas multiplicada por un factor (G) (ganancia):  (Vout = G · VS(+) − VS(−)).

Los amplificadores operacionales se usan para un motón de cosas, pero no voy a entrar en detalles. El uso que ahora mismo nos interesa es el de comparador y es en el que me voy a centrar.
Como comparador el amplificador operacional compara las dos entradas (VS(+) y VS(-)) y saca una salida en función del signo de la resta de Vs(+) y VS(-) si la resta es positiva nos va ha dar un HIGH y si es negativa un LOW. Por lo que si:
  •  Si V(+) es mayor que V(-) nos devolverá un 1 y si V(-) es mayor que V(+) nos devolverá un 0.
Este dibujo resume muy bien lo que acabo de explicar y otra forma de verlo sería de la siguiente manera, si V+ es mayor que V-, la salida sería Vs+ y si V- es mayor que V+, la salida sería Vs-.



Bueno, ahora que tenemos un poco de teoría vamos a implementarlo, para ello vamos ha montar el siguiente circuito:



Este circuito, es muy simple, se basa en un circuito divisor de voltaje. Los circuitos divisores de voltaje son unos circuitos que dividen la tensión de una fuente entre una o más impedancias conectadas. En este caso está formado por dos resistencias conectadas en serie (una el ldr y otra la del potenciómetro), como estas dos resistencias son variables, la tensión de salida variará, por lo que el voltaje de entrada en una de las patillas del integrado estará en función de la intensidad de la luz y la otra patilla recibirá un voltaje en función de la posición del  potenciómetro, lo que nos permitirá calibrar la sensibilidad del LDR.
Una vez que gracias a los divisores de tensión tenemos el voltaje que queremos en las patillas del amplificador operacional, este va ha comparar la patilla V+(la patilla 2) con la patilla V-(la patilla 3) y va ha sacar por la patilla de salida (la 6) o un HIGH o un LOW.  Esta patilla de salida del integrado, la conectaremos a cualquier pin del arduino para poder leer su estado.
Por lo que en resumen, lo que va ha hacer el circuito es gracias a los divisores de voltaje, obtener un voltage en funcion de la intesidad de la luz y de la posición del potenciómetro y luego comprarlos gracias al LM741 y sacar un HIGH o un LOW, que leeremos con el arduino, en función de esta comparación.

En este esquema os dejo también la ecuación para el calculo de divisores de tensión.
 


Para probarlo, es muy simple, solo tenemos que crear un código de arduino que nos lea el valor de un pin digital al que hemos conectado la salida del amplificador y que nos lo muestre en pantalla (todavía no he probado con las interrups, pero para probarlo esto vale XD).
 


Y bueno, como podéis ver funciona! Ya sabéis, ahora a probarlo, que estos integrados son baratos y te sirven para estar una tarde entretenid@ XD.


Hasta la próxima!


miércoles, 2 de diciembre de 2015

[Electrónica] [Arduino] Trasteando con un ATmega328 (cargandole el bootloader y un sketch)

Hola compañeros!
ftr232r (rojo) o el cp2120 (negro).
Esta tarde me la he pasado investigando un poco como poder cargar un sketch a un chip ATmega 328, usando un programador serial como el ftr232r o el cp2120 (también se suele usar una arduino UNO con el chip quitado, pero personalmente ODIO quitar el chip del arduino, siempre se dobla una patilla!!).
Lo primero de todo es que para poder cargar un programa de arduino, y que funcione en un ATmega recién comprado, es necesario que este tenga quemado el bootloader de arduino. Hay muchos vendedores que por un poco más ya los venden con el boot precargado y solo tienes que dedicarte a programarlo, pero si lo compras en una tienda de electrónica normal, como es mi caso, lo más común es que no lo traigan y tengamos que quemárselo.



Cargando el boot con el arduino
Osea que lo primero es cargar el bootloader, pues vamos a ello!:
Para cargarlo yo he utilizado mi arduino UNO y he seguido las indicaciones de la pág oficial de arduino (la .cc, no la .org) [indicaciones aquí], y para los que no sepáis ingles, voy a intentar explicarlo yo también.
Antes de nada, se necesita un crystal, una resistencia de 10k,y dos condensadores de entre 18 y 22pF (si no los tenéis disponibles en este momento y tenéis mucho SAV, [aquí si no sabes que significa SAV], id al punto 2 y leed el inciso;P ).

Ahora:

1. Lo primero es cargar en el arduino el programa "ArduinoISP" para poder usar este como
programador ISP. El programa lo encontramos dentro del IDE de arudino en "Archivo"-->
"Ejemplos"-->"ArduinoISP". (Para este paso, en la parte de herramientas, tenéis que te tener
seleccionada la placa arduino que estéis usando)-

2. Una vez que tenemos esto hecho hay que montar el circuito para conectar el ATmega al
arduino:

 --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 
Aquí quiero hacer un pequeño inciso:
Al final de la pag de arduino donde explica todo esto que estoy diciendo, viene una parte llamada "Minimal Circuit", en esta parte, cargan el boot al ATmega, sin usar ningún componente adicional, como me ha  llamado la intención, lo he querido probar, pero después de más de 15 fallos no he podido, usando la version 1.6.4 de arduino, quería probar a ver si con la 1.0 iba, pero me dio un par de veces error la descarga de arduino y lo dejé, queda pendiente.
Este método funciona sin componentes adicionales, porque usa el reloj interno del atmega y para poder usarlo tienes que añadir una carpeta (que se puede descargar según tu versión del IDE, de la misma pag de arriba, en la parte donde habla del "Minimal Circuit") dentro del directorio de instalación de arduio, en la carpeta de Hardware, para que te instale el "Atmega 328 a 8mhz", y te salga en la seccion de selección de placa del arduino IDE.
En este método el esquema de conexión quedaría de la siguiente manera:


Una vez conectado es seguir los pasos 3 y 4, solo que en el paso 3 tienes que seleccionar como placa, el ATmega328 a 8Mhz.

 --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

La otra forma, y la que me ha funcionado a la primera, es montar el circuito completo, os dejo un pequeño esquema que he hecho con mi puño y letra y que espero que resulte claro!, (no es muy profesional pero lo importante es que sea entendible  y útil)


3. Lo siguiente es ir a la sección de herramientas y seleccionar la placa que use el procesador
al que le queremos cargar el boot, por ejemplo para el atmega 328 sirve seleccionar el UNO.

4.
Bueno, pues ya casi está, ahora solo queda ir a "herramientas"-->"quemar bootloader" y esperara que nos salga debajo "bootloader cargado correctamente"




Pues bueno, una vez que nos aparece esto ya tenemos cargado el bootloader de Arduino en nuestro
ATmega328. Ahora a cargarle un program! Por ejemplo, para ser originales... el blink XD.  Para cargar el programa, voy a usar un programador Serial, como sería el Ft232 o el Cp2010.

El ATmega con el blink cargado

En este paso vamos a necesitar un crystal de 16MHz, un condensador de 0.1uF, una resistencia de 10k y dos condensadores de entre 18 y 22 pF. Bueno, y por supuesto el ftr232r o el cp2120, yo estoy usando el cp, porque no tenía ningún cable mini-usb en casa XD.
 Una vez que tenemos estos componente (practicamente los que hemos usado antes), tenemos que montar el siguiente circuito (el orden de los pines del Ft232, puede ser distinto al que he puesto, pero los nombres de estos si deberían ser los mismos) : 

OJO! Cuando he cargado el programa en mi ATmega no he usado el condensador entre el pin 7 y 8, porque no lo tenía a mano. Debería ser mejor ponerlo, pero solo quiero aclarar que yo no lo he puesto y así también funciona. Por otra parte el otro de 0.1uF si es necesario.

Los condensadores de los pines 9 y 10 tienen que ser de entre 18 y 22 pF


En cuanto tengamos el circuito ya podremos cargar programas al Atmega, simplemente seleccionando el arduino UNO en la sección de herramientas, ya que usamos el ATmega 328 y le damos a cargar, ya solo a esperar que ponga "subido" más abajo y a divertirse!

--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
No se si os habréis dado cuenta, seguramente no, porque el tema de la construcción del watchduino lo tengo un poco abandonado (solo un poco XD) [el tema aquí], pero me he puesto a "trastear con el Atmega" no para cargarle el Blink, sino para cargarle el programa del Watchduino y terminarlo.

--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Me gustaría que me comentárais abajo que os parecen los esquemas a mano, si os resultan más fáciles de ver a simple vista que los hechos con eagle o kickad o si los veis más liosos o si los veis cutres... etc, etc.