Muchas gracias por visitar diariamente mi sitio.

Cambié el diseño del sitio por uno un poco más "bloggero" y agregué un sistema de comentarios. Espero que les guste.

Descargar esquemático e impreso editable en proteus

Descargar circuito impreso editable en proteus

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

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.

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

Dada la configuración del timer, calcula el tiempo de overflow del mismo.