La estuve usando un poco como visora de viejas cintas, hasta que un día decidí ver cómo se podía modificar. Es conocido que los sensores CCD (usados en gran parte de las cámaras digitales) por naturaleza detectan un rango de luz que abarca más que la luz visible. Detectan parte del llamado "infrarrojo cercano", que está cerca del color rojo en la tabla de longitudes de onda. Este infrarrojo NO es el tipo de infrarrojo emitido por los cuerpos que tienen temperatura. El infrarrojo "térmico" es el mediano, y es imposible de ver por sensores CCD normales.

Las cámaras tienen por diseño un filtro anti-infrarrojo, que deja pasar solamente el rango de luz que el ojo ve. Esto es necesario ya que de otra forma las imágenes saldrían con un tono rojizo, y los colores no corresponderían a lo que las personas ven. Sacando a este filtro, y cambiándolo por uno paso-infrarrojo, que deje pasar lo infrarrojo y bloquee parte de la luz visible, es posible que la cámara "vea" infrarrojo.

Este filtro por lo general está bien cerca del sensor:

Luego de varias horas de búsqueda, conseguí el manual de service de la cámara en este lugar, tienen muchos manuales gratis y los escanean a pedido. En la imagen marqué con rojo cual es el filtro que hay que cambiar.

Para crear un filtro pasa-infrarrojo, es posible usar la parte interna de los disquettes, o la parte subexpuesta ("negra") de los negativos de fotos:

Para mantener la misma altura del filtro, usé un par de vidrios viejos del mismo tamaño, intentando que el grosor total sea lo más parecido al del filtro original. Al variar este alto, la cámara pierde su capacidad de ser parfocal (mantener el foco variando el zoom) y tiene problemas al enfocar en cosas cercanas. para enfocar al infinito puede ser necesario tener que desenroscar el elemento del frente más que lo posible.

Algunas fotos luego de la modificación:

Árboles y plantas "blancas" bajo la luz del sol:

Venas:

Control remoto se ve transparente:

Teclado con algunas teclas de otro color (no tengo idea por qué):

Billete de dos pesos argentinos (se ve "blanco") la tinta refleja la luz infrarroja IR. Los dólares parece que usan otro tipo de tinta y no pasa esto.

Partes del ojo

Otras cosas: Las bebidas gaseosas se ven transparentes (no saqué una foto todavía). Algunos tipos de telas dejan pasar la luz IR, por lo que se puede ver a través de algunas prendas de ropa. También hay muchas cosas que se ven "sin textura", como algunas maderas, algunas impresiones, entre otras cosas.

• Electrocardiograma (ECG)
• Electroencefalograma (EEG)
• Electroencefalograma (EEG)
• Interfaz PC-Cerebro

Electrónica analógica:

• Protección anti ESD
• Errores comunes en los circuitos (algunos están mal corregidos, CUIDADO)
• Demostraciones electrónicas online

Electrónica digital:

• Introducción al procesamiento digital de señales
• Algoritmo para hacer timers muy precisos y estables
• Rutinas muy optimizadas para PICs
• Alternativa a PWM
• Muchos proyectos
• Pasando de 8051/2 a AVR
• Modificaciones a cámaras para resolver problemas
• Conversor USB-paralelo con PIC16F628a (muy optimizado y ajustado al microcontrolador)
• Casa automatizada

Datasheets:

• Notas de aplicación de Microchip
• Set de instrucciones de AVR 8 bits (PDF)
• Circuitos de reset para 8051/2
• Arquitectura 80C51
• Estructura del sistema de archivos FAT12/16
• Guía de programación ICSP de PIC16f628A
• Datasheet AT89S52
• Manuales de servicio gratis de cosas, podés pedir y si la tienen te las escanean en 5 días, excelente!

Sistemas embebidos:

• Explicación JTAG
• Hola mundo en ARM, con GCC y emulador QEMU
• Tips para PICs
• Linux para routers WRT55AGv2

Radiofrecuencia:

• Tips para módulos RF
• Receptores de QRSS
• Índice de receptores de radio

Mecánica y reciclaje:

• Grado de protección
• Control PID sin un PhD
• Reciclaje electrónico

Programación:

• Tutoriales de algoritmos
• Usando memoria no inicializada
• Transformada de fourier discreta
• Conjunto de mandelbrot (fractales)
• Ruido simplex (como Perlin)
• Aproximación a funciones matemáticas
• Hacks con manipulación de bits
• Mini manual de referencia de debian linux
• Mini manual de canvas (HTML5)
• Acelerando la carga de tu sitio web
• Instalador rápido de muchos programas
• Lista de símbolos matemáticos de LaTex
• Matemáticas con LaTex

Abusos del traductor de google: un router con autoenvejecimiento... WTF?

En un diagnóstico de física: ¿Cuándo apareció el otro auto?

Cacho, el sistema deja de andar cuando alguien pone un apóstrofe... ¿Por qué no le decimos a la gente que no los ponga y listo?

Leve aumento del precio del Sushi (ver 5º promoción)...

Una vez hecha la placa, es posible programar al microcontrolador con algún programa que soporte ISP. Por ejemplo: Grava Atmel (puerto paralelo), AtmelWrite (puerto serie) y USBProgrammer (puerto USB.

Descargar esquemático e impreso editable en proteus

Descargar

Si encontrás algún error, dejá un comentario abajo y lo arreglaré a la brevedad.

Dadas dos resistencias y un voltaje de entrada, esta página calcula cual será el voltaje de salida del divisor resistivo.

Un divisor resistivo (también llamado divisor de tensión o de potencial) es un circuito lineal que produce un voltaje de salida (Vout) que es una fracción del voltaje de entrada (Vin)

El divisor de voltaje más sencillo cuenta con dos resistencias puestas en serie, tomando el nodo del medio como el voltaje de salida. Suele ser usado para crear un voltaje de referencia, o para obtener una señal de bajo voltaje proporcional a un voltaje medido (atenuador de señal).

La carga conectada a la salida produce un efecto carga. Es decir, al conectarla disminuye la tensión de salida. Por esto, conviene que la corriente de entrada sea mucho mayor a la corriente de salida. La desventaja de hacer esto es que la mayor parte de la corriente de entrada se pierde en forma de calor en las resistencias.

La impedancia de salida del divisor resistivo es igual a la resistencia cuando R1 y R2 están en paralelo, es decir Rout = (R1*R2)/(R1+R2).

Palabras clave: calcular tension resistencia, resistencias en series, impedancias en serie

• Apagado/Prendido: El motor se puede apagar y prender
• Apagado/Adelante/Atrás: El motor se puede apagar y hacer girar en ambas direcciones
• Apagado/Adelante/Atrás/Frenado: Además del anterior, el motor se puede "frenar", cortocircuitando sus terminales

Además, es posible controlar la velocidad de los motores por modulación de ancho de pulso (PWM), siempre que el sistema lo permita.

Primer modo: Apagado/Prendido

Este es el modo más sencillo, se puede realizar tanto con un transistor como con un relé:

Como se puede ver en el primer circuito, es un transistor operando como interruptor. El diodo es necesario porque, al ser el motor una carga inductiva, cuando se le corta la tensión retiene parte de la energía y la libera en el sentido inverso, lo que podría quemar los transistores. Los diodos deberían ser del tipo ultrarrápido si la señal de comando usa PWM.

El segundo circuito es similar, con la diferencia que el elemento de control es el relé. Es mucho más sencillo, soporta un motor de mucha más corriente, tiene menos caída de tensión y el motor puede utilizar otra fuente de tensión (es decir, está teóricamente aislado). El problema es que los relé tienen una vida útil limitada, no se puede usar PWM de alta frecuencia, y la bobina del relé agrega un consumo considerable en el caso que se manejen motores de baja corriente.

Segundo modo: Apagado/Adelante/Atrás

Este método es interesante porque se puede usar para realizar robots, autos radio controlados, entre muchas otras cosas. Al igual que el anterior, se puede realizar con transistores como con relés:

En el primer circuito, cada relé controla a qué tensión va conectada cada una de las terminales del motor, por lo que hay 4 combinaciones:

En el segundo circuito, cada transistor interrumpe o deja pasar corriente al motor, por lo que hay 16 combinaciones:

Como se puede ver, este circuito también se lo conoce con el nombre de Puente H "quemable", porque una entrada puede quemar todos los transistores. Por esto se le acopla lógica externa para evitar que esto suceda. Con transistores buenos (poco VCEmin) es posible lograr un rendimiento del orden del 90%, a diferencia de los relés, cuya corriente de bobina reduce el rendimiento. Además, con los transistores es posible regular la velocidad del motor, usando PWM.

Tercer modo: Híbrido

Considerando que por lo general en un sistema es poco frecuente el cambio de dirección de un motor, es posible combinar los dos sistemas anteriores y hacer un híbrido, en el que un relé se use para cambiar la dirección, y un transistor para variar la velocidad. Este método está en el medio de los dos:

• Corriente extra: consume más que el puente H puro con transistores, pero menos que el hecho todo con relés
• Rendimiento: tiene una caída de tensión media, más que el hecho con relés, pero menos que el hecho con transistores
• Costo: al necesitar solamente dos transistores (solamente uno de potencia) y un relé, es bastante barato
• Control de velocidad: Es posible controlarla usando PWM en el transistor que apaga y prende el motor
• Facilidad de uso: No hay una combinación en la que exploten los transistores

Estos métodos pueden ser utilizados tanto con motores como con cualquier otra carga a la que sea necesario cambiar su polaridad, como por ejemplo una celda peltier. Sería posible controlar la temperatura via PWM (con un lazo de realimentación) y además invertir su polaridad, para hacer que caliente en vez de enfriar.

Palabras clave: Puente h con relevadores, puente h con relés, puente h, girar motor con transistores, puente h con 2 relevadores, puente h con transistores

El juego usa la librería SDL y SDL_Image para abrir ventanas, manejar eventos y cargar las imágenes del juego. También usa OpenGL para el renderizado gráfico, y los "sockets de Unix" para multiplayer. Para compilarlo es necesario tener instalado mingw o cygwin, ir a la carpeta del cliente y ejecutar make.

Bajar código y ejecutable (Licencia: GPL2)

Descargar código (Licencia: Dominio público salvo el tileset que es de JohnSmith27)

Lo hice en el 2008, usando visual basic 6, en un par de horas. En la descarga pueden encontrar el código fuente, si lo quieren modificar y redistribuir no hay ningún problema (siempre que me nombren)

Por un pequeño bug no funciona si no son administradores, pero lo pueden corregir cambiando c:\temp.txt por temp.txt y recompilando el proyecto.

Descargar fuente + ejecutable

Acoplar un ADC externo hace que necesitemos más patas en el micro (generalmente el valor sampleado se da en un bus de datos de 8 bits, como en el ADC0808), más espacio en el circuito impreso, o más complejidad en el software (por ejemplo, habría que programar rutinas para comunicarse via I2C con el ADC)

Si no nos interesa la resolución, precisión, linealidad, tiempo de sampleo, una solución es usar un circuito RC, usando un estilo de conversión similar al de doble rampa, pero sin integrar, unicamente contando el tiempo que tarda en descargarse el RC

La resistencia puede ser cambiada por un termistor (PTC o NTC) si se quiere medir temperatura, o un LDR si se quiere medir luminosidad. También es posible usar un sensor capacitivo, manteniendo fija la resistencia en algún valor conocido.

Es necesario tener una pata de E/S en el microcontrolador, que permita poner la pata en estado de alta impedancia

El principio de funcionamiento es el siguiente:

• Ponemos la pata en positivo durante 1 ms, para cargar el capacitor
• Ponemos la pata en modo entrada (alta impedancia) y medimos cuanto tarda en descargarse el capacitor
• Repetimos este ciclo cada 50ms

Si no tenemos puertos con posibilidad de setear un modo de entrada/alta impedancia (como en el 8052), podemos usar un par de componentes más, como se muestra en el circuito siguiente:

Como se puede ver, el diodo hace que el capacitor solo pueda ser cargado, la resistencia extra evita algún posible cortocircuito en caso de que el potenciómetro esté en 0 ohms (puede ser removido si sabemos que tiene límite el puerto). El transistor y la resistencia de base se usan para sensar cuando la tensión del capacitor es menor a 0.7v

Un problema de este tipo de conversor es que depende de la tensión (por ejemplo si el circuito fuese alimentado a 3.3v, el capacitor tardaría mucho menos en cargarse), la baja resolución (que se puede mejorar usando interrupciones y no midiendo manualmente), y que necesita bastante tiempo de sampleado (pero se puede tunear para cada aplicación)

Cómo usarlo (en C)

	unsigned short tiempo=0;
	PIN_CARGA = 1; delay1ms(); PIN_CARGA = 0; //Cargar el capacitor	
	while(EJE0_LECTURA == 0) tiempo++; //Esperar descarga
	

Al valor resultante (16 bits) habría que restarle una constante, y escalarlo para obtener un valor entre 0 y 0xFF.

Palabras clave: sigma delta, doble rampa, rampa, integración, adc pic, adc avr, adc 8052

El esquemático seguro está incompleto o tiene errores ya que la hice en una placa universal, pero las conexiones se pueden deducir mirando el código. Soporta notación natural (infija), multiplicaciones, sumas, restas, divisiones, potencias, raices, paréntesis. La precisión depende del compilador usado (SDCC tiene unas librerías de float menos precisas que el Keil uVision)

El algoritmo usado es Shunting-Yard (para pasar la expresión a notación postfija) y luego se evalua la pila resultante de forma sencilla. Se usan algunos trucos para aprovechar mejor la memoria (necesita menos de 256 Bytes de RAM!) reusando estructuras.

Para compilar el código fuente, ejecutar el archivo .bat. Debería generarse un .hex listo para programarlo al microcontrolador. Es necesario usar SDCC, aunque el código debería ser compatible (con pequeños cambios) con Keil uVision.

Descargar esquemático y programación

Palabras clave: hacer calculadora pic, calculadora avr, calculadora 8052, calculadora con microcontrolador, calculadora electronica, lcd alfanumerico, hacer una calculadora

Cosas que soporta:

• Iluminación dinámica usando sombreado diferido.
• Luces direccionales, punto, spot
• Shaders: Mapeo de normales, agua, cielo, mapeo reflectivo
• Multiplataforma, soporte multihilo, librería matemática
• OpenGL 3 core profile usando GLFW
• Sistema de audio 3D usando FMOD
• Soporte de cámaras en 1era y 3era persona
• Manejador de eventos con soporte para mouse, teclado, joysticks, joypads
• Juegos en red usando UDP, server multihilo
• Carga de archivos Obj, texturas PNG
• Interfaz con soporte para botones, etiquetas, listas, menúes, barras deslizadoras, cajas de texto
• Sistemas de partículas usando point sprites

En desarrollo junto a Jos Kuijpers. Diseño de ventanas por Rodrigo Belfiore

Palabras clave: motor opengl, juegos opengl, juegos glsl, shaders glsl, bump mapping, normal mapping, iluminación deferida, deferred shading, glew, glee, glfw, sdl, fmod

Luego de tener todos los archivos .o resultantes (y los .a que corresponden a librerías dinámicas), es necesario juntarlos para formar el .exe final, usando un enlazador. Este proceso se encarga de unirlos, haciendo que las referencias entre las distintas partes funcione correctamente.

El proceso completo se puede ver en esta imagen:

En la implementación de compiladores de GCC (tanto el de Linux como el que se puede instalar en Windows mediante Mingw), el ejecutable principal se llama gcc, y se encarga tanto de la compilación como del enlazado.

Supongamos que quisieramos armar el "Programa.exe" como muestra la imagen. Estos serían los pasos:

1. Primero necesitamos compilar Archivo1.c para generar Archivo1.o. Esto se puede hacer con el siguiente comando: gcc Archivo1.c -o Archivo1.o
2. Luego necesitamos compilar Archivo2.c, al igual que el paso anterior. Para eso usamos un comando similar: gcc Archivo2.c -o Archivo2.o
3. Finalmente, enlazamos las tres cosas (los dos .o y la librería .a), mediante el comando gcc Archivo1.o Archivo2.o Lib1.a -o Programa.exe

Luego de este último paso, si no hubieron errores, se debería haber creado un ejecutable Programa.exe.

Si estuviésemos compilando archivos de C++, cambiar gcc por g++, y las extensiones por .cpp debería ser suficiente.

El proceso de compilación puede ser automatizado usando un archivo .bat que contenga todas los comandos a ejecutar (en orden, uno por línea). También es posible automatizarlo aún más, utilizando una herramienta llamada make, que permite, entre otras cosas, evitar la recompilación de algúnos códigos fuente que no hayan cambiado.

Palabras clave: compilando con mingw, compilando con dev-cpp, devc++, djgpp, geany, gedit, notepad++, compilación de programas de c++

Primero necesitamos incluir todas los archivos cabecera (headers, extensión .h) de todas las librerías que vayamos a usar en el editor. Estos archivos incluyen prototipos de funciones (dicen como se llaman, la cantidad y tipos de argumentos, el tipo de retorno) y son necesarios para que el compilador pueda escribir correctamente la referencia a lo que necesitemos.

#include <SDL/SDL.h>
#include <fstream>
#include <iostream>
using namespace std;

int fuente[8][8];

int main(int argc, char* args[]){
	if(SDL_Init(SDL_INIT_EVERYTHING) != 0){
		cerr << "Error al iniciar SDL" << endl;
		return -1;
	}

	SDL_Surface *pantalla = SDL_SetVideoMode( 8*32, 8*32, 32, SDL_SWSURFACE );
	
	if(pantalla == NULL){
		cerr << "Error al crear la superficie de video" << endl;
	}

	SDL_WM_SetCaption("Editor de fuentes",NULL);

	bool cerrado=false;	
	int botonApretado = 0;
	

	while(!cerrado){

		SDL_Event event;
		while(SDL_PollEvent(&event)){ 
		

			if(event.type == SDL_QUIT)
				cerrado = true;
			

			if(event.type == SDL_MOUSEBUTTONDOWN){
				if(event.button.button == SDL_BUTTON_LEFT)
					botonApretado = 1;
				else if(event.button.button == SDL_BUTTON_RIGHT)
					botonApretado = 2;	
			}
			

			if(event.type == SDL_MOUSEBUTTONUP)
				botonApretado = 0;
			

			if(botonApretado != 0){ 
				int posX = event.motion.x; 
				int posY = event.motion.y; 
				

				if(posX<32*8 && posY<32*8){
					int celdaX = posX/32;
					int celdaY = posY/32;
					
					if(botonApretado == 1){
						fuente[celdaY][celdaX] = 1;
					}else{
						fuente[celdaY][celdaX] = 0;
					}
				}
				
			}
		}
		

		for(int y=0;y<8;y++){
			for(int x=0;x<8;x++){
			
				SDL_Rect rect;
				rect.x = x*32;
				rect.y = y*32;
				rect.h = 32;
				rect.w = 32;
				

				if(fuente[y][x]==0){
					SDL_FillRect(pantalla,&rect,0x00FFFFFF);
				}else{
					SDL_FillRect(pantalla,&rect,0x00000000);
				}
			}
		}
		

		SDL_Flip(pantalla);
		SDL_Delay(1);
	}
	

	ofstream of("salida.txt");
	for(int y=0;y<8;y++){
		for(int x=0;x<8;x++){
			of << fuente[y][x] << ",";
		}
	}
	of.close();
	

	SDL_Delay(100);
	system("notepad salida.txt");
	

	SDL_Quit();
	return 0;
}

Descargar código fuente y ejecutable